.

This PR adopts lcAny in more cases of type erasure in the new code
generator.

.github/workflows/build-template.yml

@@ -1,3 +1,4 @@
+# instantiated by ci.yml
 name: build-template
 on:
   workflow_call:
@@ -45,7 +46,7 @@ jobs:
       CCACHE_DIR: ${{ github.workspace }}/.ccache
       CCACHE_COMPRESS: true
       # current cache limit
-      CCACHE_MAXSIZE: 200M
+      CCACHE_MAXSIZE: 400M
       # squelch error message about missing nixpkgs channel
       NIX_BUILD_SHELL: bash
       LSAN_OPTIONS: max_leaks=10
@@ -97,32 +98,22 @@ jobs:
           sudo apt-get install -y gcc-multilib g++-multilib ccache libuv1-dev:i386 pkgconf:i386
         if: matrix.cmultilib
       - name: Cache
+        id: restore-cache
         if: matrix.name != 'Linux Lake'
-        uses: actions/cache@v4
+        uses: actions/cache/restore@v4
         with:
+          # NOTE: must be in sync with `save` below
           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
-      - name: Cache
-        if: matrix.name == 'Linux Lake'
-        uses: actions/cache@v4
-        with:
-          path: |
-            .ccache
-            build/stage1/**/*.trace
+            ${{ matrix.name == 'Linux Lake' && 'build/stage1/**/*.trace
             build/stage1/**/*.olean
             build/stage1/**/*.ilean
             build/stage1/**/*.c
-            build/stage1/**/*.c.o*
+            build/stage1/**/*.c.o*' || '' }}
           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: |
@@ -236,6 +227,7 @@ jobs:
           make -C build update-stage0 && rm -rf build/stage* && make -C build -j$NPROC
         if: matrix.name == 'Linux' && inputs.check-level >= 1
       - name: CCache stats
+        if: always()
         run: ccache -s
       - name: Show stacktrace for coredumps
         if: failure() && runner.os == 'Linux'
@@ -243,4 +235,17 @@ jobs:
           for c in $(find . -name core); do
             progbin="$(file $c | sed "s/.*execfn: '\([^']*\)'.*/\1/")"
             echo bt | $GDB/bin/gdb -q $progbin $c || true
-          done
+          done
+      - name: Save Cache
+        if: always() && steps.restore-cache.outputs.cache-hit != 'true'
+        uses: actions/cache/save@v4
+        with:
+          # NOTE: must be in sync with `restore` above
+          path: |
+            .ccache
+            ${{ matrix.name == 'Linux Lake' && 'build/stage1/**/*.trace
+            build/stage1/**/*.olean
+            build/stage1/**/*.ilean
+            build/stage1/**/*.c
+            build/stage1/**/*.c.o*' || '' }}
+          key: ${{ steps.restore-cache.outputs.cache-primary-key }}

.github/workflows/ci.yml

@@ -166,14 +166,19 @@ jobs:
                 // foreign code may be linked against more recent glibc
                 "CTEST_OPTIONS": "-E 'foreign'"
               },
+              // deactivated due to bugs
+              /*
               {
                 "name": "Linux Lake",
                 "os": large ? "nscloud-ubuntu-22.04-amd64-4x8" : "ubuntu-latest",
                 // just a secondary PR build job for now
                 "check-level": isPr ? 0 : 3,
                 "secondary": true,
-                "CMAKE_OPTIONS": "-DUSE_LAKE=ON"
+                "CMAKE_OPTIONS": "-DUSE_LAKE=ON",
+                // TODO: why does this fail?
+                "CTEST_OPTIONS": "-E 'scopedMacros'"
               },
+              */
               {
                 "name": "Linux",
                 "os": large ? "nscloud-ubuntu-22.04-amd64-4x8" : "ubuntu-latest",
@@ -182,10 +187,10 @@ jobs:
                 "check-level": 1,
               },
               {
-                "name": "Linux Debug",
+                "name": "Linux Reldebug",
                 "os": "ubuntu-latest",
                 "check-level": 2,
-                "CMAKE_PRESET": "debug",
+                "CMAKE_PRESET": "reldebug",
                 // exclude seriously slow/stackoverflowing tests
                 "CTEST_OPTIONS": "-E 'interactivetest|leanpkgtest|laketest|benchtest|bv_bitblast_stress|3807'"
               },
@@ -251,17 +256,18 @@ jobs:
                 "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*"
               },
-              {
-                "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/ -DPKG_CONFIG_EXECUTABLE=/usr/bin/i386-linux-gnu-pkg-config",
-                "cmultilib": true,
-                "release": true,
-                "check-level": 2,
-                "cross": true,
-                "shell": "bash -euxo pipefail {0}"
-              }
+              // Started running out of memory building expensive modules, a 2GB heap is just not that much even before fragmentation
+              //{
+              //  "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/ -DPKG_CONFIG_EXECUTABLE=/usr/bin/i386-linux-gnu-pkg-config",
+              //  "cmultilib": true,
+              //  "release": true,
+              //  "check-level": 2,
+              //  "cross": true,
+              //  "shell": "bash -euxo pipefail {0}"
+              //}
               // {
               //   "name": "Web Assembly",
               //   "os": "ubuntu-latest",
@@ -343,8 +349,6 @@ jobs:
 
   # This job creates releases from tags
   # (whether they are "unofficial" releases for experiments, or official releases when the tag is "v" followed by a semver string.)
-  # We do not attempt to automatically construct a changelog here:
-  # unofficial releases don't need them, and official release notes will be written by a human.
   release:
     if: startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest

.github/workflows/pr-release.yml

@@ -111,7 +111,7 @@ jobs:
 
       - name: 'Setup jq'
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
-        uses: dcarbone/install-jq-action@v3.0.1
+        uses: dcarbone/install-jq-action@v3.1.1
 
       # Check that the most recently nightly coincides with 'git merge-base HEAD master'
       - name: Check merge-base and nightly-testing-YYYY-MM-DD

.gitignore

@@ -22,6 +22,7 @@ settings.json
 .gdb_history
 .vscode/*
 !.vscode/settings.json
+script/__pycache__
 *.produced.out
 CMakeSettings.json
 CppProperties.json

CMakeLists.txt

@@ -1,4 +1,7 @@
 cmake_minimum_required(VERSION 3.11)
+
+option(USE_MIMALLOC "use mimalloc" ON)
+
 # store all variables passed on the command line into CL_ARGS so we can pass them to the stage builds
 # https://stackoverflow.com/a/48555098/161659
 # MUST be done before call to 'project'
@@ -14,10 +17,12 @@ foreach(var ${vars})
     if("${var}" MATCHES "USE_GMP|CHECK_OLEAN_VERSION")
       # must forward options that generate incompatible .olean format
       list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
-    endif()
-    if("${var}" MATCHES "LLVM*|PKG_CONFIG|USE_LAKE")
+    elseif("${var}" MATCHES "LLVM*|PKG_CONFIG|USE_LAKE|USE_MIMALLOC")
       list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
     endif()
+  elseif("${var}" MATCHES "USE_MIMALLOC")
+    list(APPEND CL_ARGS "-D${var}=${${var}}")
+    list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
   elseif(("${var}" MATCHES "CMAKE_.*") AND NOT ("${var}" MATCHES "CMAKE_BUILD_TYPE") AND NOT ("${var}" MATCHES "CMAKE_HOME_DIRECTORY"))
     list(APPEND PLATFORM_ARGS "-D${var}=${${var}}")
   endif()
@@ -55,11 +60,23 @@ if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
       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")
+    list(APPEND EXTRA_DEPENDS cadical)
   endif()
   list(APPEND CL_ARGS -DCADICAL=${CADICAL})
 endif()
 
+if (USE_MIMALLOC)
+  ExternalProject_add(mimalloc
+    PREFIX mimalloc
+    GIT_REPOSITORY https://github.com/microsoft/mimalloc
+    GIT_TAG v2.2.3
+    # just download, we compile it as part of each stage as it is small
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND "")
+  list(APPEND EXTRA_DEPENDS mimalloc)
+endif()
+
 ExternalProject_add(stage0
   SOURCE_DIR "${LEAN_SOURCE_DIR}/stage0"
   SOURCE_SUBDIR src
@@ -91,6 +108,7 @@ ExternalProject_add(stage2
   INSTALL_COMMAND ""
   DEPENDS stage1
   EXCLUDE_FROM_ALL ON
+  STEP_TARGETS configure
 )
 ExternalProject_add(stage3
   SOURCE_DIR "${LEAN_SOURCE_DIR}"

CMakePresets.json

@@ -16,26 +16,39 @@
       "name": "debug",
       "displayName": "Debug build config",
       "cacheVariables": {
+        "LEAN_EXTRA_CXX_FLAGS": "-DLEAN_DEFAULT_THREAD_STACK_SIZE=16*1024*1024",
         "CMAKE_BUILD_TYPE": "Debug"
       },
       "generator": "Unix Makefiles",
       "binaryDir": "${sourceDir}/build/debug"
     },
+    {
+      "name": "reldebug",
+      "displayName": "Release with debug info build config",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "RelWithDebInfo"
+      },
+      "generator": "Unix Makefiles",
+      "binaryDir": "${sourceDir}/build/reldebug"
+    },
     {
       "name": "sanitize",
       "displayName": "Sanitize build config",
       "cacheVariables": {
-        "LEAN_EXTRA_CXX_FLAGS": "-fsanitize=address,undefined",
-        "LEANC_EXTRA_CC_FLAGS": "-fsanitize=address,undefined -fsanitize-link-c++-runtime",
+        "LEAN_EXTRA_CXX_FLAGS": "-fsanitize=address,undefined -DLEAN_DEFAULT_THREAD_STACK_SIZE=16*1024*1024",
+        "LEANC_EXTRA_CC_FLAGS": "-fsanitize=address,undefined",
+        "LEAN_EXTRA_LINKER_FLAGS": "-fsanitize=address,undefined -fsanitize-link-c++-runtime",
         "SMALL_ALLOCATOR": "OFF",
-        "BSYMBOLIC": "OFF"
+        "USE_MIMALLOC": "OFF",
+        "BSYMBOLIC": "OFF",
+        "LEAN_TEST_VARS": "MAIN_STACK_SIZE=16000"
       },
       "generator": "Unix Makefiles",
       "binaryDir": "${sourceDir}/build/sanitize"
     },
     {
       "name": "sandebug",
-      "inherits": ["debug", "sanitize"],
+      "inherits": ["sanitize", "debug"],
       "displayName": "Sanitize+debug build config",
       "binaryDir": "${sourceDir}/build/sandebug"
     }
@@ -49,6 +62,10 @@
       "name": "debug",
       "configurePreset": "debug"
     },
+    {
+      "name": "reldebug",
+      "configurePreset": "reldebug"
+    },
     {
       "name": "sanitize",
       "configurePreset": "sanitize"
@@ -69,6 +86,11 @@
       "configurePreset": "debug",
       "inherits": "release"
     },
+    {
+      "name": "reldebug",
+      "configurePreset": "reldebug",
+      "inherits": "release"
+    },
     {
       "name": "sanitize",
       "configurePreset": "sanitize",

RELEASES.md

@@ -4,9 +4,6 @@ We intend to provide regular "minor version" releases of the Lean language at ap
 There is not yet a strong guarantee of backwards compatibility between versions,
 only an expectation that breaking changes will be documented in the release notes.
 
-The folder [releases/](https://github.com/leanprover/lean4/tree/master/releases)
-contains work-in-progress notes for the upcoming release, as well as previous stable releases.
-
-Please check the [releases](https://github.com/leanprover/lean4/releases) page for the current status
-of each version.
+[Release notes](https://lean-lang.org/doc/reference/latest/releases/#release-notes) are available in the Lean language reference.
 
+Release notes for the current release candidate are available on the GitHub [releases](https://github.com/leanprover/lean4/releases) page.

doc/dev/release_checklist.md

@@ -5,125 +5,75 @@ See below for the checklist for release candidates.
 
 We'll use `v4.6.0` as the intended release version as a running example.
 
-- Run `scripts/release_checklist.py v4.6.0` to check the status of the release.
-  This script is purely informational, idempotent, and safe to run at any stage of the release process.
+- Run `script/release_checklist.py v4.6.0` to check the status of the release.
+  This script is idempotent, and should be safe to run at any stage of the release process.
+  Note that as of v4.19.0, this script takes some autonomous actions, which can be prevented via `--dry-run`.
 - `git checkout releases/v4.6.0`
   (This branch should already exist, from the release candidates.)
 - `git pull`
 - In `src/CMakeLists.txt`, verify you see
   - `set(LEAN_VERSION_MINOR 6)` (for whichever `6` is appropriate)
   - `set(LEAN_VERSION_IS_RELEASE 1)`
-  - (both of these should already be in place from the release candidates)
+  - (all of these should already be in place from the release candidates)
 - `git tag v4.6.0`
 - `git push $REMOTE v4.6.0`, where `$REMOTE` is the upstream Lean repository (e.g., `origin`, `upstream`)
 - Now wait, while CI runs.
   - You can monitor this at `https://github.com/leanprover/lean4/actions/workflows/ci.yml`,
     looking for the `v4.6.0` tag.
-  - This step can take up to an hour.
+  - This step can take up to two hours.
   - If you are intending to cut the next release candidate on the same day,
     you may want to start on the release candidate checklist now.
 - Next we need to prepare the release notes.
   - If the stable release is identical to the last release candidate (this should usually be the case),
-    you can reuse the release notes from `RELEASES.md`.
+    you can reuse the release notes that are already in the Lean Language Reference.
   - If you want to regenerate the release notes,
-    use `script/release_notes.py --since v4.5.0`, run on the `releases/v4.6.0` branch,
+    run `script/release_notes.py --since v4.5.0` on the `releases/v4.6.0` branch,
     and see the section "Writing the release notes" below for more information.
-  - Release notes should go in `RELEASES.md` on the `releases/v4.6.0` branch,
-    and should also be PR'd to `master` (suggested title: "chore: update release notes for v4.6.0").
+  - Release notes live in https://github.com/leanprover/reference-manual, in e.g. `Manual/Releases/v4.6.0.lean`.
+    It's best if you update these at the same time as a you update the `lean-toolchain` for the `reference-manual` repository, see below.
 - Go to https://github.com/leanprover/lean4/releases and verify that the `v4.6.0` release appears.
   - Verify on Github that "Set as the latest release" is checked.
-  - Copy the generated release note into the text box, adding the header
-    ```
-    v4.6.0
-    ----------
-    ```
 - Next, we will move a curated list of downstream repos to the latest stable release.
   - In order to have the access rights to push to these repositories and merge PRs,
     you will need to be a member of the `lean-release-managers` team at both `leanprover-community` and `leanprover`.
     Contact Kim Morrison (@kim-em) to arrange access.
-  - For each of the repositories listed below:
-    - Make a PR to `master`/`main` changing the toolchain to `v4.6.0`
-      - The usual branch name would be `bump_to_v4.6.0`.
-      - Update the toolchain file
-      - In the Lakefile, if there are dependencies on specific version tags of dependencies that you've already pushed as part of this process, update them to the new tag.
-        If they depend on `main` or `master`, don't change this; you've just updated the dependency, so it will work and be saved in the manifest
+  - For each of the repositories listed in `script/release_repos.yml`,
+    - Run `script/release_steps.py v4.6.0 <repo>` (e.g. replacing `<repo>` with `batteries`), which will walk you through the following steps:
+      - Create a new branch off `master`/`main` (as specified in the `branch` field), called `bump_to_v4.6.0`.
+      - Update the contents of `lean-toolchain` to `leanprover/lean4:v4.6.0`.
+      - In the `lakefile.toml` or `lakefile.lean`, if there are dependencies on specific version tags of dependencies, update them to the new tag.
+        If they depend on `main` or `master`, don't change this; you've just updated the dependency, so `lake update` will take care of modifying the manifest.
       - Run `lake update`
-      - The PR title should be "chore: bump toolchain to v4.6.0".
+      - Commit the changes as `chore: bump toolchain to v4.6.0` and push.
+      - Create a PR with title "chore: bump toolchain to v4.6.0".
     - Merge the PR once CI completes.
-    - Create the tag `v4.6.0` from `master`/`main` and push it.
-    - Merge the tag `v4.6.0` into the `stable` branch and push it.
-  - We do this for the repositories:
-    - [Batteries](https://github.com/leanprover-community/batteries)
-      - No dependencies
-      - Toolchain bump PR
-      - Create and push the tag
-      - Merge the tag into `stable`
-    - [lean4checker](https://github.com/leanprover/lean4checker)
-      - No dependencies
-      - Toolchain bump PR
-      - Create and push the tag
-      - Merge the tag into `stable`
-    - [quote4](https://github.com/leanprover-community/quote4)
-      - No dependencies
-      - Toolchain bump PR
-      - Create and push the tag
-      - Merge the tag into `stable`
-    - [doc-gen4](https://github.com/leanprover/doc-gen4)
-      - Dependencies: exist, but they're not part of the release workflow
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - There is no `stable` branch; skip this step
-    - [Verso](https://github.com/leanprover/verso)
-      - Dependencies: exist, but they're not part of the release workflow
-      - The `SubVerso` dependency should be compatible with _every_ Lean release simultaneously, rather than following this workflow
+    - Re-running `script/release_checklist.py` will then create the tag `v4.6.0` from `master`/`main` and push it (unless `toolchain-tag: false` in the `release_repos.yml` file)
+    - `script/release_checklist.py` will then merge the tag `v4.6.0` into the `stable` branch and push it (unless `stable-branch: false` in the `release_repos.yml` file).
+  - Special notes on repositories with exceptional requirements:
+    - `doc-gen4` has addition dependencies which we do not update at each toolchain release, although occasionally these break and need to be updated manually.
+    - `verso`:
+      - The `subverso` dependency is unusual in that it needs to be compatible with _every_ Lean release simultaneously.
+        Usually you don't need to do anything.
+        If you think something is wrong here please contact David Thrane Christiansen (@david-christiansen)
       - Warnings during `lake update` and `lake build` are expected.
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - There is no `stable` branch; skip this step
-    - [Cli](https://github.com/leanprover/lean4-cli)
-      - No dependencies
-      - Toolchain bump PR
-      - Create and push the tag
-      - There is no `stable` branch; skip this step
-    - [ProofWidgets4](https://github.com/leanprover-community/ProofWidgets4)
-      - Dependencies: `Batteries`
-      - Note on versions and branches:
-        - `ProofWidgets` uses a sequential version tagging scheme, e.g. `v0.0.29`,
-          which does not refer to the toolchain being used.
-        - Make a new release in this sequence after merging the toolchain bump PR.
-        - `ProofWidgets` does not maintain a `stable` branch.
-      - Toolchain bump PR
-      - Create and push the tag, following the version convention of the repository
-    - [Aesop](https://github.com/leanprover-community/aesop)
-      - Dependencies: `Batteries`
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - Merge the tag into `stable`
-    - [import-graph](https://github.com/leanprover-community/import-graph)
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - There is no `stable` branch; skip this step
-    - [plausible](https://github.com/leanprover-community/plausible)
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - There is no `stable` branch; skip this step
-    - [Mathlib](https://github.com/leanprover-community/mathlib4)
-      - Dependencies: `Aesop`, `ProofWidgets4`, `lean4checker`, `Batteries`, `doc-gen4`, `quote4`, `import-graph`
-      - Toolchain bump PR notes:
-        - Upstream dependencies should use their `main` or `master` branch, not toolchain tags.
-          (Unlike for other repos.)
-        - Push the PR branch to the main Mathlib repository rather than a fork, or CI may not work reliably
-        - Create and push the tag
-        - Create a new branch from the tag, push it, and open a pull request against `stable`.
-          Coordinate with a Mathlib maintainer to get this merged.
-    - [REPL](https://github.com/leanprover-community/repl)
-      - Dependencies: `Mathlib` (for test code)
-      - Note that there are two copies of `lean-toolchain`/`lakefile.lean`:
-        in the root, and in `test/Mathlib/`. Edit both, and run `lake update` in both directories.
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - Merge the tag into `stable`
-- Run `script/release_checklist.py v4.6.0` again to check that everything is in order.
+    - `reference-manual`: the release notes generated by `script/release_notes.py` as described above must be included in
+      `Manual/Releases/v4.6.0.lean`, and `import` and `include` statements adding in `Manual/Releases.lean`. 
+    - `ProofWidgets4` uses a non-standard sequential version tagging scheme, e.g. `v0.0.29`, which does not refer to the toolchain being used.
+      You will need to identify the next available version number from https://github.com/leanprover-community/ProofWidgets4/releases,
+      and push a new tag after merging the PR to `main`.
+    - `mathlib4`:
+      - The `lakefile.toml` should always refer to dependencies via their `main` or `master` branch,
+        not a toolchain tag
+        (with the exception of `ProofWidgets4`, which *must* use a sequential version tag).
+      - Push the PR branch to the main Mathlib repository rather than a fork, or CI may not work reliably
+    - `repl`:
+      There are two copies of `lean-toolchain`/`lakefile.lean`:
+      in the root, and in `test/Mathlib/`. Edit both, and run `lake update` in both directories.
+- An awkward situtation that sometimes occurs (e.g. with Verso) is that the `master`/`main` branch has already been moved
+  to a nightly toolchain that comes *after* the stable toolchain we are
+  targeting. In this case it is necessary to create a branch `releases/v4.6.0` from the last commit which was on
+  an earlier toolchain, move that branch to the stable toolchain, and create the toolchain tag from that branch.
+- Run `script/release_checklist.py v4.6.0` one last time to check that everything is in order.
 - Finally, make an announcement!
   This should go in https://leanprover.zulipchat.com/#narrow/stream/113486-announce, with topic `v4.6.0`.
   Please see previous announcements for suggested language.
@@ -131,14 +81,14 @@ We'll use `v4.6.0` as the intended release version as a running example.
   If there is a blog post, link to that from the zulip announcement.
 - Make sure that whoever is handling social media knows the release is out.
 
-## Optimistic(?) time estimates:
-- Initial checks and push the tag: 30 minutes.
-- Waiting for the release: 60 minutes.
-- Fixing release notes: 10 minutes.
-- Bumping toolchains in downstream repositories, up to creating the Mathlib PR: 30 minutes.
+## Time estimates:
+- Initial checks and push the tag: 10 minutes.
+- Waiting for the release: 120 minutes.
+- Preparing release notes: 10 minutes.
+- Bumping toolchains in downstream repositories, up to creating the Mathlib PR: 60 minutes.
 - Waiting for Mathlib CI and bors: 120 minutes.
-- Finalizing Mathlib tags and stable branch, and updating REPL: 15 minutes.
-- Posting announcement and/or blog post: 20 minutes.
+- Finalizing Mathlib tags and stable branch, and updating REPL: 20 minutes.
+- Posting announcement and/or blog post: 30 minutes.
 
 # Creating a release candidate.
 
@@ -150,6 +100,8 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
   We will use `nightly-2024-02-29` in this example.
 - It is essential to choose the nightly that will become the release candidate as early as possible, to avoid confusion.
 - Throughout this process you can use `script/release_checklist.py v4.7.0-rc1` to track progress.
+  This script will also try to do some steps autonomously. It is idempotent and safe to run at any point.
+  You can prevent it taking any actions using `--dry-run`.
 - It is essential that Batteries and Mathlib already have reviewed branches compatible with this nightly.
   - Check that both Batteries and Mathlib's `bump/v4.7.0` branch contain `nightly-2024-02-29`
     in their `lean-toolchain`.
@@ -160,8 +112,8 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
     git fetch nightly tag nightly-2024-02-29
     git checkout nightly-2024-02-29
     git checkout -b releases/v4.7.0
+    git push --set-upstream origin releases/v4.18.0
     ```
-- In `RELEASES.md` replace `Development in progress` in the `v4.7.0` section with `Release notes to be written.`
 - In `src/CMakeLists.txt`,
   - verify that you see `set(LEAN_VERSION_MINOR 7)` (for whichever `7` is appropriate); this should already have been updated when the development cycle began.
   - change the `LEAN_VERSION_IS_RELEASE` line to `set(LEAN_VERSION_IS_RELEASE 1)` (this should be a change; on `master` and nightly releases it is always `0`).
@@ -169,66 +121,55 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
 - `git tag v4.7.0-rc1`
 - `git push origin v4.7.0-rc1`
 - Now wait, while CI runs.
+  - The CI setup parses the tag to discover the `-rc1` special description, and passes it to `cmake` using a `-D` option. The `-rc1` doesn't need to be placed in the configuration file.
   - 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).
-  - Generate release notes by running `script/release_notes.py --since v4.6.0` on the `releases/v4.7.0` branch.
+  - This step can take up to two hours.
+- Verify that the release appears at https://github.com/leanprover/lean4/releases/, marked as a prerelease (this should have been done automatically by the CI release job).
+- Next we need to prepare the release notes.
+  - Run `script/release_notes.py --since v4.6.0` on the `releases/v4.7.0` branch,
+    which will report diagnostic messages on `stderr`
+    (including reporting commits that it couldn't associate with a PR, and hence will be omitted)
+    and then a chunk of markdown on `stdout`.
     See the section "Writing the release notes" below for more information.
+  - Release notes live in https://github.com/leanprover/reference-manual, in e.g. `Manual/Releases/v4.7.0.lean`.
+    It's best if you update these at the same time as a you update the `lean-toolchain` for the `reference-manual` repository, see below. 
 - 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.
-  - 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.
-  - We do this for the same list of repositories as for stable releases, see above.
+    * Note that sometimes there are *unreviewed* but necessary changes on the `nightly-testing` branch of the repository.
+      If so, you will need to merge these into the `bump_to_v4.7.0-rc1` branch manually.
+  - For each of the repositories listed in `script/release_repos.yml`,
+    - Run `script/release_steps.py v4.7.0-rc1 <repo>` (e.g. replacing `<repo>` with `batteries`), which will walk you through the following steps:
+      - Create a new branch off `master`/`main` (as specified in the `branch` field), called `bump_to_v4.7.0-rc1`.
+      - Merge `origin/bump/v4.7.0` if relevant (i.e. `bump-branch: true` appears in `release_repos.yml`).
+      - Update the contents of `lean-toolchain` to `leanprover/lean4:v4.7.0-rc1`.
+      - In the `lakefile.toml` or `lakefile.lean`, if there are dependencies on `nightly-testing`, `bump/v4.7.0`, or specific version tags, update them to the new tag.
+        If they depend on `main` or `master`, don't change this; you've just updated the dependency, so `lake update` will take care of modifying the manifest.
+      - Run `lake update`
+      - Run `lake build && if lake check-test; then lake test; fi` to check things are working.
+      - Commit the changes as `chore: bump toolchain to v4.7.0-rc1` and push.
+      - Create a PR with title "chore: bump toolchain to v4.7.0-rc1".
+    - Merge the PR once CI completes.
+    - Re-running `script/release_checklist.py` will then create the tag `v4.7.0-rc1` from `master`/`main` and push it (unless `toolchain-tag: false` in the `release_repos.yml` file)
+  - We do this for the same list of repositories as for stable releases, see above for notes about special cases.
     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!
   - It is essential for Mathlib and Batteries CI that you then create the next `bump/v4.8.0` branch
     for the next development cycle.
     Set the `lean-toolchain` file on this branch to same `nightly` you used for this release.
-  - (Note: we're currently uncertain if we really want to do this step. Check with Kim Morrison if you're unsure.)
-    For Batteries/Aesop/Mathlib, which maintain a `nightly-testing` branch, make sure there is a tag
-    `nightly-testing-2024-02-29` with date corresponding to the nightly used for the release
-    (create it if not), and then on the `nightly-testing` branch `git reset --hard master`, and force push.
+- Run `script/release_checklist.py v4.7.0-rc1` one last time to check that everything is in order.
 - Make an announcement!
   This should go in https://leanprover.zulipchat.com/#narrow/stream/113486-announce, with topic `v4.7.0-rc1`.
   Please see previous announcements for suggested language.
   You will want a few bullet points for main topics from the release notes.
   Please also make sure that whoever is handling social media knows the release is out.
 - Begin the next development cycle (i.e. for `v4.8.0`) on the Lean repository, by making a PR that:
+  - Uses branch name `dev_cycle_v4.8`.
   - Updates `src/CMakeLists.txt` to say `set(LEAN_VERSION_MINOR 8)`
-  - Replaces the "release notes will be copied" text in the `v4.6.0` section of `RELEASES.md` with the
-    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.
-    ```
-    and inserts the following section before that section:
-    ```
-    v4.8.0
-    ----------
-    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.
 Similar process, but more things go wrong.
@@ -273,7 +214,7 @@ Run this as `script/release_notes.py --since v4.6.0`, where `v4.6.0` is the *pre
 This script should be run on the `releases/v4.7.0` branch.
 This will generate output for all commits since that tag.
 Note that there is output on both stderr, which should be manually reviewed,
-and on stdout, which should be manually copied to `RELEASES.md`.
+and on stdout, which should be manually copied into the `reference-manual` repository, in the file `Manual/Releases/v4.7.0.lean`.
 
 The output on stderr should mostly be about commits for which the script could not find an associated PR,
 usually because a PR was rebase-merged because it contained an update to stage0.
@@ -281,12 +222,4 @@ Some judgement is required here: ignore commits which look minor,
 but manually add items to the release notes for significant PRs that were rebase-merged.
 
 There can also be pre-written entries in `./releases_drafts`, which should be all incorporated in the release notes and then deleted from the branch.
-  See `./releases_drafts/README.md` for more information.
-
-# `release_checklist.py`
-
-The script `script/release_checklist.py` attempts to automate checking the status of the release.
-
-Future improvements:
-* We check the release notes have been posted on Github,
-  but do not check that they are present in `RELEASES.md` on the release branch or on `master`.
+See `./releases_drafts/README.md` for more information.

doc/setup.md

@@ -7,7 +7,7 @@ Platforms built & tested by our CI, available as binary releases via elan (see b
 * x86-64 Linux with glibc 2.26+
 * x86-64 macOS 10.15+
 * aarch64 (Apple Silicon) macOS 10.15+
-* x86-64 Windows 11 (any version), Windows 10 (version 1903 or higher), Windows Server 2022
+* x86-64 Windows 11 (any version), Windows 10 (version 1903 or higher), Windows Server 2022, Windows Server 2025
 
 ### Tier 2
 

nix/bootstrap.nix

@@ -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 = ["-DSMALL_ALLOCATOR=ON" "-DUSE_MIMALLOC=OFF"] ++ (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" ];
     preConfigure = args.preConfigure or "" + ''
       # ignore absence of submodule
       sed -i 's!lake/Lake.lean!!' CMakeLists.txt

nix/buildLeanPackage.nix

@@ -159,7 +159,7 @@ with builtins; let
       dir=$(dirname $relpath)
       mkdir -p $dir $out/$dir $ilean/$dir $c/$dir
       if [ -d $src ]; then cp -r $src/. .; else cp $src $leanPath; fi
-      lean -o $out/$oleanPath -i $ilean/$ileanPath -c $c/$cPath $leanPath $leanFlags $leanPluginFlags $leanLoadDynlibFlags
+      lean -o $out/$oleanPath -i $out/$ileanPath -c $c/$cPath $leanPath $leanFlags $leanPluginFlags $leanLoadDynlibFlags
     '';
   }) // {
     inherit deps;

releases/v4.0.0-m4.md

@@ -1,292 +0,0 @@
-v4.0.0-m4 (23 March 2022)
----------
-
-* `simp` now takes user-defined simp-attributes. You can define a new `simp` attribute by creating a file (e.g., `MySimp.lean`) containing
-  ```lean
-  import Lean
-  open Lean.Meta
-
-  initialize my_ext : SimpExtension ← registerSimpAttr `my_simp "my own simp attribute"
-  ```
-  If you don't need to access `my_ext`, you can also use the macro
-  ```lean
-  import Lean
-
-  register_simp_attr my_simp "my own simp attribute"
-  ```
-  Recall that the new `simp` attribute is not active in the Lean file where it was defined.
-  Here is a small example using the new feature.
-  ```lean
-  import MySimp
-
-  def f (x : Nat) := x + 2
-  def g (x : Nat) := x + 1
-
-  @[my_simp] theorem f_eq : f x = x + 2 := rfl
-  @[my_simp] theorem g_eq : g x = x + 1 := rfl
-
-  example : f x + g x = 2*x + 3 := by
-    simp_arith [my_simp]
-  ```
-
-* Extend `match` syntax: multiple left-hand-sides in a single alternative. Example:
-  ```lean
-  def fib : Nat → Nat
-  | 0 | 1 => 1
-  | n+2 => fib n + fib (n+1)
-  ```
-  This feature was discussed at [issue 371](https://github.com/leanprover/lean4/issues/371). It was implemented as a macro expansion. Thus, the following is accepted.
-  ```lean
-  inductive StrOrNum where
-    | S (s : String)
-    | I (i : Int)
-
-  def StrOrNum.asString (x : StrOrNum) :=
-    match x with
-    | I a | S a => toString a
-  ```
-
-
-* Improve `#eval` command. Now, when it fails to synthesize a `Lean.MetaEval` instance for the result type, it reduces the type and tries again. The following example now works without additional annotations
-  ```lean
-  def Foo := List Nat
-
-  def test (x : Nat) : Foo :=
-    [x, x+1, x+2]
-
-  #eval test 4
-  ```
-
-* `rw` tactic can now apply auto-generated equation theorems for a given definition. Example:
-  ```lean
-  example (a : Nat) (h : n = 1) : [a].length = n := by
-    rw [List.length]
-    trace_state -- .. |- [].length + 1 = n
-    rw [List.length]
-    trace_state -- .. |- 0 + 1 = n
-    rw [h]
-  ```
-
-* [Fuzzy matching for auto completion](https://github.com/leanprover/lean4/pull/1023)
-
-* Extend dot-notation `x.field` for arrow types. If type of `x` is an arrow, we look up for `Function.field`.
-For example, given `f : Nat → Nat` and `g : Nat → Nat`, `f.comp g` is now notation for `Function.comp f g`.
-
-* The new `.<identifier>` notation is now also accepted where a function type is expected.
-  ```lean
-  example (xs : List Nat) : List Nat := .map .succ xs
-  example (xs : List α) : Std.RBTree α ord := xs.foldl .insert ∅
-  ```
-
-* [Add code folding support to the language server](https://github.com/leanprover/lean4/pull/1014).
-
-* Support notation `let <pattern> := <expr> | <else-case>` in `do` blocks.
-
-* Remove support for "auto" `pure`. In the [Zulip thread](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/for.2C.20unexpected.20need.20for.20type.20ascription/near/269083574), the consensus seemed to be that "auto" `pure` is more confusing than it's worth.
-
-* Remove restriction in `congr` theorems that all function arguments on the left-hand-side must be free variables. For example, the following theorem is now a valid `congr` theorem.
-  ```lean
-  @[congr]
-  theorem dep_congr [DecidableEq ι] {p : ι → Set α} [∀ i, Inhabited (p i)] :
-                    ∀ {i j} (h : i = j) (x : p i) (y : α) (hx : x = y), Pi.single (f := (p ·)) i x = Pi.single (f := (p ·)) j ⟨y, hx ▸ h ▸ x.2⟩ :=
-  ```
-
-* [Partially applied congruence theorems.](https://github.com/leanprover/lean4/issues/988)
-
-* Improve elaboration postponement heuristic when expected type is a metavariable. Lean now reduces the expected type before performing the test.
-
-* [Remove deprecated leanpkg](https://github.com/leanprover/lean4/pull/985) in favor of [Lake](https://github.com/leanprover/lake) now bundled with Lean.
-
-* Various improvements to go-to-definition & find-all-references accuracy.
-
-* Auto generated congruence lemmas with support for casts on proofs and `Decidable` instances (see [wishlist](https://github.com/leanprover/lean4/issues/988)).
-
-* Rename option `autoBoundImplicitLocal` => `autoImplicit`.
-
-* [Relax auto-implicit restrictions](https://github.com/leanprover/lean4/pull/1011). The command `set_option relaxedAutoImplicit false` disables the relaxations.
-
-* `contradiction` tactic now closes the goal if there is a `False.elim` application in the target.
-
-* Renamed tatic `byCases` => `by_cases` (motivation: enforcing naming convention).
-
-* Local instances occurring in patterns are now considered by the type class resolution procedure. Example:
-  ```lean
-  def concat : List ((α : Type) × ToString α × α) → String
-    | [] => ""
-    | ⟨_, _, a⟩ :: as => toString a ++ concat as
-  ```
-
-* Notation for providing the motive for `match` expressions has changed.
-  before:
-  ```lean
-  match x, rfl : (y : Nat) → x = y → Nat with
-  | 0,   h => ...
-  | x+1, h => ...
-  ```
-  now:
-  ```lean
-  match (motive := (y : Nat) → x = y → Nat) x, rfl with
-  | 0,   h => ...
-  | x+1, h => ...
-  ```
-  With this change, the notation for giving names to equality proofs in `match`-expressions is not whitespace sensitive anymore. That is,
-  we can now write
-  ```lean
-  match h : sort.swap a b with
-  | (r₁, r₂) => ... -- `h : sort.swap a b = (r₁, r₂)`
-  ```
-
-* `(generalizing := true)` is the default behavior for `match` expressions even if the expected type is not a proposition. In the following example, we used to have to include `(generalizing := true)` manually.
-  ```lean
-  inductive Fam : Type → Type 1 where
-    | any : Fam α
-    | nat : Nat → Fam Nat
-
-  example (a : α) (x : Fam α) : α :=
-    match x with
-    | Fam.any   => a
-    | Fam.nat n => n
-  ```
-
-* We now use `PSum` (instead of `Sum`) when compiling mutually recursive definitions using well-founded recursion.
-
-* Better support for parametric well-founded relations. See [issue #1017](https://github.com/leanprover/lean4/issues/1017). This change affects the low-level `termination_by'` hint because the fixed prefix of the function parameters in not "packed" anymore when constructing the well-founded relation type. For example, in the following definition, `as` is part of the fixed prefix, and is not packed anymore. In previous versions, the `termination_by'` term would be written as `measure fun ⟨as, i, _⟩ => as.size - i`
-  ```lean
-  def sum (as : Array Nat) (i : Nat) (s : Nat) : Nat :=
-    if h : i < as.size then
-      sum as (i+1) (s + as.get ⟨i, h⟩)
-    else
-      s
-  termination_by' measure fun ⟨i, _⟩ => as.size - i
-  ```
-
-* Add `while <cond> do <do-block>`, `repeat <do-block>`, and `repeat <do-block> until <cond>` macros for `do`-block. These macros are based on `partial` definitions, and consequently are useful only for writing programs we don't want to prove anything about.
-
-* Add `arith` option to `Simp.Config`, the macro `simp_arith` expands to `simp (config := { arith := true })`. Only `Nat` and linear arithmetic is currently supported. Example:
-  ```lean
-  example : 0 < 1 + x ∧ x + y + 2 ≥ y + 1 := by
-    simp_arith
-  ```
-
-* Add `fail <string>?` tactic that always fail.
-
-* Add support for acyclicity at dependent elimination. See [issue #1022](https://github.com/leanprover/lean4/issues/1022).
-
-* Add `trace <string>` tactic for debugging purposes.
-
-* Add nontrivial `SizeOf` instance for types `Unit → α`, and add support for them in the auto-generated `SizeOf` instances for user-defined inductive types. For example, given the inductive datatype
-  ```lean
-  inductive LazyList (α : Type u) where
-    | nil                               : LazyList α
-    | cons (hd : α) (tl : LazyList α)   : LazyList α
-    | delayed (t : Thunk (LazyList α))  : LazyList α
-  ```
-  we now have `sizeOf (LazyList.delayed t) = 1 + sizeOf t` instead of `sizeOf (LazyList.delayed t) = 2`.
-
-* Add support for guessing (very) simple well-founded relations when proving termination. For example, the following function does not require a `termination_by` annotation anymore.
-  ```lean
-  def Array.insertAtAux (i : Nat) (as : Array α) (j : Nat) : Array α :=
-    if h : i < j then
-      let as := as.swap! (j-1) j;
-      insertAtAux i as (j-1)
-    else
-      as
-  ```
-
-* Add support for `for h : x in xs do ...` notation where `h : x ∈ xs`. This is mainly useful for showing termination.
-
-* Auto implicit behavior changed for inductive families. An auto implicit argument occurring in inductive family index is also treated as an index (IF it is not fixed, see next item). For example
-  ```lean
-  inductive HasType : Index n → Vector Ty n → Ty → Type where
-  ```
-  is now interpreted as
-  ```lean
-  inductive HasType : {n : Nat} → Index n → Vector Ty n → Ty → Type where
-  ```
-
-* To make the previous feature more convenient to use, we promote a fixed prefix of inductive family indices to parameters. For example, the following declaration is now accepted by Lean
-  ```lean
-  inductive Lst : Type u → Type u
-    | nil  : Lst α
-    | cons : α → Lst α → Lst α
-  ```
-  and `α` in `Lst α` is a parameter. The actual number of parameters can be inspected using the command `#print Lst`. This feature also makes sure we still accept the declaration
-  ```lean
-  inductive Sublist : List α → List α → Prop
-    | slnil : Sublist [] []
-    | cons l₁ l₂ a : Sublist l₁ l₂ → Sublist l₁ (a :: l₂)
-    | cons2 l₁ l₂ a : Sublist l₁ l₂ → Sublist (a :: l₁) (a :: l₂)
-  ```
-
-* Added auto implicit "chaining". Unassigned metavariables occurring in the auto implicit types now become new auto implicit locals. Consider the following example:
-  ```lean
-  inductive HasType : Fin n → Vector Ty n → Ty → Type where
-    | stop : HasType 0 (ty :: ctx) ty
-    | pop  : HasType k ctx ty → HasType k.succ (u :: ctx) ty
-  ```
-  `ctx` is an auto implicit local in the two constructors, and it has type `ctx : Vector Ty ?m`. Without auto implicit "chaining", the metavariable `?m` will remain unassigned. The new feature creates yet another implicit local `n : Nat` and assigns `n` to `?m`. So, the declaration above is shorthand for
-  ```lean
-  inductive HasType : {n : Nat} → Fin n → Vector Ty n → Ty → Type where
-    | stop : {ty : Ty} → {n : Nat} → {ctx : Vector Ty n} → HasType 0 (ty :: ctx) ty
-    | pop  : {n : Nat} → {k : Fin n} → {ctx : Vector Ty n} → {ty : Ty} → HasType k ctx ty → HasType k.succ (u :: ctx) ty
-  ```
-
-* Eliminate auxiliary type annotations (e.g, `autoParam` and `optParam`) from recursor minor premises and projection declarations. Consider the following example
-  ```lean
-  structure A :=
-    x : Nat
-    h : x = 1 := by trivial
-
-  example (a : A) : a.x = 1 := by
-    have aux := a.h
-    -- `aux` has now type `a.x = 1` instead of `autoParam (a.x = 1) auto✝`
-    exact aux
-
-  example (a : A) : a.x = 1 := by
-    cases a with
-    | mk x h =>
-      -- `h` has now type `x = 1` instead of `autoParam (x = 1) auto✝`
-      assumption
-  ```
-
-* We now accept overloaded notation in patterns, but we require the set of pattern variables in each alternative to be the same. Example:
-  ```lean
-  inductive Vector (α : Type u) : Nat → Type u
-    | nil : Vector α 0
-    | cons : α → Vector α n → Vector α (n+1)
-
-  infix:67 " :: " => Vector.cons -- Overloading the `::` notation
-
-  def head1 (x : List α) (h : x ≠ []) : α :=
-    match x with
-    | a :: as => a -- `::` is `List.cons` here
-
-  def head2 (x : Vector α (n+1)) : α :=
-    match x with
-    | a :: as => a -- `::` is `Vector.cons` here
-  ```
-
-* New notation `.<identifier>` based on Swift. The namespace is inferred from the expected type. See [issue #944](https://github.com/leanprover/lean4/issues/944). Examples:
-  ```lean
-  def f (x : Nat) : Except String Nat :=
-    if x > 0 then
-      .ok x
-    else
-      .error "x is zero"
-
-  namespace Lean.Elab
-  open Lsp
-
-  def identOf : Info → Option (RefIdent × Bool)
-    | .ofTermInfo ti => match ti.expr with
-      | .const n .. => some (.const n, ti.isBinder)
-      | .fvar id .. => some (.fvar id, ti.isBinder)
-      | _ => none
-    | .ofFieldInfo fi => some (.const fi.projName, false)
-    | _ => none
-
-  def isImplicit (bi : BinderInfo) : Bool :=
-    bi matches .implicit
-
-  end Lean.Elab
-  ```

releases/v4.0.0-m5.md

@@ -1,715 +0,0 @@
-v4.0.0-m5 (07 August 2022)
----------
-
-* Update Lake to v4.0.0. See the [v4.0.0 release notes](https://github.com/leanprover/lake/releases/tag/v4.0.0) for detailed changes.
-
-* Mutual declarations in different namespaces are now supported. Example:
-  ```lean
-  mutual
-    def Foo.boo (x : Nat) :=
-      match x with
-      | 0 => 1
-      | x + 1 => 2*Boo.bla x
-
-    def Boo.bla (x : Nat) :=
-      match x with
-      | 0 => 2
-      | x+1 => 3*Foo.boo x
-  end
-  ```
-  A `namespace` is automatically created for the common prefix. Example:
-  ```lean
-  mutual
-    def Tst.Foo.boo (x : Nat) := ...
-    def Tst.Boo.bla (x : Nat) := ...
-  end
-  ```
-  expands to
-  ```lean
-  namespace Tst
-  mutual
-    def Foo.boo (x : Nat) := ...
-    def Boo.bla (x : Nat) := ...
-  end
-  end Tst
-  ```
-
-* Allow users to install their own `deriving` handlers for existing type classes.
-  See example at [Simple.lean](https://github.com/leanprover/lean4/blob/master/tests/pkg/deriving/UserDeriving/Simple.lean).
-
-* Add tactic `congr (num)?`. See doc string for additional details.
-
-* [Missing doc linter](https://github.com/leanprover/lean4/pull/1390)
-
-* `match`-syntax notation now checks for unused alternatives. See issue [#1371](https://github.com/leanprover/lean4/issues/1371).
-
-* Auto-completion for structure instance fields. Example:
-  ```lean
-  example : Nat × Nat := {
-    f -- HERE
-  }
-  ```
-  `fst` now appears in the list of auto-completion suggestions.
-
-* Auto-completion for dotted identifier notation. Example:
-  ```lean
-  example : Nat :=
-    .su -- HERE
-  ```
-  `succ` now appears in the list of auto-completion suggestions.
-
-* `nat_lit` is not needed anymore when declaring `OfNat` instances. See issues [#1389](https://github.com/leanprover/lean4/issues/1389) and [#875](https://github.com/leanprover/lean4/issues/875). Example:
-  ```lean
-  inductive Bit where
-    | zero
-    | one
-
-  instance inst0 : OfNat Bit 0 where
-    ofNat := Bit.zero
-
-  instance : OfNat Bit 1 where
-    ofNat := Bit.one
-
-  example : Bit := 0
-  example : Bit := 1
-  ```
-
-* Add `[elabAsElim]` attribute (it is called `elab_as_eliminator` in Lean 3). Motivation: simplify the Mathlib port to Lean 4.
-
-* `Trans` type class now accepts relations in `Type u`. See this [Zulip issue](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Calc.20mode/near/291214574).
-
-* Accept unescaped keywords as inductive constructor names. Escaping can often be avoided at use sites via dot notation.
-  ```lean
-  inductive MyExpr
-    | let : ...
-
-  def f : MyExpr → MyExpr
-    | .let ... => .let ...
-  ```
-
-* Throw an error message at parametric local instances such as `[Nat -> Decidable p]`. The type class resolution procedure
-  cannot use this kind of local instance because the parameter does not have a forward dependency.
-  This check can be disabled using `set_option checkBinderAnnotations false`.
-
-* Add option `pp.showLetValues`. When set to `false`, the info view hides the value of `let`-variables in a goal.
-  By default, it is `true` when visualizing tactic goals, and `false` otherwise.
-  See [issue #1345](https://github.com/leanprover/lean4/issues/1345) for additional details.
-
-* Add option `warningAsError`. When set to true, warning messages are treated as errors.
-
-* Support dotted notation and named arguments in patterns. Example:
-  ```lean
-  def getForallBinderType (e : Expr) : Expr :=
-    match e with
-    | .forallE (binderType := type) .. => type
-    | _ => panic! "forall expected"
-  ```
-
-* "jump-to-definition" now works for function names embedded in the following attributes
-  `@[implementedBy funName]`, `@[tactic parserName]`, `@[termElab parserName]`, `@[commandElab parserName]`,
-  `@[builtinTactic parserName]`, `@[builtinTermElab parserName]`, and `@[builtinCommandElab parserName]`.
-   See [issue #1350](https://github.com/leanprover/lean4/issues/1350).
-
-* Improve `MVarId` methods discoverability. See [issue #1346](https://github.com/leanprover/lean4/issues/1346).
-  We still have to add similar methods for `FVarId`, `LVarId`, `Expr`, and other objects.
-  Many existing methods have been marked as deprecated.
-
-* Add attribute `[deprecated]` for marking deprecated declarations. Examples:
-  ```lean
-  def g (x : Nat) := x + 1
-
-  -- Whenever `f` is used, a warning message is generated suggesting to use `g` instead.
-  @[deprecated g]
-  def f (x : Nat) := x + 1
-
-  #check f 0 -- warning: `f` has been deprecated, use `g` instead
-
-  -- Whenever `h` is used, a warning message is generated.
-  @[deprecated]
-  def h (x : Nat) := x + 1
-
-  #check h 0 -- warning: `h` has been deprecated
-  ```
-
-* Add type `LevelMVarId` (and abbreviation `LMVarId`) for universe level metavariable ids.
-  Motivation: prevent meta-programmers from mixing up universe and expression metavariable ids.
-
-* Improve `calc` term and tactic. See [issue #1342](https://github.com/leanprover/lean4/issues/1342).
-
-* [Relaxed antiquotation parsing](https://github.com/leanprover/lean4/pull/1272) further reduces the need for explicit `$x:p` antiquotation kind annotations.
-
-* Add support for computed fields in inductives. Example:
-  ```lean
-  inductive Exp
-    | var (i : Nat)
-    | app (a b : Exp)
-  with
-    @[computedField] hash : Exp → Nat
-      | .var i => i
-      | .app a b => a.hash * b.hash + 1
-  ```
-  The result of the `Exp.hash` function is then stored as an extra "computed" field in the `.var` and `.app` constructors;
-  `Exp.hash` accesses this field and thus runs in constant time (even on dag-like values).
-
-* Update `a[i]` notation. It is now based on the typeclass
-  ```lean
-  class GetElem (cont : Type u) (idx : Type v) (elem : outParam (Type w)) (dom : outParam (cont → idx → Prop)) where
-    getElem (xs : cont) (i : idx) (h : dom xs i) : Elem
-  ```
-  The notation `a[i]` is now defined as follows
-  ```lean
-  macro:max x:term noWs "[" i:term "]" : term => `(getElem $x $i (by get_elem_tactic))
-  ```
-  The proof that `i` is a valid index is synthesized using the tactic `get_elem_tactic`.
-  For example, the type `Array α` has the following instances
-  ```lean
-  instance : GetElem (Array α) Nat α fun xs i => LT.lt i xs.size where ...
-  instance : GetElem (Array α) USize α fun xs i => LT.lt i.toNat xs.size where ...
-  ```
-  You can use the notation `a[i]'h` to provide the proof manually.
-  Two other notations were introduced: `a[i]!` and `a[i]?`, For `a[i]!`, a panic error message is produced at
-  runtime if `i` is not a valid index. `a[i]?` has type `Option α`, and `a[i]?` evaluates to `none` if the
-  index `i` is not valid.
-  The three new notations are defined as follows:
-  ```lean
-  @[inline] def getElem' [GetElem cont idx elem dom] (xs : cont) (i : idx) (h : dom xs i) : elem :=
-  getElem xs i h
-
-  @[inline] def getElem! [GetElem cont idx elem dom] [Inhabited elem] (xs : cont) (i : idx) [Decidable (dom xs i)] : elem :=
-    if h : _ then getElem xs i h else panic! "index out of bounds"
-
-  @[inline] def getElem? [GetElem cont idx elem dom] (xs : cont) (i : idx) [Decidable (dom xs i)] : Option elem :=
-    if h : _ then some (getElem xs i h) else none
-
-  macro:max x:term noWs "[" i:term "]" noWs "?" : term => `(getElem? $x $i)
-  macro:max x:term noWs "[" i:term "]" noWs "!" : term => `(getElem! $x $i)
-  macro x:term noWs "[" i:term "]'" h:term:max : term => `(getElem' $x $i $h)
-  ```
-  See discussion on [Zulip](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/String.2EgetOp/near/287855425).
-  Examples:
-  ```lean
-  example (a : Array Int) (i : Nat) : Int :=
-    a[i] -- Error: failed to prove index is valid ...
-
-  example (a : Array Int) (i : Nat) (h : i < a.size) : Int :=
-    a[i] -- Ok
-
-  example (a : Array Int) (i : Nat) : Int :=
-    a[i]! -- Ok
-
-  example (a : Array Int) (i : Nat) : Option Int :=
-    a[i]? -- Ok
-
-  example (a : Array Int) (h : a.size = 2) : Int :=
-    a[0]'(by rw [h]; decide) -- Ok
-
-  example (a : Array Int) (h : a.size = 2) : Int :=
-    have : 0 < a.size := by rw [h]; decide
-    have : 1 < a.size := by rw [h]; decide
-    a[0] + a[1] -- Ok
-
-  example (a : Array Int) (i : USize) (h : i.toNat < a.size) : Int :=
-    a[i] -- Ok
-  ```
-  The `get_elem_tactic` is defined as
-  ```lean
-  macro "get_elem_tactic" : tactic =>
-    `(first
-      | get_elem_tactic_trivial
-      | fail "failed to prove index is valid, ..."
-     )
-  ```
-  The `get_elem_tactic_trivial` auxiliary tactic can be extended using `macro_rules`. By default, it tries `trivial`, `simp_arith`, and a special case for `Fin`. In the future, it will also try `linarith`.
-  You can extend `get_elem_tactic_trivial` using `my_tactic` as follows
-  ```lean
-  macro_rules
-  | `(tactic| get_elem_tactic_trivial) => `(tactic| my_tactic)
-  ```
-  Note that `Idx`'s type in `GetElem` does not depend on `Cont`. So, you cannot write the instance `instance : GetElem (Array α) (Fin ??) α fun xs i => ...`, but the Lean library comes equipped with the following auxiliary instance:
-  ```lean
-  instance [GetElem cont Nat elem dom] : GetElem cont (Fin n) elem fun xs i => dom xs i where
-    getElem xs i h := getElem xs i.1 h
-  ```
-  and helper tactic
-  ```lean
-  macro_rules
-  | `(tactic| get_elem_tactic_trivial) => `(tactic| apply Fin.val_lt_of_le; get_elem_tactic_trivial; done)
-  ```
-  Example:
-  ```lean
-  example (a : Array Nat) (i : Fin a.size) :=
-    a[i] -- Ok
-
-  example (a : Array Nat) (h : n ≤ a.size) (i : Fin n) :=
-    a[i] -- Ok
-  ```
-
-* Better support for qualified names in recursive declarations. The following is now supported:
-  ```lean
-  namespace Nat
-    def fact : Nat → Nat
-    | 0 => 1
-    | n+1 => (n+1) * Nat.fact n
-  end Nat
-  ```
-
-* Add support for `CommandElabM` monad at `#eval`. Example:
-  ```lean
-  import Lean
-
-  open Lean Elab Command
-
-  #eval do
-    let id := mkIdent `foo
-    elabCommand (← `(def $id := 10))
-
-  #eval foo -- 10
-  ```
-
-* Try to elaborate `do` notation even if the expected type is not available. We still delay elaboration when the expected type
-  is not available. This change is particularly useful when writing examples such as
-  ```lean
-  #eval do
-    IO.println "hello"
-    IO.println "world"
-  ```
-  That is, we don't have to use the idiom `#eval show IO _ from do ...` anymore.
-  Note that auto monadic lifting is less effective when the expected type is not available.
-  Monadic polymorphic functions (e.g., `ST.Ref.get`) also require the expected type.
-
-* On Linux, panics now print a backtrace by default, which can be disabled by setting the environment variable `LEAN_BACKTRACE` to `0`.
-  Other platforms are TBD.
-
-* The `group(·)` `syntax` combinator is now introduced automatically where necessary, such as when using multiple parsers inside `(...)+`.
-
-* Add ["Typed Macros"](https://github.com/leanprover/lean4/pull/1251): syntax trees produced and accepted by syntax antiquotations now remember their syntax kinds, preventing accidental production of ill-formed syntax trees and reducing the need for explicit `:kind` antiquotation annotations. See PR for details.
-
-* Aliases of protected definitions are protected too. Example:
-  ```lean
-  protected def Nat.double (x : Nat) := 2*x
-
-  namespace Ex
-  export Nat (double) -- Add alias Ex.double for Nat.double
-  end Ex
-
-  open Ex
-  #check Ex.double -- Ok
-  #check double -- Error, `Ex.double` is alias for `Nat.double` which is protected
-  ```
-
-* Use `IO.getRandomBytes` to initialize random seed for `IO.rand`. See discussion at [this PR](https://github.com/leanprover/lean4-samples/pull/2).
-
-* Improve dot notation and aliases interaction. See discussion on [Zulip](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Namespace-based.20overloading.20does.20not.20find.20exports/near/282946185) for additional details.
-  Example:
-  ```lean
-  def Set (α : Type) := α → Prop
-  def Set.union (s₁ s₂ : Set α) : Set α := fun a => s₁ a ∨ s₂ a
-  def FinSet (n : Nat) := Fin n → Prop
-
-  namespace FinSet
-    export Set (union) -- FinSet.union is now an alias for `Set.union`
-  end FinSet
-
-  example (x y : FinSet 10) : FinSet 10 :=
-    x.union y -- Works
-  ```
-
-* `ext` and `enter` conv tactics can now go inside let-declarations. Example:
-  ```lean
-  example (g : Nat → Nat) (y : Nat) (h : let x := y + 1; g (0+x) = x) : g (y + 1) = y + 1 := by
-    conv at h => enter [x, 1, 1]; rw [Nat.zero_add]
-    /-
-      g : Nat → Nat
-      y : Nat
-      h : let x := y + 1;
-          g x = x
-      ⊢ g (y + 1) = y + 1
-    -/
-    exact h
-  ```
-
-* Add `zeta` conv tactic to expand let-declarations. Example:
-  ```lean
-  example (h : let x := y + 1; 0 + x = y) : False := by
-    conv at h => zeta; rw [Nat.zero_add]
-    /-
-      y : Nat
-      h : y + 1 = y
-      ⊢ False
-    -/
-    simp_arith at h
-  ```
-
-* Improve namespace resolution. See issue [#1224](https://github.com/leanprover/lean4/issues/1224). Example:
-  ```lean
-  import Lean
-  open Lean Parser Elab
-  open Tactic -- now opens both `Lean.Parser.Tactic` and `Lean.Elab.Tactic`
-  ```
-
-* Rename `constant` command to `opaque`. See discussion at [Zulip](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/What.20is.20.60opaque.60.3F/near/284926171).
-
-* Extend `induction` and `cases` syntax: multiple left-hand-sides in a single alternative. This extension is very similar to the one implemented for `match` expressions. Examples:
-  ```lean
-  inductive Foo where
-    | mk1 (x : Nat) | mk2 (x : Nat) | mk3
-
-  def f (v : Foo) :=
-    match v with
-    | .mk1 x => x + 1
-    | .mk2 x => 2*x + 1
-    | .mk3   => 1
-
-  theorem f_gt_zero : f v > 0 := by
-    cases v with
-    | mk1 x | mk2 x => simp_arith!  -- New feature used here!
-    | mk3 => decide
-  ```
-
-* [`let/if` indentation in `do` blocks in now supported.](https://github.com/leanprover/lean4/issues/1120)
-
-* Add unnamed antiquotation `$_` for use in syntax quotation patterns.
-
-* [Add unused variables linter](https://github.com/leanprover/lean4/pull/1159). Feedback welcome!
-
-* Lean now generates an error if the body of a declaration body contains a universe parameter that does not occur in the declaration type, nor is an explicit parameter.
-  Examples:
-  ```lean
-  /-
-  The following declaration now produces an error because `PUnit` is universe polymorphic,
-  but the universe parameter does not occur in the function type `Nat → Nat`
-  -/
-  def f (n : Nat) : Nat :=
-    let aux (_ : PUnit) : Nat := n + 1
-    aux ⟨⟩
-
-  /-
-  The following declaration is accepted because the universe parameter was explicitly provided in the
-  function signature.
-  -/
-  def g.{u} (n : Nat) : Nat :=
-    let aux (_ : PUnit.{u}) : Nat := n + 1
-    aux ⟨⟩
-  ```
-
-* Add `subst_vars` tactic.
-
-* [Fix `autoParam` in structure fields lost in multiple inheritance.](https://github.com/leanprover/lean4/issues/1158).
-
-* Add `[eliminator]` attribute. It allows users to specify default recursor/eliminators for the `induction` and `cases` tactics.
-  It is an alternative for the `using` notation. Example:
-  ```lean
-  @[eliminator] protected def recDiag {motive : Nat → Nat → Sort u}
-      (zero_zero : motive 0 0)
-      (succ_zero : (x : Nat) → motive x 0 → motive (x + 1) 0)
-      (zero_succ : (y : Nat) → motive 0 y → motive 0 (y + 1))
-      (succ_succ : (x y : Nat) → motive x y → motive (x + 1) (y + 1))
-      (x y : Nat) :  motive x y :=
-    let rec go : (x y : Nat) → motive x y
-      | 0,     0 => zero_zero
-      | x+1, 0   => succ_zero x (go x 0)
-      | 0,   y+1 => zero_succ y (go 0 y)
-      | x+1, y+1 => succ_succ x y (go x y)
-    go x y
-  termination_by go x y => (x, y)
-
-  def f (x y : Nat) :=
-    match x, y with
-    | 0,   0   => 1
-    | x+1, 0   => f x 0
-    | 0,   y+1 => f 0 y
-    | x+1, y+1 => f x y
-  termination_by f x y => (x, y)
-
-  example (x y : Nat) : f x y > 0 := by
-    induction x, y <;> simp [f, *]
-  ```
-
-* Add support for `casesOn` applications to structural and well-founded recursion modules.
-  This feature is useful when writing definitions using tactics. Example:
-  ```lean
-  inductive Foo where
-    | a | b | c
-    | pair: Foo × Foo → Foo
-
-  def Foo.deq (a b : Foo) : Decidable (a = b) := by
-    cases a <;> cases b
-    any_goals apply isFalse Foo.noConfusion
-    any_goals apply isTrue rfl
-    case pair a b =>
-      let (a₁, a₂) := a
-      let (b₁, b₂) := b
-      exact match deq a₁ b₁, deq a₂ b₂ with
-      | isTrue h₁, isTrue h₂ => isTrue (by rw [h₁,h₂])
-      | isFalse h₁, _ => isFalse (fun h => by cases h; cases (h₁ rfl))
-      | _, isFalse h₂ => isFalse (fun h => by cases h; cases (h₂ rfl))
-  ```
-
-* `Option` is again a monad. The auxiliary type `OptionM` has been removed. See [Zulip thread](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Do.20we.20still.20need.20OptionM.3F/near/279761084).
-
-* Improve `split` tactic. It used to fail on `match` expressions of the form `match h : e with ...` where `e` is not a free variable.
-  The failure used to occur during generalization.
-
-
-* New encoding for `match`-expressions that use the `h :` notation for discriminants. The information is not lost during delaboration,
-  and it is the foundation for a better `split` tactic. at delaboration time. Example:
-  ```lean
-  #print Nat.decEq
-  /-
-  protected def Nat.decEq : (n m : Nat) → Decidable (n = m) :=
-  fun n m =>
-    match h : Nat.beq n m with
-    | true => isTrue (_ : n = m)
-    | false => isFalse (_ : ¬n = m)
-  -/
-  ```
-
-* `exists` tactic is now takes a comma separated list of terms.
-
-* Add `dsimp` and `dsimp!` tactics. They guarantee the result term is definitionally equal, and only apply
-  `rfl`-theorems.
-
-* Fix binder information for `match` patterns that use definitions tagged with `[matchPattern]` (e.g., `Nat.add`).
-  We now have proper binder information for the variable `y` in the following example.
-  ```lean
-  def f (x : Nat) : Nat :=
-    match x with
-    | 0 => 1
-    | y + 1 => y
-  ```
-
-* (Fix) the default value for structure fields may now depend on the structure parameters. Example:
-  ```lean
-  structure Something (i: Nat) where
-  n1: Nat := 1
-  n2: Nat := 1 + i
-
-  def s : Something 10 := {}
-  example : s.n2 = 11 := rfl
-  ```
-
-* Apply `rfl` theorems at the `dsimp` auxiliary method used by `simp`. `dsimp` can be used anywhere in an expression
-  because it preserves definitional equality.
-
-* Refine auto bound implicit feature. It does not consider anymore unbound variables that have the same
-  name of a declaration being defined. Example:
-  ```lean
-  def f : f → Bool := -- Error at second `f`
-    fun _ => true
-
-  inductive Foo : List Foo → Type -- Error at second `Foo`
-    | x : Foo []
-  ```
-  Before this refinement, the declarations above would be accepted and the
-  second `f` and `Foo` would be treated as auto implicit variables. That is,
-  `f : {f : Sort u} → f → Bool`, and
-  `Foo : {Foo : Type u} → List Foo → Type`.
-
-
-* Fix syntax highlighting for recursive declarations. Example
-  ```lean
-  inductive List (α : Type u) where
-    | nil : List α  -- `List` is not highlighted as a variable anymore
-    | cons (head : α) (tail : List α) : List α
-
-  def List.map (f : α → β) : List α → List β
-    | []    => []
-    | a::as => f a :: map f as -- `map` is not highlighted as a variable anymore
-  ```
-* Add `autoUnfold` option to `Lean.Meta.Simp.Config`, and the following macros
-  - `simp!` for `simp (config := { autoUnfold := true })`
-  - `simp_arith!` for `simp (config := { autoUnfold := true, arith := true })`
-  - `simp_all!` for `simp_all (config := { autoUnfold := true })`
-  - `simp_all_arith!` for `simp_all (config := { autoUnfold := true, arith := true })`
-
-  When the `autoUnfold` is set to true, `simp` tries to unfold the following kinds of definition
-  - Recursive definitions defined by structural recursion.
-  - Non-recursive definitions where the body is a `match`-expression. This
-    kind of definition is only unfolded if the `match` can be reduced.
-  Example:
-  ```lean
-  def append (as bs : List α) : List α :=
-    match as with
-    | [] => bs
-    | a :: as => a :: append as bs
-
-  theorem append_nil (as : List α) : append as [] = as := by
-    induction as <;> simp_all!
-
-  theorem append_assoc (as bs cs : List α) : append (append as bs) cs = append as (append bs cs) := by
-    induction as <;> simp_all!
-  ```
-
-* Add `save` tactic for creating checkpoints more conveniently. Example:
-  ```lean
-  example : <some-proposition> := by
-    tac_1
-    tac_2
-    save
-    tac_3
-    ...
-  ```
-  is equivalent to
-  ```lean
-  example : <some-proposition> := by
-    checkpoint
-      tac_1
-      tac_2
-    tac_3
-    ...
-  ```
-
-* Remove support for `{}` annotation from inductive datatype constructors. This annotation was barely used, and we can control the binder information for parameter bindings using the new inductive family indices to parameter promotion. Example: the following declaration using `{}`
-  ```lean
-  inductive LE' (n : Nat) : Nat → Prop where
-    | refl {} : LE' n n -- Want `n` to be explicit
-    | succ  : LE' n m → LE' n (m+1)
-  ```
-  can now be written as
-  ```lean
-  inductive LE' : Nat → Nat → Prop where
-    | refl (n : Nat) : LE' n n
-    | succ : LE' n m → LE' n (m+1)
-  ```
-  In both cases, the inductive family has one parameter and one index.
-  Recall that the actual number of parameters can be retrieved using the command `#print`.
-
-* Remove support for `{}` annotation in the `structure` command.
-
-* Several improvements to LSP server. Examples: "jump to definition" in mutually recursive sections, fixed incorrect hover information in "match"-expression patterns, "jump to definition" for pattern variables, fixed auto-completion in function headers, etc.
-
-* In `macro ... xs:p* ...` and similar macro bindings of combinators, `xs` now has the correct type `Array Syntax`
-
-* Identifiers in syntax patterns now ignore macro scopes during matching.
-
-* Improve binder names for constructor auto implicit parameters. Example, given the inductive datatype
-  ```lean
-  inductive Member : α → List α → Type u
-    | head : Member a (a::as)
-    | tail : Member a bs → Member a (b::bs)
-  ```
-  before:
-  ```lean
-  #check @Member.head
-  -- @Member.head : {x : Type u_1} → {a : x} → {as : List x} → Member a (a :: as)
-  ```
-  now:
-  ```lean
-  #check @Member.head
-  -- @Member.head : {α : Type u_1} → {a : α} → {as : List α} → Member a (a :: as)
-  ```
-
-* Improve error message when constructor parameter universe level is too big.
-
-* Add support for `for h : i in [start:stop] do .. ` where `h : i ∈ [start:stop]`. This feature is useful for proving
-  termination of functions such as:
-  ```lean
-  inductive Expr where
-    | app (f : String) (args : Array Expr)
-
-  def Expr.size (e : Expr) : Nat := Id.run do
-    match e with
-    | app f args =>
-      let mut sz := 1
-      for h : i in [: args.size] do
-        -- h.upper : i < args.size
-        sz := sz + size (args.get ⟨i, h.upper⟩)
-      return sz
-  ```
-
-* Add tactic `case'`. It is similar to `case`, but does not admit the goal on failure.
-  For example, the new tactic is useful when writing tactic scripts where we need to use `case'`
-  at `first | ... | ...`, and we want to take the next alternative when `case'` fails.
-
-* Add tactic macro
-  ```lean
-  macro "stop" s:tacticSeq : tactic => `(repeat sorry)
-  ```
-  See discussion on [Zulip](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Partial.20evaluation.20of.20a.20file).
-
-* When displaying goals, we do not display inaccessible proposition names
-if they do not have forward dependencies. We still display their types.
-For example, the goal
-  ```lean
-  case node.inl.node
-  β : Type u_1
-  b : BinTree β
-  k : Nat
-  v : β
-  left : Tree β
-  key : Nat
-  value : β
-  right : Tree β
-  ihl : BST left → Tree.find? (Tree.insert left k v) k = some v
-  ihr : BST right → Tree.find? (Tree.insert right k v) k = some v
-  h✝ : k < key
-  a✝³ : BST left
-  a✝² : ForallTree (fun k v => k < key) left
-  a✝¹ : BST right
-  a✝ : ForallTree (fun k v => key < k) right
-  ⊢ BST left
-  ```
-  is now displayed as
-  ```lean
-  case node.inl.node
-  β : Type u_1
-  b : BinTree β
-  k : Nat
-  v : β
-  left : Tree β
-  key : Nat
-  value : β
-  right : Tree β
-  ihl : BST left → Tree.find? (Tree.insert left k v) k = some v
-  ihr : BST right → Tree.find? (Tree.insert right k v) k = some v
-   : k < key
-   : BST left
-   : ForallTree (fun k v => k < key) left
-   : BST right
-   : ForallTree (fun k v => key < k) right
-  ⊢ BST left
-  ```
-
-* The hypothesis name is now optional in the `by_cases` tactic.
-
-* [Fix inconsistency between `syntax` and kind names](https://github.com/leanprover/lean4/issues/1090).
-  The node kinds `numLit`, `charLit`, `nameLit`, `strLit`, and `scientificLit` are now called
-  `num`, `char`, `name`, `str`, and `scientific` respectively. Example: we now write
-  ```lean
-  macro_rules | `($n:num) => `("hello")
-  ```
-  instead of
-  ```lean
-  macro_rules | `($n:numLit) => `("hello")
-  ```
-
-* (Experimental) New `checkpoint <tactic-seq>` tactic for big interactive proofs.
-
-* Rename tactic `nativeDecide` => `native_decide`.
-
-* Antiquotations are now accepted in any syntax. The `incQuotDepth` `syntax` parser is therefore obsolete and has been removed.
-
-* Renamed tactic `nativeDecide` => `native_decide`.
-
-* "Cleanup" local context before elaborating a `match` alternative right-hand-side. Examples:
-  ```lean
-  example (x : Nat) : Nat :=
-    match g x with
-    | (a, b) => _ -- Local context does not contain the auxiliary `_discr := g x` anymore
-
-  example (x : Nat × Nat) (h : x.1 > 0) : f x > 0 := by
-    match x with
-    | (a, b) => _ -- Local context does not contain the `h✝ : x.fst > 0` anymore
-  ```
-
-* Improve `let`-pattern (and `have`-pattern) macro expansion. In the following example,
-  ```lean
-  example (x : Nat × Nat) : f x > 0 := by
-    let (a, b) := x
-    done
-  ```
-  The resulting goal is now `... |- f (a, b) > 0` instead of `... |- f x > 0`.
-
-* Add cross-compiled [aarch64 Linux](https://github.com/leanprover/lean4/pull/1066) and [aarch64 macOS](https://github.com/leanprover/lean4/pull/1076) releases.
-
-* [Add tutorial-like examples to our documentation](https://github.com/leanprover/lean4/tree/master/doc/examples), rendered using LeanInk+Alectryon.

releases/v4.0.0.md

@@ -1,120 +0,0 @@
-v4.0.0
----------
-
-* [`Lean.Meta.getConst?` has been renamed](https://github.com/leanprover/lean4/pull/2454).
-  We have renamed `getConst?` to `getUnfoldableConst?` (and `getConstNoEx?` to `getUnfoldableConstNoEx?`).
-  These were not intended to be part of the public API, but downstream projects had been using them
-  (sometimes expecting different behaviour) incorrectly instead of `Lean.getConstInfo`.
-
-* [`dsimp` / `simp` / `simp_all` now fail by default if they make no progress](https://github.com/leanprover/lean4/pull/2336).
-
-  This can be overridden with the `(config := { failIfUnchanged := false })` option.
-  This change was made to ease manual use of `simp` (with complicated goals it can be hard to tell if it was effective)
-  and to allow easier flow control in tactics internally using `simp`.
-  See the [summary discussion](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/simp.20fails.20if.20no.20progress/near/380153295)
-  on zulip for more details.
-
-* [`simp_all` now preserves order of hypotheses](https://github.com/leanprover/lean4/pull/2334).
-
-  In order to support the `failIfUnchanged` configuration option for `dsimp` / `simp` / `simp_all`
-  the way `simp_all` replaces hypotheses has changed.
-  In particular it is now more likely to preserve the order of hypotheses.
-  See [`simp_all` reorders hypotheses unnecessarily](https://github.com/leanprover/lean4/pull/2334).
-  (Previously all non-dependent propositional hypotheses were reverted and reintroduced.
-  Now only such hypotheses which were changed, or which come after a changed hypothesis,
-  are reverted and reintroduced.
-  This has the effect of preserving the ordering amongst the non-dependent propositional hypotheses,
-  but now any dependent or non-propositional hypotheses retain their position amongst the unchanged
-  non-dependent propositional hypotheses.)
-  This may affect proofs that use `rename_i`, `case ... =>`, or `next ... =>`.
-
-* [New `have this` implementation](https://github.com/leanprover/lean4/pull/2247).
-
-  `this` is now a regular identifier again that is implicitly introduced by anonymous `have :=` for the remainder of the tactic block. It used to be a keyword that was visible in all scopes and led to unexpected behavior when explicitly used as a binder name.
-
-* [Show typeclass and tactic names in profile output](https://github.com/leanprover/lean4/pull/2170).
-
-* [Make `calc` require the sequence of relation/proof-s to have the same indentation](https://github.com/leanprover/lean4/pull/1844),
-  and [add `calc` alternative syntax allowing underscores `_` in the first relation](https://github.com/leanprover/lean4/pull/1844).
-
-  The flexible indentation in `calc` was often used to align the relation symbols:
-  ```lean
-  example (x y : Nat) : (x + y) * (x + y) = x * x + y * x + x * y + y * y :=
-    calc
-        (x + y) * (x + y) = (x + y) * x + (x + y) * y       := by rw [Nat.mul_add]
-                        -- improper indentation
-                        _ = x * x + y * x + (x + y) * y     := by rw [Nat.add_mul]
-                        _ = x * x + y * x + (x * y + y * y) := by rw [Nat.add_mul]
-                        _ = x * x + y * x + x * y + y * y   := by rw [←Nat.add_assoc]
-  ```
-
-  This is no longer legal.  The new syntax puts the first term right after the `calc` and each step has the same indentation:
-  ```lean
-  example (x y : Nat) : (x + y) * (x + y) = x * x + y * x + x * y + y * y :=
-    calc (x + y) * (x + y)
-      _ = (x + y) * x + (x + y) * y       := by rw [Nat.mul_add]
-      _ = x * x + y * x + (x + y) * y     := by rw [Nat.add_mul]
-      _ = x * x + y * x + (x * y + y * y) := by rw [Nat.add_mul]
-      _ = x * x + y * x + x * y + y * y   := by rw [←Nat.add_assoc]
-  ```
-
-
-* Update Lake to latest prerelease.
-
-* [Make go-to-definition on a typeclass projection application go to the instance(s)](https://github.com/leanprover/lean4/pull/1767).
-
-* [Include timings in trace messages when `profiler` is true](https://github.com/leanprover/lean4/pull/1995).
-
-* [Pretty-print signatures in hover and `#check <ident>`](https://github.com/leanprover/lean4/pull/1943).
-
-* [Introduce parser memoization to avoid exponential behavior](https://github.com/leanprover/lean4/pull/1799).
-
-* [feat: allow `doSeq` in `let x <- e | seq`](https://github.com/leanprover/lean4/pull/1809).
-
-* [Add hover/go-to-def/refs for options](https://github.com/leanprover/lean4/pull/1783).
-
-* [Add empty type ascription syntax `(e :)`](https://github.com/leanprover/lean4/pull/1797).
-
-* [Make tokens in `<|>` relevant to syntax match](https://github.com/leanprover/lean4/pull/1744).
-
-* [Add `linter.deprecated` option to silence deprecation warnings](https://github.com/leanprover/lean4/pull/1768).
-
-* [Improve fuzzy-matching heuristics](https://github.com/leanprover/lean4/pull/1710).
-
-* [Implementation-detail hypotheses](https://github.com/leanprover/lean4/pull/1692).
-
-* [Hover information for `cases`/`induction` case names](https://github.com/leanprover/lean4/pull/1660).
-
-* [Prefer longer parse even if unsuccessful](https://github.com/leanprover/lean4/pull/1658).
-
-* [Show declaration module in hover](https://github.com/leanprover/lean4/pull/1638).
-
-* [New `conv` mode structuring tactics](https://github.com/leanprover/lean4/pull/1636).
-
-* `simp` can track information and can print an equivalent `simp only`. [PR #1626](https://github.com/leanprover/lean4/pull/1626).
-
-* Enforce uniform indentation in tactic blocks / do blocks. See issue [#1606](https://github.com/leanprover/lean4/issues/1606).
-
-* Moved `AssocList`, `HashMap`, `HashSet`, `RBMap`, `RBSet`, `PersistentArray`, `PersistentHashMap`, `PersistentHashSet` to the Lean package. The [standard library](https://github.com/leanprover/std4) contains versions that will evolve independently to simplify bootstrapping process.
-
-* Standard library moved to the [std4 GitHub repository](https://github.com/leanprover/std4).
-
-* `InteractiveGoals` now has information that a client infoview can use to show what parts of the goal have changed after applying a tactic. [PR #1610](https://github.com/leanprover/lean4/pull/1610).
-
-* Add `[inheritDoc]` attribute. [PR #1480](https://github.com/leanprover/lean4/pull/1480).
-
-* Expose that `panic = default`. [PR #1614](https://github.com/leanprover/lean4/pull/1614).
-
-* New [code generator](https://github.com/leanprover/lean4/tree/master/src/Lean/Compiler/LCNF) project has started.
-
-* Remove description argument from `register_simp_attr`. [PR #1566](https://github.com/leanprover/lean4/pull/1566).
-
-* [Additional concurrency primitives](https://github.com/leanprover/lean4/pull/1555).
-
-* [Collapsible traces with messages](https://github.com/leanprover/lean4/pull/1448).
-
-* [Hygienic resolution of namespaces](https://github.com/leanprover/lean4/pull/1442).
-
-* [New `Float` functions](https://github.com/leanprover/lean4/pull/1460).
-
-* Many new doc strings have been added to declarations at `Init`.

releases/v4.1.0.md

@@ -1,21 +0,0 @@
-v4.1.0
----------
-
-* The error positioning on missing tokens has been [improved](https://github.com/leanprover/lean4/pull/2393). In particular, this should make it easier to spot errors in incomplete tactic proofs.
-
-* After elaborating a configuration file, Lake will now cache the configuration to a `lakefile.olean`. Subsequent runs of Lake will import this OLean instead of elaborating the configuration file. This provides a significant performance improvement (benchmarks indicate that using the OLean cuts Lake's startup time in half), but there are some important details to keep in mind:
-  + Lake will regenerate this OLean after each modification to the `lakefile.lean` or `lean-toolchain`. You can also force a reconfigure by passing the new `--reconfigure` / `-R` option to `lake`.
-  + Lake configuration options (i.e., `-K`) will be fixed at the moment of elaboration. Setting these options when `lake` is using the cached configuration will have no effect. To change options, run `lake` with `-R` / `--reconfigure`.
-  + **The `lakefile.olean` is a local configuration and should not be committed to Git. Therefore, existing Lake packages need to add it to their `.gitignore`.**
-
-* The signature of `Lake.buildO` has changed, `args` has been split into `weakArgs` and `traceArgs`. `traceArgs` are included in the input trace and `weakArgs` are not. See Lake's [FFI example](src/lake/examples/ffi/lib/lakefile.lean) for a demonstration of how to adapt to this change.
-
-* The signatures of `Lean.importModules`, `Lean.Elab.headerToImports`, and `Lean.Elab.parseImports`
-  have [changed](https://github.com/leanprover/lean4/pull/2480) from taking `List Import` to `Array Import`.
-
-* There is now [an `occs` field](https://github.com/leanprover/lean4/pull/2470)
-  in the configuration object for the `rewrite` tactic,
-  allowing control of which occurrences of a pattern should be rewritten.
-  This was previously a separate argument for `Lean.MVarId.rewrite`,
-  and this has been removed in favour of an additional field of `Rewrite.Config`.
-  It was not previously accessible from user tactics.

releases/v4.10.0.md

@@ -1,281 +0,0 @@
-v4.10.0
-----------
-
-### Language features, tactics, and metaprograms
-
-* `split` tactic:
-  * [#4401](https://github.com/leanprover/lean4/pull/4401) improves the strategy `split` uses to generalize discriminants of matches and adds `trace.split.failure` trace class for diagnosing issues.
-
-* `rw` tactic:
-  * [#4385](https://github.com/leanprover/lean4/pull/4385) prevents the tactic from claiming pre-existing goals are new subgoals.
-  * [dac1da](https://github.com/leanprover/lean4/commit/dac1dacc5b39911827af68247d575569d9c399b5) adds configuration for ordering new goals, like for `apply`.
-
-* `simp` tactic:
-  * [#4430](https://github.com/leanprover/lean4/pull/4430) adds `dsimproc`s for `if` expressions (`ite` and `dite`).
-  * [#4434](https://github.com/leanprover/lean4/pull/4434) improves heuristics for unfolding. Equational lemmas now have priorities where more-specific equationals lemmas are tried first before a possible catch-all.
-  * [#4481](https://github.com/leanprover/lean4/pull/4481) fixes an issue where function-valued `OfNat` numeric literals would become denormalized.
-  * [#4467](https://github.com/leanprover/lean4/pull/4467) fixes an issue where dsimp theorems might not apply to literals.
-  * [#4484](https://github.com/leanprover/lean4/pull/4484) fixes the source position for the warning for deprecated simp arguments.
-  * [#4258](https://github.com/leanprover/lean4/pull/4258) adds docstrings for `dsimp` configuration.
-  * [#4567](https://github.com/leanprover/lean4/pull/4567) improves the accuracy of used simp lemmas reported by `simp?`.
-  * [fb9727](https://github.com/leanprover/lean4/commit/fb97275dcbb683efe6da87ed10a3f0cd064b88fd) adds (but does not implement) the simp configuration option `implicitDefEqProofs`, which will enable including `rfl`-theorems in proof terms.
-* `omega` tactic:
-  * [#4360](https://github.com/leanprover/lean4/pull/4360) makes the tactic generate error messages lazily, improving its performance when used in tactic combinators.
-* `bv_omega` tactic:
-  * [#4579](https://github.com/leanprover/lean4/pull/4579) works around changes to the definition of `Fin.sub` in this release.
-* [#4490](https://github.com/leanprover/lean4/pull/4490) sets up groundwork for a tactic index in generated documentation, as there was in Lean 3. See PR description for details.
-
-* **Commands**
-  * [#4370](https://github.com/leanprover/lean4/pull/4370) makes the `variable` command fully elaborate binders during validation, fixing an issue where some errors would be reported only at the next declaration.
-  * [#4408](https://github.com/leanprover/lean4/pull/4408) fixes a discrepancy in universe parameter order between `theorem` and `def` declarations.
-  * [#4493](https://github.com/leanprover/lean4/pull/4493) and
-    [#4482](https://github.com/leanprover/lean4/pull/4482) fix a discrepancy in the elaborators for `theorem`, `def`, and `example`,
-    making `Prop`-valued `example`s and other definition commands elaborate like `theorem`s.
-  * [8f023b](https://github.com/leanprover/lean4/commit/8f023b85c554186ae562774b8122322d856c674e), [3c4d6b](https://github.com/leanprover/lean4/commit/3c4d6ba8648eb04d90371eb3fdbd114d16949501) and [0783d0](https://github.com/leanprover/lean4/commit/0783d0fcbe31b626fbd3ed2f29d838e717f09101) change the `#reduce` command to be able to control what gets reduced.
-    For example, `#reduce (proofs := true) (types := false) e` reduces both proofs and types in the expression `e`.
-    By default, neither proofs or types are reduced.
-  * [#4489](https://github.com/leanprover/lean4/pull/4489) fixes an elaboration bug in `#check_tactic`.
-  * [#4505](https://github.com/leanprover/lean4/pull/4505) adds support for `open _root_.<namespace>`.
-
-* **Options**
-  * [#4576](https://github.com/leanprover/lean4/pull/4576) adds the `debug.byAsSorry` option. Setting `set_option debug.byAsSorry true` causes all `by ...` terms to elaborate as `sorry`.
-  * [7b56eb](https://github.com/leanprover/lean4/commit/7b56eb20a03250472f4b145118ae885274d1f8f7) and [d8e719](https://github.com/leanprover/lean4/commit/d8e719f9ab7d049e423473dfc7a32867d32c856f) add the `debug.skipKernelTC` option. Setting `set_option debug.skipKernelTC true` turns off kernel typechecking. This is meant for temporarily working around kernel performance issues, and it compromises soundness since buggy tactics may produce invalid proofs, which will not be caught if this option is set to true.
-
-* [#4301](https://github.com/leanprover/lean4/pull/4301)
-  adds a linter to flag situations where a local variable's name is one of
-  the argumentless constructors of its type. This can arise when a user either
-  doesn't open a namespace or doesn't add a dot or leading qualifier, as
-  in the following:
-
-  ```lean
-  inductive Tree (α : Type) where
-    | leaf
-    | branch (left : Tree α) (val : α) (right : Tree α)
-
-  def depth : Tree α → Nat
-    | leaf => 0
-  ```
-
-  With this linter, the `leaf` pattern is highlighted as a local
-  variable whose name overlaps with the constructor `Tree.leaf`.
-
-  The linter can be disabled with `set_option linter.constructorNameAsVariable false`.
-
-  Additionally, the error message that occurs when a name in a pattern that takes arguments isn't valid now suggests similar names that would be valid. This means that the following definition:
-
-  ```lean
-  def length (list : List α) : Nat :=
-    match list with
-    | nil => 0
-    | cons x xs => length xs + 1
-  ```
-
-  now results in the following warning:
-
-  ```
-  warning: Local variable 'nil' resembles constructor 'List.nil' - write '.nil' (with a dot) or 'List.nil' to use the constructor.
-  note: this linter can be disabled with `set_option linter.constructorNameAsVariable false`
-  ```
-
-  and error:
-
-  ```
-  invalid pattern, constructor or constant marked with '[match_pattern]' expected
-
-  Suggestion: 'List.cons' is similar
-  ```
-
-* **Metaprogramming**
-  * [#4454](https://github.com/leanprover/lean4/pull/4454) adds public `Name.isInternalDetail` function for filtering declarations using naming conventions for internal names.
-
-* **Other fixes or improvements**
-  * [#4416](https://github.com/leanprover/lean4/pull/4416) sorts the output of `#print axioms` for determinism.
-  * [#4528](https://github.com/leanprover/lean4/pull/4528) fixes error message range for the cdot focusing tactic.
-
-### Language server, widgets, and IDE extensions
-
-* [#4443](https://github.com/leanprover/lean4/pull/4443) makes the watchdog be more resilient against badly behaving clients.
-
-### Pretty printing
-
-* [#4433](https://github.com/leanprover/lean4/pull/4433) restores fallback pretty printers when context is not available, and documents `addMessageContext`.
-* [#4556](https://github.com/leanprover/lean4/pull/4556) introduces `pp.maxSteps` option and sets the default value of `pp.deepTerms` to `false`. Together, these keep excessively large or deep terms from overwhelming the Infoview.
-
-### Library
-* [#4560](https://github.com/leanprover/lean4/pull/4560) splits `GetElem` class into `GetElem` and `GetElem?`.
-  This enables removing `Decidable` instance arguments from `GetElem.getElem?` and `GetElem.getElem!`, improving their rewritability.
-  See the docstrings for these classes for more information.
-* `Array`
-  * [#4389](https://github.com/leanprover/lean4/pull/4389) makes `Array.toArrayAux_eq` be a `simp` lemma.
-  * [#4399](https://github.com/leanprover/lean4/pull/4399) improves robustness of the proof for `Array.reverse_data`.
-* `List`
-  * [#4469](https://github.com/leanprover/lean4/pull/4469) and [#4475](https://github.com/leanprover/lean4/pull/4475) improve the organization of the `List` API.
-  * [#4470](https://github.com/leanprover/lean4/pull/4470) improves the `List.set` and `List.concat` API.
-  * [#4472](https://github.com/leanprover/lean4/pull/4472) upstreams lemmas about `List.filter` from Batteries.
-  * [#4473](https://github.com/leanprover/lean4/pull/4473) adjusts `@[simp]` attributes.
-  * [#4488](https://github.com/leanprover/lean4/pull/4488) makes `List.getElem?_eq_getElem` be a simp lemma.
-  * [#4487](https://github.com/leanprover/lean4/pull/4487) adds missing `List.replicate` API.
-  * [#4521](https://github.com/leanprover/lean4/pull/4521) adds lemmas about `List.map`.
-  * [#4500](https://github.com/leanprover/lean4/pull/4500) changes `List.length_cons` to use `as.length + 1` instead of `as.length.succ`.
-  * [#4524](https://github.com/leanprover/lean4/pull/4524) fixes the statement of `List.filter_congr`.
-  * [#4525](https://github.com/leanprover/lean4/pull/4525) changes binder explicitness in `List.bind_map`.
-  * [#4550](https://github.com/leanprover/lean4/pull/4550) adds `maximum?_eq_some_iff'` and `minimum?_eq_some_iff?`.
-* [#4400](https://github.com/leanprover/lean4/pull/4400) switches the normal forms for indexing `List` and `Array` to `xs[n]` and `xs[n]?`.
-* `HashMap`
-  * [#4372](https://github.com/leanprover/lean4/pull/4372) fixes linearity in `HashMap.insert` and `HashMap.erase`, leading to a 40% speedup in a replace-heavy workload.
-* `Option`
-  * [#4403](https://github.com/leanprover/lean4/pull/4403) generalizes type of `Option.forM` from `Unit` to `PUnit`.
-  * [#4504](https://github.com/leanprover/lean4/pull/4504) remove simp attribute from `Option.elim` and instead adds it to individual reduction lemmas, making unfolding less aggressive.
-* `Nat`
-  * [#4242](https://github.com/leanprover/lean4/pull/4242) adds missing theorems for `n + 1` and `n - 1` normal forms.
-  * [#4486](https://github.com/leanprover/lean4/pull/4486) makes `Nat.min_assoc` be a simp lemma.
-  * [#4522](https://github.com/leanprover/lean4/pull/4522) moves `@[simp]` from `Nat.pred_le` to `Nat.sub_one_le`.
-  * [#4532](https://github.com/leanprover/lean4/pull/4532) changes various `Nat.succ n` to `n + 1`.
-* `Int`
-  * [#3850](https://github.com/leanprover/lean4/pull/3850) adds complete div/mod simprocs for `Int`.
-* `String`/`Char`
-  * [#4357](https://github.com/leanprover/lean4/pull/4357) make the byte size interface be `Nat`-valued with functions `Char.utf8Size` and `String.utf8ByteSize`.
-  * [#4438](https://github.com/leanprover/lean4/pull/4438) upstreams `Char.ext` from Batteries and adds some `Char` documentation to the manual.
-* `Fin`
-  * [#4421](https://github.com/leanprover/lean4/pull/4421) adjusts `Fin.sub` to be more performant in definitional equality checks.
-* `Prod`
-  * [#4526](https://github.com/leanprover/lean4/pull/4526) adds missing `Prod.map` lemmas.
-  * [#4533](https://github.com/leanprover/lean4/pull/4533) fixes binder explicitness in lemmas.
-* `BitVec`
-  * [#4428](https://github.com/leanprover/lean4/pull/4428) adds missing `simproc` for `BitVec` equality.
-  * [#4417](https://github.com/leanprover/lean4/pull/4417) adds `BitVec.twoPow` and lemmas, toward bitblasting multiplication for LeanSAT.
-* `Std` library
-  * [#4499](https://github.com/leanprover/lean4/pull/4499) introduces `Std`, a library situated between `Init` and `Lean`, providing functionality not in the prelude both to Lean's implementation and to external users.
-* **Other fixes or improvements**
-  * [#3056](https://github.com/leanprover/lean4/pull/3056) standardizes on using `(· == a)` over `(a == ·)`.
-  * [#4502](https://github.com/leanprover/lean4/pull/4502) fixes errors reported by running the library through the the Batteries linters.
-
-### Lean internals
-
-* [#4391](https://github.com/leanprover/lean4/pull/4391) makes `getBitVecValue?` recognize `BitVec.ofNatLt`.
-* [#4410](https://github.com/leanprover/lean4/pull/4410) adjusts `instantiateMVars` algorithm to zeta reduce `let` expressions while beta reducing instantiated metavariables.
-* [#4420](https://github.com/leanprover/lean4/pull/4420) fixes occurs check for metavariable assignments to also take metavariable types into account.
-* [#4425](https://github.com/leanprover/lean4/pull/4425) fixes `forEachModuleInDir` to iterate over each Lean file exactly once.
-* [#3886](https://github.com/leanprover/lean4/pull/3886) adds support to build Lean core oleans using Lake.
-* **Defeq and WHNF algorithms**
-  * [#4387](https://github.com/leanprover/lean4/pull/4387) improves performance of `isDefEq` by eta reducing lambda-abstracted terms during metavariable assignments, since these are beta reduced during metavariable instantiation anyway.
-  * [#4388](https://github.com/leanprover/lean4/pull/4388) removes redundant code in `isDefEqQuickOther`.
-* **Typeclass inference**
-  * [#4530](https://github.com/leanprover/lean4/pull/4530) fixes handling of metavariables when caching results at `synthInstance?`.
-* **Elaboration**
-  * [#4426](https://github.com/leanprover/lean4/pull/4426) makes feature where the "don't know how to synthesize implicit argument" error reports the name of the argument more reliable.
-  * [#4497](https://github.com/leanprover/lean4/pull/4497) fixes a name resolution bug for generalized field notation (dot notation).
-  * [#4536](https://github.com/leanprover/lean4/pull/4536) blocks the implicit lambda feature for `(e :)` notation.
-  * [#4562](https://github.com/leanprover/lean4/pull/4562) makes it be an error for there to be two functions with the same name in a `where`/`let rec` block.
-* Recursion principles
-  * [#4549](https://github.com/leanprover/lean4/pull/4549) refactors `findRecArg`, extracting `withRecArgInfo`.
-    Errors are now reported in parameter order rather than the order they are tried (non-indices are tried first).
-    For every argument, it will say why it wasn't tried, even if the reason is obvious (e.g. a fixed prefix or is `Prop`-typed, etc.).
-* Porting core C++ to Lean
-  * [#4474](https://github.com/leanprover/lean4/pull/4474) takes a step to refactor `constructions` toward a future port to Lean.
-  * [#4498](https://github.com/leanprover/lean4/pull/4498) ports `mk_definition_inferring_unsafe` to Lean.
-  * [#4516](https://github.com/leanprover/lean4/pull/4516) ports `recOn` construction to Lean.
-  * [#4517](https://github.com/leanprover/lean4/pull/4517), [#4653](https://github.com/leanprover/lean4/pull/4653), and [#4651](https://github.com/leanprover/lean4/pull/4651) port `below` and `brecOn` construction to Lean.
-* Documentation
-  * [#4501](https://github.com/leanprover/lean4/pull/4501) adds a more-detailed docstring for `PersistentEnvExtension`.
-* **Other fixes or improvements**
-  * [#4382](https://github.com/leanprover/lean4/pull/4382) removes `@[inline]` attribute from `NameMap.find?`, which caused respecialization at each call site.
-  * [5f9ded](https://github.com/leanprover/lean4/commit/5f9dedfe5ee9972acdebd669f228f487844a6156) improves output of `trace.Elab.snapshotTree`.
-  * [#4424](https://github.com/leanprover/lean4/pull/4424) removes "you might need to open '{dir}' in your editor" message that is now handled by Lake and the VS Code extension.
-  * [#4451](https://github.com/leanprover/lean4/pull/4451) improves the performance of `CollectMVars` and `FindMVar`.
-  * [#4479](https://github.com/leanprover/lean4/pull/4479) adds missing `DecidableEq` and `Repr` instances for intermediate structures used by the `BitVec` and `Fin` simprocs.
-  * [#4492](https://github.com/leanprover/lean4/pull/4492) adds tests for a previous `isDefEq` issue.
-  * [9096d6](https://github.com/leanprover/lean4/commit/9096d6fc7180fe533c504f662bcb61550e4a2492) removes `PersistentHashMap.size`.
-  * [#4508](https://github.com/leanprover/lean4/pull/4508) fixes `@[implemented_by]` for functions defined by well-founded recursion.
-  * [#4509](https://github.com/leanprover/lean4/pull/4509) adds additional tests for `apply?` tactic.
-  * [d6eab3](https://github.com/leanprover/lean4/commit/d6eab393f4df9d473b5736d636b178eb26d197e6) fixes a benchmark.
-  * [#4563](https://github.com/leanprover/lean4/pull/4563) adds a workaround for a bug in `IndPredBelow.mkBelowMatcher`.
-* **Cleanup:** [#4380](https://github.com/leanprover/lean4/pull/4380), [#4431](https://github.com/leanprover/lean4/pull/4431), [#4494](https://github.com/leanprover/lean4/pull/4494), [e8f768](https://github.com/leanprover/lean4/commit/e8f768f9fd8cefc758533bc76e3a12b398ed4a39), [de2690](https://github.com/leanprover/lean4/commit/de269060d17a581ed87f40378dbec74032633b27), [d3a756](https://github.com/leanprover/lean4/commit/d3a7569c97123d022828106468d54e9224ed8207), [#4404](https://github.com/leanprover/lean4/pull/4404), [#4537](https://github.com/leanprover/lean4/pull/4537).
-
-### Compiler, runtime, and FFI
-
-* [d85d3d](https://github.com/leanprover/lean4/commit/d85d3d5f3a09ff95b2ee47c6f89ef50b7e339126) fixes criterion for tail-calls in ownership calculation.
-* [#3963](https://github.com/leanprover/lean4/pull/3963) adds validation of UTF-8 at the C++-to-Lean boundary in the runtime.
-* [#4512](https://github.com/leanprover/lean4/pull/4512) fixes missing unboxing in interpreter when loading initialized value.
-* [#4477](https://github.com/leanprover/lean4/pull/4477) exposes the compiler flags for the bundled C compiler (clang).
-
-### Lake
-
-* [#4384](https://github.com/leanprover/lean4/pull/4384) deprecates `inputFile` and replaces it with `inputBinFile` and `inputTextFile`. Unlike `inputBinFile` (and `inputFile`), `inputTextFile` normalizes line endings, which helps ensure text file traces are platform-independent.
-* [#4371](https://github.com/leanprover/lean4/pull/4371) simplifies dependency resolution code.
-* [#4439](https://github.com/leanprover/lean4/pull/4439) touches up the Lake configuration DSL and makes other improvements:
-  string literals can now be used instead of identifiers for names,
-  avoids using French quotes in `lake new` and `lake init` templates,
-  changes the `exe` template to use `Main` for the main module,
-  improves the `math` template error if `lean-toolchain` fails to download,
-  and downgrades unknown configuration fields from an error to a warning to improve cross-version compatibility.
-* [#4496](https://github.com/leanprover/lean4/pull/4496) tweaks `require` syntax and updates docs. Now `require` in TOML for a package name such as `doc-gen4` does not need French quotes.
-* [#4485](https://github.com/leanprover/lean4/pull/4485) fixes a bug where package versions in indirect dependencies would take precedence over direct dependencies.
-* [#4478](https://github.com/leanprover/lean4/pull/4478) fixes a bug where Lake incorrectly included the module dynamic library in a platform-independent trace.
-* [#4529](https://github.com/leanprover/lean4/pull/4529) fixes some issues with bad import errors.
-  A bad import in an executable no longer prevents the executable's root
-  module from being built. This also fixes a problem where the location
-  of a transitive bad import would not been shown.
-  The root module of the executable now respects `nativeFacets`.
-* [#4564](https://github.com/leanprover/lean4/pull/4564) fixes a bug where non-identifier script names could not be entered on the CLI without French quotes.
-* [#4566](https://github.com/leanprover/lean4/pull/4566) addresses a few issues with precompiled libraries.
-  * Fixes a bug where Lake would always precompile the package of a module.
-  * If a module is precompiled, it now precompiles its imports. Previously, it would only do this if imported.
-* [#4495](https://github.com/leanprover/lean4/pull/4495), [#4692](https://github.com/leanprover/lean4/pull/4692), [#4849](https://github.com/leanprover/lean4/pull/4849)
-  add a new type of `require` that fetches package metadata from a
-  registry API endpoint (e.g. Reservoir) and then clones a Git package
-  using the information provided. To require such a dependency, the new
-  syntax is:
-
-  ```lean
-  require <scope> / <pkg-name> [@ git <rev>]
-  -- Examples:
-  require "leanprover" / "doc-gen4"
-  require "leanprover-community" / "proofwidgets" @ git "v0.0.39"
-  ```
-
-  Or in TOML:
-  ```toml
-  [[require]]
-  name = "<pkg-name>"
-  scope = "<scope>"
-  rev = "<rev>"
-  ```
-
-  Unlike with Git dependencies, Lake can make use of the richer
-  information provided by the registry to determine the default branch of
-  the package. This means for repositories of packages like `doc-gen4`
-  which have a default branch that is not `master`, Lake will now use said
-  default branch (e.g., in `doc-gen4`'s case, `main`).
-
-  Lake also supports configuring the registry endpoint via an environment
-  variable: `RESERVIOR_API_URL`. Thus, any server providing a similar
-  interface to Reservoir can be used as the registry. Further
-  configuration options paralleling those of Cargo's [Alternative Registries](https://doc.rust-lang.org/cargo/reference/registries.html)
-  and [Source Replacement](https://doc.rust-lang.org/cargo/reference/source-replacement.html)
-  will come in the future.
-
-### DevOps/CI
-* [#4427](https://github.com/leanprover/lean4/pull/4427) uses Namespace runners for CI for `leanprover/lean4`.
-* [#4440](https://github.com/leanprover/lean4/pull/4440) fixes speedcenter tests in CI.
-* [#4441](https://github.com/leanprover/lean4/pull/4441) fixes that workflow change would break CI for unrebased PRs.
-* [#4442](https://github.com/leanprover/lean4/pull/4442) fixes Wasm release-ci.
-* [6d265b](https://github.com/leanprover/lean4/commit/6d265b42b117eef78089f479790587a399da7690) fixes for `github.event.pull_request.merge_commit_sha` sometimes not being available.
-* [16cad2](https://github.com/leanprover/lean4/commit/16cad2b45c6a77efe4dce850dcdbaafaa7c91fc3) adds optimization for CI to not fetch complete history.
-* [#4544](https://github.com/leanprover/lean4/pull/4544) causes releases to be marked as prerelease on GitHub.
-* [#4446](https://github.com/leanprover/lean4/pull/4446) switches Lake to using `src/lake/lakefile.toml` to avoid needing to load a version of Lake to build Lake.
-* Nix
-  * [5eb5fa](https://github.com/leanprover/lean4/commit/5eb5fa49cf9862e99a5bccff8d4ca1a062f81900) fixes `update-stage0-commit` for Nix.
-  * [#4476](https://github.com/leanprover/lean4/pull/4476) adds gdb to Nix shell.
-  * [e665a0](https://github.com/leanprover/lean4/commit/e665a0d716dc42ba79b339b95e01eb99fe932cb3) fixes `update-stage0` for Nix.
-  * [4808eb](https://github.com/leanprover/lean4/commit/4808eb7c4bfb98f212b865f06a97d46c44978a61) fixes `cacheRoots` for Nix.
-  * [#3811](https://github.com/leanprover/lean4/pull/3811) adds platform-dependent flag to lib target.
-  * [#4587](https://github.com/leanprover/lean4/pull/4587) adds linking of `-lStd` back into nix build flags on darwin.
-
-### Breaking changes
-
-* `Char.csize` is replaced by `Char.utf8Size` ([#4357](https://github.com/leanprover/lean4/pull/4357)).
-* Library lemmas now are in terms of `(· == a)` over `(a == ·)` ([#3056](https://github.com/leanprover/lean4/pull/3056)).
-* Now the normal forms for indexing into `List` and `Array` is `xs[n]` and `xs[n]?` rather than using functions like `List.get` ([#4400](https://github.com/leanprover/lean4/pull/4400)).
-* Sometimes terms created via a sequence of unifications will be more eta reduced than before and proofs will require adaptation ([#4387](https://github.com/leanprover/lean4/pull/4387)).
-* The `GetElem` class has been split into two; see the docstrings for `GetElem` and `GetElem?` for more information ([#4560](https://github.com/leanprover/lean4/pull/4560)).

releases/v4.11.0.md

@@ -1,337 +0,0 @@
-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), [#4814](https://github.com/leanprover/lean4/pull/4814), [#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.

releases/v4.12.0.md

@@ -1,312 +0,0 @@
-v4.12.0
-----------
-
-### Language features, tactics, and metaprograms
-
-* `bv_decide` tactic. This release introduces a new tactic for proving goals involving `BitVec` and `Bool`. It reduces the goal to a SAT instance that is refuted by an external solver, and the resulting LRAT proof is checked in Lean. This is used to synthesize a proof of the goal by reflection. As this process uses verified algorithms, proofs generated by this tactic use `Lean.ofReduceBool`, so this tactic includes the Lean compiler as part of the trusted code base. The external solver CaDiCaL is included with Lean and does not need to be installed separately to make use of `bv_decide`.
-
-  For example, we can use `bv_decide` to verify that a bit twiddling formula leaves at most one bit set:
-  ```lean
-  def popcount (x : BitVec 64) : BitVec 64 :=
-    let rec go (x pop : BitVec 64) : Nat → BitVec 64
-      | 0 => pop
-      | n + 1 => go (x >>> 2) (pop + (x &&& 1)) n
-    go x 0 64
-
-  example (x : BitVec 64) : popcount ((x &&& (x - 1)) ^^^ x) ≤ 1 := by
-    simp only [popcount, popcount.go]
-    bv_decide
-  ```
-  When the external solver fails to refute the SAT instance generated by `bv_decide`, it can report a counterexample:
-  ```lean
-  /--
-  error: The prover found a counterexample, consider the following assignment:
-  x = 0xffffffffffffffff#64
-  -/
-  #guard_msgs in
-  example (x : BitVec 64) : x < x + 1 := by
-    bv_decide
-  ```
-
-  See `Lean.Elab.Tactic.BVDecide` for a more detailed overview, and look in `tests/lean/run/bv_*` for examples.
-
-  [#5013](https://github.com/leanprover/lean4/pull/5013), [#5074](https://github.com/leanprover/lean4/pull/5074), [#5100](https://github.com/leanprover/lean4/pull/5100), [#5113](https://github.com/leanprover/lean4/pull/5113), [#5137](https://github.com/leanprover/lean4/pull/5137), [#5203](https://github.com/leanprover/lean4/pull/5203), [#5212](https://github.com/leanprover/lean4/pull/5212), [#5220](https://github.com/leanprover/lean4/pull/5220).
-
-* `simp` tactic
-  * [#4988](https://github.com/leanprover/lean4/pull/4988) fixes a panic in the `reducePow` simproc.
-  * [#5071](https://github.com/leanprover/lean4/pull/5071) exposes the `index` option to the `dsimp` tactic, introduced to `simp` in [#4202](https://github.com/leanprover/lean4/pull/4202).
-  * [#5159](https://github.com/leanprover/lean4/pull/5159) fixes a panic at `Fin.isValue` simproc.
-  * [#5167](https://github.com/leanprover/lean4/pull/5167) and [#5175](https://github.com/leanprover/lean4/pull/5175) rename the `simpCtorEq` simproc to `reduceCtorEq` and makes it optional. (See breaking changes.)
-  * [#5187](https://github.com/leanprover/lean4/pull/5187) ensures `reduceCtorEq` is enabled in the `norm_cast` tactic.
-  * [#5073](https://github.com/leanprover/lean4/pull/5073) modifies the simp debug trace messages to tag with "dpre" and "dpost" instead of "pre" and "post" when in definitional rewrite mode. [#5054](https://github.com/leanprover/lean4/pull/5054) explains the `reduce` steps for `trace.Debug.Meta.Tactic.simp` trace messages.
-* `ext` tactic
-  * [#4996](https://github.com/leanprover/lean4/pull/4996) reduces default maximum iteration depth from 1000000 to 100.
-* `induction` tactic
-  * [#5117](https://github.com/leanprover/lean4/pull/5117) fixes a bug where `let` bindings in minor premises wouldn't be counted correctly.
-
-* `omega` tactic
-  * [#5157](https://github.com/leanprover/lean4/pull/5157) fixes a panic.
-
-* `conv` tactic
-  * [#5149](https://github.com/leanprover/lean4/pull/5149) improves `arg n` to handle subsingleton instance arguments.
-
-* [#5044](https://github.com/leanprover/lean4/pull/5044) upstreams the `#time` command.
-* [#5079](https://github.com/leanprover/lean4/pull/5079) makes `#check` and `#reduce` typecheck the elaborated terms.
-
-* **Incrementality**
-  * [#4974](https://github.com/leanprover/lean4/pull/4974) fixes regression where we would not interrupt elaboration of previous document versions.
-  * [#5004](https://github.com/leanprover/lean4/pull/5004) fixes a performance regression.
-  * [#5001](https://github.com/leanprover/lean4/pull/5001) disables incremental body elaboration in presence of `where` clauses in declarations.
-  * [#5018](https://github.com/leanprover/lean4/pull/5018) enables infotrees on the command line for ilean generation.
-  * [#5040](https://github.com/leanprover/lean4/pull/5040) and [#5056](https://github.com/leanprover/lean4/pull/5056) improve performance of info trees.
-  * [#5090](https://github.com/leanprover/lean4/pull/5090) disables incrementality in the `case .. | ..` tactic.
-  * [#5312](https://github.com/leanprover/lean4/pull/5312) fixes a bug where changing whitespace after the module header could break subsequent commands.
-
-* **Definitions**
-  * [#5016](https://github.com/leanprover/lean4/pull/5016) and [#5066](https://github.com/leanprover/lean4/pull/5066) add `clean_wf` tactic to clean up tactic state in `decreasing_by`. This can be disabled with `set_option debug.rawDecreasingByGoal false`.
-  * [#5055](https://github.com/leanprover/lean4/pull/5055) unifies equational theorems between structural and well-founded recursion.
-  * [#5041](https://github.com/leanprover/lean4/pull/5041) allows mutually recursive functions to use different parameter names among the “fixed parameter prefix”
-  * [#4154](https://github.com/leanprover/lean4/pull/4154) and [#5109](https://github.com/leanprover/lean4/pull/5109) add fine-grained equational lemmas for non-recursive functions. See breaking changes.
-  * [#5129](https://github.com/leanprover/lean4/pull/5129) unifies equation lemmas for recursive and non-recursive definitions. The `backward.eqns.deepRecursiveSplit` option can be set to `false` to get the old behavior. See breaking changes.
-  * [#5141](https://github.com/leanprover/lean4/pull/5141) adds `f.eq_unfold` lemmas. Now Lean produces the following zoo of rewrite rules:
-    ```
-    Option.map.eq_1      : Option.map f none = none
-    Option.map.eq_2      : Option.map f (some x) = some (f x)
-    Option.map.eq_def    : Option.map f p = match o with | none => none | (some x) => some (f x)
-    Option.map.eq_unfold : Option.map = fun f p => match o with | none => none | (some x) => some (f x)
-    ```
-    The `f.eq_unfold` variant is especially useful to rewrite with `rw` under binders.
-  * [#5136](https://github.com/leanprover/lean4/pull/5136) fixes bugs in recursion over predicates.
-
-* **Variable inclusion**
-  * [#5206](https://github.com/leanprover/lean4/pull/5206) documents that `include` currently only applies to theorems.
-
-* **Elaboration**
-  * [#4926](https://github.com/leanprover/lean4/pull/4926) fixes a bug where autoparam errors were associated to an incorrect source position.
-  * [#4833](https://github.com/leanprover/lean4/pull/4833) fixes an issue where cdot anonymous functions (e.g. `(· + ·)`) would not handle ambiguous notation correctly. Numbers the parameters, making this example expand as `fun x1 x2 => x1 + x2` rather than `fun x x_1 => x + x_1`.
-  * [#5037](https://github.com/leanprover/lean4/pull/5037) improves strength of the tactic that proves array indexing is in bounds.
-  * [#5119](https://github.com/leanprover/lean4/pull/5119) fixes a bug in the tactic that proves indexing is in bounds where it could loop in the presence of mvars.
-  * [#5072](https://github.com/leanprover/lean4/pull/5072) makes the structure type clickable in "not a field of structure" errors for structure instance notation.
-  * [#4717](https://github.com/leanprover/lean4/pull/4717) fixes a bug where mutual `inductive` commands could create terms that the kernel rejects.
-  * [#5142](https://github.com/leanprover/lean4/pull/5142) fixes a bug where `variable` could fail when mixing binder updates and declarations.
-
-* **Other fixes or improvements**
-  * [#5118](https://github.com/leanprover/lean4/pull/5118) changes the definition of the `syntheticHole` parser so that hovering over `_` in `?_` gives the docstring for synthetic holes.
-  * [#5173](https://github.com/leanprover/lean4/pull/5173) uses the emoji variant selector for ✅️,❌️,💥️ in messages, improving fonts selection.
-  * [#5183](https://github.com/leanprover/lean4/pull/5183) fixes a bug in `rename_i` where implementation detail hypotheses could be renamed.
-
-### Language server, widgets, and IDE extensions
-
-* [#4821](https://github.com/leanprover/lean4/pull/4821) resolves two language server bugs that especially affect Windows users. (1) Editing the header could result in the watchdog not correctly restarting the file worker, which would lead to the file seemingly being processed forever. (2) On an especially slow Windows machine, we found that starting the language server would sometimes not succeed at all. This PR also resolves an issue where we would not correctly emit messages that we received while the file worker is being restarted to the corresponding file worker after the restart.
-* [#5006](https://github.com/leanprover/lean4/pull/5006) updates the user widget manual.
-* [#5193](https://github.com/leanprover/lean4/pull/5193) updates the quickstart guide with the new display name for the Lean 4 extension ("Lean 4").
-* [#5185](https://github.com/leanprover/lean4/pull/5185) fixes a bug where over time "import out of date" messages would accumulate.
-* [#4900](https://github.com/leanprover/lean4/pull/4900) improves ilean loading performance by about a factor of two. Optimizes the JSON parser and the conversion from JSON to Lean data structures; see PR description for details.
-* **Other fixes or improvements**
-  * [#5031](https://github.com/leanprover/lean4/pull/5031) localizes an instance in `Lsp.Diagnostics`.
-
-### Pretty printing
-
-* [#4976](https://github.com/leanprover/lean4/pull/4976) introduces `@[app_delab]`, a macro for creating delaborators for particular constants. The `@[app_delab ident]` syntax resolves `ident` to its constant name `name` and then expands to `@[delab app.name]`.
-* [#4982](https://github.com/leanprover/lean4/pull/4982) fixes a bug where the pretty printer assumed structure projections were type correct (such terms can appear in type mismatch errors). Improves hoverability of `#print` output for structures.
-* [#5218](https://github.com/leanprover/lean4/pull/5218) and [#5239](https://github.com/leanprover/lean4/pull/5239) add `pp.exprSizes` debugging option. When true, each pretty printed expression is prefixed with `[size a/b/c]`, where `a` is the size without sharing, `b` is the actual size, and `c` is the size with the maximum possible sharing.
-
-### Library
-
-* [#5020](https://github.com/leanprover/lean4/pull/5020) swaps the parameters to `Membership.mem`. A purpose of this change is to make set-like `CoeSort` coercions to refer to the eta-expanded function `fun x => Membership.mem s x`, which can reduce in many computations. Another is that having the `s` argument first leads to better discrimination tree keys. (See breaking changes.)
-* `Array`
-  * [#4970](https://github.com/leanprover/lean4/pull/4970) adds `@[ext]` attribute to `Array.ext`.
-  * [#4957](https://github.com/leanprover/lean4/pull/4957) deprecates `Array.get_modify`.
-* `List`
-  * [#4995](https://github.com/leanprover/lean4/pull/4995) upstreams `List.findIdx` lemmas.
-  * [#5029](https://github.com/leanprover/lean4/pull/5029), [#5048](https://github.com/leanprover/lean4/pull/5048) and [#5132](https://github.com/leanprover/lean4/pull/5132) add `List.Sublist` lemmas, some upstreamed. [#5077](https://github.com/leanprover/lean4/pull/5077) fixes implicitness in refl/rfl lemma binders.  add `List.Sublist` theorems.
-  * [#5047](https://github.com/leanprover/lean4/pull/5047) upstreams `List.Pairwise` lemmas.
-  * [#5053](https://github.com/leanprover/lean4/pull/5053), [#5124](https://github.com/leanprover/lean4/pull/5124), and [#5161](https://github.com/leanprover/lean4/pull/5161) add `List.find?/findSome?/findIdx?` theorems.
-  * [#5039](https://github.com/leanprover/lean4/pull/5039) adds `List.foldlRecOn` and `List.foldrRecOn` recursion principles to prove things about `List.foldl` and `List.foldr`.
-  * [#5069](https://github.com/leanprover/lean4/pull/5069) upstreams `List.Perm`.
-  * [#5092](https://github.com/leanprover/lean4/pull/5092) and [#5107](https://github.com/leanprover/lean4/pull/5107) add `List.mergeSort` and a fast `@[csimp]` implementation.
-  * [#5103](https://github.com/leanprover/lean4/pull/5103) makes the simp lemmas for `List.subset` more aggressive.
-  * [#5106](https://github.com/leanprover/lean4/pull/5106) changes the statement of `List.getLast?_cons`.
-  * [#5123](https://github.com/leanprover/lean4/pull/5123) and [#5158](https://github.com/leanprover/lean4/pull/5158) add `List.range` and `List.iota` lemmas.
-  * [#5130](https://github.com/leanprover/lean4/pull/5130) adds `List.join` lemmas.
-  * [#5131](https://github.com/leanprover/lean4/pull/5131) adds `List.append` lemmas.
-  * [#5152](https://github.com/leanprover/lean4/pull/5152) adds `List.erase(|P|Idx)` lemmas.
-  * [#5127](https://github.com/leanprover/lean4/pull/5127) makes miscellaneous lemma updates.
-  * [#5153](https://github.com/leanprover/lean4/pull/5153) and [#5160](https://github.com/leanprover/lean4/pull/5160) add lemmas about `List.attach` and `List.pmap`.
-  * [#5164](https://github.com/leanprover/lean4/pull/5164), [#5177](https://github.com/leanprover/lean4/pull/5177), and [#5215](https://github.com/leanprover/lean4/pull/5215) add `List.find?` and `List.range'/range/iota` lemmas.
-  * [#5196](https://github.com/leanprover/lean4/pull/5196) adds `List.Pairwise_erase` and related lemmas.
-  * [#5151](https://github.com/leanprover/lean4/pull/5151) and [#5163](https://github.com/leanprover/lean4/pull/5163) improve confluence of `List` simp lemmas. [#5105](https://github.com/leanprover/lean4/pull/5105) and [#5102](https://github.com/leanprover/lean4/pull/5102) adjust `List` simp lemmas.
-  * [#5178](https://github.com/leanprover/lean4/pull/5178) removes `List.getLast_eq_iff_getLast_eq_some` as a simp lemma.
-  * [#5210](https://github.com/leanprover/lean4/pull/5210) reverses the meaning of `List.getElem_drop` and `List.getElem_drop'`.
-  * [#5214](https://github.com/leanprover/lean4/pull/5214) moves `@[csimp]` lemmas earlier where possible.
-* `Nat` and `Int`
-  * [#5104](https://github.com/leanprover/lean4/pull/5104) adds `Nat.add_left_eq_self` and relatives.
-  * [#5146](https://github.com/leanprover/lean4/pull/5146) adds missing `Nat.and_xor_distrib_(left|right)`.
-  * [#5148](https://github.com/leanprover/lean4/pull/5148) and [#5190](https://github.com/leanprover/lean4/pull/5190) improve `Nat` and `Int` simp lemma confluence.
-  * [#5165](https://github.com/leanprover/lean4/pull/5165) adjusts `Int` simp lemmas.
-  * [#5166](https://github.com/leanprover/lean4/pull/5166) adds `Int` lemmas relating `neg` and `emod`/`mod`.
-  * [#5208](https://github.com/leanprover/lean4/pull/5208) reverses the direction of the `Int.toNat_sub` simp lemma.
-  * [#5209](https://github.com/leanprover/lean4/pull/5209) adds `Nat.bitwise` lemmas.
-  * [#5230](https://github.com/leanprover/lean4/pull/5230) corrects the docstrings for integer division and modulus.
-* `Option`
-  * [#5128](https://github.com/leanprover/lean4/pull/5128) and [#5154](https://github.com/leanprover/lean4/pull/5154) add `Option` lemmas.
-* `BitVec`
-  * [#4889](https://github.com/leanprover/lean4/pull/4889) adds `sshiftRight` bitblasting.
-  * [#4981](https://github.com/leanprover/lean4/pull/4981) adds `Std.Associative` and `Std.Commutative` instances for `BitVec.[and|or|xor]`.
-  * [#4913](https://github.com/leanprover/lean4/pull/4913) enables `missingDocs` error for `BitVec` modules.
-  * [#4930](https://github.com/leanprover/lean4/pull/4930) makes parameter names for `BitVec` more consistent.
-  * [#5098](https://github.com/leanprover/lean4/pull/5098) adds `BitVec.intMin`. Introduces `boolToPropSimps` simp set for converting from boolean to propositional expressions.
-  * [#5200](https://github.com/leanprover/lean4/pull/5200) and [#5217](https://github.com/leanprover/lean4/pull/5217) rename `BitVec.getLsb` to `BitVec.getLsbD`, etc., to bring naming in line with `List`/`Array`/etc.
-  * **Theorems:** [#4977](https://github.com/leanprover/lean4/pull/4977), [#4951](https://github.com/leanprover/lean4/pull/4951), [#4667](https://github.com/leanprover/lean4/pull/4667), [#5007](https://github.com/leanprover/lean4/pull/5007), [#4997](https://github.com/leanprover/lean4/pull/4997), [#5083](https://github.com/leanprover/lean4/pull/5083), [#5081](https://github.com/leanprover/lean4/pull/5081), [#4392](https://github.com/leanprover/lean4/pull/4392)
-* `UInt`
-  * [#4514](https://github.com/leanprover/lean4/pull/4514) fixes naming convention for `UInt` lemmas.
-* `Std.HashMap` and `Std.HashSet`
-  * [#4943](https://github.com/leanprover/lean4/pull/4943) deprecates variants of hash map query methods. (See breaking changes.)
-  * [#4917](https://github.com/leanprover/lean4/pull/4917) switches the library and Lean to `Std.HashMap` and `Std.HashSet` almost everywhere.
-  * [#4954](https://github.com/leanprover/lean4/pull/4954) deprecates `Lean.HashMap` and `Lean.HashSet`.
-  * [#5023](https://github.com/leanprover/lean4/pull/5023) cleans up lemma parameters.
-
-* `Std.Sat` (for `bv_decide`)
-  * [#4933](https://github.com/leanprover/lean4/pull/4933) adds definitions of SAT and CNF.
-  * [#4953](https://github.com/leanprover/lean4/pull/4953) defines "and-inverter graphs" (AIGs) as described in section 3 of [Davis-Swords 2013](https://arxiv.org/pdf/1304.7861.pdf).
-
-* **Parsec**
-  * [#4774](https://github.com/leanprover/lean4/pull/4774) generalizes the `Parsec` library, allowing parsing of iterable data beyond `String` such as `ByteArray`. (See breaking changes.)
-  * [#5115](https://github.com/leanprover/lean4/pull/5115) moves `Lean.Data.Parsec` to `Std.Internal.Parsec` for bootstrappng reasons.
-
-* `Thunk`
-  * [#4969](https://github.com/leanprover/lean4/pull/4969) upstreams `Thunk.ext`.
-
-* **IO**
-  * [#4973](https://github.com/leanprover/lean4/pull/4973) modifies `IO.FS.lines` to handle `\r\n` on all operating systems instead of just on Windows.
-  * [#5125](https://github.com/leanprover/lean4/pull/5125) adds `createTempFile` and `withTempFile` for creating temporary files that can only be read and written by the current user.
-
-* **Other fixes or improvements**
-  * [#4945](https://github.com/leanprover/lean4/pull/4945) adds `Array`, `Bool` and `Prod` utilities from LeanSAT.
-  * [#4960](https://github.com/leanprover/lean4/pull/4960) adds `Relation.TransGen.trans`.
-  * [#5012](https://github.com/leanprover/lean4/pull/5012) states `WellFoundedRelation Nat` using `<`, not `Nat.lt`.
-  * [#5011](https://github.com/leanprover/lean4/pull/5011) uses `≠` instead of `Not (Eq ...)` in `Fin.ne_of_val_ne`.
-  * [#5197](https://github.com/leanprover/lean4/pull/5197) upstreams `Fin.le_antisymm`.
-  * [#5042](https://github.com/leanprover/lean4/pull/5042) reduces usage of `refine'`.
-  * [#5101](https://github.com/leanprover/lean4/pull/5101) adds about `if-then-else` and `Option`.
-  * [#5112](https://github.com/leanprover/lean4/pull/5112) adds basic instances for `ULift` and `PLift`.
-  * [#5133](https://github.com/leanprover/lean4/pull/5133) and [#5168](https://github.com/leanprover/lean4/pull/5168) make fixes from running the simpNF linter over Lean.
-  * [#5156](https://github.com/leanprover/lean4/pull/5156) removes a bad simp lemma in `omega` theory.
-  * [#5155](https://github.com/leanprover/lean4/pull/5155) improves confluence of `Bool` simp lemmas.
-  * [#5162](https://github.com/leanprover/lean4/pull/5162) improves confluence of `Function.comp` simp lemmas.
-  * [#5191](https://github.com/leanprover/lean4/pull/5191) improves confluence of `if-then-else` simp lemmas.
-  * [#5147](https://github.com/leanprover/lean4/pull/5147) adds `@[elab_as_elim]` to `Quot.rec`, `Nat.strongInductionOn` and `Nat.casesStrongInductionOn`, and also renames the latter two to `Nat.strongRecOn` and `Nat.casesStrongRecOn` (deprecated in [#5179](https://github.com/leanprover/lean4/pull/5179)).
-  * [#5180](https://github.com/leanprover/lean4/pull/5180) disables some simp lemmas with bad discrimination tree keys.
-  * [#5189](https://github.com/leanprover/lean4/pull/5189) cleans up internal simp lemmas that had leaked.
-  * [#5198](https://github.com/leanprover/lean4/pull/5198) cleans up `allowUnsafeReducibility`.
-  * [#5229](https://github.com/leanprover/lean4/pull/5229) removes unused lemmas from some `simp` tactics.
-  * [#5199](https://github.com/leanprover/lean4/pull/5199) removes >6 month deprecations.
-
-### Lean internals
-
-* **Performance**
-  * Some core algorithms have been rewritten in C++ for performance.
-    * [#4910](https://github.com/leanprover/lean4/pull/4910) and [#4912](https://github.com/leanprover/lean4/pull/4912) reimplement `instantiateLevelMVars`.
-    * [#4915](https://github.com/leanprover/lean4/pull/4915), [#4922](https://github.com/leanprover/lean4/pull/4922), and [#4931](https://github.com/leanprover/lean4/pull/4931) reimplement `instantiateExprMVars`, 30% faster on a benchmark.
-  * [#4934](https://github.com/leanprover/lean4/pull/4934) has optimizations for the kernel's `Expr` equality test.
-  * [#4990](https://github.com/leanprover/lean4/pull/4990) fixes bug in hashing for the kernel's `Expr` equality test.
-  * [#4935](https://github.com/leanprover/lean4/pull/4935) and [#4936](https://github.com/leanprover/lean4/pull/4936) skip some `PreDefinition` transformations if they are not needed.
-  * [#5225](https://github.com/leanprover/lean4/pull/5225) adds caching for visited exprs at `CheckAssignmentQuick` in `ExprDefEq`.
-  * [#5226](https://github.com/leanprover/lean4/pull/5226) maximizes term sharing at `instantiateMVarDeclMVars`, used by `runTactic`.
-* **Diagnostics and profiling**
-  * [#4923](https://github.com/leanprover/lean4/pull/4923) adds profiling for `instantiateMVars` in `Lean.Elab.MutualDef`, which can be a bottleneck there.
-  * [#4924](https://github.com/leanprover/lean4/pull/4924) adds diagnostics for large theorems, controlled by the `diagnostics.threshold.proofSize` option.
-  * [#4897](https://github.com/leanprover/lean4/pull/4897) improves display of diagnostic results.
-* **Other fixes or improvements**
-  * [#4921](https://github.com/leanprover/lean4/pull/4921) cleans up `Expr.betaRev`.
-  * [#4940](https://github.com/leanprover/lean4/pull/4940) fixes tests by not writing directly to stdout, which is unreliable now that elaboration and reporting are executed in separate threads.
-  * [#4955](https://github.com/leanprover/lean4/pull/4955) documents that `stderrAsMessages` is now the default on the command line as well.
-  * [#4647](https://github.com/leanprover/lean4/pull/4647) adjusts documentation for building on macOS.
-  * [#4987](https://github.com/leanprover/lean4/pull/4987) makes regular mvar assignments take precedence over delayed ones in `instantiateMVars`. Normally delayed assignment metavariables are never directly assigned, but on errors Lean assigns `sorry` to unassigned metavariables.
-  * [#4967](https://github.com/leanprover/lean4/pull/4967) adds linter name to errors when a linter crashes.
-  * [#5043](https://github.com/leanprover/lean4/pull/5043) cleans up command line snapshots logic.
-  * [#5067](https://github.com/leanprover/lean4/pull/5067) minimizes some imports.
-  * [#5068](https://github.com/leanprover/lean4/pull/5068) generalizes the monad for `addMatcherInfo`.
-  * [f71a1f](https://github.com/leanprover/lean4/commit/f71a1fb4ae958fccb3ad4d48786a8f47ced05c15) adds missing test for [#5126](https://github.com/leanprover/lean4/issues/5126).
-  * [#5201](https://github.com/leanprover/lean4/pull/5201) restores a test.
-  * [#3698](https://github.com/leanprover/lean4/pull/3698) fixes a bug where label attributes did not pass on the attribute kind.
-  * Typos: [#5080](https://github.com/leanprover/lean4/pull/5080), [#5150](https://github.com/leanprover/lean4/pull/5150), [#5202](https://github.com/leanprover/lean4/pull/5202)
-
-### Compiler, runtime, and FFI
-
-* [#3106](https://github.com/leanprover/lean4/pull/3106) moves frontend to new snapshot architecture. Note that `Frontend.processCommand` and `FrontendM` are no longer used by Lean core, but they will be preserved.
-* [#4919](https://github.com/leanprover/lean4/pull/4919) adds missing include in runtime for `AUTO_THREAD_FINALIZATION` feature on Windows.
-* [#4941](https://github.com/leanprover/lean4/pull/4941) adds more `LEAN_EXPORT`s for Windows.
-* [#4911](https://github.com/leanprover/lean4/pull/4911) improves formatting of CLI help text for the frontend.
-* [#4950](https://github.com/leanprover/lean4/pull/4950) improves file reading and writing.
-  * `readBinFile` and `readFile` now only require two system calls (`stat` + `read`) instead of one `read` per 1024 byte chunk.
-  * `Handle.getLine` and `Handle.putStr` no longer get tripped up by NUL characters.
-* [#4971](https://github.com/leanprover/lean4/pull/4971) handles the SIGBUS signal when detecting stack overflows.
-* [#5062](https://github.com/leanprover/lean4/pull/5062) avoids overwriting existing signal handlers, like in [rust-lang/rust#69685](https://github.com/rust-lang/rust/pull/69685).
-* [#4860](https://github.com/leanprover/lean4/pull/4860) improves workarounds for building on Windows. Splits `libleanshared` on Windows to avoid symbol limit, removes the `LEAN_EXPORT` denylist workaround, adds missing `LEAN_EXPORT`s.
-* [#4952](https://github.com/leanprover/lean4/pull/4952) output panics into Lean's redirected stderr, ensuring panics ARE visible as regular messages in the language server and properly ordered in relation to other messages on the command line.
-* [#4963](https://github.com/leanprover/lean4/pull/4963) links LibUV.
-
-### Lake
-
-* [#5030](https://github.com/leanprover/lean4/pull/5030) removes dead code.
-* [#4770](https://github.com/leanprover/lean4/pull/4770) adds additional fields to the package configuration which will be used by Reservoir. See the PR description for details.
-
-
-### DevOps/CI
-* [#4914](https://github.com/leanprover/lean4/pull/4914) and [#4937](https://github.com/leanprover/lean4/pull/4937) improve the release checklist.
-* [#4925](https://github.com/leanprover/lean4/pull/4925) ignores stale leanpkg tests.
-* [#5003](https://github.com/leanprover/lean4/pull/5003) upgrades `actions/cache` in CI.
-* [#5010](https://github.com/leanprover/lean4/pull/5010) sets `save-always` in cache actions in CI.
-* [#5008](https://github.com/leanprover/lean4/pull/5008) adds more libuv search patterns for the speedcenter.
-* [#5009](https://github.com/leanprover/lean4/pull/5009) reduce number of runs in the speedcenter for "fast" benchmarks from 10 to 3.
-* [#5014](https://github.com/leanprover/lean4/pull/5014) adjusts lakefile editing to use new `git` syntax in `pr-release` workflow.
-* [#5025](https://github.com/leanprover/lean4/pull/5025) has `pr-release` workflow pass `--retry` to `curl`.
-* [#5022](https://github.com/leanprover/lean4/pull/5022) builds MacOS Aarch64 release for PRs by default.
-* [#5045](https://github.com/leanprover/lean4/pull/5045) adds libuv to the required packages heading in macos docs.
-* [#5034](https://github.com/leanprover/lean4/pull/5034) fixes the install name of `libleanshared_1` on macOS.
-* [#5051](https://github.com/leanprover/lean4/pull/5051) fixes Windows stage 0.
-* [#5052](https://github.com/leanprover/lean4/pull/5052) fixes 32bit stage 0 builds in CI.
-* [#5057](https://github.com/leanprover/lean4/pull/5057) avoids rebuilding `leanmanifest` in each build.
-* [#5099](https://github.com/leanprover/lean4/pull/5099) makes `restart-on-label` workflow also filter by commit SHA.
-* [#4325](https://github.com/leanprover/lean4/pull/4325) adds CaDiCaL.
-
-### Breaking changes
-
-* [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. ([#4963](https://github.com/leanprover/lean4/pull/4963))
-
-* Recursive definitions with a `decreasing_by` clause that begins with `simp_wf` may break. Try removing `simp_wf` or replacing it with `simp`. ([#5016](https://github.com/leanprover/lean4/pull/5016))
-
-* The behavior of `rw [f]` where `f` is a non-recursive function defined by pattern matching changed.
-
-  For example, preciously, `rw [Option.map]` would rewrite `Option.map f o` to `match o with … `. Now this rewrite fails because it will use the equational lemmas, and these require constructors – just like for `List.map`.
-
-  Remedies:
-  * Split on `o` before rewriting.
-  * Use `rw [Option.map.eq_def]`, which rewrites any (saturated) application of `Option.map`.
-  * Use `set_option backward.eqns.nonrecursive false` when *defining* the function in question.
-  ([#4154](https://github.com/leanprover/lean4/pull/4154))
-
-* The unified handling of equation lemmas for recursive and non-recursive functions can break existing code, as there now can be extra equational lemmas:
-
-  * Explicit uses of `f.eq_2` might have to be adjusted if the numbering changed.
-
-  * Uses of `rw [f]` or `simp [f]` may no longer apply if they previously matched (and introduced a `match` statement), when the equational lemmas got more fine-grained.
-
-    In this case either case analysis on the parameters before rewriting helps, or setting the option `backward.eqns.deepRecursiveSplit false` while *defining* the function.
-
-  ([#5129](https://github.com/leanprover/lean4/pull/5129), [#5207](https://github.com/leanprover/lean4/pull/5207))
-
-* The `reduceCtorEq` simproc is now optional, and it might need to be included in lists of simp lemmas, like `simp only [reduceCtorEq]`. This simproc is responsible for reducing equalities of constructors. ([#5167](https://github.com/leanprover/lean4/pull/5167))
-
-* `Nat.strongInductionOn` is now `Nat.strongRecOn` and `Nat.caseStrongInductionOn` to `Nat.caseStrongRecOn`. ([#5147](https://github.com/leanprover/lean4/pull/5147))
-
-* The parameters to `Membership.mem` have been swapped, which affects all `Membership` instances. ([#5020](https://github.com/leanprover/lean4/pull/5020))
-
-* The meanings of `List.getElem_drop` and `List.getElem_drop'` have been reversed and the first is now a simp lemma. ([#5210](https://github.com/leanprover/lean4/pull/5210))
-
-* The `Parsec` library has moved from `Lean.Data.Parsec` to `Std.Internal.Parsec`. The `Parsec` type is now more general with a parameter for an iterable. Users parsing strings can migrate to `Parser` in the `Std.Internal.Parsec.String` namespace, which also includes string-focused parsing combinators. ([#4774](https://github.com/leanprover/lean4/pull/4774))
-
-* The `Lean` module has switched from `Lean.HashMap` and `Lean.HashSet` to `Std.HashMap` and `Std.HashSet` ([#4943](https://github.com/leanprover/lean4/pull/4943)). `Lean.HashMap` and `Lean.HashSet` are now deprecated ([#4954](https://github.com/leanprover/lean4/pull/4954)) 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 changes from `Lean.HashMap` to `Std.HashMap`:
-  * query functions use the term `get` instead of `find`, ([#4943](https://github.com/leanprover/lean4/pull/4943))
-  * the notation `map[key]` no longer returns an optional value but instead expects a proof that the key is present in the map. The previous behavior is available via the `map[key]?` notation.

releases/v4.13.0.md

@@ -1,312 +0,0 @@
-v4.13.0
-----------
-
-**Full Changelog**: https://github.com/leanprover/lean4/compare/v4.12.0...v4.13.0
-
-### Language features, tactics, and metaprograms
-
-* `structure` command
-  * [#5511](https://github.com/leanprover/lean4/pull/5511) allows structure parents to be type synonyms.
-  * [#5531](https://github.com/leanprover/lean4/pull/5531) allows default values for structure fields to be noncomputable.
-
-* `rfl` and `apply_rfl` tactics
-  * [#3714](https://github.com/leanprover/lean4/pull/3714), [#3718](https://github.com/leanprover/lean4/pull/3718) improve the `rfl` tactic and give better error messages.
-  * [#3772](https://github.com/leanprover/lean4/pull/3772) makes `rfl` no longer use kernel defeq for ground terms.
-  * [#5329](https://github.com/leanprover/lean4/pull/5329) tags `Iff.refl` with `@[refl]` (@Parcly-Taxel)
-  * [#5359](https://github.com/leanprover/lean4/pull/5359) ensures that the `rfl` tactic tries `Iff.rfl` (@Parcly-Taxel)
-
-* `unfold` tactic
-  * [#4834](https://github.com/leanprover/lean4/pull/4834) let `unfold` do zeta-delta reduction of local definitions, incorporating functionality of the Mathlib `unfold_let` tactic.
-
-* `omega` tactic
-  * [#5382](https://github.com/leanprover/lean4/pull/5382) fixes spurious error in [#5315](https://github.com/leanprover/lean4/issues/5315)
-  * [#5523](https://github.com/leanprover/lean4/pull/5523) supports `Int.toNat`
-
-* `simp` tactic
-  * [#5479](https://github.com/leanprover/lean4/pull/5479) lets `simp` apply rules with higher-order patterns.
-
-* `induction` tactic
-  * [#5494](https://github.com/leanprover/lean4/pull/5494) fixes `induction`’s "pre-tactic" block to always be indented, avoiding unintended uses of it.
-
-* `ac_nf` tactic
-  * [#5524](https://github.com/leanprover/lean4/pull/5524) adds `ac_nf`, a counterpart to `ac_rfl`, for normalizing expressions with respect to associativity and commutativity. Tests it with `BitVec` expressions.
-
-* `bv_decide`
-  * [#5211](https://github.com/leanprover/lean4/pull/5211) makes `extractLsb'` the primitive `bv_decide` understands, rather than `extractLsb` (@alexkeizer)
-  * [#5365](https://github.com/leanprover/lean4/pull/5365) adds `bv_decide` diagnoses.
-  * [#5375](https://github.com/leanprover/lean4/pull/5375) adds `bv_decide` normalization rules for `ofBool (a.getLsbD i)` and `ofBool a[i]` (@alexkeizer)
-  * [#5423](https://github.com/leanprover/lean4/pull/5423) enhances the rewriting rules of `bv_decide`
-  * [#5433](https://github.com/leanprover/lean4/pull/5433) presents the `bv_decide` counterexample at the API
-  * [#5484](https://github.com/leanprover/lean4/pull/5484) handles `BitVec.ofNat` with `Nat` fvars in `bv_decide`
-  * [#5506](https://github.com/leanprover/lean4/pull/5506), [#5507](https://github.com/leanprover/lean4/pull/5507) add `bv_normalize` rules.
-  * [#5568](https://github.com/leanprover/lean4/pull/5568) generalize the `bv_normalize` pipeline to support more general preprocessing passes
-  * [#5573](https://github.com/leanprover/lean4/pull/5573) gets `bv_normalize` up-to-date with the current `BitVec` rewrites
-  * Cleanups: [#5408](https://github.com/leanprover/lean4/pull/5408), [#5493](https://github.com/leanprover/lean4/pull/5493), [#5578](https://github.com/leanprover/lean4/pull/5578)
-
-
-* Elaboration improvements
-  * [#5266](https://github.com/leanprover/lean4/pull/5266) preserve order of overapplied arguments in `elab_as_elim` procedure.
-  * [#5510](https://github.com/leanprover/lean4/pull/5510) generalizes `elab_as_elim` to allow arbitrary motive applications.
-  * [#5283](https://github.com/leanprover/lean4/pull/5283), [#5512](https://github.com/leanprover/lean4/pull/5512) refine how named arguments suppress explicit arguments. Breaking change: some previously omitted explicit arguments may need explicit `_` arguments now.
-  * [#5376](https://github.com/leanprover/lean4/pull/5376) modifies projection instance binder info for instances, making parameters that are instance implicit in the type be implicit.
-  * [#5402](https://github.com/leanprover/lean4/pull/5402) localizes universe metavariable errors to `let` bindings and `fun` binders if possible. Makes "cannot synthesize metavariable" errors take precedence over unsolved universe level errors.
-  * [#5419](https://github.com/leanprover/lean4/pull/5419) must not reduce `ite` in the discriminant of `match`-expression when reducibility setting is `.reducible`
-  * [#5474](https://github.com/leanprover/lean4/pull/5474) have autoparams report parameter/field on failure
-  * [#5530](https://github.com/leanprover/lean4/pull/5530) makes automatic instance names about types with hygienic names be hygienic.
-
-* Deriving handlers
-  * [#5432](https://github.com/leanprover/lean4/pull/5432) makes `Repr` deriving instance handle explicit type parameters
-
-* Functional induction
-  * [#5364](https://github.com/leanprover/lean4/pull/5364) adds more equalities in context, more careful cleanup.
-
-* Linters
-  * [#5335](https://github.com/leanprover/lean4/pull/5335) fixes the unused variables linter complaining about match/tactic combinations
-  * [#5337](https://github.com/leanprover/lean4/pull/5337) fixes the unused variables linter complaining about some wildcard patterns
-
-* Other fixes
-  * [#4768](https://github.com/leanprover/lean4/pull/4768) fixes a parse error when `..` appears with a `.` on the next line
-
-* Metaprogramming
-  * [#3090](https://github.com/leanprover/lean4/pull/3090) handles level parameters in `Meta.evalExpr` (@eric-wieser)
-  * [#5401](https://github.com/leanprover/lean4/pull/5401) instance for `Inhabited (TacticM α)` (@alexkeizer)
-  * [#5412](https://github.com/leanprover/lean4/pull/5412) expose Kernel.check for debugging purposes
-  * [#5556](https://github.com/leanprover/lean4/pull/5556) improves the "invalid projection" type inference error in `inferType`.
-  * [#5587](https://github.com/leanprover/lean4/pull/5587) allows `MVarId.assertHypotheses` to set `BinderInfo` and `LocalDeclKind`.
-  * [#5588](https://github.com/leanprover/lean4/pull/5588) adds `MVarId.tryClearMany'`, a variant of `MVarId.tryClearMany`.
-
-
-
-### Language server, widgets, and IDE extensions
-
-* [#5205](https://github.com/leanprover/lean4/pull/5205) decreases the latency of auto-completion in tactic blocks.
-* [#5237](https://github.com/leanprover/lean4/pull/5237) fixes symbol occurrence highlighting in VS Code not highlighting occurrences when moving the text cursor into the identifier from the right.
-* [#5257](https://github.com/leanprover/lean4/pull/5257) fixes several instances of incorrect auto-completions being reported.
-* [#5299](https://github.com/leanprover/lean4/pull/5299) allows auto-completion to report completions for global identifiers when the elaborator fails to provide context-specific auto-completions.
-* [#5312](https://github.com/leanprover/lean4/pull/5312) fixes the server breaking when changing whitespace after the module header.
-* [#5322](https://github.com/leanprover/lean4/pull/5322) fixes several instances of auto-completion reporting non-existent namespaces.
-* [#5428](https://github.com/leanprover/lean4/pull/5428) makes sure to always report some recent file range as progress when waiting for elaboration.
-
-
-### Pretty printing
-
-* [#4979](https://github.com/leanprover/lean4/pull/4979) make pretty printer escape identifiers that are tokens.
-* [#5389](https://github.com/leanprover/lean4/pull/5389) makes formatter use the current token table.
-* [#5513](https://github.com/leanprover/lean4/pull/5513) use breakable instead of unbreakable whitespace when formatting tokens.
-
-
-### Library
-
-* [#5222](https://github.com/leanprover/lean4/pull/5222) reduces allocations in `Json.compress`.
-* [#5231](https://github.com/leanprover/lean4/pull/5231) upstreams `Zero` and `NeZero`
-* [#5292](https://github.com/leanprover/lean4/pull/5292) refactors `Lean.Elab.Deriving.FromToJson` (@arthur-adjedj)
-* [#5415](https://github.com/leanprover/lean4/pull/5415) implements `Repr Empty` (@TomasPuverle)
-* [#5421](https://github.com/leanprover/lean4/pull/5421) implements `To/FromJSON Empty` (@TomasPuverle)
-
-* Logic
-  * [#5263](https://github.com/leanprover/lean4/pull/5263) allows simplifying `dite_not`/`decide_not` with only `Decidable (¬p)`.
-  * [#5268](https://github.com/leanprover/lean4/pull/5268) fixes binders on `ite_eq_left_iff`
-  * [#5284](https://github.com/leanprover/lean4/pull/5284) turns off `Inhabited (Sum α β)` instances
-  * [#5355](https://github.com/leanprover/lean4/pull/5355) adds simp lemmas for `LawfulBEq`
-  * [#5374](https://github.com/leanprover/lean4/pull/5374) add `Nonempty` instances for products, allowing more `partial` functions to elaborate successfully
-  * [#5447](https://github.com/leanprover/lean4/pull/5447) updates Pi instance names
-  * [#5454](https://github.com/leanprover/lean4/pull/5454) makes some instance arguments implicit
-  * [#5456](https://github.com/leanprover/lean4/pull/5456) adds `heq_comm`
-  * [#5529](https://github.com/leanprover/lean4/pull/5529) moves `@[simp]` from `exists_prop'` to `exists_prop`
-
-* `Bool`
-  * [#5228](https://github.com/leanprover/lean4/pull/5228) fills gaps in Bool lemmas
-  * [#5332](https://github.com/leanprover/lean4/pull/5332) adds notation `^^` for Bool.xor
-  * [#5351](https://github.com/leanprover/lean4/pull/5351) removes `_root_.and` (and or/not/xor) and instead exports/uses `Bool.and` (etc.).
-
-* `BitVec`
-  * [#5240](https://github.com/leanprover/lean4/pull/5240) removes BitVec simps with complicated RHS
-  * [#5247](https://github.com/leanprover/lean4/pull/5247) `BitVec.getElem_zeroExtend`
-  * [#5248](https://github.com/leanprover/lean4/pull/5248) simp lemmas for BitVec, improving confluence
-  * [#5249](https://github.com/leanprover/lean4/pull/5249) removes `@[simp]` from some BitVec lemmas
-  * [#5252](https://github.com/leanprover/lean4/pull/5252) changes `BitVec.intMin/Max` from abbrev to def
-  * [#5278](https://github.com/leanprover/lean4/pull/5278) adds `BitVec.getElem_truncate` (@tobiasgrosser)
-  * [#5281](https://github.com/leanprover/lean4/pull/5281) adds udiv/umod bitblasting for `bv_decide` (@bollu)
-  * [#5297](https://github.com/leanprover/lean4/pull/5297) `BitVec` unsigned order theoretic results
-  * [#5313](https://github.com/leanprover/lean4/pull/5313) adds more basic BitVec ordering theory for UInt
-  * [#5314](https://github.com/leanprover/lean4/pull/5314) adds `toNat_sub_of_le` (@bollu)
-  * [#5357](https://github.com/leanprover/lean4/pull/5357) adds `BitVec.truncate` lemmas
-  * [#5358](https://github.com/leanprover/lean4/pull/5358) introduces `BitVec.setWidth` to unify zeroExtend and truncate (@tobiasgrosser)
-  * [#5361](https://github.com/leanprover/lean4/pull/5361) some BitVec GetElem lemmas
-  * [#5385](https://github.com/leanprover/lean4/pull/5385) adds `BitVec.ofBool_[and|or|xor]_ofBool` theorems (@tobiasgrosser)
-  * [#5404](https://github.com/leanprover/lean4/pull/5404) more of `BitVec.getElem_*` (@tobiasgrosser)
-  * [#5410](https://github.com/leanprover/lean4/pull/5410) BitVec analogues of `Nat.{mul_two, two_mul, mul_succ, succ_mul}` (@bollu)
-  * [#5411](https://github.com/leanprover/lean4/pull/5411) `BitVec.toNat_{add,sub,mul_of_lt}` for BitVector non-overflow reasoning (@bollu)
-  * [#5413](https://github.com/leanprover/lean4/pull/5413) adds `_self`, `_zero`, and `_allOnes` for `BitVec.[and|or|xor]` (@tobiasgrosser)
-  * [#5416](https://github.com/leanprover/lean4/pull/5416) adds LawCommIdentity + IdempotentOp for `BitVec.[and|or|xor]` (@tobiasgrosser)
-  * [#5418](https://github.com/leanprover/lean4/pull/5418) decidable quantifers for BitVec
-  * [#5450](https://github.com/leanprover/lean4/pull/5450) adds `BitVec.toInt_[intMin|neg|neg_of_ne_intMin]` (@tobiasgrosser)
-  * [#5459](https://github.com/leanprover/lean4/pull/5459) missing BitVec lemmas
-  * [#5469](https://github.com/leanprover/lean4/pull/5469) adds `BitVec.[not_not, allOnes_shiftLeft_or_shiftLeft, allOnes_shiftLeft_and_shiftLeft]` (@luisacicolini)
-  * [#5478](https://github.com/leanprover/lean4/pull/5478) adds `BitVec.(shiftLeft_add_distrib, shiftLeft_ushiftRight)` (@luisacicolini)
-  * [#5487](https://github.com/leanprover/lean4/pull/5487) adds `sdiv_eq`, `smod_eq` to allow `sdiv`/`smod` bitblasting (@bollu)
-  * [#5491](https://github.com/leanprover/lean4/pull/5491) adds `BitVec.toNat_[abs|sdiv|smod]` (@tobiasgrosser)
-  * [#5492](https://github.com/leanprover/lean4/pull/5492) `BitVec.(not_sshiftRight, not_sshiftRight_not, getMsb_not, msb_not)` (@luisacicolini)
-  * [#5499](https://github.com/leanprover/lean4/pull/5499) `BitVec.Lemmas` - drop non-terminal simps (@tobiasgrosser)
-  * [#5505](https://github.com/leanprover/lean4/pull/5505) unsimps `BitVec.divRec_succ'`
-  * [#5508](https://github.com/leanprover/lean4/pull/5508) adds `BitVec.getElem_[add|add_add_bool|mul|rotateLeft|rotateRight…` (@tobiasgrosser)
-  * [#5554](https://github.com/leanprover/lean4/pull/5554) adds `Bitvec.[add, sub, mul]_eq_xor` and `width_one_cases` (@luisacicolini)
-
-* `List`
-  * [#5242](https://github.com/leanprover/lean4/pull/5242) improve naming for `List.mergeSort` lemmas
-  * [#5302](https://github.com/leanprover/lean4/pull/5302) provide `mergeSort` comparator autoParam
-  * [#5373](https://github.com/leanprover/lean4/pull/5373) fix name of `List.length_mergeSort`
-  * [#5377](https://github.com/leanprover/lean4/pull/5377) upstream `map_mergeSort`
-  * [#5378](https://github.com/leanprover/lean4/pull/5378) modify signature of lemmas about `mergeSort`
-  * [#5245](https://github.com/leanprover/lean4/pull/5245) avoid importing `List.Basic` without List.Impl
-  * [#5260](https://github.com/leanprover/lean4/pull/5260) review of List API
-  * [#5264](https://github.com/leanprover/lean4/pull/5264) review of List API
-  * [#5269](https://github.com/leanprover/lean4/pull/5269) remove HashMap's duplicated Pairwise and Sublist
-  * [#5271](https://github.com/leanprover/lean4/pull/5271) remove @[simp] from `List.head_mem` and similar
-  * [#5273](https://github.com/leanprover/lean4/pull/5273) lemmas about `List.attach`
-  * [#5275](https://github.com/leanprover/lean4/pull/5275) reverse direction of `List.tail_map`
-  * [#5277](https://github.com/leanprover/lean4/pull/5277) more `List.attach` lemmas
-  * [#5285](https://github.com/leanprover/lean4/pull/5285) `List.count` lemmas
-  * [#5287](https://github.com/leanprover/lean4/pull/5287) use boolean predicates in `List.filter`
-  * [#5289](https://github.com/leanprover/lean4/pull/5289) `List.mem_ite_nil_left` and analogues
-  * [#5293](https://github.com/leanprover/lean4/pull/5293) cleanup of `List.findIdx` / `List.take` lemmas
-  * [#5294](https://github.com/leanprover/lean4/pull/5294) switch primes on `List.getElem_take`
-  * [#5300](https://github.com/leanprover/lean4/pull/5300) more `List.findIdx` theorems
-  * [#5310](https://github.com/leanprover/lean4/pull/5310) fix `List.all/any` lemmas
-  * [#5311](https://github.com/leanprover/lean4/pull/5311) fix `List.countP` lemmas
-  * [#5316](https://github.com/leanprover/lean4/pull/5316) `List.tail` lemma
-  * [#5331](https://github.com/leanprover/lean4/pull/5331) fix implicitness of `List.getElem_mem`
-  * [#5350](https://github.com/leanprover/lean4/pull/5350) `List.replicate` lemmas
-  * [#5352](https://github.com/leanprover/lean4/pull/5352) `List.attachWith` lemmas
-  * [#5353](https://github.com/leanprover/lean4/pull/5353) `List.head_mem_head?`
-  * [#5360](https://github.com/leanprover/lean4/pull/5360) lemmas about `List.tail`
-  * [#5391](https://github.com/leanprover/lean4/pull/5391) review of `List.erase` / `List.find` lemmas
-  * [#5392](https://github.com/leanprover/lean4/pull/5392) `List.fold` / `attach` lemmas
-  * [#5393](https://github.com/leanprover/lean4/pull/5393) `List.fold` relators
-  * [#5394](https://github.com/leanprover/lean4/pull/5394) lemmas about `List.maximum?`
-  * [#5403](https://github.com/leanprover/lean4/pull/5403) theorems about `List.toArray`
-  * [#5405](https://github.com/leanprover/lean4/pull/5405) reverse direction of `List.set_map`
-  * [#5448](https://github.com/leanprover/lean4/pull/5448) add lemmas about `List.IsPrefix` (@Command-Master)
-  * [#5460](https://github.com/leanprover/lean4/pull/5460) missing `List.set_replicate_self`
-  * [#5518](https://github.com/leanprover/lean4/pull/5518) rename `List.maximum?` to `max?`
-  * [#5519](https://github.com/leanprover/lean4/pull/5519) upstream `List.fold` lemmas
-  * [#5520](https://github.com/leanprover/lean4/pull/5520) restore `@[simp]` on `List.getElem_mem` etc.
-  * [#5521](https://github.com/leanprover/lean4/pull/5521) List simp fixes
-  * [#5550](https://github.com/leanprover/lean4/pull/5550) `List.unattach` and simp lemmas
-  * [#5594](https://github.com/leanprover/lean4/pull/5594) induction-friendly `List.min?_cons`
-
-* `Array`
-  * [#5246](https://github.com/leanprover/lean4/pull/5246) cleanup imports of Array.Lemmas
-  * [#5255](https://github.com/leanprover/lean4/pull/5255) split Init.Data.Array.Lemmas for better bootstrapping
-  * [#5288](https://github.com/leanprover/lean4/pull/5288) rename `Array.data` to `Array.toList`
-  * [#5303](https://github.com/leanprover/lean4/pull/5303) cleanup of `List.getElem_append` variants
-  * [#5304](https://github.com/leanprover/lean4/pull/5304) `Array.not_mem_empty`
-  * [#5400](https://github.com/leanprover/lean4/pull/5400) reorganization in Array/Basic
-  * [#5420](https://github.com/leanprover/lean4/pull/5420) make `Array` functions either semireducible or use structural recursion
-  * [#5422](https://github.com/leanprover/lean4/pull/5422) refactor `DecidableEq (Array α)`
-  * [#5452](https://github.com/leanprover/lean4/pull/5452) refactor of Array
-  * [#5458](https://github.com/leanprover/lean4/pull/5458) cleanup of Array docstrings after refactor
-  * [#5461](https://github.com/leanprover/lean4/pull/5461) restore `@[simp]` on `Array.swapAt!_def`
-  * [#5465](https://github.com/leanprover/lean4/pull/5465) improve Array GetElem lemmas
-  * [#5466](https://github.com/leanprover/lean4/pull/5466) `Array.foldX` lemmas
-  * [#5472](https://github.com/leanprover/lean4/pull/5472) @[simp] lemmas about `List.toArray`
-  * [#5485](https://github.com/leanprover/lean4/pull/5485) reverse simp direction for `toArray_concat`
-  * [#5514](https://github.com/leanprover/lean4/pull/5514) `Array.eraseReps`
-  * [#5515](https://github.com/leanprover/lean4/pull/5515) upstream `Array.qsortOrd`
-  * [#5516](https://github.com/leanprover/lean4/pull/5516) upstream `Subarray.empty`
-  * [#5526](https://github.com/leanprover/lean4/pull/5526) fix name of `Array.length_toList`
-  * [#5527](https://github.com/leanprover/lean4/pull/5527) reduce use of deprecated lemmas in Array
-  * [#5534](https://github.com/leanprover/lean4/pull/5534) cleanup of Array GetElem lemmas
-  * [#5536](https://github.com/leanprover/lean4/pull/5536) fix `Array.modify` lemmas
-  * [#5551](https://github.com/leanprover/lean4/pull/5551) upstream `Array.flatten` lemmas
-  * [#5552](https://github.com/leanprover/lean4/pull/5552) switch obvious cases of array "bang"`[]!` indexing to rely on hypothesis (@TomasPuverle)
-  * [#5577](https://github.com/leanprover/lean4/pull/5577) add missing simp to `Array.size_feraseIdx`
-  * [#5586](https://github.com/leanprover/lean4/pull/5586) `Array/Option.unattach`
-
-* `Option`
-  * [#5272](https://github.com/leanprover/lean4/pull/5272) remove @[simp] from `Option.pmap/pbind` and add simp lemmas
-  * [#5307](https://github.com/leanprover/lean4/pull/5307) restoring Option simp confluence
-  * [#5354](https://github.com/leanprover/lean4/pull/5354) remove @[simp] from `Option.bind_map`
-  * [#5532](https://github.com/leanprover/lean4/pull/5532) `Option.attach`
-  * [#5539](https://github.com/leanprover/lean4/pull/5539) fix explicitness of `Option.mem_toList`
-
-* `Nat`
-  * [#5241](https://github.com/leanprover/lean4/pull/5241) add @[simp] to `Nat.add_eq_zero_iff`
-  * [#5261](https://github.com/leanprover/lean4/pull/5261) Nat bitwise lemmas
-  * [#5262](https://github.com/leanprover/lean4/pull/5262) `Nat.testBit_add_one` should not be a global simp lemma
-  * [#5267](https://github.com/leanprover/lean4/pull/5267) protect some Nat bitwise theorems
-  * [#5305](https://github.com/leanprover/lean4/pull/5305) rename Nat bitwise lemmas
-  * [#5306](https://github.com/leanprover/lean4/pull/5306) add `Nat.self_sub_mod` lemma
-  * [#5503](https://github.com/leanprover/lean4/pull/5503) restore @[simp] to upstreamed `Nat.lt_off_iff`
-
-* `Int`
-  * [#5301](https://github.com/leanprover/lean4/pull/5301) rename `Int.div/mod` to `Int.tdiv/tmod`
-  * [#5320](https://github.com/leanprover/lean4/pull/5320) add `ediv_nonneg_of_nonpos_of_nonpos` to DivModLemmas (@sakehl)
-
-* `Fin`
-  * [#5250](https://github.com/leanprover/lean4/pull/5250) missing lemma about `Fin.ofNat'`
-  * [#5356](https://github.com/leanprover/lean4/pull/5356) `Fin.ofNat'` uses `NeZero`
-  * [#5379](https://github.com/leanprover/lean4/pull/5379) remove some @[simp]s from Fin lemmas
-  * [#5380](https://github.com/leanprover/lean4/pull/5380) missing Fin @[simp] lemmas
-
-* `HashMap`
-  * [#5244](https://github.com/leanprover/lean4/pull/5244) (`DHashMap`|`HashMap`|`HashSet`).(`getKey?`|`getKey`|`getKey!`|`getKeyD`)
-  * [#5362](https://github.com/leanprover/lean4/pull/5362) remove the last use of `Lean.(HashSet|HashMap)`
-  * [#5369](https://github.com/leanprover/lean4/pull/5369) `HashSet.ofArray`
-  * [#5370](https://github.com/leanprover/lean4/pull/5370) `HashSet.partition`
-  * [#5581](https://github.com/leanprover/lean4/pull/5581) `Singleton`/`Insert`/`Union` instances for `HashMap`/`Set`
-  * [#5582](https://github.com/leanprover/lean4/pull/5582) `HashSet.all`/`any`
-  * [#5590](https://github.com/leanprover/lean4/pull/5590) adding `Insert`/`Singleton`/`Union` instances for `HashMap`/`Set.Raw`
-  * [#5591](https://github.com/leanprover/lean4/pull/5591) `HashSet.Raw.all/any`
-
-* `Monads`
-  * [#5463](https://github.com/leanprover/lean4/pull/5463) upstream some monad lemmas
-  * [#5464](https://github.com/leanprover/lean4/pull/5464) adjust simp attributes on monad lemmas
-  * [#5522](https://github.com/leanprover/lean4/pull/5522) more monadic simp lemmas
-
-* Simp lemma cleanup
-  * [#5251](https://github.com/leanprover/lean4/pull/5251) remove redundant simp annotations
-  * [#5253](https://github.com/leanprover/lean4/pull/5253) remove Int simp lemmas that can't fire
-  * [#5254](https://github.com/leanprover/lean4/pull/5254) variables appearing on both sides of an iff should be implicit
-  * [#5381](https://github.com/leanprover/lean4/pull/5381) cleaning up redundant simp lemmas
-
-
-### Compiler, runtime, and FFI
-
-* [#4685](https://github.com/leanprover/lean4/pull/4685) fixes a typo in the C `run_new_frontend` signature
-* [#4729](https://github.com/leanprover/lean4/pull/4729) has IR checker suggest using `noncomputable`
-* [#5143](https://github.com/leanprover/lean4/pull/5143) adds a shared library for Lake
-* [#5437](https://github.com/leanprover/lean4/pull/5437) removes (syntactically) duplicate imports (@euprunin)
-* [#5462](https://github.com/leanprover/lean4/pull/5462) updates `src/lake/lakefile.toml` to the adjusted Lake build process
-* [#5541](https://github.com/leanprover/lean4/pull/5541) removes new shared libs before build to better support Windows
-* [#5558](https://github.com/leanprover/lean4/pull/5558) make `lean.h` compile with MSVC (@kant2002)
-* [#5564](https://github.com/leanprover/lean4/pull/5564) removes non-conforming size-0 arrays (@eric-wieser)
-
-
-### Lake
-  * Reservoir build cache. Lake will now attempt to fetch a pre-built copy of the package from Reservoir before building it. This is only enabled for packages in the leanprover or leanprover-community organizations on versions indexed by Reservoir. Users can force Lake to build packages from the source by passing --no-cache on the CLI or by setting the  LAKE_NO_CACHE environment variable to true. [#5486](https://github.com/leanprover/lean4/pull/5486), [#5572](https://github.com/leanprover/lean4/pull/5572), [#5583](https://github.com/leanprover/lean4/pull/5583), [#5600](https://github.com/leanprover/lean4/pull/5600), [#5641](https://github.com/leanprover/lean4/pull/5641), [#5642](https://github.com/leanprover/lean4/pull/5642).
-  * [#5504](https://github.com/leanprover/lean4/pull/5504) lake new and lake init now produce TOML configurations by default.
-  * [#5878](https://github.com/leanprover/lean4/pull/5878) fixes a serious issue where Lake would delete path dependencies when attempting to cleanup a dependency required with an incorrect name.
-
-  * **Breaking changes**
-    * [#5641](https://github.com/leanprover/lean4/pull/5641) A Lake build of target within a package will no longer build a package's dependencies package-level extra target dependencies. At the technical level, a package's extraDep facet no longer transitively builds its dependencies’ extraDep facets (which include their extraDepTargets).
-
-### Documentation fixes
-
-* [#3918](https://github.com/leanprover/lean4/pull/3918) `@[builtin_doc]` attribute (@digama0)
-* [#4305](https://github.com/leanprover/lean4/pull/4305) explains the borrow syntax (@eric-wieser)
-* [#5349](https://github.com/leanprover/lean4/pull/5349) adds documentation for `groupBy.loop` (@vihdzp)
-* [#5473](https://github.com/leanprover/lean4/pull/5473) fixes typo in `BitVec.mul` docstring (@llllvvuu)
-* [#5476](https://github.com/leanprover/lean4/pull/5476) fixes typos in `Lean.MetavarContext`
-* [#5481](https://github.com/leanprover/lean4/pull/5481) removes mention of `Lean.withSeconds` (@alexkeizer)
-* [#5497](https://github.com/leanprover/lean4/pull/5497) updates documentation and tests for `toUIntX` functions (@TomasPuverle)
-* [#5087](https://github.com/leanprover/lean4/pull/5087) mentions that `inferType` does not ensure type correctness
-* Many fixes to spelling across the doc-strings, (@euprunin): [#5425](https://github.com/leanprover/lean4/pull/5425) [#5426](https://github.com/leanprover/lean4/pull/5426) [#5427](https://github.com/leanprover/lean4/pull/5427) [#5430](https://github.com/leanprover/lean4/pull/5430)  [#5431](https://github.com/leanprover/lean4/pull/5431) [#5434](https://github.com/leanprover/lean4/pull/5434) [#5435](https://github.com/leanprover/lean4/pull/5435) [#5436](https://github.com/leanprover/lean4/pull/5436) [#5438](https://github.com/leanprover/lean4/pull/5438) [#5439](https://github.com/leanprover/lean4/pull/5439) [#5440](https://github.com/leanprover/lean4/pull/5440) [#5599](https://github.com/leanprover/lean4/pull/5599)
-
-### Changes to CI
-
-* [#5343](https://github.com/leanprover/lean4/pull/5343) allows addition of `release-ci` label via comment (@thorimur)
-* [#5344](https://github.com/leanprover/lean4/pull/5344) sets check level correctly during workflow (@thorimur)
-* [#5444](https://github.com/leanprover/lean4/pull/5444) Mathlib's `lean-pr-testing-NNNN` branches should use Batteries' `lean-pr-testing-NNNN` branches
-* [#5489](https://github.com/leanprover/lean4/pull/5489) commit `lake-manifest.json` when updating `lean-pr-testing` branches
-* [#5490](https://github.com/leanprover/lean4/pull/5490) use separate secrets for commenting and branching in `pr-release.yml`

releases/v4.14.0.md

@@ -1,282 +0,0 @@
-v4.14.0
-----------
-
-**Full Changelog**: https://github.com/leanprover/lean4/compare/v4.13.0...v4.14.0
-
-### Language features, tactics, and metaprograms
-
-* `structure` and `inductive` commands
-  * [#5517](https://github.com/leanprover/lean4/pull/5517) improves universe level inference for the resulting type of an `inductive` or `structure.` Recall that a `Prop`-valued inductive type is a syntactic subsingleton if it has at most one constructor and all the arguments to the constructor are in `Prop`. Such types have large elimination, so they could be defined in `Type` or `Prop` without any trouble. The way inference has changed is that if a type is a syntactic subsingleton with exactly one constructor, and the constructor has at least one parameter/field, then the `inductive`/`structure` command will prefer creating a `Prop` instead of a `Type`. The upshot is that the `: Prop` in `structure S : Prop` is often no longer needed. (With @arthur-adjedj).
-  * [#5842](https://github.com/leanprover/lean4/pull/5842) and [#5783](https://github.com/leanprover/lean4/pull/5783) implement a feature where the `structure` command can now define recursive inductive types:
-    ```lean
-    structure Tree where
-      n : Nat
-      children : Fin n → Tree
-
-    def Tree.size : Tree → Nat
-      | {n, children} => Id.run do
-        let mut s := 0
-        for h : i in [0 : n] do
-          s := s + (children ⟨i, h.2⟩).size
-        pure s
-    ```
-  * [#5814](https://github.com/leanprover/lean4/pull/5814) fixes a bug where Mathlib's `Type*` elaborator could lead to incorrect universe parameters with the `inductive` command.
-  * [#3152](https://github.com/leanprover/lean4/pull/3152) and [#5844](https://github.com/leanprover/lean4/pull/5844) fix bugs in default value processing for structure instance notation (with @arthur-adjedj).
-  * [#5399](https://github.com/leanprover/lean4/pull/5399) promotes instance synthesis order calculation failure from a soft error to a hard error.
-  * [#5542](https://github.com/leanprover/lean4/pull/5542) deprecates `:=` variants of `inductive` and `structure` (see breaking changes).
-
-* **Application elaboration improvements**
-  * [#5671](https://github.com/leanprover/lean4/pull/5671) makes `@[elab_as_elim]` require at least one discriminant, since otherwise there is no advantage to this alternative elaborator.
-  * [#5528](https://github.com/leanprover/lean4/pull/5528) enables field notation in explicit mode. The syntax `@x.f` elaborates as `@S.f` with `x` supplied to the appropriate parameter.
-  * [#5692](https://github.com/leanprover/lean4/pull/5692) modifies the dot notation resolution algorithm so that it can apply `CoeFun` instances. For example, Mathlib has `Multiset.card : Multiset α →+ Nat`, and now with `m : Multiset α`, the notation `m.card` resolves to `⇑Multiset.card m`.
-  * [#5658](https://github.com/leanprover/lean4/pull/5658) fixes a bug where 'don't know how to synthesize implicit argument' errors might have the incorrect local context when the eta arguments feature is activated.
-  * [#5933](https://github.com/leanprover/lean4/pull/5933) fixes a bug where `..` ellipses in patterns made use of optparams and autoparams.
-  * [#5770](https://github.com/leanprover/lean4/pull/5770) makes dot notation for structures resolve using *all* ancestors. Adds a *resolution order* for generalized field notation. This is the order of namespaces visited during resolution when trying to resolve names. The algorithm to compute a resolution order is the commonly used C3 linearization (used for example by Python), which when successful ensures that immediate parents' namespaces are considered before more distant ancestors' namespaces. By default we use a relaxed version of the algorithm that tolerates inconsistencies, but using `set_option structure.strictResolutionOrder true` makes inconsistent parent orderings into warnings.
-
-* **Recursion and induction principles**
-  * [#5619](https://github.com/leanprover/lean4/pull/5619) fixes functional induction principle generation to avoid over-eta-expanding in the preprocessing step.
-  * [#5766](https://github.com/leanprover/lean4/pull/5766) fixes structural nested recursion so that it is not confused when a nested type appears first.
-  * [#5803](https://github.com/leanprover/lean4/pull/5803) fixes a bug in functional induction principle generation when there are `let` bindings.
-  * [#5904](https://github.com/leanprover/lean4/pull/5904) improves functional induction principle generation to unfold aux definitions more carefully.
-  * [#5850](https://github.com/leanprover/lean4/pull/5850) refactors code for `Predefinition.Structural`.
-
-* **Error messages**
-  * [#5276](https://github.com/leanprover/lean4/pull/5276) fixes a bug in "type mismatch" errors that would structurally assign metavariables during the algorithm to expose differences.
-  * [#5919](https://github.com/leanprover/lean4/pull/5919) makes "type mismatch" errors add type ascriptions to expose differences for numeric literals.
-  * [#5922](https://github.com/leanprover/lean4/pull/5922) makes "type mismatch" errors expose differences in the bodies of functions and pi types.
-  * [#5888](https://github.com/leanprover/lean4/pull/5888) improves the error message for invalid induction alternative names in `match` expressions (@josojo).
-  * [#5719](https://github.com/leanprover/lean4/pull/5719) improves `calc` error messages.
-
-* [#5627](https://github.com/leanprover/lean4/pull/5627) and [#5663](https://github.com/leanprover/lean4/pull/5663) improve the **`#eval` command** and introduce some new features.
-  * Now results can be pretty printed if there is a `ToExpr` instance, which means **hoverable output**. If `ToExpr` fails, it then tries looking for a `Repr` or `ToString` instance like before. Setting `set_option eval.pp false` disables making use of `ToExpr` instances.
-  * There is now **auto-derivation** of `Repr` instances, enabled with the `pp.derive.repr` option (default to **true**). For example:
-    ```lean
-    inductive Baz
-    | a | b
-
-    #eval Baz.a
-    -- Baz.a
-    ```
-    It simply does `deriving instance Repr for Baz` when there's no way to represent `Baz`.
-  * The option `eval.type` controls whether or not to include the type in the output. For now the default is false.
-  * Now expressions such as `#eval do return 2`, where monad is unknown, work. It tries unifying the monad with `CommandElabM`, `TermElabM`, or `IO`.
-  * The classes `Lean.Eval` and `Lean.MetaEval` have been removed. These each used to be responsible for adapting monads and printing results. Now the `MonadEval` class is responsible for adapting monads for evaluation (it is similar to `MonadLift`, but instances are allowed to use default data when initializing state), and representing results is handled through a separate process.
-  * Error messages about failed instance synthesis are now more precise. Once it detects that a `MonadEval` class applies, then the error message will be specific about missing `ToExpr`/`Repr`/`ToString` instances.
-  * Fixes bugs where evaluating `MetaM` and `CoreM` wouldn't collect log messages.
-  * Fixes a bug where `let rec` could not be used in `#eval`.
-
-* `partial` definitions
-  * [#5780](https://github.com/leanprover/lean4/pull/5780) improves the error message when `partial` fails to prove a type is inhabited. Add delta deriving.
-  * [#5821](https://github.com/leanprover/lean4/pull/5821) gives `partial` inhabitation the ability to create local `Inhabited` instances from parameters.
-
-* **New tactic configuration syntax.** The configuration syntax for all core tactics has been given an upgrade. Rather than `simp (config := { contextual := true, maxSteps := 22})`, one can now write `simp +contextual (maxSteps := 22)`. Tactic authors can migrate by switching from `(config)?` to `optConfig` in tactic syntaxes and potentially deleting `mkOptionalNode` in elaborators. [#5883](https://github.com/leanprover/lean4/pull/5883), [#5898](https://github.com/leanprover/lean4/pull/5898),  [#5928](https://github.com/leanprover/lean4/pull/5928), and [#5932](https://github.com/leanprover/lean4/pull/5932). (Tactic authors, see breaking changes.)
-
-* `simp` tactic
-  * [#5632](https://github.com/leanprover/lean4/pull/5632) fixes the simpproc for `Fin` literals to reduce more consistently.
-  * [#5648](https://github.com/leanprover/lean4/pull/5648) fixes a bug in `simpa ... using t` where metavariables in `t` were not properly accounted for, and also improves the type mismatch error.
-  * [#5838](https://github.com/leanprover/lean4/pull/5838) fixes the docstring of `simp!` to actually talk about `simp!`.
-  * [#5870](https://github.com/leanprover/lean4/pull/5870) adds support for `attribute [simp ←]` (note the reverse direction). This adds the reverse of a theorem as a global simp theorem.
-
-* `decide` tactic
-  * [#5665](https://github.com/leanprover/lean4/pull/5665) adds `decide!` tactic for using kernel reduction (warning: this is renamed to `decide +kernel` in a future release).
-
-* `bv_decide` tactic
-  * [#5714](https://github.com/leanprover/lean4/pull/5714) adds inequality regression tests (@alexkeizer).
-  * [#5608](https://github.com/leanprover/lean4/pull/5608) adds `bv_toNat` tag for `toNat_ofInt` (@bollu).
-  * [#5618](https://github.com/leanprover/lean4/pull/5618) adds support for `at` in `ac_nf` and uses it in `bv_normalize` (@tobiasgrosser).
-  * [#5628](https://github.com/leanprover/lean4/pull/5628) adds udiv support.
-  * [#5635](https://github.com/leanprover/lean4/pull/5635) adds auxiliary bitblasters for negation and subtraction.
-  * [#5637](https://github.com/leanprover/lean4/pull/5637) adds more `getLsbD` bitblaster theory.
-  * [#5652](https://github.com/leanprover/lean4/pull/5652) adds umod support.
-  * [#5653](https://github.com/leanprover/lean4/pull/5653) adds performance benchmark for modulo.
-  * [#5655](https://github.com/leanprover/lean4/pull/5655) reduces error on `bv_check` to warning.
-  * [#5670](https://github.com/leanprover/lean4/pull/5670) adds `~~~(-x)` support.
-  * [#5673](https://github.com/leanprover/lean4/pull/5673) disables `ac_nf` by default.
-  * [#5675](https://github.com/leanprover/lean4/pull/5675) fixes context tracking in `bv_decide` counter example.
-  * [#5676](https://github.com/leanprover/lean4/pull/5676) adds an error when the LRAT proof is invalid.
-  * [#5781](https://github.com/leanprover/lean4/pull/5781) introduces uninterpreted symbols everywhere.
-  * [#5823](https://github.com/leanprover/lean4/pull/5823) adds `BitVec.sdiv` support.
-  * [#5852](https://github.com/leanprover/lean4/pull/5852) adds `BitVec.ofBool` support.
-  * [#5855](https://github.com/leanprover/lean4/pull/5855) adds `if` support.
-  * [#5869](https://github.com/leanprover/lean4/pull/5869) adds support for all the SMTLIB BitVec divison/remainder operations.
-  * [#5886](https://github.com/leanprover/lean4/pull/5886) adds embedded constraint substitution.
-  * [#5918](https://github.com/leanprover/lean4/pull/5918) fixes loose mvars bug in `bv_normalize`.
-  * Documentation:
-    * [#5636](https://github.com/leanprover/lean4/pull/5636) adds remarks about multiplication.
-
-* `conv` mode
-  * [#5861](https://github.com/leanprover/lean4/pull/5861) improves the `congr` conv tactic to handle "over-applied" functions.
-  * [#5894](https://github.com/leanprover/lean4/pull/5894) improves the `arg` conv tactic so that it can access more arguments and so that it can handle "over-applied" functions (it generates a specialized congruence lemma for the specific argument in question). Makes `arg 1` and `arg 2` apply to pi types in more situations. Adds negative indexing, for example `arg -2` is equivalent to the `lhs` tactic. Makes the `enter [...]` tactic show intermediate states like `rw`.
-
-* **Other tactics**
-  * [#4846](https://github.com/leanprover/lean4/pull/4846) fixes a bug where `generalize ... at *` would apply to implementation details (@ymherklotz).
-  * [#5730](https://github.com/leanprover/lean4/pull/5730) upstreams the `classical` tactic combinator.
-  * [#5815](https://github.com/leanprover/lean4/pull/5815) improves the error message when trying to unfold a local hypothesis that is not a local definition.
-  * [#5862](https://github.com/leanprover/lean4/pull/5862) and [#5863](https://github.com/leanprover/lean4/pull/5863) change how `apply` and `simp` elaborate, making them not disable error recovery. This improves hovers and completions when the term has elaboration errors.
-
-* `deriving` clauses
-  * [#5899](https://github.com/leanprover/lean4/pull/5899) adds declaration ranges for delta-derived instances.
-  * [#5265](https://github.com/leanprover/lean4/pull/5265) removes unused syntax in `deriving` clauses for providing arguments to deriving handlers (see breaking changes).
-
-* [#5065](https://github.com/leanprover/lean4/pull/5065) upstreams and updates `#where`, a command that reports the current scope information.
-
-* **Linters**
-  * [#5338](https://github.com/leanprover/lean4/pull/5338) makes the unused variables linter ignore variables defined in tactics by default now, avoiding performance bottlenecks.
-  * [#5644](https://github.com/leanprover/lean4/pull/5644) ensures that linters in general do not run on `#guard_msgs` itself.
-
-* **Metaprogramming interface**
-  * [#5720](https://github.com/leanprover/lean4/pull/5720) adds `pushGoal`/`pushGoals` and `popGoal` for manipulating the goal state. These are an alternative to `replaceMainGoal` and `getMainGoal`, and with them you don't need to worry about making sure nothing clears assigned metavariables from the goal list between assigning the main goal and using `replaceMainGoal`. Modifies `closeMainGoalUsing`, which is like a `TacticM` version of `liftMetaTactic`. Now the callback is run in a context where the main goal is removed from the goal list, and the callback is free to modify the goal list. Furthermore, the `checkUnassigned` argument has been replaced with `checkNewUnassigned`, which checks whether the value assigned to the goal has any *new* metavariables, relative to the start of execution of the callback. Modifies `withCollectingNewGoalsFrom` to take the `parentTag` argument explicitly rather than indirectly via `getMainTag`. Modifies `elabTermWithHoles` to optionally take `parentTag?`.
-  * [#5563](https://github.com/leanprover/lean4/pull/5563) fixes `getFunInfo` and `inferType` to use `withAtLeastTransparency` rather than `withTransparency`.
-  * [#5679](https://github.com/leanprover/lean4/pull/5679) fixes `RecursorVal.getInduct` to return the name of major argument’s type. This makes "structure eta" work for nested inductives.
-  * [#5681](https://github.com/leanprover/lean4/pull/5681) removes unused `mkRecursorInfoForKernelRec`.
-  * [#5686](https://github.com/leanprover/lean4/pull/5686) makes discrimination trees index the domains of foralls, for better performance of the simplify and type class search.
-  * [#5760](https://github.com/leanprover/lean4/pull/5760) adds `Lean.Expr.name?` recognizer for `Name` expressions.
-  * [#5800](https://github.com/leanprover/lean4/pull/5800) modifies `liftCommandElabM` to preserve more state, fixing an issue where using it would drop messages.
-  * [#5857](https://github.com/leanprover/lean4/pull/5857) makes it possible to use dot notation in `m!` strings, for example `m!"{.ofConstName n}"`.
-  * [#5841](https://github.com/leanprover/lean4/pull/5841) and [#5853](https://github.com/leanprover/lean4/pull/5853) record the complete list of `structure` parents in the `StructureInfo` environment extension.
-
-* **Other fixes or improvements**
-  * [#5566](https://github.com/leanprover/lean4/pull/5566) fixes a bug introduced in [#4781](https://github.com/leanprover/lean4/pull/4781) where heartbeat exceptions were no longer being handled properly. Now such exceptions are tagged with `runtime.maxHeartbeats` (@eric-wieser).
-  * [#5708](https://github.com/leanprover/lean4/pull/5708) modifies the proof objects produced by the proof-by-reflection tactics `ac_nf0` and `simp_arith` so that the kernel is less prone to reducing expensive atoms.
-  * [#5768](https://github.com/leanprover/lean4/pull/5768) adds a `#version` command that prints Lean's version information.
-  * [#5822](https://github.com/leanprover/lean4/pull/5822) fixes elaborator algorithms to match kernel algorithms for primitive projections (`Expr.proj`).
-  * [#5811](https://github.com/leanprover/lean4/pull/5811) improves the docstring for the `rwa` tactic.
-
-
-### Language server, widgets, and IDE extensions
-
-* [#5224](https://github.com/leanprover/lean4/pull/5224) fixes `WorkspaceClientCapabilities` to make `applyEdit` optional, in accordance with the LSP specification (@pzread).
-* [#5340](https://github.com/leanprover/lean4/pull/5340) fixes a server deadlock when shutting down the language server and a desync between client and language server after a file worker crash.
-* [#5560](https://github.com/leanprover/lean4/pull/5560) makes `initialize` and `builtin_initialize` participate in the call hierarchy and other requests.
-* [#5650](https://github.com/leanprover/lean4/pull/5650) makes references in attributes participate in the call hierarchy and other requests.
-* [#5666](https://github.com/leanprover/lean4/pull/5666) add auto-completion in tactic blocks without having to type the first character of the tactic, and adds tactic completion docs to tactic auto-completion items.
-* [#5677](https://github.com/leanprover/lean4/pull/5677) fixes several cases where goal states were not displayed in certain text cursor positions.
-* [#5707](https://github.com/leanprover/lean4/pull/5707) indicates deprecations in auto-completion items.
-* [#5736](https://github.com/leanprover/lean4/pull/5736), [#5752](https://github.com/leanprover/lean4/pull/5752), [#5763](https://github.com/leanprover/lean4/pull/5763), [#5802](https://github.com/leanprover/lean4/pull/5802), and [#5805](https://github.com/leanprover/lean4/pull/5805) fix various performance issues in the language server.
-* [#5801](https://github.com/leanprover/lean4/pull/5801) distinguishes theorem auto-completions from non-theorem auto-completions.
-
-### Pretty printing
-
-* [#5640](https://github.com/leanprover/lean4/pull/5640) fixes a bug where goal states in messages might print newlines as spaces.
-* [#5643](https://github.com/leanprover/lean4/pull/5643) adds option `pp.mvars.delayed` (default false), which when false causes delayed assignment metavariables to pretty print with what they are assigned to. Now `fun x : Nat => ?a` pretty prints as `fun x : Nat => ?a` rather than `fun x ↦ ?m.7 x`.
-* [#5711](https://github.com/leanprover/lean4/pull/5711) adds options `pp.mvars.anonymous` and `pp.mvars.levels`, which when false respectively cause expression metavariables and level metavariables to pretty print as `?_`.
-* [#5710](https://github.com/leanprover/lean4/pull/5710) adjusts the `⋯` elaboration warning to mention `pp.maxSteps`.
-
-* [#5759](https://github.com/leanprover/lean4/pull/5759) fixes the app unexpander for `sorryAx`.
-* [#5827](https://github.com/leanprover/lean4/pull/5827) improves accuracy of binder names in the signature pretty printer (like in output of `#check`). Also fixes the issue where consecutive hygienic names pretty print without a space separating them, so we now have `(x✝ y✝ : Nat)` rather than `(x✝y✝ : Nat)`.
-* [#5830](https://github.com/leanprover/lean4/pull/5830) makes sure all the core delaborators respond to `pp.explicit` when appropriate.
-* [#5639](https://github.com/leanprover/lean4/pull/5639) makes sure name literals use escaping when pretty printing.
-* [#5854](https://github.com/leanprover/lean4/pull/5854) adds delaborators for `<|>`, `<*>`, `>>`, `<*`, and `*>`.
-
-### Library
-
-* `Array`
-  * [#5687](https://github.com/leanprover/lean4/pull/5687) deprecates `Array.data`.
-  * [#5705](https://github.com/leanprover/lean4/pull/5705) uses a better default value for `Array.swapAt!`.
-  * [#5748](https://github.com/leanprover/lean4/pull/5748) moves `Array.mapIdx` lemmas to a new file.
-  * [#5749](https://github.com/leanprover/lean4/pull/5749) simplifies signature of `Array.mapIdx`.
-  * [#5758](https://github.com/leanprover/lean4/pull/5758) upstreams `Array.reduceOption`.
-  * [#5786](https://github.com/leanprover/lean4/pull/5786) adds simp lemmas for `Array.isEqv` and `BEq`.
-  * [#5796](https://github.com/leanprover/lean4/pull/5796) renames `Array.shrink` to `Array.take`, and relates it to `List.take`.
-  * [#5798](https://github.com/leanprover/lean4/pull/5798) upstreams `List.modify`, adds lemmas, relates to `Array.modify`.
-  * [#5799](https://github.com/leanprover/lean4/pull/5799) relates `Array.forIn` and `List.forIn`.
-  * [#5833](https://github.com/leanprover/lean4/pull/5833) adds `Array.forIn'`, and relates to `List`.
-  * [#5848](https://github.com/leanprover/lean4/pull/5848) fixes deprecations in `Init.Data.Array.Basic` to not recommend the deprecated constant.
-  * [#5895](https://github.com/leanprover/lean4/pull/5895) adds `LawfulBEq (Array α) ↔ LawfulBEq α`.
-  * [#5896](https://github.com/leanprover/lean4/pull/5896) moves `@[simp]` from `back_eq_back?` to `back_push`.
-  * [#5897](https://github.com/leanprover/lean4/pull/5897) renames `Array.back` to `back!`.
-
-* `List`
-  * [#5605](https://github.com/leanprover/lean4/pull/5605) removes `List.redLength`.
-  * [#5696](https://github.com/leanprover/lean4/pull/5696) upstreams `List.mapIdx` and adds lemmas.
-  * [#5697](https://github.com/leanprover/lean4/pull/5697) upstreams `List.foldxM_map`.
-  * [#5701](https://github.com/leanprover/lean4/pull/5701) renames `List.join` to `List.flatten`.
-  * [#5703](https://github.com/leanprover/lean4/pull/5703) upstreams `List.sum`.
-  * [#5706](https://github.com/leanprover/lean4/pull/5706) marks `prefix_append_right_inj` as a simp lemma.
-  * [#5716](https://github.com/leanprover/lean4/pull/5716) fixes `List.drop_drop` addition order.
-  * [#5731](https://github.com/leanprover/lean4/pull/5731) renames `List.bind` and `Array.concatMap` to `flatMap`.
-  * [#5732](https://github.com/leanprover/lean4/pull/5732) renames `List.pure` to `List.singleton`.
-  * [#5742](https://github.com/leanprover/lean4/pull/5742) upstreams `ne_of_mem_of_not_mem`.
-  * [#5743](https://github.com/leanprover/lean4/pull/5743) upstreams `ne_of_apply_ne`.
-  * [#5816](https://github.com/leanprover/lean4/pull/5816) adds more `List.modify` lemmas.
-  * [#5879](https://github.com/leanprover/lean4/pull/5879) renames `List.groupBy` to `splitBy`.
-  * [#5913](https://github.com/leanprover/lean4/pull/5913) relates `for` loops over `List` with `foldlM`.
-
-* `Nat`
-  * [#5694](https://github.com/leanprover/lean4/pull/5694) removes `instBEqNat`, which is redundant with `instBEqOfDecidableEq` but not defeq.
-  * [#5746](https://github.com/leanprover/lean4/pull/5746) deprecates `Nat.sum`.
-  * [#5785](https://github.com/leanprover/lean4/pull/5785) adds `Nat.forall_lt_succ` and variants.
-
-* Fixed width integers
-  * [#5323](https://github.com/leanprover/lean4/pull/5323) redefine unsigned fixed width integers in terms of `BitVec`.
-  * [#5735](https://github.com/leanprover/lean4/pull/5735) adds `UIntX.[val_ofNat, toBitVec_ofNat]`.
-  * [#5790](https://github.com/leanprover/lean4/pull/5790) defines `Int8`.
-  * [#5901](https://github.com/leanprover/lean4/pull/5901) removes native code for `UInt8.modn`.
-
-* `BitVec`
-  * [#5604](https://github.com/leanprover/lean4/pull/5604) completes `BitVec.[getMsbD|getLsbD|msb]` for shifts (@luisacicolini).
-  * [#5609](https://github.com/leanprover/lean4/pull/5609) adds lemmas for division when denominator is zero (@bollu).
-  * [#5620](https://github.com/leanprover/lean4/pull/5620) documents Bitblasting (@bollu)
-  * [#5623](https://github.com/leanprover/lean4/pull/5623) moves `BitVec.udiv/umod/sdiv/smod` after `add/sub/mul/lt` (@tobiasgrosser).
-  * [#5645](https://github.com/leanprover/lean4/pull/5645) defines `udiv` normal form to be `/`, resp. `umod` and `%` (@bollu).
-  * [#5646](https://github.com/leanprover/lean4/pull/5646) adds lemmas about arithmetic inequalities (@bollu).
-  * [#5680](https://github.com/leanprover/lean4/pull/5680) expands relationship with `toFin` (@tobiasgrosser).
-  * [#5691](https://github.com/leanprover/lean4/pull/5691) adds `BitVec.(getMSbD, msb)_(add, sub)` and `BitVec.getLsbD_sub` (@luisacicolini).
-  * [#5712](https://github.com/leanprover/lean4/pull/5712) adds `BitVec.[udiv|umod]_[zero|one|self]` (@tobiasgrosser).
-  * [#5718](https://github.com/leanprover/lean4/pull/5718) adds `BitVec.sdiv_[zero|one|self]` (@tobiasgrosser).
-  * [#5721](https://github.com/leanprover/lean4/pull/5721) adds `BitVec.(msb, getMsbD, getLsbD)_(neg, abs)` (@luisacicolini).
-  * [#5772](https://github.com/leanprover/lean4/pull/5772) adds `BitVec.toInt_sub`, simplifies `BitVec.toInt_neg` (@tobiasgrosser).
-  * [#5778](https://github.com/leanprover/lean4/pull/5778) prove that `intMin` the smallest signed bitvector (@alexkeizer).
-  * [#5851](https://github.com/leanprover/lean4/pull/5851) adds `(msb, getMsbD)_twoPow` (@luisacicolini).
-  * [#5858](https://github.com/leanprover/lean4/pull/5858) adds `BitVec.[zero_ushiftRight|zero_sshiftRight|zero_mul]` and cleans up BVDecide (@tobiasgrosser).
-  * [#5865](https://github.com/leanprover/lean4/pull/5865) adds `BitVec.(msb, getMsbD)_concat` (@luisacicolini).
-  * [#5881](https://github.com/leanprover/lean4/pull/5881) adds `Hashable (BitVec n)`
-
-* `String`/`Char`
-  * [#5728](https://github.com/leanprover/lean4/pull/5728) upstreams `String.dropPrefix?`.
-  * [#5745](https://github.com/leanprover/lean4/pull/5745) changes `String.dropPrefix?` signature.
-  * [#5747](https://github.com/leanprover/lean4/pull/5747) adds `Hashable Char` instance
-
-* `HashMap`
-  * [#5880](https://github.com/leanprover/lean4/pull/5880) adds interim implementation of `HashMap.modify`/`alter`
-
-* **Other**
-  * [#5704](https://github.com/leanprover/lean4/pull/5704) removes `@[simp]` from `Option.isSome_eq_isSome`.
-  * [#5739](https://github.com/leanprover/lean4/pull/5739) upstreams material on `Prod`.
-  * [#5740](https://github.com/leanprover/lean4/pull/5740) moves `Antisymm` to `Std.Antisymm`.
-  * [#5741](https://github.com/leanprover/lean4/pull/5741) upstreams basic material on `Sum`.
-  * [#5756](https://github.com/leanprover/lean4/pull/5756) adds `Nat.log2_two_pow` (@spinylobster).
-  * [#5892](https://github.com/leanprover/lean4/pull/5892) removes duplicated `ForIn` instances.
-  * [#5900](https://github.com/leanprover/lean4/pull/5900) removes `@[simp]` from `Sum.forall` and `Sum.exists`.
-  * [#5812](https://github.com/leanprover/lean4/pull/5812) removes redundant `Decidable` assumptions (@FR-vdash-bot).
-
-### Compiler, runtime, and FFI
-
-* [#5685](https://github.com/leanprover/lean4/pull/5685) fixes help message flags, removes the `-f` flag and adds the `-g` flag (@James-Oswald).
-* [#5930](https://github.com/leanprover/lean4/pull/5930) adds `--short-version` (`-V`) option to display short version (@juhp).
-* [#5144](https://github.com/leanprover/lean4/pull/5144) switches all 64-bit platforms over to consistently using GMP for bignum arithmetic.
-* [#5753](https://github.com/leanprover/lean4/pull/5753) raises the minimum supported Windows version to Windows 10 1903 (released May 2019).
-
-### Lake
-
-* [#5715](https://github.com/leanprover/lean4/pull/5715) changes `lake new math` to use `autoImplicit false` (@eric-wieser).
-* [#5688](https://github.com/leanprover/lean4/pull/5688) makes `Lake` not create core aliases in the `Lake` namespace.
-* [#5924](https://github.com/leanprover/lean4/pull/5924) adds a `text` option for `buildFile*` utilities.
-* [#5789](https://github.com/leanprover/lean4/pull/5789) makes `lake init` not `git init` when inside git work tree (@haoxins).
-* [#5684](https://github.com/leanprover/lean4/pull/5684) has Lake update a package's `lean-toolchain` file on `lake update` if it finds the package's direct dependencies use a newer compatible toolchain. To skip this step, use the `--keep-toolchain` CLI option. (See breaking changes.)
-* [#6218](https://github.com/leanprover/lean4/pull/6218) makes Lake no longer automatically fetch GitHub cloud releases if the package build directory is already present (mirroring the behavior of the Reservoir cache). This prevents the cache from clobbering existing prebuilt artifacts. Users can still manually fetch the cache and clobber the build directory by running `lake build <pkg>:release`.
-* [#6231](https://github.com/leanprover/lean4/pull/6231) improves the errors Lake produces when it fails to fetch a dependency from Reservoir. If the package is not indexed, it will produce a suggestion about how to require it from GitHub.
-
-### Documentation
-
-* [#5617](https://github.com/leanprover/lean4/pull/5617) fixes MSYS2 build instructions.
-* [#5725](https://github.com/leanprover/lean4/pull/5725) points out that `OfScientific` is called with raw literals (@eric-wieser).
-* [#5794](https://github.com/leanprover/lean4/pull/5794) adds a stub for application ellipsis notation (@eric-wieser).
-
-### Breaking changes
-
-* The syntax for providing arguments to deriving handlers has been removed, which was not used by any major Lean projects in the ecosystem. As a result, the  `applyDerivingHandlers` now takes one fewer argument, `registerDerivingHandlerWithArgs` is now simply `registerDerivingHandler`, `DerivingHandler` no longer includes the unused parameter, and `DerivingHandlerNoArgs` has been deprecated. To migrate code, delete the unused `none` argument and use `registerDerivingHandler` and `DerivingHandler`. ([#5265](https://github.com/leanprover/lean4/pull/5265))
-* The minimum supported Windows version has been raised to Windows 10 1903, released May 2019. ([#5753](https://github.com/leanprover/lean4/pull/5753))
-* The `--lean` CLI option for `lake` was removed. Use the `LEAN` environment variable instead. ([#5684](https://github.com/leanprover/lean4/pull/5684))
-* The `inductive ... :=`, `structure ... :=`, and `class ... :=` syntaxes have been deprecated in favor of the `... where` variants. The old syntax produces a warning, controlled by the `linter.deprecated` option. ([#5542](https://github.com/leanprover/lean4/pull/5542))
-* The generated tactic configuration elaborators now land in `TacticM` to make use of the current recovery state. Commands that wish to elaborate configurations should now use `declare_command_config_elab` instead of `declare_config_elab` to get an elaborator landing in `CommandElabM`. Syntaxes should migrate to `optConfig` instead of `(config)?`, but the elaborators are reverse compatible. ([#5883](https://github.com/leanprover/lean4/pull/5883))

releases/v4.15.0.md

@@ -1,645 +0,0 @@
-v4.15.0
-----------
-
-## Language
-
-- [#4595](https://github.com/leanprover/lean4/pull/4595) implements `Simp.Config.implicitDefEqsProofs`. When `true`
-(default: `true`), `simp` will **not** create a proof term for a
-rewriting rule associated with an `rfl`-theorem. Rewriting rules are
-provided by users by annotating theorems with the attribute `@[simp]`.
-If the proof of the theorem is just `rfl` (reflexivity), and
-`implicitDefEqProofs := true`, `simp` will **not** create a proof term
-which is an application of the annotated theorem.
-
-- [#5429](https://github.com/leanprover/lean4/pull/5429) avoid negative environment lookup
-
-- [#5501](https://github.com/leanprover/lean4/pull/5501) ensure `instantiateMVarsProfiling` adds a trace node
-
-- [#5856](https://github.com/leanprover/lean4/pull/5856) adds a feature to the the mutual def elaborator where the
-`instance` command yields theorems instead of definitions when the class
-is a `Prop`.
-
-- [#5907](https://github.com/leanprover/lean4/pull/5907) unset trailing for `simpa?` "try this" suggestion
-
-- [#5920](https://github.com/leanprover/lean4/pull/5920) changes the rule for which projections become instances. Before,
-all parents along with all indirect ancestors that were represented as
-subobject fields would have their projections become instances. Now only
-projections for direct parents become instances.
-
-- [#5934](https://github.com/leanprover/lean4/pull/5934) make `all_goals` admit goals on failure
-
-- [#5942](https://github.com/leanprover/lean4/pull/5942) introduce synthetic atoms in bv_decide
-
-- [#5945](https://github.com/leanprover/lean4/pull/5945) adds a new definition `Message.kind` which returns the top-level
-tag of a message. This is serialized as the new field `kind` in
-`SerialMessaege` so that i can be used by external consumers (e.g.,
-Lake) to identify messages via `lean --json`.
-
-- [#5968](https://github.com/leanprover/lean4/pull/5968) `arg` conv tactic misreported number of arguments on error
-
-- [#5979](https://github.com/leanprover/lean4/pull/5979) BitVec.twoPow in bv_decide
-
-- [#5991](https://github.com/leanprover/lean4/pull/5991) simplifies the implementation of `omega`.
-
-- [#5992](https://github.com/leanprover/lean4/pull/5992) fix style in bv_decide normalizer
-
-- [#5999](https://github.com/leanprover/lean4/pull/5999) adds configuration options for
-`decide`/`decide!`/`native_decide` and refactors the tactics to be
-frontends to the same backend. Adds a `+revert` option that cleans up
-the local context and reverts all local variables the goal depends on,
-along with indirect propositional hypotheses. Makes `native_decide` fail
-at elaboration time on failure without sacrificing performance (the
-decision procedure is still evaluated just once). Now `native_decide`
-supports universe polymorphism.
-
-- [#6010](https://github.com/leanprover/lean4/pull/6010) changes `bv_decide`'s configuration from lots of `set_option` to
-an elaborated config like `simp` or `omega`. The notable exception is
-`sat.solver` which is still a `set_option` such that users can configure
-a custom SAT solver globally for an entire project or file. Additionally
-it introduces the ability to set `maxSteps` for the simp preprocessing
-run through the new config.
-
-- [#6012](https://github.com/leanprover/lean4/pull/6012) improves the validation of new syntactic tokens. Previously, the
-validation code had inconsistencies: some atoms would be accepted only
-if they had a leading space as a pretty printer hint. Additionally,
-atoms with internal whitespace are no longer allowed.
-
-- [#6016](https://github.com/leanprover/lean4/pull/6016) removes the `decide!` tactic in favor of `decide +kernel`
-(breaking change).
-
-- [#6019](https://github.com/leanprover/lean4/pull/6019) removes @[specilize] from `MkBinding.mkBinding`, which is a
-function that cannot be specialized (as none of its arguments are
-functions). As a result, the specializable function `Nat.foldRevM.loop`
-doesn't get specialized, which leads to worse performing code.
-
-- [#6022](https://github.com/leanprover/lean4/pull/6022) makes the `change` tactic and conv tactic use the same
-elaboration strategy. It works uniformly for both the target and local
-hypotheses. Now `change` can assign metavariables, for example:
-```lean
-example (x y z : Nat) : x + y = z := by
-  change ?a = _
-  let w := ?a
-  -- now `w : Nat := x + y`
-```
-
-- [#6024](https://github.com/leanprover/lean4/pull/6024) fixes a bug where the monad lift coercion elaborator would
-partially unify expressions even if they were not monads. This could be
-taken advantage of to propagate information that could help elaboration
-make progress, for example the first `change` worked because the monad
-lift coercion elaborator was unifying `@Eq _ _` with `@Eq (Nat × Nat)
-p`:
-```lean
-example (p : Nat × Nat) : p = p := by
-  change _ = ⟨_, _⟩ -- used to work (yielding `p = (p.fst, p.snd)`), now it doesn't
-  change ⟨_, _⟩ = _ -- never worked
-```
-As such, this is a breaking change; you may need to adjust expressions
-to include additional implicit arguments.
-
-- [#6029](https://github.com/leanprover/lean4/pull/6029) adds a normalization rule to `bv_normalize` (which is used by
-`bv_decide`) that converts `x / 2^k` into `x >>> k` under suitable
-conditions. This allows us to simplify the expensive division circuits
-that are used for bitblasting into much cheaper shifting circuits.
-Concretely, it allows for the following canonicalization:
-
-- [#6030](https://github.com/leanprover/lean4/pull/6030) fixes `simp only [· ∈ ·]` after #5020.
-
-- [#6035](https://github.com/leanprover/lean4/pull/6035) introduces the and flattening pre processing pass from Bitwuzla
-to `bv_decide`. It splits hypotheses of the form `(a && b) = true` into
-`a = true` and `b = true` which has synergy potential with the already
-existing embedded constraint substitution pass.
-
-- [#6037](https://github.com/leanprover/lean4/pull/6037) fixes `bv_decide`'s embedded constraint substitution to generate
-correct counter examples in the corner case where duplicate theorems are
-in the local context.
-
-- [#6045](https://github.com/leanprover/lean4/pull/6045) add `LEAN_ALWAYS_INLINE` to some functions
-
-- [#6048](https://github.com/leanprover/lean4/pull/6048) fixes `simp?` suggesting output with invalid indentation
-
-- [#6051](https://github.com/leanprover/lean4/pull/6051) mark `Meta.Context.config` as private
-
-- [#6053](https://github.com/leanprover/lean4/pull/6053) fixes the caching infrastructure for `whnf` and `isDefEq`,
-ensuring the cache accounts for all relevant configuration flags. It
-also cleans up the `WHNF.lean` module and improves the configuration of
-`whnf`.
-
-- [#6061](https://github.com/leanprover/lean4/pull/6061) adds a simp_arith benchmark.
-
-- [#6062](https://github.com/leanprover/lean4/pull/6062) optimize Nat.Linear.Expr.toPoly
-
-- [#6064](https://github.com/leanprover/lean4/pull/6064) optimize Nat.Linear.Poly.norm
-
-- [#6068](https://github.com/leanprover/lean4/pull/6068) improves the asymptotic performance of `simp_arith` when there are many variables to consider.
-
-- [#6077](https://github.com/leanprover/lean4/pull/6077) adds options to `bv_decide`'s configuration structure such that
-all non mandatory preprocessing passes can be disabled.
-
-- [#6082](https://github.com/leanprover/lean4/pull/6082) changes how the canonicalizer handles `forall` and `lambda`,
-replacing bvars with temporary fvars. Fixes a bug reported by @hrmacbeth
-on
-[zulip](https://leanprover.zulipchat.com/#narrow/channel/270676-lean4/topic/Quantifiers.20in.20CanonM/near/482483448).
-
-- [#6093](https://github.com/leanprover/lean4/pull/6093) use mkFreshUserName in ArgsPacker
-
-- [#6096](https://github.com/leanprover/lean4/pull/6096) improves the `#print` command for structures to show all fields
-and which parents the fields were inherited from, hiding internal
-details such as which parents are represented as subobjects. This
-information is still present in the constructor if needed. The pretty
-printer for private constants is also improved, and it now handles
-private names from the current module like any other name; private names
-from other modules are made hygienic.
-
-- [#6098](https://github.com/leanprover/lean4/pull/6098) modifies `Lean.MVarId.replaceTargetDefEq` and
-`Lean.MVarId.replaceLocalDeclDefEq` to use `Expr.equal` instead of
-`Expr.eqv` when determining whether the expression has changed. This is
-justified on the grounds that binder names and binder infos are
-user-visible and affect elaboration.
-
-- [#6105](https://github.com/leanprover/lean4/pull/6105) fixes a stack overflow caused by a cyclic assignment in the
-metavariable context. The cycle is unintentionally introduced by the
-structure instance elaborator.
-
-- [#6108](https://github.com/leanprover/lean4/pull/6108) turn off pp.mvars in apply? results
-
-- [#6109](https://github.com/leanprover/lean4/pull/6109) fixes an issue in the `injection` tactic. This tactic may
-execute multiple sub-tactics. If any of them fail, we must backtrack the
-partial assignment. This issue was causing the error: "`mvarId` is
-already assigned" in issue #6066. The issue is not yet resolved, as the
-equation generator for the match expressions is failing in the example
-provided in this issue.
-
-- [#6112](https://github.com/leanprover/lean4/pull/6112) makes stricter requirements for the `@[deprecated]` attribute,
-requiring either a replacement identifier as `@[deprecated bar]` or
-suggestion text `@[deprecated "Past its use by date"]`, and also
-requires a `since := "..."` field.
-
-- [#6114](https://github.com/leanprover/lean4/pull/6114) liberalizes atom rules by allowing `''` to be a prefix of an
-atom, after #6012 only added an exception for `''` alone, and also adds
-some unit tests for atom validation.
-
-- [#6116](https://github.com/leanprover/lean4/pull/6116) fixes a bug where structural recursion did not work when indices
-of the recursive argument appeared as function parameters in a different
-order than in the argument's type's definition.
-
-- [#6125](https://github.com/leanprover/lean4/pull/6125) adds support for `structure` in `mutual` blocks, allowing
-inductive types defined by `inductive` and `structure` to be mutually
-recursive. The limitations are (1) that the parents in the `extends`
-clause must be defined before the `mutual` block and (2) mutually
-recursive classes are not allowed (a limitation shared by `class
-inductive`). There are also improvements to universe level inference for
-inductive types and structures. Breaking change: structure parents now
-elaborate with the structure in scope (fix: use qualified names or
-rename the structure to avoid shadowing), and structure parents no
-longer elaborate with autoimplicits enabled.
-
-- [#6128](https://github.com/leanprover/lean4/pull/6128) does the same fix as #6104, but such that it doesn't break the
-test/the file in `Plausible`. This is done by not creating unused let
-binders in metavariable types that are made by `elimMVar`. (This is also
-a positive thing for users looking at metavariable types, for example in
-error messages)
-
-- [#6129](https://github.com/leanprover/lean4/pull/6129) fixes a bug at `isDefEq` when `zetaDelta := false`. See new test
-for a small example that exposes the issue.
-
-- [#6131](https://github.com/leanprover/lean4/pull/6131) fixes a bug at the definitional equality test (`isDefEq`). At
-unification constraints of the form `c.{u} =?= c.{v}`, it was not trying
-to unfold `c`. This bug did not affect the kernel.
-
-- [#6141](https://github.com/leanprover/lean4/pull/6141) make use of recursive structures in snapshot types
-
-- [#6145](https://github.com/leanprover/lean4/pull/6145) fixes the `revert` tactic so that it creates a `syntheticOpaque`
-metavariable as the new goal, instead of a `natural` metavariable
-
-- [#6146](https://github.com/leanprover/lean4/pull/6146) fixes a non-termination bug that occurred when generating the
-match-expression splitter theorem. The bug was triggered when the proof
-automation for the splitter theorem repeatedly applied `injection` to
-the same local declaration, as it could not be removed due to forward
-dependencies. See issue #6065 for an example that reproduces this issue.
-
-- [#6165](https://github.com/leanprover/lean4/pull/6165) modifies structure instance notation and `where` notation to use
-the same notation for fields. Structure instance notation now admits
-binders, type ascriptions, and equations, and `where` notation admits
-full structure lvals. Examples of these for structure instance notation:
-```lean
-structure PosFun where
-  f : Nat → Nat
-  pos : ∀ n, 0 < f n
-```
-
-- [#6168](https://github.com/leanprover/lean4/pull/6168) extends the "motive is not type correct" error message for the
-rewrite tactic to explain what it means. It also pretty prints the
-type-incorrect motive and reports the type error.
-
-- [#6170](https://github.com/leanprover/lean4/pull/6170) adds core metaprogramming functions for forking off background
-tasks from elaboration such that their results are visible to reporting
-and the language server
-
-- [#6175](https://github.com/leanprover/lean4/pull/6175) fixes a bug with the `structure`/`class` command where if there
-are parents that are not represented as subobjects but which used other
-parents as instances, then there would be a kernel error. Closes #2611.
-
-- [#6180](https://github.com/leanprover/lean4/pull/6180) fixes a non-termination bug that occurred when generating the
-match-expression equation theorems. The bug was triggered when the proof
-automation for the equation theorem repeatedly applied `injection(` to
-the same local declaration, as it could not be removed due to forward
-dependencies. See issue #6067 for an example that reproduces this issue.
-
-- [#6189](https://github.com/leanprover/lean4/pull/6189) changes how generalized field notation ("dot notation") resolves
-the function. The new resolution rule is that if `x : S`, then `x.f`
-resolves the name `S.f` relative to the root namespace (hence it now
-affected by `export` and `open`). Breaking change: aliases now resolve
-differently. Before, if `x : S`, and if `S.f` is an alias for `S'.f`,
-then `x.f` would use `S'.f` and look for an argument of type `S'`. Now,
-it looks for an argument of type `S`, which is more generally useful
-behavior. Code making use of the old behavior should consider defining
-`S` or `S'` in terms of the other, since dot notation can unfold
-definitions during resolution.
-
-- [#6206](https://github.com/leanprover/lean4/pull/6206) makes it possible to write `rw (occs := [1,2]) ...` instead of
-`rw (occs := .pos [1,2]) ...` by adding a coercion from `List.Nat` to
-`Lean.Meta.Occurrences`.
-
-- [#6220](https://github.com/leanprover/lean4/pull/6220) adds proper support for `let_fun` in `simp`.
-
-- [#6236](https://github.com/leanprover/lean4/pull/6236) fixes an issue where edits to a command containing a nested
-docstring fail to reparse the entire command.
-
-## Library
-
-- [#4904](https://github.com/leanprover/lean4/pull/4904) introduces date and time functionality to the Lean 4 Std.
-
-- [#5616](https://github.com/leanprover/lean4/pull/5616) is a follow-up to https://github.com/leanprover/lean4/pull/5609,
-where we add lemmas characterizing `smtUDiv` and `smtSDiv`'s behavior
-when the denominator is zero.
-
-- [#5866](https://github.com/leanprover/lean4/pull/5866) verifies the `keys` function on `Std.HashMap`.
-
-- [#5885](https://github.com/leanprover/lean4/pull/5885) add Int16/Int32/Int64
-
-- [#5926](https://github.com/leanprover/lean4/pull/5926) add `Option.or_some'`
-
-- [#5927](https://github.com/leanprover/lean4/pull/5927) `List.pmap_eq_self`
-
-- [#5937](https://github.com/leanprover/lean4/pull/5937) upstream lemmas about Fin.foldX
-
-- [#5938](https://github.com/leanprover/lean4/pull/5938) upstream List.ofFn and relate to Array.ofFn
-
-- [#5941](https://github.com/leanprover/lean4/pull/5941) List.mapFinIdx, lemmas, relate to Array version
-
-- [#5949](https://github.com/leanprover/lean4/pull/5949) consolidate `decide_True` and `decide_true_eq_true`
-
-- [#5950](https://github.com/leanprover/lean4/pull/5950) relate Array.takeWhile with List.takeWhile
-
-- [#5951](https://github.com/leanprover/lean4/pull/5951) remove @[simp] from BitVec.ofFin_sub and sub_ofFin
-
-- [#5952](https://github.com/leanprover/lean4/pull/5952) relate Array.eraseIdx with List.eraseIdx
-
-- [#5961](https://github.com/leanprover/lean4/pull/5961) define ISize and basic operations on it
-
-- [#5969](https://github.com/leanprover/lean4/pull/5969) upstream List.insertIdx from Batteries, lemmas from Mathlib, and revise lemmas
-
-- [#5970](https://github.com/leanprover/lean4/pull/5970) deprecate Array.split in favour of identical Array.partition
-
-- [#5971](https://github.com/leanprover/lean4/pull/5971) relate Array.isPrefixOf with List.isPrefixOf
-
-- [#5972](https://github.com/leanprover/lean4/pull/5972) relate Array.zipWith/zip/unzip with List versions
-
-- [#5974](https://github.com/leanprover/lean4/pull/5974) add another List.find?_eq_some lemma
-
-- [#5981](https://github.com/leanprover/lean4/pull/5981) names the default SizeOf instance `instSizeOfDefault`
-
-- [#5982](https://github.com/leanprover/lean4/pull/5982) minor lemmas about List.ofFn
-
-- [#5984](https://github.com/leanprover/lean4/pull/5984) adds lemmas for `List` for the interactions between {`foldl`,
-`foldr`, `foldlM`, `foldlrM`} and {`filter`, `filterMap`}.
-
-- [#5985](https://github.com/leanprover/lean4/pull/5985) relates the operations `findSomeM?`, `findM?`, `findSome?`, and
-`find?` on `Array` with the corresponding operations on `List`, and also
-provides simp lemmas for the `Array` operations `findSomeRevM?`,
-`findRevM?`, `findSomeRev?`, `findRev?` (in terms of `reverse` and the
-usual forward find operations).
-
-- [#5987](https://github.com/leanprover/lean4/pull/5987) BitVec.getMsbD in bv_decide
-
-- [#5988](https://github.com/leanprover/lean4/pull/5988) changes the signature of `Array.set` to take a `Nat`, and a
-tactic-provided bound, rather than a `Fin`.
-
-- [#5995](https://github.com/leanprover/lean4/pull/5995) BitVec.sshiftRight' in bv_decide
-
-- [#6007](https://github.com/leanprover/lean4/pull/6007) List.modifyTailIdx naming fix
-
-- [#6008](https://github.com/leanprover/lean4/pull/6008) missing @[ext] attribute on monad transformer ext lemmas
-
-- [#6023](https://github.com/leanprover/lean4/pull/6023) variants of List.forIn_eq_foldlM
-
-- [#6025](https://github.com/leanprover/lean4/pull/6025) deprecate duplicated Fin.size_pos
-
-- [#6032](https://github.com/leanprover/lean4/pull/6032) changes the signature of `Array.get` to take a Nat and a proof,
-rather than a `Fin`, for consistency with the rest of the (planned)
-Array API. Note that because of bootstrapping issues we can't provide
-`get_elem_tactic` as an autoparameter for the proof. As users will
-mostly use the `xs[i]` notation provided by `GetElem`, this hopefully
-isn't a problem.
-
-- [#6041](https://github.com/leanprover/lean4/pull/6041) modifies the order of arguments for higher-order `Array`
-functions, preferring to put the `Array` last (besides positional
-arguments with defaults). This is more consistent with the `List` API,
-and is more flexible, as dot notation allows two different partially
-applied versions.
-
-- [#6049](https://github.com/leanprover/lean4/pull/6049) adds a primitive for accessing the current thread ID
-
-- [#6052](https://github.com/leanprover/lean4/pull/6052) adds `Array.pmap`, as well as a `@[csimp]` lemma in terms of the
-no-copy `Array.attachWith`.
-
-- [#6055](https://github.com/leanprover/lean4/pull/6055) adds lemmas about for loops over `Array`, following the existing
-lemmas for `List`.
-
-- [#6056](https://github.com/leanprover/lean4/pull/6056) upstream some NameMap functions
-
-- [#6060](https://github.com/leanprover/lean4/pull/6060) implements conversion functions from `Bool` to all `UIntX` and
-`IntX` types.
-
-- [#6070](https://github.com/leanprover/lean4/pull/6070) adds the Lean.RArray data structure.
-
-- [#6074](https://github.com/leanprover/lean4/pull/6074) allow `Sort u` in `Squash`
-
-- [#6094](https://github.com/leanprover/lean4/pull/6094) adds raw transmutation of floating-point numbers to and from
-`UInt64`. Floats and UInts share the same endianness across all
-supported platforms. The IEEE 754 standard precisely specifies the bit
-layout of floats. Note that `Float.toBits` is distinct from
-`Float.toUInt64`, which attempts to preserve the numeric value rather
-than the bitwise value.
-
-- [#6095](https://github.com/leanprover/lean4/pull/6095) generalize `List.get_mem`
-
-- [#6097](https://github.com/leanprover/lean4/pull/6097) naming convention and `NaN` normalization
-
-- [#6102](https://github.com/leanprover/lean4/pull/6102) moves `IO.rand` and `IO.setRandSeed` to be in the `BaseIO`
-monad.
-
-- [#6106](https://github.com/leanprover/lean4/pull/6106) fix naming of left/right injectivity lemmas
-
-- [#6111](https://github.com/leanprover/lean4/pull/6111) fills in the API for `Array.findSome?` and `Array.find?`,
-transferring proofs from the corresponding List statements.
-
-- [#6120](https://github.com/leanprover/lean4/pull/6120) adds theorems `BitVec.(getMsbD, msb)_(rotateLeft, rotateRight)`.
-
-- [#6126](https://github.com/leanprover/lean4/pull/6126) adds lemmas for extracting a given bit of a `BitVec` obtained
-via `sub`/`neg`/`sshiftRight'`/`abs`.
-
-- [#6130](https://github.com/leanprover/lean4/pull/6130) adds `Lean.loadPlugin` which exposes functionality similar to
-the `lean` executable's `--plugin` option to Lean code.
-
-- [#6132](https://github.com/leanprover/lean4/pull/6132) duplicates the verification API for
-`List.attach`/`attachWith`/`pmap` over to `Array`.
-
-- [#6133](https://github.com/leanprover/lean4/pull/6133) replaces `Array.feraseIdx` and `Array.insertAt` with
-`Array.eraseIdx` and `Array.insertIdx`, both of which take a `Nat`
-argument and a tactic-provided proof that it is in bounds. We also have
-`eraseIdxIfInBounds` and `insertIdxIfInBounds` which are noops if the
-index is out of bounds. We also provide a `Fin` valued version of
-`Array.findIdx?`. Together, these quite ergonomically improve the array
-indexing safety at a number of places in the compiler/elaborator.
-
-- [#6136](https://github.com/leanprover/lean4/pull/6136) fixes the run-time evaluation of `(default : Float)`.
-
-- [#6139](https://github.com/leanprover/lean4/pull/6139) modifies the signature of the functions `Nat.fold`,
-`Nat.foldRev`, `Nat.any`, `Nat.all`, so that the function is passed the
-upper bound. This allows us to change runtime array bounds checks to
-compile time checks in many places.
-
-- [#6148](https://github.com/leanprover/lean4/pull/6148) adds a primitive for creating temporary directories, akin to the
-existing functionality for creating temporary files.
-
-- [#6149](https://github.com/leanprover/lean4/pull/6149) completes the elementwise accessors for `ofNatLt`, `allOnes`,
-and `not` by adding their implementations of `getMsbD`.
-
-- [#6151](https://github.com/leanprover/lean4/pull/6151) completes the `toInt` interface for `BitVec` bitwise operations.
-
-- [#6154](https://github.com/leanprover/lean4/pull/6154) implements `BitVec.toInt_abs`.
-
-- [#6155](https://github.com/leanprover/lean4/pull/6155) adds `toNat` theorems for `BitVec.signExtend.`
-
-- [#6157](https://github.com/leanprover/lean4/pull/6157) adds toInt theorems for BitVec.signExtend.
-
-- [#6160](https://github.com/leanprover/lean4/pull/6160) adds theorem `mod_eq_sub`, makes theorem
-`sub_mul_eq_mod_of_lt_of_le` not private anymore and moves its location
-within the `rotate*` section to use it in other proofs.
-
-- [#6184](https://github.com/leanprover/lean4/pull/6184) uses `Array.findFinIdx?` in preference to `Array.findIdx?` where
-it allows converting a runtime bounds check to a compile time bounds
-check.
-
-- [#6188](https://github.com/leanprover/lean4/pull/6188) completes the `toNat` theorems for the bitwise operations
-(`and`, `or`, `xor`, `shiftLeft`, `shiftRight`) of the UInt types and
-adds `toBitVec` theorems as well. It also renames `and_toNat` to
-`toNat_and` to fit with the current naming convention.
-
-- [#6190](https://github.com/leanprover/lean4/pull/6190) adds the builtin simproc `USize.reduceToNat` which reduces the
-`USize.toNat` operation on literals less than `UInt32.size` (i.e.,
-`4294967296`).
-
-- [#6191](https://github.com/leanprover/lean4/pull/6191) adds `Array.zipWithAll`, and the basic lemmas relating it to
-`List.zipWithAll`.
-
-- [#6192](https://github.com/leanprover/lean4/pull/6192) adds deprecations for `Lean.HashMap` functions which did not
-receive deprecation attributes initially.
-
-- [#6193](https://github.com/leanprover/lean4/pull/6193) completes the TODO in `Init.Data.Array.BinSearch`, removing the
-`partial` keyword and converting runtime bounds checks to compile time
-bounds checks.
-
-- [#6194](https://github.com/leanprover/lean4/pull/6194) changes the signature of `Array.swap`, so it takes `Nat`
-arguments with tactic provided bounds checking. It also renames
-`Array.swap!` to `Array.swapIfInBounds`.
-
-- [#6195](https://github.com/leanprover/lean4/pull/6195) renames `Array.setD` to `Array.setIfInBounds`.
-
-- [#6197](https://github.com/leanprover/lean4/pull/6197) upstreams the definition of `Vector` from Batteries, along with
-the basic functions.
-
-- [#6200](https://github.com/leanprover/lean4/pull/6200) upstreams `Nat.lt_pow_self` and `Nat.lt_two_pow` from Mathlib
-and uses them to prove the simp theorem `Nat.mod_two_pow`.
-
-- [#6202](https://github.com/leanprover/lean4/pull/6202) makes `USize.toUInt64` a regular non-opaque definition.
-
-- [#6203](https://github.com/leanprover/lean4/pull/6203) adds the theorems `le_usize_size` and `usize_size_le`, which
-make proving inequalities about `USize.size` easier.
-
-- [#6205](https://github.com/leanprover/lean4/pull/6205) upstreams some UInt theorems from Batteries and adds more
-`toNat`-related theorems. It also adds the missing `UInt8` and `UInt16`
-to/from `USize` conversions so that the the interface is uniform across
-the UInt types.
-
-- [#6207](https://github.com/leanprover/lean4/pull/6207) ensures the `Fin.foldl` and `Fin.foldr` are semireducible.
-Without this the defeq `example (f : Fin 3 → ℕ) : List.ofFn f = [f 0, f
-1, f 2] := rfl` was failing.
-
-- [#6208](https://github.com/leanprover/lean4/pull/6208) fix Vector.indexOf?
-
-- [#6217](https://github.com/leanprover/lean4/pull/6217) adds `simp` lemmas about `List`'s `==` operation.
-
-- [#6221](https://github.com/leanprover/lean4/pull/6221) fixes:
-- Problems in other linux distributions that the default `tzdata`
-directory is not the same as previously defined by ensuring it with a
-fallback behavior when directory is missing.
-- Trim unnecessary characters from local time identifier.
-
-- [#6222](https://github.com/leanprover/lean4/pull/6222) changes the definition of `HashSet.insertMany` and
-`HashSet.Raw.insertMany` so that it is equivalent to repeatedly calling
-`HashSet.insert`/`HashSet.Raw.insert`. It also clarifies the docstrings
-of all the `insert` and `insertMany` functions.
-
-- [#6230](https://github.com/leanprover/lean4/pull/6230) copies some lemmas about `List.foldX` to `Array`.
-
-- [#6233](https://github.com/leanprover/lean4/pull/6233) upstreams lemmas about `Vector` from Batteries.
-
-- [#6234](https://github.com/leanprover/lean4/pull/6234) upstreams the definition and basic lemmas about `List.finRange`
-from Batteries.
-
-- [#6235](https://github.com/leanprover/lean4/pull/6235) relates that operations `Nat.fold`/`foldRev`/`any`/`all` to the
-corresponding List operations over `List.finRange`.
-
-- [#6241](https://github.com/leanprover/lean4/pull/6241) refactors `Array.qsort` to remove runtime array bounds checks,
-and avoids the use of `partial`. We use the `Vector` API, along with
-auto_params, to avoid having to write any proofs. The new code
-benchmarks indistinguishably from the old.
-
-- [#6242](https://github.com/leanprover/lean4/pull/6242) deprecates `Fin.ofNat` in favour of `Fin.ofNat'` (which takes an
-`[NeZero]` instance, rather than returning an element of `Fin (n+1)`).
-
-- [#6247](https://github.com/leanprover/lean4/pull/6247) adds the theorems `numBits_pos`, `le_numBits`, `numBits_le` ,
-which make proving inequalities about `System.Platform.numBits` easier.
-
-## Compiler
-
-- [#5840](https://github.com/leanprover/lean4/pull/5840) changes `lean_sharecommon_{eq,hash}` to only consider the
-salient bytes of an object, and not any bytes of any
-unspecified/uninitialized unused capacity.
-
-- [#6087](https://github.com/leanprover/lean4/pull/6087) fixes a bug in the constant folding for the `Nat.ble` and
-`Nat.blt` function in the old code generator, leading to a
-miscompilation.
-
-- [#6143](https://github.com/leanprover/lean4/pull/6143) should make lean better-behaved around sanitizers, per
-https://github.com/google/sanitizers/issues/1688.
-As far as I can tell,
-https://github.com/google/sanitizers/wiki/AddressSanitizerUseAfterReturn#algorithm
-replaces local variables with heap allocations, and so taking the
-address of a local is not effective at producing a monotonic measure of
-stack usage.
-
-- [#6209](https://github.com/leanprover/lean4/pull/6209) documents under which conditions `Runtime.markPersistent` is
-unsafe and adjusts the elaborator accordingly
-
-- [#6257](https://github.com/leanprover/lean4/pull/6257) harden `markPersistent` uses
-
-## Pretty Printing
-
-- [#2934](https://github.com/leanprover/lean4/pull/2934) adds the option `pp.parens` (default: false) that causes the
-pretty printer to eagerly insert parentheses, which can be useful for
-teaching and for understanding the structure of expressions. For
-example, it causes `p → q → r` to pretty print as `p → (q → r)`.
-
-- [#6014](https://github.com/leanprover/lean4/pull/6014) prevents `Nat.succ ?_` from pretty printing as `?_.succ`, which
-should make `apply?` be more usable.
-
-- [#6085](https://github.com/leanprover/lean4/pull/6085) improves the term info for coercions marked with
-`CoeFnType.coeFun` (such as `DFunLike.coe` in Mathlib), making "go to
-definition" on the function name work. Hovering over such a coerced
-function will show the coercee rather than the coercion expression. The
-coercion expression can still be seen by hovering over the whitespace in
-the function application.
-
-- [#6096](https://github.com/leanprover/lean4/pull/6096) improves the `#print` command for structures to show all fields
-and which parents the fields were inherited from, hiding internal
-details such as which parents are represented as subobjects. This
-information is still present in the constructor if needed. The pretty
-printer for private constants is also improved, and it now handles
-private names from the current module like any other name; private names
-from other modules are made hygienic.
-
-- [#6119](https://github.com/leanprover/lean4/pull/6119) adds a new delab option `pp.coercions.types` which, when
-enabled, will display all coercions with an explicit type ascription.
-
-- [#6161](https://github.com/leanprover/lean4/pull/6161) ensures whitespace is printed before `+opt` and `-opt`
-configuration options when pretty printing, improving the experience of
-tactics such as `simp?`.
-
-- [#6181](https://github.com/leanprover/lean4/pull/6181) fixes a bug where the signature pretty printer would ignore the
-current setting of `pp.raw`. This fixes an issue where `#check ident`
-would not heed `pp.raw`. Closes #6090.
-
-- [#6213](https://github.com/leanprover/lean4/pull/6213) exposes the difference in "synthesized type class instance is
-not definitionally equal" errors.
-
-## Documentation
-
-- [#6009](https://github.com/leanprover/lean4/pull/6009) fixes a typo in the docstring for prec and makes the text
-slightly more precise.
-
-- [#6040](https://github.com/leanprover/lean4/pull/6040) join → flatten in docstring
-
-- [#6110](https://github.com/leanprover/lean4/pull/6110) does some mild refactoring of the `Lean.Elab.StructInst` module
-while adding documentation.
-
-- [#6144](https://github.com/leanprover/lean4/pull/6144) converts 3 doc-string to module docs since it seems that this is
-what they were intended to be!
-
-- [#6150](https://github.com/leanprover/lean4/pull/6150) refine kernel code comments
-
-- [#6158](https://github.com/leanprover/lean4/pull/6158) adjust file reference in Data.Sum
-
-- [#6239](https://github.com/leanprover/lean4/pull/6239) explains the order in which `Expr.abstract` introduces de Bruijn
-indices.
-
-## Server
-
-- [#5835](https://github.com/leanprover/lean4/pull/5835) adds auto-completion for the fields of structure instance notation. Specifically, querying the completions via `Ctrl+Space` in the whitespace of a structure instance notation will now bring up the full list of fields. Whitespace structure completion can be enabled for custom syntax by wrapping the parser for the list of fields in a `structInstFields` parser.
-
-- [#5837](https://github.com/leanprover/lean4/pull/5837) fixes an old auto-completion bug where `x.` would issue
-nonsensical completions when `x.` could not be elaborated as a dot
-completion.
-
-- [#5996](https://github.com/leanprover/lean4/pull/5996) avoid max heartbeat error in completion
-
-- [#6031](https://github.com/leanprover/lean4/pull/6031) fixes a regression with go-to-definition and document highlight
-misbehaving on tactic blocks.
-
-- [#6246](https://github.com/leanprover/lean4/pull/6246) fixes a performance issue where the Lean language server would
-walk the full project file tree every time a file was saved, blocking
-the processing of all other requests and notifications and significantly
-increasing overall language server latency after saving.
-
-## Lake
-
-- [#5684](https://github.com/leanprover/lean4/pull/5684) update toolchain on `lake update`
-
-- [#6026](https://github.com/leanprover/lean4/pull/6026) adds a newline at end of each Lean file generated by `lake new`
-templates.
-
-- [#6218](https://github.com/leanprover/lean4/pull/6218) makes Lake no longer automatically fetch GitHub cloud releases
-if the package build directory is already present (mirroring the
-behavior of the Reservoir cache). This prevents the cache from
-clobbering existing prebuilt artifacts. Users can still manually fetch
-the cache and clobber the build directory by running `lake build
-<pkg>:release`.
-
-- [#6225](https://github.com/leanprover/lean4/pull/6225) makes `lake build` also eagerly print package materialization
-log lines. Previously, only a `lake update` performed eager logging.
-
-- [#6231](https://github.com/leanprover/lean4/pull/6231) improves the errors Lake produces when it fails to fetch a
-dependency from Reservoir. If the package is not indexed, it will
-produce a suggestion about how to require it from GitHub.
-
-## Other
-
-- [#6137](https://github.com/leanprover/lean4/pull/6137) adds support for displaying multiple threads in the trace
-profiler output.
-
-- [#6138](https://github.com/leanprover/lean4/pull/6138) fixes `trace.profiler.pp` not using the term pretty printer.
-
-- [#6259](https://github.com/leanprover/lean4/pull/6259) ensures that nesting trace nodes are annotated with timing
-information iff `trace.profiler` is active.

releases/v4.16.0.md

@@ -1,565 +0,0 @@
-v4.16.0
-----------
-## Highlights
-
-### Unique `sorry`s
-
-[#5757](https://github.com/leanprover/lean4/pull/5757) makes it harder to create "fake" theorems about definitions that
-are stubbed-out with `sorry` by ensuring that each `sorry` is not
-definitionally equal to any other. For example, this now fails:
-```lean
-example : (sorry : Nat) = sorry := rfl -- fails
-```
-However, this still succeeds, since the `sorry` is a single
-indeterminate `Nat`:
-```lean
-def f (n : Nat) : Nat := sorry
-example : f 0 = f 1 := rfl -- succeeds
-```
-One can be more careful by putting parameters to the right of the colon:
-```lean
-def f : (n : Nat) → Nat := sorry
-example : f 0 = f 1 := rfl -- fails
-```
-Most sources of synthetic sorries (recall: a sorry that originates from
-the elaborator) are now unique, except for elaboration errors, since
-making these unique tends to cause a confusing cascade of errors. In
-general, however, such sorries are labeled. This enables "go to
-definition" on `sorry` in the Infoview, which brings you to its origin.
-The option `set_option pp.sorrySource true` causes the pretty printer to
-show source position information on sorries.
-
-### Separators in numeric literals
-
-[#6204](https://github.com/leanprover/lean4/pull/6204) lets `_` be used in numeric literals as a separator. For
-example, `1_000_000`, `0xff_ff` or `0b_10_11_01_00`. New lexical syntax:
-```text
-numeral10 : [0-9]+ ("_"+ [0-9]+)*
-numeral2  : "0" [bB] ("_"* [0-1]+)+
-numeral8  : "0" [oO] ("_"* [0-7]+)+
-numeral16 : "0" [xX] ("_"* hex_char+)+
-float     : numeral10 "." numeral10? [eE[+-]numeral10]
-```
-
-### Additional new featues
-
-* [#6300](https://github.com/leanprover/lean4/pull/6300) adds the `debug.proofAsSorry` option. When enabled, the proofs
-of theorems are ignored and replaced with `sorry`.
-
-* [#6362](https://github.com/leanprover/lean4/pull/6362) adds the `--error=kind` option (shorthand: `-Ekind`) to the
-`lean` CLI. When set, messages of `kind` (e.g.,
-`linter.unusedVariables`) will be reported as errors. This setting does
-nothing in interactive contexts (e.g., the server).
-
-* [#6366](https://github.com/leanprover/lean4/pull/6366) adds support for `Float32` and fixes a bug in the runtime.
-
-### Library updates
-
-The Lean 4 library saw many changes that improve arithmetic reasoning, enhance data structure APIs,
-and refine library organization. Key changes include better support for bitwise operations, shifts,
-and conversions, expanded lemmas for `Array`, `Vector`, and `List`, and improved ordering definitions.
-Some modules have been reorganized for clarity, and internal refinements ensure greater consistency and correctness.
-
-### Breaking changes
-
-[#6330](https://github.com/leanprover/lean4/pull/6330) removes unnecessary parameters from the functional induction
-principles. This is a breaking change; broken code can typically be adjusted
-simply by passing fewer parameters.
-
-_This highlights section was contributed by Violetta Sim._
-
-For this release, 201 changes landed. In addition to the 74 feature additions and 44 fixes listed below there were 7 refactoring changes, 5 documentation improvements and 62 chores.
-
-## Language
-
-* [#3696](https://github.com/leanprover/lean4/pull/3696) makes all message constructors handle pretty printer errors.
-
-* [#4460](https://github.com/leanprover/lean4/pull/4460) runs all linters for a single command (together) on a separate
-thread from further elaboration, making a first step towards
-parallelizing the elaborator.
-
-* [#5757](https://github.com/leanprover/lean4/pull/5757), see the highlights section above for details.
-
-* [#6123](https://github.com/leanprover/lean4/pull/6123) ensures that the configuration in `Simp.Config` is used when
-reducing terms and checking definitional equality in `simp`.
-
-* [#6204](https://github.com/leanprover/lean4/pull/6204), see the highlights section above for details.
-
-* [#6270](https://github.com/leanprover/lean4/pull/6270) fixes a bug that could cause the `injectivity` tactic to fail in
-reducible mode, which could cause unfolding lemma generation to fail
-(used by tactics such as `unfold`). In particular,
-`Lean.Meta.isConstructorApp'?` was not aware that `n + 1` is equivalent
-to `Nat.succ n`.
-
-* [#6273](https://github.com/leanprover/lean4/pull/6273) modifies the "foo has been deprecated: use betterFoo instead"
-warning so that foo and betterFoo are hoverable.
-
-* [#6278](https://github.com/leanprover/lean4/pull/6278) enables simp configuration options to be passed to `norm_cast`.
-
-* [#6286](https://github.com/leanprover/lean4/pull/6286) ensure `bv_decide` uses definitional equality in its reflection
-procedure as much as possible. Previously it would build up explicit
-congruence proofs for the kernel to check. This reduces the size of
-proof terms passed to kernel speeds up checking of large reflection
-proofs.
-
-* [#6288](https://github.com/leanprover/lean4/pull/6288) uses Lean.RArray in bv_decide's reflection proofs. Giving
-speedups on problems with lots of variables.
-
-* [#6295](https://github.com/leanprover/lean4/pull/6295) sets up simprocs for all the remaining operations defined in
-`Init.Data.Fin.Basic`
-
-* [#6300](https://github.com/leanprover/lean4/pull/6300), see the highlights section above for details.
-
-* [#6330](https://github.com/leanprover/lean4/pull/6330), see the highlights section above for details.
-
-* [#6362](https://github.com/leanprover/lean4/pull/6362), see the highlights section above for details.
-
-* [#6366](https://github.com/leanprover/lean4/pull/6366), see the highlights section above for details.
-
-* [#6375](https://github.com/leanprover/lean4/pull/6375) fixes a bug in the simplifier. It was producing terms with loose
-bound variables when eliminating unused `let_fun` expressions.
-
-* [#6378](https://github.com/leanprover/lean4/pull/6378) adds an explanation to the error message when `cases` and
-`induction` are applied to a term whose type is not an inductive type.
-For `Prop`, these tactics now suggest the `by_cases` tactic. Example:
-```
-tactic 'cases' failed, major premise type is not an inductive type
-  Prop
-```
-
-* [#6381](https://github.com/leanprover/lean4/pull/6381) fixes a bug in `withTrackingZetaDelta` and
-`withTrackingZetaDeltaSet`. The `MetaM` caches need to be reset. See new
-test.
-
-* [#6385](https://github.com/leanprover/lean4/pull/6385) fixes a bug in `simp_all?` that caused some local declarations
-to be omitted from the `Try this:` suggestions.
-
-* [#6386](https://github.com/leanprover/lean4/pull/6386) ensures that `revertAll` clears auxiliary declarations when
-invoked directly by users.
-
-* [#6387](https://github.com/leanprover/lean4/pull/6387) fixes a type error in the proof generated by the `contradiction`
-tactic.
-
-* [#6397](https://github.com/leanprover/lean4/pull/6397) ensures that `simp` and `dsimp` do not unfold definitions that
-are not intended to be unfolded by the user. See issue #5755 for an
-example affected by this issue.
-
-* [#6398](https://github.com/leanprover/lean4/pull/6398) ensures `Meta.check` check projections.
-
-* [#6412](https://github.com/leanprover/lean4/pull/6412) adds reserved names for congruence theorems used in the
-simplifier and `grind` tactics. The idea is prevent the same congruence
-theorems to be generated over and over again.
-
-* [#6413](https://github.com/leanprover/lean4/pull/6413) introduces the following features to the WIP `grind` tactic:
-- `Expr` internalization.
-- Congruence theorem cache.
-- Procedure for adding new facts
-- New tracing options
-- New preprocessing steps: fold projections and eliminate dangling
-`Expr.mdata`
-
-* [#6414](https://github.com/leanprover/lean4/pull/6414) fixes a bug in `Lean.Meta.Closure` that would introduce
-under-applied delayed assignment metavariables, which would keep them
-from ever getting instantiated. This bug affected `match` elaboration
-when the expected type contained postponed elaboration problems, for
-example tactic blocks.
-
-* [#6419](https://github.com/leanprover/lean4/pull/6419) fixes multiple bugs in the WIP `grind` tactic. It also adds
-support for printing the `grind` internal state.
-
-* [#6428](https://github.com/leanprover/lean4/pull/6428) adds a new preprocessing step to the `grind` tactic:
-universe-level normalization. The goal is to avoid missing equalities in
-the congruence closure module.
-
-* [#6430](https://github.com/leanprover/lean4/pull/6430) adds the predicate `Expr.fvarsSet a b`, which returns `true` if
-and only if the free variables in `a` are a subset of the free variables
-in `b`.
-
-* [#6433](https://github.com/leanprover/lean4/pull/6433) adds a custom type and instance canonicalizer for the (WIP)
-`grind` tactic. The `grind` tactic uses congruence closure but
-disregards types, type formers, instances, and proofs. Proofs are
-ignored due to proof irrelevance. Types, type formers, and instances are
-considered supporting elements and are not factored into congruence
-detection. Instead, `grind` only checks whether elements are
-structurally equal, which, in the context of the `grind` tactic, is
-equivalent to pointer equality. See new tests for examples where the
-canonicalizer is important.
-
-* [#6435](https://github.com/leanprover/lean4/pull/6435) implements the congruence table for the (WIP) `grind` tactic. It
-also fixes several bugs, and adds a new preprocessing step.
-
-* [#6437](https://github.com/leanprover/lean4/pull/6437) adds support for detecting congruent terms in the (WIP) `grind`
-tactic. It also introduces the `grind.debug` option, which, when set to
-`true`, checks many invariants after each equivalence class is merged.
-This option is intended solely for debugging purposes.
-
-* [#6438](https://github.com/leanprover/lean4/pull/6438) ensures `norm_cast` doesn't fail to act in the presence of
-`no_index` annotations
-
-* [#6441](https://github.com/leanprover/lean4/pull/6441) adds basic truth value propagation rules to the (WIP) `grind`
-tactic.
-
-* [#6442](https://github.com/leanprover/lean4/pull/6442) fixes the `checkParents` sanity check in `grind`.
-
-* [#6443](https://github.com/leanprover/lean4/pull/6443) adds support for propagating the truth value of equalities in
-the (WIP) `grind` tactic.
-
-* [#6447](https://github.com/leanprover/lean4/pull/6447) refactors `grind` and adds support for invoking the simplifier
-using the `GrindM` monad.
-
-* [#6448](https://github.com/leanprover/lean4/pull/6448) declares the command `builtin_grind_propagator` for registering
-equation propagator for `grind`. It also declares the auxiliary the
-attribute.
-
-* [#6449](https://github.com/leanprover/lean4/pull/6449) completes the implementation of the command
-`builtin_grind_propagator`.
-
-* [#6452](https://github.com/leanprover/lean4/pull/6452) adds support for generating (small) proofs for any two
-expressions that belong to the same equivalence class in the `grind`
-tactic state.
-
-* [#6453](https://github.com/leanprover/lean4/pull/6453) improves bv_decide's performance in the presence of large
-literals.
-
-* [#6455](https://github.com/leanprover/lean4/pull/6455) fixes a bug in the equality proof generator in the (WIP) `grind`
-tactic.
-
-* [#6456](https://github.com/leanprover/lean4/pull/6456) fixes another bug in the equality proof generator in the (WIP)
-`grind` tactic.
-
-* [#6457](https://github.com/leanprover/lean4/pull/6457) adds support for generating congruence proofs for congruences
-detected by the `grind` tactic.
-
-* [#6458](https://github.com/leanprover/lean4/pull/6458) adds support for compact congruence proofs in the (WIP) `grind`
-tactic. The `mkCongrProof` function now verifies whether the congruence
-proof can be constructed using only `congr`, `congrFun`, and `congrArg`,
-avoiding the need to generate the more complex `hcongr` auxiliary
-theorems.
-
-* [#6459](https://github.com/leanprover/lean4/pull/6459) adds the (WIP) `grind` tactic. It currently generates a warning
-message to make it clear that the tactic is not ready for production.
-
-* [#6461](https://github.com/leanprover/lean4/pull/6461) adds a new propagation rule for negation to the (WIP) `grind`
-tactic.
-
-* [#6463](https://github.com/leanprover/lean4/pull/6463) adds support for constructors to the (WIP) `grind` tactic. When
-merging equivalence classes, `grind` checks for equalities between
-constructors. If they are distinct, it closes the goal; if they are the
-same, it applies injectivity.
-
-* [#6464](https://github.com/leanprover/lean4/pull/6464) completes support for literal values in the (WIP) `grind`
-tactic. `grind` now closes the goal whenever it merges two equivalence
-classes with distinct literal values.
-
-* [#6465](https://github.com/leanprover/lean4/pull/6465) adds support for projection functions to the (WIP) `grind`
-tactic.
-
-* [#6466](https://github.com/leanprover/lean4/pull/6466) completes the implementation of `addCongrTable` in the (WIP)
-`grind` tactic. It also adds a new test to demonstrate why the extra
-check is needed. It also updates the field `cgRoot` (congruence root).
-
-* [#6468](https://github.com/leanprover/lean4/pull/6468) fixes issue #6467
-
-* [#6469](https://github.com/leanprover/lean4/pull/6469) adds support code for implementing e-match in the (WIP) `grind`
-tactic.
-
-* [#6470](https://github.com/leanprover/lean4/pull/6470) introduces a command for specifying patterns used in the
-heuristic instantiation of global theorems in the `grind` tactic. Note
-that this PR only adds the parser.
-
-* [#6472](https://github.com/leanprover/lean4/pull/6472) implements the command `grind_pattern`. The new command allows
-users to associate patterns with theorems. These patterns are used for
-performing heuristic instantiation with e-matching. In the future, we
-will add the attributes `@[grind_eq]`, `@[grind_fwd]`, and
-`@[grind_bwd]` to compute the patterns automatically for theorems.
-
-* [#6473](https://github.com/leanprover/lean4/pull/6473) adds a deriving handler for the `ToExpr` class. It can handle
-mutual and nested inductive types, however it falls back to creating
-`partial` instances in such cases. This is upstreamed from the Mathlib
-deriving handler written by @kmill, but has fixes to handle autoimplicit
-universe level variables.
-
-* [#6474](https://github.com/leanprover/lean4/pull/6474) adds pattern validation to the `grind_pattern` command. The new
-`checkCoverage` function will also be used to implement the attributes
-`@[grind_eq]`, `@[grind_fwd]`, and `@[grind_bwd]`.
-
-* [#6475](https://github.com/leanprover/lean4/pull/6475) adds support for activating relevant theorems for the (WIP)
-`grind` tactic. We say a theorem is relevant to a `grind` goal if the
-symbols occurring in its patterns also occur in the goal.
-
-* [#6478](https://github.com/leanprover/lean4/pull/6478) internalize nested ground patterns when activating ematch
-theorems in the (WIP) `grind` tactic.
-
-* [#6481](https://github.com/leanprover/lean4/pull/6481) implements E-matching for the (WIP) `grind` tactic. We still
-need to finalize and internalize the new instances.
-
-* [#6484](https://github.com/leanprover/lean4/pull/6484) addresses a few error messages where diffs weren't being
-exposed.
-
-* [#6485](https://github.com/leanprover/lean4/pull/6485) implements `Grind.EMatch.instantiateTheorem` in the (WIP)
-`grind` tactic.
-
-* [#6487](https://github.com/leanprover/lean4/pull/6487) adds source position information for `structure` parent
-projections, supporting "go to definition". Closes #3063.
-
-* [#6488](https://github.com/leanprover/lean4/pull/6488) fixes and refactors the E-matching module for the (WIP) `grind`
-tactic.
-
-* [#6490](https://github.com/leanprover/lean4/pull/6490) adds basic configuration options for the `grind` tactic.
-
-* [#6492](https://github.com/leanprover/lean4/pull/6492) fixes a bug in the theorem instantiation procedure in the (WIP)
-`grind` tactic. 
-
-* [#6497](https://github.com/leanprover/lean4/pull/6497) fixes another theorem instantiation bug in the `grind` tactic.
-It also moves new instances to be processed to `Goal`.
-
-* [#6498](https://github.com/leanprover/lean4/pull/6498) adds support in the `grind` tactic for propagating dependent
-forall terms `forall (h : p), q[h]` where `p` is a proposition.
-
-* [#6499](https://github.com/leanprover/lean4/pull/6499) fixes the proof canonicalizer for `grind`.
-
-* [#6500](https://github.com/leanprover/lean4/pull/6500) fixes a bug in the `markNestedProofs` used in `grind`. See new
-test.
-
-* [#6502](https://github.com/leanprover/lean4/pull/6502) fixes a bug in the proof assembly procedure utilized by the
-`grind` tactic.
-
-* [#6503](https://github.com/leanprover/lean4/pull/6503) adds a simple strategy to the (WIP) `grind` tactic. It just
-keeps internalizing new theorem instances found by E-matching. 
-
-* [#6506](https://github.com/leanprover/lean4/pull/6506) adds the `monotonicity` tactic, intended to be used inside the
-`partial_fixpoint` feature.
-
-* [#6508](https://github.com/leanprover/lean4/pull/6508) fixes a bug in the sanity checkers for the `grind` tactic. See
-the new test for an example of a case where it was panicking.
-
-* [#6509](https://github.com/leanprover/lean4/pull/6509) fixes a bug in the congruence closure data structure used in the
-`grind` tactic. The new test includes an example that previously caused
-a panic. A similar panic was also occurring in the test
-`grind_nested_proofs.lean`.
-
-* [#6510](https://github.com/leanprover/lean4/pull/6510) adds a custom congruence rule for equality in `grind`. The new
-rule takes into account that `Eq` is a symmetric relation. In the
-future, we will add support for arbitrary symmetric relations. The
-current rule is important for propagating disequalities effectively in
-`grind`.
-
-* [#6512](https://github.com/leanprover/lean4/pull/6512) introduces support for user-defined fallback code in the `grind`
-tactic. The fallback code can be utilized to inspect the state of
-failing `grind` subgoals and/or invoke user-defined automation. Users
-can now write `grind on_failure <code>`, where `<code>` should have the
-type `GoalM Unit`. See the modified tests in this PR for examples.
-
-* [#6513](https://github.com/leanprover/lean4/pull/6513) adds support for (dependent) if-then-else terms (i.e., `ite` and
-`dite` applications) in the `grind` tactic.
-
-* [#6514](https://github.com/leanprover/lean4/pull/6514) enhances the assertion of new facts in `grind` by avoiding the
-creation of unnecessary metavariables.
-
-## Library
-
-* [#6182](https://github.com/leanprover/lean4/pull/6182) adds `BitVec.[toInt|toFin]_concat` and moves a couple of
-theorems into the concat section, as `BitVec.msb_concat` is needed for
-the `toInt_concat` proof.
-
-* [#6188](https://github.com/leanprover/lean4/pull/6188) completes the `toNat` theorems for the bitwise operations
-(`and`, `or`, `xor`, `shiftLeft`, `shiftRight`) of the UInt types and
-adds `toBitVec` theorems as well. It also renames `and_toNat` to
-`toNat_and` to fit with the current naming convention.
-
-* [#6238](https://github.com/leanprover/lean4/pull/6238) adds theorems characterizing the value of the unsigned shift
-right of a bitvector in terms of its 2s complement interpretation as an
-integer.
-Unsigned shift right by at least one bit makes the value of the
-bitvector less than or equal to `2^(w-1)`,
-makes the interpretation of the bitvector `Int` and `Nat` agree.
-In the case when `n = 0`, then the shift right value equals the integer
-interpretation.
-
-* [#6244](https://github.com/leanprover/lean4/pull/6244) changes the implementation of `HashMap.toList`, so the ordering
-agrees with `HashMap.toArray`.
-
-* [#6272](https://github.com/leanprover/lean4/pull/6272) introduces the basic theory of permutations of `Array`s and
-proves `Array.swap_perm`.
-
-* [#6282](https://github.com/leanprover/lean4/pull/6282) moves `IO.Channel` and `IO.Mutex` from `Init` to `Std.Sync` and
-renames them to `Std.Channel` and `Std.Mutex`.
-
-* [#6294](https://github.com/leanprover/lean4/pull/6294) upstreams `List.length_flatMap`, `countP_flatMap` and
-`count_flatMap` from Mathlib. These were not possible to state before we
-upstreamed `List.sum`.
-
-* [#6315](https://github.com/leanprover/lean4/pull/6315) adds `protected` to `Fin.cast` and `BitVec.cast`, to avoid
-confusion with `_root_.cast`. These should mostly be used via
-dot-notation in any case.
-
-* [#6316](https://github.com/leanprover/lean4/pull/6316) adds lemmas simplifying `for` loops over `Option` into
-`Option.pelim`, giving parity with lemmas simplifying `for` loops of
-`List` into `List.fold`.
-
-* [#6317](https://github.com/leanprover/lean4/pull/6317) completes the basic API for BitVec.ofBool.
-
-* [#6318](https://github.com/leanprover/lean4/pull/6318) generalizes the universe level for `Array.find?`, by giving it a
-separate implementation from `Array.findM?`.
-
-* [#6324](https://github.com/leanprover/lean4/pull/6324) adds `GetElem` lemmas for the basic `Vector` operations.
-
-* [#6333](https://github.com/leanprover/lean4/pull/6333) generalizes the panic functions to a type of `Sort u` rather
-than `Type u`. This better supports universe polymorphic types and
-avoids confusing errors.
-
-* [#6334](https://github.com/leanprover/lean4/pull/6334) adds `Nat` theorems for distributing `>>>` over bitwise
-operations, paralleling those of `BitVec`.
-
-* [#6338](https://github.com/leanprover/lean4/pull/6338) adds `BitVec.[toFin|getMsbD]_setWidth` and
-`[getMsb|msb]_signExtend` as well as `ofInt_toInt`.
-
-* [#6341](https://github.com/leanprover/lean4/pull/6341) generalizes `DecidableRel` to allow a heterogeneous relation.
-
-* [#6353](https://github.com/leanprover/lean4/pull/6353) reproduces the API around `List.any/all` for `Array.any/all`.
-
-* [#6364](https://github.com/leanprover/lean4/pull/6364) makes fixes suggested by the Batteries environment linters,
-particularly `simpNF`, and `unusedHavesSuffices`.
-
-* [#6365](https://github.com/leanprover/lean4/pull/6365) expands the `Array.set` and `Array.setIfInBounds` lemmas to
-match existing lemmas for `List.set`.
-
-* [#6367](https://github.com/leanprover/lean4/pull/6367) brings Vector lemmas about membership and indexing to parity
-with List and Array.
-
-* [#6369](https://github.com/leanprover/lean4/pull/6369) adds lemmas about `Vector.set`, `anyM`, `any`, `allM`, and
-`all`.
-
-* [#6376](https://github.com/leanprover/lean4/pull/6376) adds theorems about `==` on `Vector`, reproducing those already
-on `List` and `Array`.
-
-* [#6379](https://github.com/leanprover/lean4/pull/6379) replaces the inductive predicate `List.lt` with an upstreamed version of `List.Lex` from Mathlib.
-(Previously `Lex.lt` was defined in terms of `<`; now it is generalized to take an arbitrary relation.)
-This subtly changes the notion of ordering on `List α`.
-
-  `List.lt` was a weaker relation: in particular if `l₁ < l₂`, then `a :: l₁ < b :: l₂` may hold according to `List.lt` even if `a` and `b` are merely incomparable (either neither `a < b` nor `b < a`), whereas according to `List.Lex` this would require `a = b`.
-
-  When `<` is total, in the sense that `¬ · < ·` is antisymmetric, then the two relations coincide.
-
-  Mathlib was already overriding the order instances for `List α`, so this change should not be noticed by anyone already using Mathlib.
-
-  We simultaneously add the boolean valued `List.lex` function, parameterised by a `BEq` typeclass and an arbitrary `lt` function. This will support the flexibility previously provided for `List.lt`, via a `==` function which is weaker than strict equality.
-
-* [#6390](https://github.com/leanprover/lean4/pull/6390) redefines `Range.forIn'` and `Range.forM`, in preparation for
-writing lemmas about them.
-
-* [#6391](https://github.com/leanprover/lean4/pull/6391) requires that the step size in `Std.Range` is positive, to avoid
-ill-specified behaviour.
-
-* [#6396](https://github.com/leanprover/lean4/pull/6396) adds lemmas reducing for loops over `Std.Range` to for loops
-over `List.range'`.
-
-* [#6399](https://github.com/leanprover/lean4/pull/6399) adds basic lemmas about lexicographic order on Array and Vector,
-achieving parity with List.
-
-* [#6423](https://github.com/leanprover/lean4/pull/6423) adds missing lemmas about lexicographic order on
-List/Array/Vector.
-
-* [#6477](https://github.com/leanprover/lean4/pull/6477) adds the necessary domain theory that backs the
-`partial_fixpoint` feature.
-
-## Compiler
-
-* [#6311](https://github.com/leanprover/lean4/pull/6311) adds support for `HEq` to the new code generator.
-
-* [#6348](https://github.com/leanprover/lean4/pull/6348) adds support for `Float32` to the Lean runtime.
-
-* [#6350](https://github.com/leanprover/lean4/pull/6350) adds missing features and fixes bugs in the `Float32` support
-
-* [#6383](https://github.com/leanprover/lean4/pull/6383) ensures the new code generator produces code for `opaque`
-definitions that are not tagged as `@[extern]`.
-Remark: This is the behavior of the old code generator.
-
-* [#6405](https://github.com/leanprover/lean4/pull/6405) adds support for erasure of `Decidable.decide` to the new code
-generator. It also adds a new `Probe.runOnDeclsNamed` function, which is
-helpful for writing targeted single-file tests of compiler internals.
-
-* [#6415](https://github.com/leanprover/lean4/pull/6415) fixes a bug in the `sharecommon` module, which was returning
-incorrect results for objects that had already been processed by
-`sharecommon`. See the new test for an example that triggered the bug.
-
-* [#6429](https://github.com/leanprover/lean4/pull/6429) adds support for extern LCNF decls, which is required for parity
-with the existing code generator.
-
-* [#6535](https://github.com/leanprover/lean4/pull/6535) avoids a linker warning on Windows.
-
-* [#6547](https://github.com/leanprover/lean4/pull/6547) should prevent Lake from accidentally picking up other linkers
-installed on the machine.
-
-* [#6574](https://github.com/leanprover/lean4/pull/6574) actually prevents Lake from accidentally picking up other
-toolchains installed on the machine.
-
-## Pretty Printing
-
-* [#5689](https://github.com/leanprover/lean4/pull/5689) adjusts the way the pretty printer unresolves names. It used to
-make use of all `export`s when pretty printing, but now it only uses
-`export`s that put names into parent namespaces (heuristic: these are
-"API exports" that are intended by the library author), rather than
-"horizontal exports" that put the names into an unrelated namespace,
-which the dot notation feature in #6189 now incentivizes.
-
-* [#5757](https://github.com/leanprover/lean4/pull/5757), aside from introducing labeled sorries, fixes the bug that the metadata attached to the pretty-printed representation of arguments with a borrow annotation (for example, the second argument of `String.append`), is inconsistent with the metadata attached to the regular arguments.
-
-## Documentation
-
-* [#6450](https://github.com/leanprover/lean4/pull/6450) adds a docstring to the `@[app_delab]` attribute.
-
-## Server
-
-* [#6279](https://github.com/leanprover/lean4/pull/6279) fixes a bug in structure instance field completion that caused
-it to not function correctly for bracketed structure instances written
-in Mathlib style.
-
-* [#6408](https://github.com/leanprover/lean4/pull/6408) fixes a regression where goals that don't exist were being
-displayed. The regression was triggered by #5835 and originally caused
-by #4926.
-
-## Lake
-
-* [#6176](https://github.com/leanprover/lean4/pull/6176) changes Lake's build process to no longer use `leanc` for
-compiling C files or linking shared libraries and executables. Instead,
-it directly invokes the bundled compiler (or the native compiler if
-none) using the necessary flags.
-
-* [#6289](https://github.com/leanprover/lean4/pull/6289) adapts Lake modules to use `prelude` and includes them in the
-`check-prelude` CI.
-
-* [#6291](https://github.com/leanprover/lean4/pull/6291) ensures the the log error position is properly preserved when
-prepending stray log entries to the job log. It also adds comparison
-support for `Log.Pos`.
-
-* [#6388](https://github.com/leanprover/lean4/pull/6388) merges `BuildJob` and `Job`, deprecating the former. `Job` now
-contains a trace as part of its state which can be interacted with
-monadically. also simplifies the implementation of `OpaqueJob`.
-
-* [#6411](https://github.com/leanprover/lean4/pull/6411) adds the ability to override package entries in a Lake manifest
-via a separate JSON file. This file can be specified on the command line
-with `--packages` or applied persistently by placing it at
-`.lake/package-overrides.json`.
-
-* [#6422](https://github.com/leanprover/lean4/pull/6422) fixes a bug in #6388 where the `Package.afterBuildCahe*`
-functions would produce different traces depending on whether the cache
-was fetched.
-
-* [#6627](https://github.com/leanprover/lean4/pull/6627) aims to fix the trace issues reported by Mathlib that are
-breaking `lake exe cache` in downstream projects.
-
-* [#6631](https://github.com/leanprover/lean4/pull/6631) sets `MACOSX_DEPLOYMENT_TARGET` for shared libraries (it was
-previously only set for executables).
-
-## Other
-
-* [#6285](https://github.com/leanprover/lean4/pull/6285) upstreams the `ToLevel` typeclass from mathlib and uses it to
-fix the existing `ToExpr` instances so that they are truly universe
-polymorphic (previously it generated malformed expressions when the
-universe level was nonzero). We improve on the mathlib definition of
-`ToLevel` to ensure the class always lives in `Type`, irrespective of
-the universe parameter.
-
-* [#6363](https://github.com/leanprover/lean4/pull/6363) fixes errors at load time in the comparison mode of the Firefox
-profiler.

releases/v4.2.0.md

@@ -1,16 +0,0 @@
-v4.2.0
----------
-
-* [isDefEq cache for terms not containing metavariables.](https://github.com/leanprover/lean4/pull/2644).
-* Make [`Environment.mk`](https://github.com/leanprover/lean4/pull/2604) and [`Environment.add`](https://github.com/leanprover/lean4/pull/2642) private, and add [`replay`](https://github.com/leanprover/lean4/pull/2617) as a safer alternative.
-* `IO.Process.output` no longer inherits the standard input of the caller.
-* [Do not inhibit caching](https://github.com/leanprover/lean4/pull/2612) of default-level `match` reduction.
-* [List the valid case tags](https://github.com/leanprover/lean4/pull/2629) when the user writes an invalid one.
-* The derive handler for `DecidableEq` [now handles](https://github.com/leanprover/lean4/pull/2591) mutual inductive types.
-* [Show path of failed import in Lake](https://github.com/leanprover/lean4/pull/2616).
-* [Fix linker warnings on macOS](https://github.com/leanprover/lean4/pull/2598).
-* **Lake:** Add `postUpdate?` package configuration option. Used by a package to specify some code which should be run after a successful `lake update` of the package or one of its downstream dependencies. ([lake#185](https://github.com/leanprover/lake/issues/185))
-* Improvements to Lake startup time ([#2572](https://github.com/leanprover/lean4/pull/2572), [#2573](https://github.com/leanprover/lean4/pull/2573))
-* `refine e` now replaces the main goal with metavariables which were created during elaboration of `e` and no longer captures pre-existing metavariables that occur in `e` ([#2502](https://github.com/leanprover/lean4/pull/2502)).
-  * This is accomplished via changes to `withCollectingNewGoalsFrom`, which also affects `elabTermWithHoles`, `refine'`, `calc` (tactic), and `specialize`. Likewise, all of these now only include newly-created metavariables in their output.
-  * Previously, both newly-created and pre-existing metavariables occurring in `e` were returned inconsistently in different edge cases, causing duplicated goals in the infoview (issue [#2495](https://github.com/leanprover/lean4/issues/2495)), erroneously closed goals (issue [#2434](https://github.com/leanprover/lean4/issues/2434)), and unintuitive behavior due to `refine e` capturing previously-created goals appearing unexpectedly in `e` (no issue; see PR).

releases/v4.3.0.md

@@ -1,37 +0,0 @@
-v4.3.0
----------
-
-* `simp [f]` does not unfold partial applications of `f` anymore. See issue [#2042](https://github.com/leanprover/lean4/issues/2042).
-  To fix proofs affected by this change, use `unfold f` or `simp (config := { unfoldPartialApp := true }) [f]`.
-* By default, `simp` will no longer try to use Decidable instances to rewrite terms. In particular, not all decidable goals will be closed by `simp`, and the `decide` tactic may be useful in such cases. The `decide` simp configuration option can be used to locally restore the old `simp` behavior, as in `simp (config := {decide := true})`; this includes using Decidable instances to verify side goals such as numeric inequalities.
-
-* Many bug fixes:
-  * [Add left/right actions to term tree coercion elaborator and make `^`` a right action](https://github.com/leanprover/lean4/pull/2778)
-  * [Fix for #2775, don't catch max recursion depth errors](https://github.com/leanprover/lean4/pull/2790)
-  * [Reduction of `Decidable` instances very slow when using `cases` tactic](https://github.com/leanprover/lean4/issues/2552)
-  * [`simp` not rewriting in binder](https://github.com/leanprover/lean4/issues/1926)
-  * [`simp` unfolding `let` even with `zeta := false` option](https://github.com/leanprover/lean4/issues/2669)
-  * [`simp` (with beta/zeta disabled) and discrimination trees](https://github.com/leanprover/lean4/issues/2281)
-  * [unknown free variable introduced by `rw ... at h`](https://github.com/leanprover/lean4/issues/2711)
-  * [`dsimp` doesn't use `rfl` theorems which consist of an unapplied constant](https://github.com/leanprover/lean4/issues/2685)
-  * [`dsimp` does not close reflexive equality goals if they are wrapped in metadata](https://github.com/leanprover/lean4/issues/2514)
-  * [`rw [h]` uses `h` from the environment in preference to `h` from the local context](https://github.com/leanprover/lean4/issues/2729)
-  * [missing `withAssignableSyntheticOpaque` for `assumption` tactic](https://github.com/leanprover/lean4/issues/2361)
-  * [ignoring default value for field warning](https://github.com/leanprover/lean4/issues/2178)
-* [Cancel outstanding tasks on document edit in the language server](https://github.com/leanprover/lean4/pull/2648).
-* [Remove unnecessary `%` operations in `Fin.mod` and `Fin.div`](https://github.com/leanprover/lean4/pull/2688)
-* [Avoid `DecidableEq` in `Array.mem`](https://github.com/leanprover/lean4/pull/2774)
-* [Ensure `USize.size` unifies with `?m + 1`](https://github.com/leanprover/lean4/issues/1926)
-* [Improve compatibility with emacs eglot client](https://github.com/leanprover/lean4/pull/2721)
-
-**Lake:**
-
-* [Sensible defaults for `lake new MyProject math`](https://github.com/leanprover/lean4/pull/2770)
-* Changed `postUpdate?` configuration option to a `post_update` declaration. See the `post_update` syntax docstring for more information on the new syntax.
-* [A manifest is automatically created on workspace load if one does not exists.](https://github.com/leanprover/lean4/pull/2680).
-* The `:=` syntax for configuration declarations (i.e., `package`, `lean_lib`, and `lean_exe`) has been deprecated. For example, `package foo := {...}` is deprecated.
-* [support for overriding package URLs via `LAKE_PKG_URL_MAP`](https://github.com/leanprover/lean4/pull/2709)
-* Moved the default build directory (e.g., `build`), default packages directory (e.g., `lake-packages`), and the compiled configuration (e.g., `lakefile.olean`) into a new dedicated directory for Lake outputs, `.lake`. The cloud release build archives are also stored here, fixing [#2713](https://github.com/leanprover/lean4/issues/2713).
-* Update manifest format to version 7 (see [lean4#2801](https://github.com/leanprover/lean4/pull/2801) for details on the changes).
-* Deprecate the `manifestFile` field of a package configuration.
-* There is now a more rigorous check on `lakefile.olean` compatibility (see [#2842](https://github.com/leanprover/lean4/pull/2842) for more details).

releases/v4.4.0.md

@@ -1,45 +0,0 @@
-v4.4.0
----------
-
-* Lake and the language server now support per-package server options using the `moreServerOptions` config field, as well as options that apply to both the language server and `lean` using the `leanOptions` config field. Setting either of these fields instead of `moreServerArgs` ensures that viewing files from a dependency uses the options for that dependency. Additionally, `moreServerArgs` is being deprecated in favor of the `moreGlobalServerArgs` field. See PR [#2858](https://github.com/leanprover/lean4/pull/2858).
-
-  A Lakefile with the following deprecated package declaration:
-  ```lean
-  def moreServerArgs := #[
-    "-Dpp.unicode.fun=true"
-  ]
-  def moreLeanArgs := moreServerArgs
-
-  package SomePackage where
-    moreServerArgs := moreServerArgs
-    moreLeanArgs := moreLeanArgs
-  ```
-
-  ... can be updated to the following package declaration to use per-package options:
-  ```lean
-  package SomePackage where
-    leanOptions := #[⟨`pp.unicode.fun, true⟩]
-  ```
-* [Rename request handler](https://github.com/leanprover/lean4/pull/2462).
-* [Import auto-completion](https://github.com/leanprover/lean4/pull/2904).
-* [`pp.beta`` to apply beta reduction when pretty printing](https://github.com/leanprover/lean4/pull/2864).
-* [Embed and check githash in .olean](https://github.com/leanprover/lean4/pull/2766).
-* [Guess lexicographic order for well-founded recursion](https://github.com/leanprover/lean4/pull/2874).
-* [Allow trailing comma in tuples, lists, and tactics](https://github.com/leanprover/lean4/pull/2643).
-
-Bug fixes for [#2628](https://github.com/leanprover/lean4/issues/2628), [#2883](https://github.com/leanprover/lean4/issues/2883),
-[#2810](https://github.com/leanprover/lean4/issues/2810), [#2925](https://github.com/leanprover/lean4/issues/2925), and [#2914](https://github.com/leanprover/lean4/issues/2914).
-
-**Lake:**
-
-* `lake init .` and a bare `lake init` and will now use the current directory as the package name. [#2890](https://github.com/leanprover/lean4/pull/2890)
-* `lake new` and `lake init` will now produce errors on invalid package names such as `..`, `foo/bar`, `Init`, `Lean`, `Lake`, and `Main`. See issue [#2637](https://github.com/leanprover/lean4/issues/2637) and PR [#2890](https://github.com/leanprover/lean4/pull/2890).
-* `lean_lib` no longer converts its name to upper camel case (e.g., `lean_lib bar` will include modules named `bar.*` rather than `Bar.*`). See issue [#2567](https://github.com/leanprover/lean4/issues/2567) and PR [#2889](https://github.com/leanprover/lean4/pull/2889).
-* Lean and Lake now properly support non-identifier library names (e.g., `lake new 123-hello` and `import «123Hello»` now work correctly). See issue [#2865](https://github.com/leanprover/lean4/issues/2865) and PR [#2889](https://github.com/leanprover/lean4/pull/2888).
-* Lake now filters the environment extensions loaded from a compiled configuration (`lakefile.olean`) to include only those relevant to Lake's workspace loading process. This resolves segmentation faults caused by environment extension type mismatches (e.g., when defining custom elaborators via `elab` in configurations). See issue [#2632](https://github.com/leanprover/lean4/issues/2632) and PR [#2896](https://github.com/leanprover/lean4/pull/2896).
-* Cloud releases will now properly be re-unpacked if the build directory is removed. See PR [#2928](https://github.com/leanprover/lean4/pull/2928).
-* Lake's `math` template has been simplified. See PR [#2930](https://github.com/leanprover/lean4/pull/2930).
-* `lake exe <target>` now parses `target` like a build target (as the help text states it should) rather than as a basic name. For example, `lake exe @mathlib/runLinter` should now work. See PR [#2932](https://github.com/leanprover/lean4/pull/2932).
-* `lake new foo.bar [std]` now generates executables named `foo-bar` and `lake new foo.bar exe` properly creates `foo/bar.lean`. See PR [#2932](https://github.com/leanprover/lean4/pull/2932).
-* Later packages and libraries in the dependency tree are now preferred over earlier ones. That is, the later ones "shadow" the earlier ones. Such an ordering is more consistent with how declarations generally work in programming languages. This will break any package that relied on the previous ordering. See issue [#2548](https://github.com/leanprover/lean4/issues/2548) and PR [#2937](https://github.com/leanprover/lean4/pull/2937).
-* Executable roots are no longer mistakenly treated as importable. They will no longer be picked up by `findModule?`. See PR [#2937](https://github.com/leanprover/lean4/pull/2937).

releases/v4.5.0.md

@@ -1,77 +0,0 @@
-v4.5.0
----------
-
-* Modify the lexical syntax of string literals to have string gaps, which are escape sequences of the form `"\" newline whitespace*`.
-  These have the interpretation of an empty string and allow a string to flow across multiple lines without introducing additional whitespace.
-  The following is equivalent to `"this is a string"`.
-  ```lean
-  "this is \
-     a string"
-  ```
-  [PR #2821](https://github.com/leanprover/lean4/pull/2821) and [RFC #2838](https://github.com/leanprover/lean4/issues/2838).
-
-* Add raw string literal syntax. For example, `r"\n"` is equivalent to `"\\n"`, with no escape processing.
-  To include double quote characters in a raw string one can add sufficiently many `#` characters before and after
-  the bounding `"`s, as in `r#"the "the" is in quotes"#` for `"the \"the\" is in quotes"`.
-  [PR #2929](https://github.com/leanprover/lean4/pull/2929) and [issue #1422](https://github.com/leanprover/lean4/issues/1422).
-
-* The low-level `termination_by'` clause is no longer supported.
-
-  Migration guide: Use `termination_by` instead, e.g.:
-  ```diff
-  -termination_by' measure (fun ⟨i, _⟩ => as.size - i)
-  +termination_by i _ => as.size - i
-  ```
-
-  If the well-founded relation you want to use is not the one that the
-  `WellFoundedRelation` type class would infer for your termination argument,
-  you can use `WellFounded.wrap` from the std library to explicitly give one:
-  ```diff
-  -termination_by' ⟨r, hwf⟩
-  +termination_by x => hwf.wrap x
-  ```
-
-* Support snippet edits in LSP `TextEdit`s. See `Lean.Lsp.SnippetString` for more details.
-
-* Deprecations and changes in the widget API.
-  - `Widget.UserWidgetDefinition` is deprecated in favour of `Widget.Module`. The annotation `@[widget]` is deprecated in favour of `@[widget_module]`. To migrate a definition of type `UserWidgetDefinition`, remove the `name` field and replace the type with `Widget.Module`. Removing the `name` results in a title bar no longer being drawn above your panel widget. To add it back, draw it as part of the component using `<details open=true><summary class='mv2 pointer'>{name}</summary>{rest_of_widget}</details>`. See an example migration [here](https://github.com/leanprover/std4/pull/475/files#diff-857376079661a0c28a53b7ff84701afabbdf529836a6944d106c5294f0e68109R43-R83).
-  - The new command `show_panel_widgets` allows displaying always-on and locally-on panel widgets.
-  - `RpcEncodable` widget props can now be stored in the infotree.
-  - See [RFC 2963](https://github.com/leanprover/lean4/issues/2963) for more details and motivation.
-
-* If no usable lexicographic order can be found automatically for a termination proof, explain why.
-  See [feat: GuessLex: if no measure is found, explain why](https://github.com/leanprover/lean4/pull/2960).
-
-* Option to print [inferred termination argument](https://github.com/leanprover/lean4/pull/3012).
-  With `set_option showInferredTerminationBy true` you will get messages like
-  ```
-  Inferred termination argument:
-  termination_by
-  ackermann n m => (sizeOf n, sizeOf m)
-  ```
-  for automatically generated `termination_by` clauses.
-
-* More detailed error messages for [invalid mutual blocks](https://github.com/leanprover/lean4/pull/2949).
-
-* [Multiple](https://github.com/leanprover/lean4/pull/2923) [improvements](https://github.com/leanprover/lean4/pull/2969) to the output of `simp?` and `simp_all?`.
-
-* Tactics with `withLocation *` [no longer fail](https://github.com/leanprover/lean4/pull/2917) if they close the main goal.
-
-* Implementation of a `test_extern` command for writing tests for `@[extern]` and `@[implemented_by]` functions.
-  Usage is
-  ```
-  import Lean.Util.TestExtern
-
-  test_extern Nat.add 17 37
-  ```
-  The head symbol must be the constant with the `@[extern]` or `@[implemented_by]` attribute. The return type must have a `DecidableEq` instance.
-
-Bug fixes for
-[#2853](https://github.com/leanprover/lean4/issues/2853), [#2953](https://github.com/leanprover/lean4/issues/2953), [#2966](https://github.com/leanprover/lean4/issues/2966),
-[#2971](https://github.com/leanprover/lean4/issues/2971), [#2990](https://github.com/leanprover/lean4/issues/2990), [#3094](https://github.com/leanprover/lean4/issues/3094).
-
-Bug fix for [eager evaluation of default value](https://github.com/leanprover/lean4/pull/3043) in `Option.getD`.
-Avoid [panic in `leanPosToLspPos`](https://github.com/leanprover/lean4/pull/3071) when file source is unavailable.
-Improve [short-circuiting behavior](https://github.com/leanprover/lean4/pull/2972) for `List.all` and `List.any`.
-
-Several Lake bug fixes: [#3036](https://github.com/leanprover/lean4/issues/3036), [#3064](https://github.com/leanprover/lean4/issues/3064), [#3069](https://github.com/leanprover/lean4/issues/3069).

releases/v4.6.0.md

@@ -1,230 +0,0 @@
-v4.6.0
----------
-
-* Add custom simplification procedures (aka `simproc`s) to `simp`. Simprocs can be triggered by the simplifier on a specified term-pattern. Here is an small example:
-  ```lean
-  import Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat
-
-  def foo (x : Nat) : Nat :=
-    x + 10
-
-  /--
-  The `simproc` `reduceFoo` is invoked on terms that match the pattern `foo _`.
-  -/
-  simproc reduceFoo (foo _) :=
-    /- A term of type `Expr → SimpM Step -/
-    fun e => do
-      /-
-      The `Step` type has three constructors: `.done`, `.visit`, `.continue`.
-      * The constructor `.done` instructs `simp` that the result does
-        not need to be simplified further.
-      * The constructor `.visit` instructs `simp` to visit the resulting expression.
-      * The constructor `.continue` instructs `simp` to try other simplification procedures.
-
-      All three constructors take a `Result`. The `.continue` constructor may also take `none`.
-      `Result` has two fields `expr` (the new expression), and `proof?` (an optional proof).
-       If the new expression is definitionally equal to the input one, then `proof?` can be omitted or set to `none`.
-      -/
-      /- `simp` uses matching modulo reducibility. So, we ensure the term is a `foo`-application. -/
-      unless e.isAppOfArity ``foo 1 do
-        return .continue
-      /- `Nat.fromExpr?` tries to convert an expression into a `Nat` value -/
-      let some n ← Nat.fromExpr? e.appArg!
-        | return .continue
-      return .done { expr := Lean.mkNatLit (n+10) }
-  ```
-  We disable simprocs support by using the command `set_option simprocs false`. This command is particularly useful when porting files to v4.6.0.
-  Simprocs can be scoped, manually added to `simp` commands, and suppressed using `-`. They are also supported by `simp?`. `simp only` does not execute any `simproc`. Here are some examples for the `simproc` defined above.
-  ```lean
-  example : x + foo 2 = 12 + x := by
-    set_option simprocs false in
-      /- This `simp` command does not make progress since `simproc`s are disabled. -/
-      fail_if_success simp
-    simp_arith
-
-  example : x + foo 2 = 12 + x := by
-    /- `simp only` must not use the default simproc set. -/
-    fail_if_success simp only
-    simp_arith
-
-  example : x + foo 2 = 12 + x := by
-    /-
-    `simp only` does not use the default simproc set,
-    but we can provide simprocs as arguments. -/
-    simp only [reduceFoo]
-    simp_arith
-
-  example : x + foo 2 = 12 + x := by
-    /- We can use `-` to disable `simproc`s. -/
-    fail_if_success simp [-reduceFoo]
-    simp_arith
-  ```
-  The command `register_simp_attr <id>` now creates a `simp` **and** a `simproc` set with the name `<id>`. The following command instructs Lean to insert the `reduceFoo` simplification procedure into the set `my_simp`. If no set is specified, Lean uses the default `simp` set.
-  ```lean
-  simproc [my_simp] reduceFoo (foo _) := ...
-  ```
-
-* The syntax of the `termination_by` and `decreasing_by` termination hints is overhauled:
-
-  * They are now placed directly after the function they apply to, instead of
-    after the whole `mutual` block.
-  * Therefore, the function name no longer has to be mentioned in the hint.
-  * If the function has a `where` clause, the `termination_by` and
-    `decreasing_by` for that function come before the `where`. The
-    functions in the `where` clause can have their own termination hints, each
-    following the corresponding definition.
-  * The `termination_by` clause can only bind “extra parameters”, that are not
-    already bound by the function header, but are bound in a lambda (`:= fun x
-    y z =>`) or in patterns (`| x, n + 1 => …`). These extra parameters used to
-    be understood as a suffix of the function parameters; now it is a prefix.
-
-  Migration guide: In simple cases just remove the function name, and any
-  variables already bound at the header.
-  ```diff
-   def foo : Nat → Nat → Nat := …
-  -termination_by foo a b => a - b
-  +termination_by a b => a - b
-  ```
-  or
-  ```diff
-   def foo : Nat → Nat → Nat := …
-  -termination_by _ a b => a - b
-  +termination_by a b => a - b
-  ```
-
-  If the parameters are bound in the function header (before the `:`), remove them as well:
-  ```diff
-   def foo (a b : Nat) : Nat := …
-  -termination_by foo a b => a - b
-  +termination_by a - b
-  ```
-
-  Else, if there are multiple extra parameters, make sure to refer to the right
-  ones; the bound variables are interpreted from left to right, no longer from
-  right to left:
-  ```diff
-   def foo : Nat → Nat → Nat → Nat
-     | a, b, c => …
-  -termination_by foo b c => b
-  +termination_by a b => b
-  ```
-
-  In the case of a `mutual` block, place the termination arguments (without the
-  function name) next to the function definition:
-  ```diff
-  -mutual
-  -def foo : Nat → Nat → Nat := …
-  -def bar : Nat → Nat := …
-  -end
-  -termination_by
-  -  foo a b => a - b
-  -  bar a => a
-  +mutual
-  +def foo : Nat → Nat → Nat := …
-  +termination_by a b => a - b
-  +def bar : Nat → Nat := …
-  +termination_by a => a
-  +end
-  ```
-
-  Similarly, if you have (mutual) recursion through `where` or `let rec`, the
-  termination hints are now placed directly after the function they apply to:
-  ```diff
-  -def foo (a b : Nat) : Nat := …
-  -  where bar (x : Nat) : Nat := …
-  -termination_by
-  -  foo a b => a - b
-  -  bar x => x
-  +def foo (a b : Nat) : Nat := …
-  +termination_by a - b
-  +  where
-  +    bar (x : Nat) : Nat := …
-  +    termination_by x
-
-  -def foo (a b : Nat) : Nat :=
-  -  let rec bar (x : Nat) :  Nat := …
-  -  …
-  -termination_by
-  -  foo a b => a - b
-  -  bar x => x
-  +def foo (a b : Nat) : Nat :=
-  +  let rec bar (x : Nat) : Nat := …
-  +    termination_by x
-  +  …
-  +termination_by a - b
-  ```
-
-  In cases where a single `decreasing_by` clause applied to multiple mutually
-  recursive functions before, the tactic now has to be duplicated.
-
-* The semantics of `decreasing_by` changed; the tactic is applied to all
-  termination proof goals together, not individually.
-
-  This helps when writing termination proofs interactively, as one can focus
-  each subgoal individually, for example using `·`. Previously, the given
-  tactic script had to work for _all_ goals, and one had to resort to tactic
-  combinators like `first`:
-
-  ```diff
-   def foo (n : Nat) := … foo e1 … foo e2 …
-  -decreasing_by
-  -simp_wf
-  -first | apply something_about_e1; …
-  -      | apply something_about_e2; …
-  +decreasing_by
-  +all_goals simp_wf
-  +· apply something_about_e1; …
-  +· apply something_about_e2; …
-  ```
-
-  To obtain the old behaviour of applying a tactic to each goal individually,
-  use `all_goals`:
-  ```diff
-   def foo (n : Nat) := …
-  -decreasing_by some_tactic
-  +decreasing_by all_goals some_tactic
-  ```
-
-  In the case of mutual recursion each `decreasing_by` now applies to just its
-  function. If some functions in a recursive group do not have their own
-  `decreasing_by`, the default `decreasing_tactic` is used. If the same tactic
-  ought to be applied to multiple functions, the `decreasing_by` clause has to
-  be repeated at each of these functions.
-
-* Modify `InfoTree.context` to facilitate augmenting it with partial contexts while elaborating a command. This breaks backwards compatibility with all downstream projects that traverse the `InfoTree` manually instead of going through the functions in `InfoUtils.lean`, as well as those manually creating and saving `InfoTree`s. See [PR #3159](https://github.com/leanprover/lean4/pull/3159) for how to migrate your code.
-
-* Add language server support for [call hierarchy requests](https://www.youtube.com/watch?v=r5LA7ivUb2c) ([PR #3082](https://github.com/leanprover/lean4/pull/3082)). The change to the .ilean format in this PR means that projects must be fully rebuilt once in order to generate .ilean files with the new format before features like "find references" work correctly again.
-
-* Structure instances with multiple sources (for example `{a, b, c with x := 0}`) now have their fields filled from these sources
-  in strict left-to-right order. Furthermore, the structure instance elaborator now aggressively use sources to fill in subobject
-  fields, which prevents unnecessary eta expansion of the sources,
-  and hence greatly reduces the reliance on costly structure eta reduction. This has a large impact on mathlib,
-  reducing total CPU instructions by 3% and enabling impactful refactors like leanprover-community/mathlib4#8386
-  which reduces the build time by almost 20%.
-  See [PR #2478](https://github.com/leanprover/lean4/pull/2478) and [RFC #2451](https://github.com/leanprover/lean4/issues/2451).
-
-* Add pretty printer settings to omit deeply nested terms (`pp.deepTerms false` and `pp.deepTerms.threshold`) ([PR #3201](https://github.com/leanprover/lean4/pull/3201))
-
-* Add pretty printer options `pp.numeralTypes` and `pp.natLit`.
-  When `pp.numeralTypes` is true, then natural number literals, integer literals, and rational number literals
-  are pretty printed with type ascriptions, such as `(2 : Rat)`, `(-2 : Rat)`, and `(-2 / 3 : Rat)`.
-  When `pp.natLit` is true, then raw natural number literals are pretty printed as `nat_lit 2`.
-  [PR #2933](https://github.com/leanprover/lean4/pull/2933) and [RFC #3021](https://github.com/leanprover/lean4/issues/3021).
-
-Lake updates:
-* improved platform information & control [#3226](https://github.com/leanprover/lean4/pull/3226)
-* `lake update` from unsupported manifest versions [#3149](https://github.com/leanprover/lean4/pull/3149)
-
-Other improvements:
-* make `intro` be aware of `let_fun` [#3115](https://github.com/leanprover/lean4/pull/3115)
-* produce simpler proof terms in `rw` [#3121](https://github.com/leanprover/lean4/pull/3121)
-* fuse nested `mkCongrArg` calls in proofs generated by `simp` [#3203](https://github.com/leanprover/lean4/pull/3203)
-* `induction using` followed by a general term [#3188](https://github.com/leanprover/lean4/pull/3188)
-* allow generalization in `let` [#3060](https://github.com/leanprover/lean4/pull/3060), fixing [#3065](https://github.com/leanprover/lean4/issues/3065)
-* reducing out-of-bounds `swap!` should return `a`, not `default`` [#3197](https://github.com/leanprover/lean4/pull/3197), fixing [#3196](https://github.com/leanprover/lean4/issues/3196)
-* derive `BEq` on structure with `Prop`-fields [#3191](https://github.com/leanprover/lean4/pull/3191), fixing [#3140](https://github.com/leanprover/lean4/issues/3140)
-* refine through more `casesOnApp`/`matcherApp` [#3176](https://github.com/leanprover/lean4/pull/3176), fixing [#3175](https://github.com/leanprover/lean4/pull/3175)
-* do not strip dotted components from lean module names [#2994](https://github.com/leanprover/lean4/pull/2994), fixing [#2999](https://github.com/leanprover/lean4/issues/2999)
-* fix `deriving` only deriving the first declaration for some handlers [#3058](https://github.com/leanprover/lean4/pull/3058), fixing [#3057](https://github.com/leanprover/lean4/issues/3057)
-* do not instantiate metavariables in kabstract/rw for disallowed occurrences [#2539](https://github.com/leanprover/lean4/pull/2539), fixing [#2538](https://github.com/leanprover/lean4/issues/2538)
-* hover info for `cases h : ...` [#3084](https://github.com/leanprover/lean4/pull/3084)

releases/v4.6.1.md

@@ -1,4 +0,0 @@
-v4.6.1
----------
-* Backport of [#3552](https://github.com/leanprover/lean4/pull/3552) fixing a performance regression
-  in server startup.

releases/v4.7.0.md

@@ -1,186 +0,0 @@
-v4.7.0
----------
-
-* `simp` and `rw` now use instance arguments found by unification,
-  rather than always resynthesizing. For backwards compatibility, the original behaviour is
-  available via `set_option tactic.skipAssignedInstances false`.
-  [#3507](https://github.com/leanprover/lean4/pull/3507) and
-  [#3509](https://github.com/leanprover/lean4/pull/3509).
-
-* When the `pp.proofs` is false, now omitted proofs use `⋯` rather than `_`,
-  which gives a more helpful error message when copied from the Infoview.
-  The `pp.proofs.threshold` option lets small proofs always be pretty printed.
-  [#3241](https://github.com/leanprover/lean4/pull/3241).
-
-* `pp.proofs.withType` is now set to false by default to reduce noise in the info view.
-
-* The pretty printer for applications now handles the case of over-application itself when applying app unexpanders.
-  In particular, the ``| `($_ $a $b $xs*) => `(($a + $b) $xs*)`` case of an `app_unexpander` is no longer necessary.
-  [#3495](https://github.com/leanprover/lean4/pull/3495).
-
-* New `simp` (and `dsimp`) configuration option: `zetaDelta`. It is `false` by default.
-  The `zeta` option is still `true` by default, but their meaning has changed.
-  - When `zeta := true`, `simp` and `dsimp` reduce terms of the form
-    `let x := val; e[x]` into `e[val]`.
-  - When `zetaDelta := true`, `simp` and `dsimp` will expand let-variables in
-    the context. For example, suppose the context contains `x := val`. Then,
-    any occurrence of `x` is replaced with `val`.
-
-  See [issue #2682](https://github.com/leanprover/lean4/pull/2682) for additional details. Here are some examples:
-  ```
-  example (h : z = 9) : let x := 5; let y := 4; x + y = z := by
-    intro x
-    simp
-    /-
-    New goal:
-    h : z = 9; x := 5 |- x + 4 = z
-    -/
-    rw [h]
-
-  example (h : z = 9) : let x := 5; let y := 4; x + y = z := by
-    intro x
-    -- Using both `zeta` and `zetaDelta`.
-    simp (config := { zetaDelta := true })
-    /-
-    New goal:
-    h : z = 9; x := 5 |- 9 = z
-    -/
-    rw [h]
-
-  example (h : z = 9) : let x := 5; let y := 4; x + y = z := by
-    intro x
-    simp [x] -- asks `simp` to unfold `x`
-    /-
-    New goal:
-    h : z = 9; x := 5 |- 9 = z
-    -/
-    rw [h]
-
-  example (h : z = 9) : let x := 5; let y := 4; x + y = z := by
-    intro x
-    simp (config := { zetaDelta := true, zeta := false })
-    /-
-    New goal:
-    h : z = 9; x := 5 |- let y := 4; 5 + y = z
-    -/
-    rw [h]
-  ```
-
-* When adding new local theorems to `simp`, the system assumes that the function application arguments
-  have been annotated with `no_index`. This modification, which addresses [issue #2670](https://github.com/leanprover/lean4/issues/2670),
-  restores the Lean 3 behavior that users expect. With this modification, the following examples are now operational:
-  ```
-  example {α β : Type} {f : α × β → β → β} (h : ∀ p : α × β, f p p.2 = p.2)
-    (a : α) (b : β) : f (a, b) b = b := by
-    simp [h]
-
-  example {α β : Type} {f : α × β → β → β}
-    (a : α) (b : β) (h : f (a,b) (a,b).2 = (a,b).2) : f (a, b) b = b := by
-    simp [h]
-  ```
-  In both cases, `h` is applicable because `simp` does not index f-arguments anymore when adding `h` to the `simp`-set.
-  It's important to note, however, that global theorems continue to be indexed in the usual manner.
-
-* Improved the error messages produced by the `decide` tactic. [#3422](https://github.com/leanprover/lean4/pull/3422)
-
-* Improved auto-completion performance. [#3460](https://github.com/leanprover/lean4/pull/3460)
-
-* Improved initial language server startup performance. [#3552](https://github.com/leanprover/lean4/pull/3552)
-
-* Changed call hierarchy to sort entries and strip private header from names displayed in the call hierarchy. [#3482](https://github.com/leanprover/lean4/pull/3482)
-
-* There is now a low-level error recovery combinator in the parsing framework, primarily intended for DSLs. [#3413](https://github.com/leanprover/lean4/pull/3413)
-
-* You can now write `termination_by?` after a declaration to see the automatically inferred
-  termination argument, and turn it into a `termination_by …` clause using the “Try this” widget or a code action. [#3514](https://github.com/leanprover/lean4/pull/3514)
-
-* A large fraction of `Std` has been moved into the Lean repository.
-  This was motivated by:
-  1. Making universally useful tactics such as `ext`, `by_cases`, `change at`,
-    `norm_cast`, `rcases`, `simpa`, `simp?`, `omega`, and `exact?`
-    available to all users of Lean, without imports.
-  2. Minimizing the syntactic changes between plain Lean and Lean with `import Std`.
-  3. Simplifying the development process for the basic data types
-     `Nat`, `Int`, `Fin` (and variants such as `UInt64`), `List`, `Array`,
-     and `BitVec` as we begin making the APIs and simp normal forms for these types
-     more complete and consistent.
-  4. Laying the groundwork for the Std roadmap, as a library focused on
-     essential datatypes not provided by the core language (e.g. `RBMap`)
-     and utilities such as basic IO.
-  While we have achieved most of our initial aims in `v4.7.0-rc1`,
-  some upstreaming will continue over the coming months.
-
-* The `/` and `%` notations in `Int` now use `Int.ediv` and `Int.emod`
-  (i.e. the rounding conventions have changed).
-  Previously `Std` overrode these notations, so this is no change for users of `Std`.
-  There is now kernel support for these functions.
-  [#3376](https://github.com/leanprover/lean4/pull/3376).
-
-* `omega`, our integer linear arithmetic tactic, is now available in the core language.
-  * It is supplemented by a preprocessing tactic `bv_omega` which can solve goals about `BitVec`
-    which naturally translate into linear arithmetic problems.
-    [#3435](https://github.com/leanprover/lean4/pull/3435).
-  * `omega` now has support for `Fin` [#3427](https://github.com/leanprover/lean4/pull/3427),
-    the `<<<` operator [#3433](https://github.com/leanprover/lean4/pull/3433).
-  * During the port `omega` was modified to no longer identify atoms up to definitional equality
-    (so in particular it can no longer prove `id x ≤ x`). [#3525](https://github.com/leanprover/lean4/pull/3525).
-    This may cause some regressions.
-    We plan to provide a general purpose preprocessing tactic later, or an `omega!` mode.
-  * `omega` is now invoked in Lean's automation for termination proofs
-    [#3503](https://github.com/leanprover/lean4/pull/3503) as well as in
-    array indexing proofs [#3515](https://github.com/leanprover/lean4/pull/3515).
-    This automation will be substantially revised in the medium term,
-    and while `omega` does help automate some proofs, we plan to make this much more robust.
-
-* The library search tactics `exact?` and `apply?` that were originally in
-  Mathlib are now available in Lean itself.  These use the implementation using
-  lazy discrimination trees from `Std`, and thus do not require a disk cache but
-  have a slightly longer startup time.  The order used for selection lemmas has
-  changed as well to favor goals purely based on how many terms in the head
-  pattern match the current goal.
-
-* The `solve_by_elim` tactic has been ported from `Std` to Lean so that library
-  search can use it.
-
-* New `#check_tactic` and `#check_simp` commands have been added.  These are
-  useful for checking tactics (particularly `simp`) behave as expected in test
-  suites.
-
-* Previously, app unexpanders would only be applied to entire applications. However, some notations produce
-  functions, and these functions can be given additional arguments. The solution so far has been to write app unexpanders so that they can take an arbitrary number of additional arguments. However this leads to misleading hover information in the Infoview. For example, while `HAdd.hAdd f g 1` pretty prints as `(f + g) 1`, hovering over `f + g` shows `f`. There is no way to fix the situation from within an app unexpander; the expression position for `HAdd.hAdd f g` is absent, and app unexpanders cannot register TermInfo.
-
-  This commit changes the app delaborator to try running app unexpanders on every prefix of an application, from longest to shortest prefix. For efficiency, it is careful to only try this when app delaborators do in fact exist for the head constant, and it also ensures arguments are only delaborated once. Then, in `(f + g) 1`, the `f + g` gets TermInfo registered for that subexpression, making it properly hoverable.
-
-  [#3375](https://github.com/leanprover/lean4/pull/3375)
-
-Breaking changes:
-* `Lean.withTraceNode` and variants got a stronger `MonadAlwaysExcept` assumption to
-  fix trace trees not being built on elaboration runtime exceptions. Instances for most elaboration
-  monads built on `EIO Exception` should be synthesized automatically.
-* The `match ... with.` and `fun.` notations previously in Std have been replaced by
-  `nomatch ...` and `nofun`. [#3279](https://github.com/leanprover/lean4/pull/3279) and [#3286](https://github.com/leanprover/lean4/pull/3286)
-
-
-Other improvements:
-* several bug fixes for `simp`:
-  * we should not crash when `simp` loops [#3269](https://github.com/leanprover/lean4/pull/3269)
-  * `simp` gets stuck on `autoParam` [#3315](https://github.com/leanprover/lean4/pull/3315)
-  * `simp` fails when custom discharger makes no progress [#3317](https://github.com/leanprover/lean4/pull/3317)
-  * `simp` fails to discharge `autoParam` premises even when it can reduce them to `True` [#3314](https://github.com/leanprover/lean4/pull/3314)
-  * `simp?` suggests generated equations lemma names, fixes [#3547](https://github.com/leanprover/lean4/pull/3547) [#3573](https://github.com/leanprover/lean4/pull/3573)
-* fixes for `match` expressions:
-  * fix regression with builtin literals [#3521](https://github.com/leanprover/lean4/pull/3521)
-  * accept `match` when patterns cover all cases of a `BitVec` finite type [#3538](https://github.com/leanprover/lean4/pull/3538)
-  * fix matching `Int` literals [#3504](https://github.com/leanprover/lean4/pull/3504)
-  * patterns containing int values and constructors [#3496](https://github.com/leanprover/lean4/pull/3496)
-* improve `termination_by` error messages [#3255](https://github.com/leanprover/lean4/pull/3255)
-* fix `rename_i` in macros, fixes [#3553](https://github.com/leanprover/lean4/pull/3553) [#3581](https://github.com/leanprover/lean4/pull/3581)
-* fix excessive resource usage in `generalize`, fixes [#3524](https://github.com/leanprover/lean4/pull/3524) [#3575](https://github.com/leanprover/lean4/pull/3575)
-* an equation lemma with autoParam arguments fails to rewrite, fixing [#2243](https://github.com/leanprover/lean4/pull/2243) [#3316](https://github.com/leanprover/lean4/pull/3316)
-* `add_decl_doc` should check that declarations are local [#3311](https://github.com/leanprover/lean4/pull/3311)
-* instantiate the types of inductives with the right parameters, closing [#3242](https://github.com/leanprover/lean4/pull/3242) [#3246](https://github.com/leanprover/lean4/pull/3246)
-* New simprocs for many basic types. [#3407](https://github.com/leanprover/lean4/pull/3407)
-
-Lake fixes:
-* Warn on fetch cloud release failure [#3401](https://github.com/leanprover/lean4/pull/3401)
-* Cloud release trace & `lake build :release` errors [#3248](https://github.com/leanprover/lean4/pull/3248)

releases/v4.8.0.md

@@ -1,494 +0,0 @@
-v4.8.0
----------
-
-### Language features, tactics, and metaprograms
-
-* **Functional induction principles.**
-  [#3432](https://github.com/leanprover/lean4/pull/3432), [#3620](https://github.com/leanprover/lean4/pull/3620),
-  [#3754](https://github.com/leanprover/lean4/pull/3754), [#3762](https://github.com/leanprover/lean4/pull/3762),
-  [#3738](https://github.com/leanprover/lean4/pull/3738), [#3776](https://github.com/leanprover/lean4/pull/3776),
-  [#3898](https://github.com/leanprover/lean4/pull/3898).
-
-  Derived from the definition of a (possibly mutually) recursive function,
-  a **functional induction principle** is created that is tailored to proofs about that function.
-
-  For example from:
-  ```
-  def ackermann : Nat → Nat → Nat
-    | 0, m => m + 1
-    | n+1, 0 => ackermann n 1
-    | n+1, m+1 => ackermann n (ackermann (n + 1) m)
-  ```
-  we get
-  ```
-  ackermann.induct (motive : Nat → Nat → Prop) (case1 : ∀ (m : Nat), motive 0 m)
-    (case2 : ∀ (n : Nat), motive n 1 → motive (Nat.succ n) 0)
-    (case3 : ∀ (n m : Nat), motive (n + 1) m → motive n (ackermann (n + 1) m) → motive (Nat.succ n) (Nat.succ m))
-    (x x : Nat) : motive x x
-  ```
-
-  It can be used in the `induction` tactic using the `using` syntax:
-  ```
-  induction n, m using ackermann.induct
-  ```
-* The termination checker now recognizes more recursion patterns without an
-  explicit `termination_by`. In particular the idiom of counting up to an upper
-  bound, as in
-  ```
-  def Array.sum (arr : Array Nat) (i acc : Nat) : Nat :=
-    if _ : i < arr.size then
-      Array.sum arr (i+1) (acc + arr[i])
-    else
-      acc
-  ```
-  is recognized without having to say `termination_by arr.size - i`.
-  * [#3630](https://github.com/leanprover/lean4/pull/3630) makes `termination_by?` not use `sizeOf` when not needed
-  * [#3652](https://github.com/leanprover/lean4/pull/3652) improves the `termination_by` syntax.
-  * [#3658](https://github.com/leanprover/lean4/pull/3658) changes how termination arguments are elaborated.
-  * [#3665](https://github.com/leanprover/lean4/pull/3665) refactors GuessLex to allow inferring more complex termination arguments
-  * [#3666](https://github.com/leanprover/lean4/pull/3666) infers termination arguments such as `xs.size - i`
-* [#3629](https://github.com/leanprover/lean4/pull/3629),
-  [#3655](https://github.com/leanprover/lean4/pull/3655),
-  [#3747](https://github.com/leanprover/lean4/pull/3747):
-  Adds `@[induction_eliminator]` and `@[cases_eliminator]` attributes to be able to define custom eliminators
-  for the `induction` and `cases` tactics, replacing the `@[eliminator]` attribute.
-  Gives custom eliminators for `Nat` so that `induction` and `cases` put goal states into terms of `0` and `n + 1`
-  rather than `Nat.zero` and `Nat.succ n`.
-  Added option `tactic.customEliminators` to control whether to use custom eliminators.
-  Added a hack for `rcases`/`rintro`/`obtain` to use the custom eliminator for `Nat`.
-* **Shorter instances names.** There is a new algorithm for generating names for anonymous instances.
-  Across Std and Mathlib, the median ratio between lengths of new names and of old names is about 72%.
-  With the old algorithm, the longest name was 1660 characters, and now the longest name is 202 characters.
-  The new algorithm's 95th percentile name length is 67 characters, versus 278 for the old algorithm.
-  While the new algorithm produces names that are 1.2% less unique,
-  it avoids cross-project collisions by adding a module-based suffix
-  when it does not refer to declarations from the same "project" (modules that share the same root).
-  [#3089](https://github.com/leanprover/lean4/pull/3089)
-  and [#3934](https://github.com/leanprover/lean4/pull/3934).
-* [8d2adf](https://github.com/leanprover/lean4/commit/8d2adf521d2b7636347a5b01bfe473bf0fcfaf31)
-  Importing two different files containing proofs of the same theorem is no longer considered an error.
-  This feature is particularly useful for theorems that are automatically generated on demand (e.g., equational theorems).
-* [84b091](https://github.com/leanprover/lean4/commit/84b0919a116e9be12f933e764474f45d964ce85c)
-  Lean now generates an error if the type of a theorem is **not** a proposition.
-* **Definition transparency.** [47a343](https://github.com/leanprover/lean4/commit/47a34316fc03ce936fddd2d3dce44784c5bcdfa9). `@[reducible]`, `@[semireducible]`, and `@[irreducible]` are now scoped and able to be set for imported declarations.
-* `simp`/`dsimp`
-  * [#3607](https://github.com/leanprover/lean4/pull/3607) enables kernel projection reduction in `dsimp`
-  * [b24fbf](https://github.com/leanprover/lean4/commit/b24fbf44f3aaa112f5d799ef2a341772d1eb222d)
-    and [acdb00](https://github.com/leanprover/lean4/commit/acdb0054d5a0efa724cff596ac26852fad5724c4):
-    `dsimproc` command
-    to define defeq-preserving simplification procedures.
-  * [#3624](https://github.com/leanprover/lean4/pull/3624) makes `dsimp` normalize raw nat literals as `OfNat.ofNat` applications.
-  * [#3628](https://github.com/leanprover/lean4/pull/3628) makes `simp` correctly handle `OfScientific.ofScientific` literals.
-  * [#3654](https://github.com/leanprover/lean4/pull/3654) makes `dsimp?` report used simprocs.
-  * [dee074](https://github.com/leanprover/lean4/commit/dee074dcde03a37b7895a4901df2e4fa490c73c7) fixes equation theorem
-    handling in `simp` for non-recursive definitions.
-  * [#3819](https://github.com/leanprover/lean4/pull/3819) improved performance when simp encounters a loop.
-  * [#3821](https://github.com/leanprover/lean4/pull/3821) fixes discharger/cache interaction.
-  * [#3824](https://github.com/leanprover/lean4/pull/3824) keeps `simp` from breaking `Char` literals.
-  * [#3838](https://github.com/leanprover/lean4/pull/3838) allows `Nat` instances matching to be more lenient.
-  * [#3870](https://github.com/leanprover/lean4/pull/3870) documentation for `simp` configuration options.
-  * [#3972](https://github.com/leanprover/lean4/pull/3972) fixes simp caching.
-  * [#4044](https://github.com/leanprover/lean4/pull/4044) improves cache behavior for "well-behaved" dischargers.
-* `omega`
-  * [#3639](https://github.com/leanprover/lean4/pull/3639), [#3766](https://github.com/leanprover/lean4/pull/3766),
-    [#3853](https://github.com/leanprover/lean4/pull/3853), [#3875](https://github.com/leanprover/lean4/pull/3875):
-    introduces a term canonicalizer.
-  * [#3736](https://github.com/leanprover/lean4/pull/3736) improves handling of positivity for the modulo operator for `Int`.
-  * [#3828](https://github.com/leanprover/lean4/pull/3828) makes it work as a `simp` discharger.
-  * [#3847](https://github.com/leanprover/lean4/pull/3847) adds helpful error messages.
-* `rfl`
-  * [#3671](https://github.com/leanprover/lean4/pull/3671), [#3708](https://github.com/leanprover/lean4/pull/3708): upstreams the `@[refl]` attribute and the `rfl` tactic.
-  * [#3751](https://github.com/leanprover/lean4/pull/3751) makes `apply_rfl` not operate on `Eq` itself.
-  * [#4067](https://github.com/leanprover/lean4/pull/4067) improves error message when there are no goals.
-* [#3719](https://github.com/leanprover/lean4/pull/3719) upstreams the `rw?` tactic, with fixes and improvements in
-  [#3783](https://github.com/leanprover/lean4/pull/3783), [#3794](https://github.com/leanprover/lean4/pull/3794),
-  [#3911](https://github.com/leanprover/lean4/pull/3911).
-* `conv`
-  * [#3659](https://github.com/leanprover/lean4/pull/3659) adds a `conv` version of the `calc` tactic.
-  * [#3763](https://github.com/leanprover/lean4/pull/3763) makes `conv` clean up using `try with_reducible rfl` instead of `try rfl`.
-* `#guard_msgs`
-  * [#3617](https://github.com/leanprover/lean4/pull/3617) introduces whitespace protection using the `⏎` character.
-  * [#3883](https://github.com/leanprover/lean4/pull/3883):
-    The `#guard_msgs` command now has options to change whitespace normalization and sensitivity to message ordering.
-    For example, `#guard_msgs (whitespace := lax) in cmd` collapses whitespace before checking messages,
-    and `#guard_msgs (ordering := sorted) in cmd` sorts the messages in lexicographic order before checking.
-  * [#3931](https://github.com/leanprover/lean4/pull/3931) adds an unused variables ignore function for `#guard_msgs`.
-  * [#3912](https://github.com/leanprover/lean4/pull/3912) adds a diff between the expected and actual outputs. This feature is currently
-    disabled by default, but can be enabled with `set_option guard_msgs.diff true`.
-    Depending on user feedback, this option may default to `true` in a future version of Lean.
-* `do` **notation**
-  * [#3820](https://github.com/leanprover/lean4/pull/3820) makes it an error to lift `(<- ...)` out of a pure `if ... then ... else ...`
-* **Lazy discrimination trees**
-  * [#3610](https://github.com/leanprover/lean4/pull/3610) fixes a name collision for `LazyDiscrTree` that could lead to cache poisoning.
-  * [#3677](https://github.com/leanprover/lean4/pull/3677) simplifies and fixes `LazyDiscrTree` handling for `exact?`/`apply?`.
-  * [#3685](https://github.com/leanprover/lean4/pull/3685) moves general `exact?`/`apply?` functionality into `LazyDiscrTree`.
-  * [#3769](https://github.com/leanprover/lean4/pull/3769) has lemma selection improvements for `rw?` and `LazyDiscrTree`.
-  * [#3818](https://github.com/leanprover/lean4/pull/3818) improves ordering of matches.
-* [#3590](https://github.com/leanprover/lean4/pull/3590) adds `inductive.autoPromoteIndices` option to be able to disable auto promotion of indices in the `inductive` command.
-* **Miscellaneous bug fixes and improvements**
-  * [#3606](https://github.com/leanprover/lean4/pull/3606) preserves `cache` and `dischargeDepth` fields in `Lean.Meta.Simp.Result.mkEqSymm`.
-  * [#3633](https://github.com/leanprover/lean4/pull/3633) makes `elabTermEnsuringType` respect `errToSorry`, improving error recovery of the `have` tactic.
-  * [#3647](https://github.com/leanprover/lean4/pull/3647) enables `noncomputable unsafe` definitions, for deferring implementations until later.
-  * [#3672](https://github.com/leanprover/lean4/pull/3672) adjust namespaces of tactics.
-  * [#3725](https://github.com/leanprover/lean4/pull/3725) fixes `Ord` derive handler for indexed inductive types with unused alternatives.
-  * [#3893](https://github.com/leanprover/lean4/pull/3893) improves performance of derived `Ord` instances.
-  * [#3771](https://github.com/leanprover/lean4/pull/3771) changes error reporting for failing tactic macros. Improves `rfl` error message.
-  * [#3745](https://github.com/leanprover/lean4/pull/3745) fixes elaboration of generalized field notation if the object of the notation is an optional parameter.
-  * [#3799](https://github.com/leanprover/lean4/pull/3799) makes commands such as `universe`, `variable`, `namespace`, etc. require that their argument appear in a later column.
-    Commands that can optionally parse an `ident` or parse any number of `ident`s generally should require
-    that the `ident` use `colGt`. This keeps typos in commands from being interpreted as identifiers.
-  * [#3815](https://github.com/leanprover/lean4/pull/3815) lets the `split` tactic be used for writing code.
-  * [#3822](https://github.com/leanprover/lean4/pull/3822) adds missing info in `induction` tactic for `with` clauses of the form `| cstr a b c => ?_`.
-  * [#3806](https://github.com/leanprover/lean4/pull/3806) fixes `withSetOptionIn` combinator.
-  * [#3844](https://github.com/leanprover/lean4/pull/3844) removes unused `trace.Elab.syntax` option.
-  * [#3896](https://github.com/leanprover/lean4/pull/3896) improves hover and go-to-def for `attribute` command.
-  * [#3989](https://github.com/leanprover/lean4/pull/3989) makes linter options more discoverable.
-  * [#3916](https://github.com/leanprover/lean4/pull/3916) fixes go-to-def for syntax defined with `@[builtin_term_parser]`.
-  * [#3962](https://github.com/leanprover/lean4/pull/3962) fixes how `solveByElim` handles `symm` lemmas, making `exact?`/`apply?` usable again.
-  * [#3968](https://github.com/leanprover/lean4/pull/3968) improves the `@[deprecated]` attribute, adding `(since := "<date>")` field.
-  * [#3768](https://github.com/leanprover/lean4/pull/3768) makes `#print` command show structure fields.
-  * [#3974](https://github.com/leanprover/lean4/pull/3974) makes `exact?%` behave like `by exact?` rather than `by apply?`.
-  * [#3994](https://github.com/leanprover/lean4/pull/3994) makes elaboration of `he ▸ h` notation more predictable.
-  * [#3991](https://github.com/leanprover/lean4/pull/3991) adjusts transparency for `decreasing_trivial` macros.
-  * [#4092](https://github.com/leanprover/lean4/pull/4092) improves performance of `binop%` and `binrel%` expression tree elaborators.
-* **Docs:** [#3748](https://github.com/leanprover/lean4/pull/3748), [#3796](https://github.com/leanprover/lean4/pull/3796),
-[#3800](https://github.com/leanprover/lean4/pull/3800), [#3874](https://github.com/leanprover/lean4/pull/3874),
-[#3863](https://github.com/leanprover/lean4/pull/3863), [#3862](https://github.com/leanprover/lean4/pull/3862),
-[#3891](https://github.com/leanprover/lean4/pull/3891), [#3873](https://github.com/leanprover/lean4/pull/3873),
-[#3908](https://github.com/leanprover/lean4/pull/3908), [#3872](https://github.com/leanprover/lean4/pull/3872).
-
-### Language server and IDE extensions
-
-* [#3602](https://github.com/leanprover/lean4/pull/3602) enables `import` auto-completions.
-* [#3608](https://github.com/leanprover/lean4/pull/3608) fixes issue [leanprover/vscode-lean4#392](https://github.com/leanprover/vscode-lean4/issues/392).
-  Diagnostic ranges had an off-by-one error that would misplace goal states for example.
-* [#3014](https://github.com/leanprover/lean4/pull/3014) introduces snapshot trees, foundational work for incremental tactics and parallelism.
-  [#3849](https://github.com/leanprover/lean4/pull/3849) adds basic incrementality API.
-* [#3271](https://github.com/leanprover/lean4/pull/3271) adds support for server-to-client requests.
-* [#3656](https://github.com/leanprover/lean4/pull/3656) fixes jump to definition when there are conflicting names from different files.
-  Fixes issue [#1170](https://github.com/leanprover/lean4/issues/1170).
-* [#3691](https://github.com/leanprover/lean4/pull/3691), [#3925](https://github.com/leanprover/lean4/pull/3925),
-  [#3932](https://github.com/leanprover/lean4/pull/3932) keep semantic tokens synchronized (used for semantic highlighting), with performance improvements.
-* [#3247](https://github.com/leanprover/lean4/pull/3247) and [#3730](https://github.com/leanprover/lean4/pull/3730)
-  add diagnostics to run "Restart File" when a file dependency is saved.
-* [#3722](https://github.com/leanprover/lean4/pull/3722) uses the correct module names when displaying references.
-* [#3728](https://github.com/leanprover/lean4/pull/3728) makes errors in header reliably appear and makes the "Import out of date" warning be at "hint" severity.
-  [#3739](https://github.com/leanprover/lean4/pull/3739) simplifies the text of this warning.
-* [#3778](https://github.com/leanprover/lean4/pull/3778) fixes [#3462](https://github.com/leanprover/lean4/issues/3462),
-  where info nodes from before the cursor would be used for computing completions.
-* [#3985](https://github.com/leanprover/lean4/pull/3985) makes trace timings appear in Infoview.
-
-### Pretty printing
-
-* [#3797](https://github.com/leanprover/lean4/pull/3797) fixes the hovers over binders so that they show their types.
-* [#3640](https://github.com/leanprover/lean4/pull/3640) and [#3735](https://github.com/leanprover/lean4/pull/3735): Adds attribute `@[pp_using_anonymous_constructor]` to make structures pretty print as `⟨x, y, z⟩`
-  rather than as `{a := x, b := y, c := z}`.
-  This attribute is applied to `Sigma`, `PSigma`, `PProd`, `Subtype`, `And`, and `Fin`.
-* [#3749](https://github.com/leanprover/lean4/pull/3749)
-  Now structure instances pretty print with parent structures' fields inlined.
-  That is, if `B` extends `A`, then `{ toA := { x := 1 }, y := 2 }` now pretty prints as `{ x := 1, y := 2 }`.
-  Setting option `pp.structureInstances.flatten` to false turns this off.
-* [#3737](https://github.com/leanprover/lean4/pull/3737), [#3744](https://github.com/leanprover/lean4/pull/3744)
-  and [#3750](https://github.com/leanprover/lean4/pull/3750):
-  Option `pp.structureProjections` is renamed to `pp.fieldNotation`, and there is now a suboption `pp.fieldNotation.generalized`
-  to enable pretty printing function applications using generalized field notation (defaults to true).
-  Field notation can be disabled on a function-by-function basis using the `@[pp_nodot]` attribute.
-  The notation is not used for theorems.
-* [#4071](https://github.com/leanprover/lean4/pull/4071) fixes interaction between app unexpanders and `pp.fieldNotation.generalized`
-* [#3625](https://github.com/leanprover/lean4/pull/3625) makes `delabConstWithSignature` (used by `#check`) have the ability to put arguments "after the colon"
-  to avoid printing inaccessible names.
-* [#3798](https://github.com/leanprover/lean4/pull/3798),
-  [#3978](https://github.com/leanprover/lean4/pull/3978),
-  [#3798](https://github.com/leanprover/lean4/pull/3980):
-  Adds options `pp.mvars` (default: true) and `pp.mvars.withType` (default: false).
-  When `pp.mvars` is false, expression metavariables pretty print as `?_` and universe metavariables pretty print as `_`.
-  When `pp.mvars.withType` is true, expression metavariables pretty print with a type ascription.
-  These can be set when using `#guard_msgs` to make tests not depend on the particular names of metavariables.
-* [#3917](https://github.com/leanprover/lean4/pull/3917) makes binders hoverable and gives them docstrings.
-* [#4034](https://github.com/leanprover/lean4/pull/4034) makes hovers for RHS terms in `match` expressions in the Infoview reliably show the correct term.
-
-### Library
-
-* `Bool`/`Prop`
-  * [#3508](https://github.com/leanprover/lean4/pull/3508) improves `simp` confluence for `Bool` and `Prop` terms.
-  * Theorems: [#3604](https://github.com/leanprover/lean4/pull/3604)
-* `Nat`
-  * [#3579](https://github.com/leanprover/lean4/pull/3579) makes `Nat.succ_eq_add_one` be a simp lemma, now that `induction`/`cases` uses `n + 1` instead of `Nat.succ n`.
-  * [#3808](https://github.com/leanprover/lean4/pull/3808) replaces `Nat.succ` simp rules with simprocs.
-  * [#3876](https://github.com/leanprover/lean4/pull/3876) adds faster `Nat.repr` implementation in C.
-* `Int`
-  * Theorems: [#3890](https://github.com/leanprover/lean4/pull/3890)
-* `UInt`s
-  * [#3960](https://github.com/leanprover/lean4/pull/3960) improves performance of upcasting.
-* `Array` and `Subarray`
-  * [#3676](https://github.com/leanprover/lean4/pull/3676) removes `Array.eraseIdxAux`, `Array.eraseIdxSzAux`, and `Array.eraseIdx'`.
-  * [#3648](https://github.com/leanprover/lean4/pull/3648) simplifies `Array.findIdx?`.
-  * [#3851](https://github.com/leanprover/lean4/pull/3851) renames fields of `Subarray`.
-* `List`
-  * [#3785](https://github.com/leanprover/lean4/pull/3785) upstreams tail-recursive List operations and `@[csimp]` lemmas.
-* `BitVec`
-  * Theorems: [#3593](https://github.com/leanprover/lean4/pull/3593),
-  [#3593](https://github.com/leanprover/lean4/pull/3593), [#3597](https://github.com/leanprover/lean4/pull/3597),
-  [#3598](https://github.com/leanprover/lean4/pull/3598), [#3721](https://github.com/leanprover/lean4/pull/3721),
-  [#3729](https://github.com/leanprover/lean4/pull/3729), [#3880](https://github.com/leanprover/lean4/pull/3880),
-  [#4039](https://github.com/leanprover/lean4/pull/4039).
-  * [#3884](https://github.com/leanprover/lean4/pull/3884) protects `Std.BitVec`.
-* `String`
-  * [#3832](https://github.com/leanprover/lean4/pull/3832) fixes `String.splitOn`.
-  * [#3959](https://github.com/leanprover/lean4/pull/3959) adds `String.Pos.isValid`.
-  * [#3959](https://github.com/leanprover/lean4/pull/3959) UTF-8 string validation.
-  * [#3961](https://github.com/leanprover/lean4/pull/3961) adds a model implementation for UTF-8 encoding and decoding.
-* `IO`
-  * [#4097](https://github.com/leanprover/lean4/pull/4097) adds `IO.getTaskState` which returns whether a task is finished, actively running, or waiting on other Tasks to finish.
-
-* **Refactors**
-  * [#3605](https://github.com/leanprover/lean4/pull/3605) reduces imports for `Init.Data.Nat` and `Init.Data.Int`.
-  * [#3613](https://github.com/leanprover/lean4/pull/3613) reduces imports for `Init.Omega.Int`.
-  * [#3634](https://github.com/leanprover/lean4/pull/3634) upstreams `Std.Data.Nat`
-    and [#3635](https://github.com/leanprover/lean4/pull/3635) upstreams `Std.Data.Int`.
-  * [#3790](https://github.com/leanprover/lean4/pull/3790) reduces more imports for `omega`.
-  * [#3694](https://github.com/leanprover/lean4/pull/3694) extends `GetElem` interface with `getElem!` and `getElem?` to simplify containers like `RBMap`.
-  * [#3865](https://github.com/leanprover/lean4/pull/3865) renames `Option.toMonad` (see breaking changes below).
-  * [#3882](https://github.com/leanprover/lean4/pull/3882) unifies `lexOrd` with `compareLex`.
-* **Other fixes or improvements**
-  * [#3765](https://github.com/leanprover/lean4/pull/3765) makes `Quotient.sound` be a `theorem`.
-  * [#3645](https://github.com/leanprover/lean4/pull/3645) fixes `System.FilePath.parent` in the case of absolute paths.
-  * [#3660](https://github.com/leanprover/lean4/pull/3660) `ByteArray.toUInt64LE!` and `ByteArray.toUInt64BE!` were swapped.
-  * [#3881](https://github.com/leanprover/lean4/pull/3881), [#3887](https://github.com/leanprover/lean4/pull/3887) fix linearity issues in `HashMap.insertIfNew`, `HashSet.erase`, and `HashMap.erase`.
-    The `HashMap.insertIfNew` fix improves `import` performance.
-  * [#3830](https://github.com/leanprover/lean4/pull/3830) ensures linearity in `Parsec.many*Core`.
-  * [#3930](https://github.com/leanprover/lean4/pull/3930) adds `FS.Stream.isTty` field.
-  * [#3866](https://github.com/leanprover/lean4/pull/3866) deprecates `Option.toBool` in favor of `Option.isSome`.
-  * [#3975](https://github.com/leanprover/lean4/pull/3975) upstreams `Data.List.Init` and `Data.Array.Init` material from Std.
-  * [#3942](https://github.com/leanprover/lean4/pull/3942) adds instances that make `ac_rfl` work without Mathlib.
-  * [#4010](https://github.com/leanprover/lean4/pull/4010) changes `Fin.induction` to use structural induction.
-  * [02753f](https://github.com/leanprover/lean4/commit/02753f6e4c510c385efcbf71fa9a6bec50fce9ab)
-    fixes bug in `reduceLeDiff` simproc.
-  * [#4097](https://github.com/leanprover/lean4/pull/4097)
-    adds `IO.TaskState` and `IO.getTaskState` to get the task from the Lean runtime's task manager.
-* **Docs:** [#3615](https://github.com/leanprover/lean4/pull/3615), [#3664](https://github.com/leanprover/lean4/pull/3664),
-  [#3707](https://github.com/leanprover/lean4/pull/3707), [#3734](https://github.com/leanprover/lean4/pull/3734),
-  [#3868](https://github.com/leanprover/lean4/pull/3868), [#3861](https://github.com/leanprover/lean4/pull/3861),
-  [#3869](https://github.com/leanprover/lean4/pull/3869), [#3858](https://github.com/leanprover/lean4/pull/3858),
-  [#3856](https://github.com/leanprover/lean4/pull/3856), [#3857](https://github.com/leanprover/lean4/pull/3857),
-  [#3867](https://github.com/leanprover/lean4/pull/3867), [#3864](https://github.com/leanprover/lean4/pull/3864),
-  [#3860](https://github.com/leanprover/lean4/pull/3860), [#3859](https://github.com/leanprover/lean4/pull/3859),
-  [#3871](https://github.com/leanprover/lean4/pull/3871), [#3919](https://github.com/leanprover/lean4/pull/3919).
-
-### Lean internals
-
-* **Defeq and WHNF algorithms**
-  * [#3616](https://github.com/leanprover/lean4/pull/3616) gives better support for reducing `Nat.rec` expressions.
-  * [#3774](https://github.com/leanprover/lean4/pull/3774) add tracing for "non-easy" WHNF cases.
-  * [#3807](https://github.com/leanprover/lean4/pull/3807) fixes an `isDefEq` performance issue, now trying structure eta *after* lazy delta reduction.
-  * [#3816](https://github.com/leanprover/lean4/pull/3816) fixes `.yesWithDeltaI` behavior to prevent increasing transparency level when reducing projections.
-  * [#3837](https://github.com/leanprover/lean4/pull/3837) improves heuristic at `isDefEq`.
-  * [#3965](https://github.com/leanprover/lean4/pull/3965) improves `isDefEq` for constraints of the form `t.i =?= s.i`.
-  * [#3977](https://github.com/leanprover/lean4/pull/3977) improves `isDefEqProj`.
-  * [#3981](https://github.com/leanprover/lean4/pull/3981) adds universe constraint approximations to be able to solve `u =?= max u ?v` using `?v = u`.
-    These approximations are only applied when universe constraints cannot be postponed anymore.
-  * [#4004](https://github.com/leanprover/lean4/pull/4004) improves `isDefEqProj` during typeclass resolution.
-  * [#4012](https://github.com/leanprover/lean4/pull/4012) adds `backward.isDefEq.lazyProjDelta` and `backward.isDefEq.lazyWhnfCore` backwards compatibility flags.
-* **Kernel**
-  * [#3966](https://github.com/leanprover/lean4/pull/3966) removes dead code.
-  * [#4035](https://github.com/leanprover/lean4/pull/4035) fixes mismatch for `TheoremVal` between Lean and C++.
-* **Discrimination trees**
-  * [423fed](https://github.com/leanprover/lean4/commit/423fed79a9de75705f34b3e8648db7e076c688d7)
-    and [3218b2](https://github.com/leanprover/lean4/commit/3218b25974d33e92807af3ce42198911c256ff1d):
-    simplify handling of dependent/non-dependent pi types.
-* **Typeclass instance synthesis**
-  * [#3638](https://github.com/leanprover/lean4/pull/3638) eta-reduces synthesized instances
-  * [ce350f](https://github.com/leanprover/lean4/commit/ce350f348161e63fccde6c4a5fe1fd2070e7ce0f) fixes a linearity issue
-  * [917a31](https://github.com/leanprover/lean4/commit/917a31f694f0db44d6907cc2b1485459afe74d49)
-    improves performance by considering at most one answer for subgoals not containing metavariables.
-    [#4008](https://github.com/leanprover/lean4/pull/4008) adds `backward.synthInstance.canonInstances` backward compatibility flag.
-* **Definition processing**
-  * [#3661](https://github.com/leanprover/lean4/pull/3661), [#3767](https://github.com/leanprover/lean4/pull/3767) changes automatically generated equational theorems to be named
-    using suffix `.eq_<idx>` instead of `._eq_<idx>`, and `.eq_def` instead of `._unfold`. (See breaking changes below.)
-    [#3675](https://github.com/leanprover/lean4/pull/3675) adds a mechanism to reserve names.
-    [#3803](https://github.com/leanprover/lean4/pull/3803) fixes reserved name resolution inside namespaces and fixes handling of `match`er declarations and equation lemmas.
-  * [#3662](https://github.com/leanprover/lean4/pull/3662) causes auxiliary definitions nested inside theorems to become `def`s if they are not proofs.
-  * [#4006](https://github.com/leanprover/lean4/pull/4006) makes proposition fields of `structure`s be theorems.
-  * [#4018](https://github.com/leanprover/lean4/pull/4018) makes it an error for a theorem to be `extern`.
-  * [#4047](https://github.com/leanprover/lean4/pull/4047) improves performance making equations for well-founded recursive definitions.
-* **Refactors**
-  * [#3614](https://github.com/leanprover/lean4/pull/3614) avoids unfolding in `Lean.Meta.evalNat`.
-  * [#3621](https://github.com/leanprover/lean4/pull/3621) centralizes functionality for `Fix`/`GuessLex`/`FunInd` in the `ArgsPacker` module.
-  * [#3186](https://github.com/leanprover/lean4/pull/3186) rewrites the UnusedVariable linter to be more performant.
-  * [#3589](https://github.com/leanprover/lean4/pull/3589) removes coercion from `String` to `Name` (see breaking changes below).
-  * [#3237](https://github.com/leanprover/lean4/pull/3237) removes the `lines` field from `FileMap`.
-  * [#3951](https://github.com/leanprover/lean4/pull/3951) makes msg parameter to `throwTacticEx` optional.
-* **Diagnostics**
-  * [#4016](https://github.com/leanprover/lean4/pull/4016), [#4019](https://github.com/leanprover/lean4/pull/4019),
-    [#4020](https://github.com/leanprover/lean4/pull/4020), [#4030](https://github.com/leanprover/lean4/pull/4030),
-    [#4031](https://github.com/leanprover/lean4/pull/4031),
-    [c3714b](https://github.com/leanprover/lean4/commit/c3714bdc6d46845c0428735b283c5b48b23cbcf7),
-    [#4049](https://github.com/leanprover/lean4/pull/4049) adds `set_option diagnostics true` for diagnostic counters.
-    Tracks number of unfolded declarations, instances, reducible declarations, used instances, recursor reductions,
-    `isDefEq` heuristic applications, among others.
-    This option is suggested in exceptional situations, such as at deterministic timeout and maximum recursion depth.
-  * [283587](https://github.com/leanprover/lean4/commit/283587987ab2eb3b56fbc3a19d5f33ab9e04a2ef)
-    adds diagnostic information for `simp`.
-  * [#4043](https://github.com/leanprover/lean4/pull/4043) adds diagnostic information for congruence theorems.
-  * [#4048](https://github.com/leanprover/lean4/pull/4048) display diagnostic information
-    for `set_option diagnostics true in <tactic>` and `set_option diagnostics true in <term>`.
-* **Other features**
-  * [#3800](https://github.com/leanprover/lean4/pull/3800) adds environment extension to record which definitions use structural or well-founded recursion.
-  * [#3801](https://github.com/leanprover/lean4/pull/3801) `trace.profiler` can now export to Firefox Profiler.
-  * [#3918](https://github.com/leanprover/lean4/pull/3918), [#3953](https://github.com/leanprover/lean4/pull/3953) adds `@[builtin_doc]` attribute to make docs and location of a declaration available as a builtin.
-  * [#3939](https://github.com/leanprover/lean4/pull/3939) adds the `lean --json` CLI option to print messages as JSON.
-  * [#3075](https://github.com/leanprover/lean4/pull/3075) improves `test_extern` command.
-  * [#3970](https://github.com/leanprover/lean4/pull/3970) gives monadic generalization of `FindExpr`.
-* **Docs:** [#3743](https://github.com/leanprover/lean4/pull/3743), [#3921](https://github.com/leanprover/lean4/pull/3921),
-  [#3954](https://github.com/leanprover/lean4/pull/3954).
-* **Other fixes:** [#3622](https://github.com/leanprover/lean4/pull/3622),
-  [#3726](https://github.com/leanprover/lean4/pull/3726), [#3823](https://github.com/leanprover/lean4/pull/3823),
-  [#3897](https://github.com/leanprover/lean4/pull/3897), [#3964](https://github.com/leanprover/lean4/pull/3964),
-  [#3946](https://github.com/leanprover/lean4/pull/3946), [#4007](https://github.com/leanprover/lean4/pull/4007),
-  [#4026](https://github.com/leanprover/lean4/pull/4026).
-
-### Compiler, runtime, and FFI
-
-* [#3632](https://github.com/leanprover/lean4/pull/3632) makes it possible to allocate and free thread-local runtime resources for threads not started by Lean itself.
-* [#3627](https://github.com/leanprover/lean4/pull/3627) improves error message about compacting closures.
-* [#3692](https://github.com/leanprover/lean4/pull/3692) fixes deadlock in `IO.Promise.resolve`.
-* [#3753](https://github.com/leanprover/lean4/pull/3753) catches error code from `MoveFileEx` on Windows.
-* [#4028](https://github.com/leanprover/lean4/pull/4028) fixes a double `reset` bug in `ResetReuse` transformation.
-* [6e731b](https://github.com/leanprover/lean4/commit/6e731b4370000a8e7a5cfb675a7f3d7635d21f58)
-  removes `interpreter` copy constructor to avoid potential memory safety issues.
-
-### Lake
-
-* **TOML Lake configurations**. [#3298](https://github.com/leanprover/lean4/pull/3298), [#4104](https://github.com/leanprover/lean4/pull/4104).
-
-  Lake packages can now use TOML as a alternative configuration file format instead of Lean. If the default `lakefile.lean` is missing, Lake will also look for a `lakefile.toml`. The TOML version of the configuration supports a restricted set of the Lake configuration options, only including those which can easily mapped to a TOML data structure. The TOML syntax itself fully compiles with the TOML v1.0.0 specification.
-
-  As part of the introduction of this new feature, we have been helping maintainers of some major packages within the ecosystem switch to this format. For example, the following is Aesop's new `lakefile.toml`:
-
-
-  **[leanprover-community/aesop/lakefile.toml](https://raw.githubusercontent.com/leanprover-community/aesop/de11e0ecf372976e6d627c210573146153090d2d/lakefile.toml)**
-  ```toml
-  name = "aesop"
-  defaultTargets = ["Aesop"]
-  testRunner = "test"
-  precompileModules = false
-
-  [[require]]
-  name = "batteries"
-  git = "https://github.com/leanprover-community/batteries"
-  rev = "main"
-
-  [[lean_lib]]
-  name = "Aesop"
-
-  [[lean_lib]]
-  name = "AesopTest"
-  globs = ["AesopTest.+"]
-  leanOptions = {linter.unusedVariables = false}
-
-  [[lean_exe]]
-  name = "test"
-  srcDir = "scripts"
-  ```
-
-  To assist users who wish to transition their packages between configuration file formats, there is also a new `lake translate-config` command for migrating to/from TOML.
-
-  Running `lake translate-config toml` will produce a `lakefile.toml` version of a package's `lakefile.lean`. Any configuration options unsupported by the TOML format will be discarded during translation, but the original `lakefile.lean` will remain so that you can verify the translation looks good before deleting it.
-
-* **Build progress overhaul.** [#3835](https://github.com/leanprover/lean4/pull/3835), [#4115](https://github.com/leanprover/lean4/pull/4115), [#4127](https://github.com/leanprover/lean4/pull/4127), [#4220](https://github.com/leanprover/lean4/pull/4220), [#4232](https://github.com/leanprover/lean4/pull/4232), [#4236](https://github.com/leanprover/lean4/pull/4236).
-
-  Builds are now managed by a top-level Lake build monitor, this makes the output of Lake builds more standardized and enables producing prettier and more configurable progress reports.
-
-  As part of this change, job isolation has improved. Stray I/O and other build related errors in custom targets are now properly isolated and caught as part of their job. Import errors no longer cause Lake to abort the entire build and are instead localized to the build jobs of the modules in question.
-
-  Lake also now uses ANSI escape sequences to add color and produce progress lines that update in-place; this can be toggled on and off using `--ansi` / `--no-ansi`.
-
-
-  `--wfail` and `--iofail` options have been added that causes a build to fail if any of the jobs log a warning (`--wfail`) or produce any output or log information messages (`--iofail`). Unlike some other build systems, these options do **NOT** convert these logs into errors, and Lake does not abort jobs on such a log (i.e., dependent jobs will still continue unimpeded).
-
-* `lake test`. [#3779](https://github.com/leanprover/lean4/pull/3779).
-
-  Lake now has a built-in `test` command which will run a script or executable labelled `@[test_runner]` (in Lean) or defined as the `testRunner` (in TOML) in the root package.
-
-  Lake also provides a `lake check-test` command which will exit with code `0` if the package has a properly configured test runner or error with `1` otherwise.
-
-* `lake lean`. [#3793](https://github.com/leanprover/lean4/pull/3793).
-
-  The new command `lake lean <file> [-- <args...>]` functions like `lake env lean <file> <args...>`, except that it builds the imports of `file` before running `lean`. This makes it very useful for running test or example code that imports modules that are not guaranteed to have been built beforehand.
-
-* **Miscellaneous bug fixes and improvements**
-  * [#3609](https://github.com/leanprover/lean4/pull/3609) `LEAN_GITHASH` environment variable to override the detected Git hash for Lean when computing traces, useful for testing custom builds of Lean.
-  * [#3795](https://github.com/leanprover/lean4/pull/3795) improves relative package directory path normalization in the pre-rename check.
-  * [#3957](https://github.com/leanprover/lean4/pull/3957) fixes handling of packages that appear multiple times in a dependency tree.
-  * [#3999](https://github.com/leanprover/lean4/pull/3999) makes it an error for there to be a mismatch between a package name and what it is required as. Also adds a special message for the `std`-to-`batteries` rename.
-  * [#4033](https://github.com/leanprover/lean4/pull/4033) fixes quiet mode.
-* **Docs:** [#3704](https://github.com/leanprover/lean4/pull/3704).
-
-### DevOps
-
-* [#3536](https://github.com/leanprover/lean4/pull/3536) and [#3833](https://github.com/leanprover/lean4/pull/3833)
-  add a checklist for the release process.
-* [#3600](https://github.com/leanprover/lean4/pull/3600) runs nix-ci more uniformly.
-* [#3612](https://github.com/leanprover/lean4/pull/3612) avoids argument limits when building on Windows.
-* [#3682](https://github.com/leanprover/lean4/pull/3682) builds Lean's `.o` files in parallel to rest of core.
-* [#3601](https://github.com/leanprover/lean4/pull/3601)
-  changes the way Lean is built on Windows (see breaking changes below).
-  As a result, Lake now dynamically links executables with `supportInterpreter := true` on Windows
-  to `libleanshared.dll` and `libInit_shared.dll`. Therefore, such executables will not run
-  unless those shared libraries are co-located with the executables or part of `PATH`.
-  Running the executable via `lake exe` will ensure these libraries are part of `PATH`.
-
-  In a related change, the signature of the `nativeFacets` Lake configuration options has changed
-  from a static `Array` to a function `(shouldExport : Bool) → Array`.
-  See its docstring or Lake's [README](src/lake/README.md) for further details on the changed option.
-* [#3690](https://github.com/leanprover/lean4/pull/3690) marks "Build matrix complete" as canceled if the build is canceled.
-* [#3700](https://github.com/leanprover/lean4/pull/3700), [#3702](https://github.com/leanprover/lean4/pull/3702),
-  [#3701](https://github.com/leanprover/lean4/pull/3701), [#3834](https://github.com/leanprover/lean4/pull/3834),
-  [#3923](https://github.com/leanprover/lean4/pull/3923): fixes and improvements for std and mathlib CI.
-* [#3712](https://github.com/leanprover/lean4/pull/3712) fixes `nix build .` on macOS.
-* [#3717](https://github.com/leanprover/lean4/pull/3717) replaces `shell.nix` in devShell with `flake.nix`.
-* [#3715](https://github.com/leanprover/lean4/pull/3715) and [#3790](https://github.com/leanprover/lean4/pull/3790) add test result summaries.
-* [#3971](https://github.com/leanprover/lean4/pull/3971) prevents stage0 changes via the merge queue.
-* [#3979](https://github.com/leanprover/lean4/pull/3979) adds handling for `changes-stage0` label.
-* [#3952](https://github.com/leanprover/lean4/pull/3952) adds a script to summarize GitHub issues.
-* [18a699](https://github.com/leanprover/lean4/commit/18a69914da53dbe37c91bc2b9ce65e1dc01752b6)
-  fixes asan linking
-
-### Breaking changes
-
-* Due to the major Lake build refactor, code using the affected parts of the Lake API or relying on the previous output format of Lake builds is likely to have been broken. We have tried to minimize the breakages and, where possible, old definitions have been marked `@[deprecated]` with a reference to the new alternative.
-
-* Executables configured with `supportInterpreter := true` on Windows should now be run via `lake exe` to function properly.
-
-* Automatically generated equational theorems are now named using suffix `.eq_<idx>` instead of `._eq_<idx>`, and `.eq_def` instead of `._unfold`. Example:
-```
-def fact : Nat → Nat
-  | 0 => 1
-  | n+1 => (n+1) * fact n
-
-theorem ex : fact 0 = 1 := by unfold fact; decide
-
-#check fact.eq_1
--- fact.eq_1 : fact 0 = 1
-
-#check fact.eq_2
--- fact.eq_2 (n : Nat) : fact (Nat.succ n) = (n + 1) * fact n
-
-#check fact.eq_def
-/-
-fact.eq_def :
-  ∀ (x : Nat),
-    fact x =
-      match x with
-      | 0 => 1
-      | Nat.succ n => (n + 1) * fact n
--/
-```
-
-* The coercion from `String` to `Name` was removed. Previously, it was `Name.mkSimple`, which does not separate strings at dots, but experience showed that this is not always the desired coercion. For the previous behavior, manually insert a call to `Name.mkSimple`.
-
-* The `Subarray` fields `as`, `h₁` and `h₂` have been renamed to `array`, `start_le_stop`, and `stop_le_array_size`, respectively. This more closely follows standard Lean conventions. Deprecated aliases for the field projections were added; these will be removed in a future release.
-
-* The change to the instance name algorithm (described above) can break projects that made use of the auto-generated names.
-
-* `Option.toMonad` has been renamed to `Option.getM` and the unneeded `[Monad m]` instance argument has been removed.

releases/v4.9.0.md

@@ -1,321 +0,0 @@
-v4.9.0
-----------
-
-### Language features, tactics, and metaprograms
-
-* **Definition transparency**
-  * [#4053](https://github.com/leanprover/lean4/pull/4053) adds the `seal` and `unseal` commands, which make definitions locally be irreducible or semireducible.
-  * [#4061](https://github.com/leanprover/lean4/pull/4061) marks functions defined by well-founded recursion with `@[irreducible]` by default,
-    which should prevent the expensive and often unfruitful unfolding of such definitions (see breaking changes below).
-* **Incrementality**
-  * [#3940](https://github.com/leanprover/lean4/pull/3940) extends incremental elaboration into various steps inside of declarations:
-    definition headers, bodies, and tactics.
-    ![Recording 2024-05-10](https://github.com/leanprover/lean4/assets/109126/c9d67b6f-c131-4bc3-a0de-7d63eaf1bfc9).
-  * [250994](https://github.com/leanprover/lean4/commit/250994166ce036ab8644e459129f51ea79c1c2d2)
-    and [67338b](https://github.com/leanprover/lean4/commit/67338bac2333fa39a8656e8f90574784e4c23d3d)
-    add `@[incremental]` attribute to mark an elaborator as supporting incremental elaboration.
-  * [#4259](https://github.com/leanprover/lean4/pull/4259) improves resilience by ensuring incremental commands and tactics are reached only in supported ways.
-  * [#4268](https://github.com/leanprover/lean4/pull/4268) adds special handling for `:= by` so that stray tokens in tactic blocks do not inhibit incrementality.
-  * [#4308](https://github.com/leanprover/lean4/pull/4308) adds incremental `have` tactic.
-  * [#4340](https://github.com/leanprover/lean4/pull/4340) fixes incorrect info tree reuse.
-  * [#4364](https://github.com/leanprover/lean4/pull/4364) adds incrementality for careful command macros such as `set_option in theorem`, `theorem foo.bar`, and `lemma`.
-  * [#4395](https://github.com/leanprover/lean4/pull/4395) adds conservative fix for whitespace handling to avoid incremental reuse leading to goals in front of the text cursor being shown.
-  * [#4407](https://github.com/leanprover/lean4/pull/4407) fixes non-incremental commands in macros blocking further incremental reporting.
-  * [#4436](https://github.com/leanprover/lean4/pull/4436) fixes incremental reporting when there are nested tactics in terms.
-  * [#4459](https://github.com/leanprover/lean4/pull/4459) adds incrementality support for `next` and `if` tactics.
-  * [#4554](https://github.com/leanprover/lean4/pull/4554) disables incrementality for tactics in terms in tactics.
-* **Functional induction**
-  * [#4135](https://github.com/leanprover/lean4/pull/4135) ensures that the names used for functional induction are reserved.
-  * [#4327](https://github.com/leanprover/lean4/pull/4327) adds support for structural recursion on reflexive types.
-    For example,
-    ```lean4
-    inductive Many (α : Type u) where
-      | none : Many α
-      | more : α → (Unit → Many α) → Many α
-
-    def Many.map {α β : Type u} (f : α → β) : Many α → Many β
-      | .none => .none
-      | .more x xs => .more (f x) (fun _ => (xs ()).map f)
-
-    #check Many.map.induct
-    /-
-    Many.map.induct {α β : Type u} (f : α → β) (motive : Many α → Prop)
-      (case1 : motive Many.none)
-      (case2 : ∀ (x : α) (xs : Unit → Many α), motive (xs ()) → motive (Many.more x xs)) :
-      ∀ (a : Many α), motive a
-    -/
-    ```
-* [#3903](https://github.com/leanprover/lean4/pull/3903) makes the Lean frontend normalize all line endings to LF before processing.
-  This lets Lean be insensitive to CRLF vs LF line endings, improving the cross-platform experience and making Lake hashes be faithful to what Lean processes.
-* [#4130](https://github.com/leanprover/lean4/pull/4130) makes the tactic framework be able to recover from runtime errors (for example, deterministic timeouts or maximum recursion depth errors).
-* `split` tactic
-  * [#4211](https://github.com/leanprover/lean4/pull/4211) fixes `split at h` when `h` has forward dependencies.
-  * [#4349](https://github.com/leanprover/lean4/pull/4349) allows `split` for `if`-expressions to work on non-propositional goals.
-* `apply` tactic
-  * [#3929](https://github.com/leanprover/lean4/pull/3929) makes error message for `apply` show implicit arguments in unification errors as needed.
-    Modifies `MessageData` type (see breaking changes below).
-* `cases` tactic
-  * [#4224](https://github.com/leanprover/lean4/pull/4224) adds support for unification of offsets such as `x + 20000 = 20001` in `cases` tactic.
-* `omega` tactic
-  * [#4073](https://github.com/leanprover/lean4/pull/4073) lets `omega` fall back to using classical `Decidable` instances when setting up contradiction proofs.
-  * [#4141](https://github.com/leanprover/lean4/pull/4141) and [#4184](https://github.com/leanprover/lean4/pull/4184) fix bugs.
-  * [#4264](https://github.com/leanprover/lean4/pull/4264) improves `omega` error message if no facts found in local context.
-  * [#4358](https://github.com/leanprover/lean4/pull/4358) improves expression matching in `omega` by using `match_expr`.
-* `simp` tactic
-  * [#4176](https://github.com/leanprover/lean4/pull/4176) makes names of erased lemmas clickable.
-  * [#4208](https://github.com/leanprover/lean4/pull/4208) adds a pretty printer for discrimination tree keys.
-  * [#4202](https://github.com/leanprover/lean4/pull/4202) adds `Simp.Config.index` configuration option,
-    which controls whether to use the full discrimination tree when selecting candidate simp lemmas.
-    When `index := false`, only the head function is taken into account, like in Lean 3.
-    This feature can help users diagnose tricky simp failures or issues in code from libraries
-    developed using Lean 3 and then ported to Lean 4.
-
-    In the following example, it will report that `foo` is a problematic theorem.
-    ```lean
-    opaque f : Nat → Nat → Nat
-
-    @[simp] theorem foo : f x (x, y).2 = y := by sorry
-
-    example : f a b ≤ b := by
-      set_option diagnostics true in
-      simp (config := { index := false })
-    /-
-    [simp] theorems with bad keys
-      foo, key: f _ (@Prod.mk ℕ ℕ _ _).2
-    -/
-    ```
-    With the information above, users can annotate theorems such as `foo` using `no_index` for problematic subterms. Example:
-    ```lean
-    opaque f : Nat → Nat → Nat
-
-    @[simp] theorem foo : f x (no_index (x, y).2) = y := by sorry
-
-    example : f a b ≤ b := by
-      simp -- `foo` is still applied with `index := true`
-    ```
-  * [#4274](https://github.com/leanprover/lean4/pull/4274) prevents internal `match` equational theorems from appearing in simp trace.
-  * [#4177](https://github.com/leanprover/lean4/pull/4177) and [#4359](https://github.com/leanprover/lean4/pull/4359) make `simp` continue even if a simp lemma does not elaborate, if the tactic state is in recovery mode.
-  * [#4341](https://github.com/leanprover/lean4/pull/4341) fixes panic when applying `@[simp]` to malformed theorem syntax.
-  * [#4345](https://github.com/leanprover/lean4/pull/4345) fixes `simp` so that it does not use the forward version of a user-specified backward theorem.
-  * [#4352](https://github.com/leanprover/lean4/pull/4352) adds missing `dsimp` simplifications for fixed parameters of generated congruence theorems.
-  * [#4362](https://github.com/leanprover/lean4/pull/4362) improves trace messages for `simp` so that constants are hoverable.
-* **Elaboration**
-  * [#4046](https://github.com/leanprover/lean4/pull/4046) makes subst notation (`he ▸ h`) try rewriting in both directions even when there is no expected type available.
-  * [#3328](https://github.com/leanprover/lean4/pull/3328) adds support for identifiers in autoparams (for example, `rfl` in `(h : x = y := by exact rfl)`).
-  * [#4096](https://github.com/leanprover/lean4/pull/4096) changes how the type in `let` and `have` is elaborated, requiring that any tactics in the type be evaluated before proceeding, improving performance.
-  * [#4215](https://github.com/leanprover/lean4/pull/4215) ensures the expression tree elaborator commits to the computed "max type" for the entire arithmetic expression.
-  * [#4267](https://github.com/leanprover/lean4/pull/4267) cases signature elaboration errors to show even if there are parse errors in the body.
-  * [#4368](https://github.com/leanprover/lean4/pull/4368) improves error messages when numeric literals fail to synthesize an `OfNat` instance,
-    including special messages warning when the expected type of the numeral can be a proposition.
-  * [#4643](https://github.com/leanprover/lean4/pull/4643) fixes issue leading to nested error messages and info trees vanishing, where snapshot subtrees were not restored on reuse.
-  * [#4657](https://github.com/leanprover/lean4/pull/4657) calculates error suppression per snapshot, letting elaboration errors appear even when there are later parse errors ([RFC #3556](https://github.com/leanprover/lean4/issues/3556)).
-* **Metaprogramming**
-  * [#4167](https://github.com/leanprover/lean4/pull/4167) adds `Lean.MVarId.revertAll` to revert all free variables.
-  * [#4169](https://github.com/leanprover/lean4/pull/4169) adds `Lean.MVarId.ensureNoMVar` to ensure the goal's target contains no expression metavariables.
-  * [#4180](https://github.com/leanprover/lean4/pull/4180) adds `cleanupAnnotations` parameter to `forallTelescope` methods.
-  * [#4307](https://github.com/leanprover/lean4/pull/4307) adds support for parser aliases in syntax quotations.
-* Work toward implementing `grind` tactic
-  * [0a515e](https://github.com/leanprover/lean4/commit/0a515e2ec939519dafb4b99daa81d6bf3c411404)
-    and [#4164](https://github.com/leanprover/lean4/pull/4164)
-    add `grind_norm` and `grind_norm_proc` attributes and `@[grind_norm]` theorems.
-  * [#4170](https://github.com/leanprover/lean4/pull/4170), [#4221](https://github.com/leanprover/lean4/pull/4221),
-    and [#4249](https://github.com/leanprover/lean4/pull/4249) create `grind` preprocessor and core module.
-  * [#4235](https://github.com/leanprover/lean4/pull/4235) and [d6709e](https://github.com/leanprover/lean4/commit/d6709eb1576c5d40fc80462637dc041f970e4d9f)
-    add special `cases` tactic to `grind` along with `@[grind_cases]` attribute to mark types that this `cases` tactic should automatically apply to.
-  * [#4243](https://github.com/leanprover/lean4/pull/4243) adds special `injection?` tactic to `grind`.
-* **Other fixes or improvements**
-  * [#4065](https://github.com/leanprover/lean4/pull/4065) fixes a bug in the `Nat.reduceLeDiff` simproc.
-  * [#3969](https://github.com/leanprover/lean4/pull/3969) makes deprecation warnings activate even for generalized field notation ("dot notation").
-  * [#4132](https://github.com/leanprover/lean4/pull/4132) fixes the `sorry` term so that it does not activate the implicit lambda feature
-  * [9803c5](https://github.com/leanprover/lean4/commit/9803c5dd63dc993628287d5f998525e74af03839)
-    and [47c8e3](https://github.com/leanprover/lean4/commit/47c8e340d65b01f4d9f011686e3dda0d4bb30a20)
-    move `cdot` and `calc` parsers to `Lean` namespace.
-  * [#4252](https://github.com/leanprover/lean4/pull/4252) fixes the `case` tactic so that it is usable in macros by having it erase macro scopes from the tag.
-  * [26b671](https://github.com/leanprover/lean4/commit/26b67184222e75529e1b166db050aaebee323d2d)
-    and [cc33c3](https://github.com/leanprover/lean4/commit/cc33c39cb022d8a3166b1e89677c78835ead1fc7)
-    extract `haveId` syntax.
-  * [#4335](https://github.com/leanprover/lean4/pull/4335) fixes bugs in partial `calc` tactic when there is mdata or metavariables.
-  * [#4329](https://github.com/leanprover/lean4/pull/4329) makes `termination_by?` report unused each unused parameter as `_`.
-* **Docs:** [#4238](https://github.com/leanprover/lean4/pull/4238), [#4294](https://github.com/leanprover/lean4/pull/4294),
-  [#4338](https://github.com/leanprover/lean4/pull/4338).
-
-### Language server, widgets, and IDE extensions
-* [#4066](https://github.com/leanprover/lean4/pull/4066) fixes features like "Find References" when browsing core Lean sources.
-* [#4254](https://github.com/leanprover/lean4/pull/4254) allows embedding user widgets in structured messages.
-  Companion PR is [vscode-lean4#449](https://github.com/leanprover/vscode-lean4/pull/449).
-* [#4445](https://github.com/leanprover/lean4/pull/4445) makes watchdog more resilient against badly behaving clients.
-
-### Library
-* [#4059](https://github.com/leanprover/lean4/pull/4059) upstreams many `List` and `Array` operations and theorems from Batteries.
-* [#4055](https://github.com/leanprover/lean4/pull/4055) removes the unused `Inhabited` instance for `Subtype`.
-* [#3967](https://github.com/leanprover/lean4/pull/3967) adds dates in existing `@[deprecated]` attributes.
-* [#4231](https://github.com/leanprover/lean4/pull/4231) adds boilerplate `Char`, `UInt`, and `Fin` theorems.
-* [#4205](https://github.com/leanprover/lean4/pull/4205) fixes the `MonadStore` type classes to use `semiOutParam`.
-* [#4350](https://github.com/leanprover/lean4/pull/4350) renames `IsLawfulSingleton` to `LawfulSingleton`.
-* `Nat`
-  * [#4094](https://github.com/leanprover/lean4/pull/4094) swaps `Nat.zero_or` and `Nat.or_zero`.
-  * [#4098](https://github.com/leanprover/lean4/pull/4098) and [#4145](https://github.com/leanprover/lean4/pull/4145)
-    change the definition of `Nat.mod` so that `n % (m + n)` reduces when `n` is literal without relying on well-founded recursion,
-    which becomes irreducible by default in [#4061](https://github.com/leanprover/lean4/pull/4061).
-  * [#4188](https://github.com/leanprover/lean4/pull/4188) redefines `Nat.testBit` to be more performant.
-  * Theorems: [#4199](https://github.com/leanprover/lean4/pull/4199).
-* `Array`
-  * [#4074](https://github.com/leanprover/lean4/pull/4074) improves the functional induction principle `Array.feraseIdx.induct`.
-* `List`
-  * [#4172](https://github.com/leanprover/lean4/pull/4172) removes `@[simp]` from `List.length_pos`.
-* `Option`
-  * [#4037](https://github.com/leanprover/lean4/pull/4037) adds theorems to simplify `Option`-valued dependent if-then-else.
-  * [#4314](https://github.com/leanprover/lean4/pull/4314) removes `@[simp]` from `Option.bind_eq_some`.
-* `BitVec`
-  * Theorems: [#3920](https://github.com/leanprover/lean4/pull/3920), [#4095](https://github.com/leanprover/lean4/pull/4095),
-    [#4075](https://github.com/leanprover/lean4/pull/4075), [#4148](https://github.com/leanprover/lean4/pull/4148),
-    [#4165](https://github.com/leanprover/lean4/pull/4165), [#4178](https://github.com/leanprover/lean4/pull/4178),
-    [#4200](https://github.com/leanprover/lean4/pull/4200), [#4201](https://github.com/leanprover/lean4/pull/4201),
-    [#4298](https://github.com/leanprover/lean4/pull/4298), [#4299](https://github.com/leanprover/lean4/pull/4299),
-    [#4257](https://github.com/leanprover/lean4/pull/4257), [#4179](https://github.com/leanprover/lean4/pull/4179),
-    [#4321](https://github.com/leanprover/lean4/pull/4321), [#4187](https://github.com/leanprover/lean4/pull/4187).
-  * [#4193](https://github.com/leanprover/lean4/pull/4193) adds simprocs for reducing `x >>> i` and `x <<< i` where `i` is a bitvector literal.
-  * [#4194](https://github.com/leanprover/lean4/pull/4194) adds simprocs for reducing `(x <<< i) <<< j` and `(x >>> i) >>> j` where `i` and `j` are natural number literals.
-  * [#4229](https://github.com/leanprover/lean4/pull/4229) redefines `rotateLeft`/`rotateRight` to use modulo reduction of shift offset.
-  * [0d3051](https://github.com/leanprover/lean4/commit/0d30517dca094a07bcb462252f718e713b93ffba) makes `<num>#<term>` bitvector literal notation global.
-* `Char`/`String`
-  * [#4143](https://github.com/leanprover/lean4/pull/4143) modifies `String.substrEq` to avoid linter warnings in downstream code.
-  * [#4233](https://github.com/leanprover/lean4/pull/4233) adds simprocs for `Char` and `String` inequalities.
-  * [#4348](https://github.com/leanprover/lean4/pull/4348) upstreams Mathlib lemmas.
-  * [#4354](https://github.com/leanprover/lean4/pull/4354) upstreams basic `String` lemmas.
-* `HashMap`
-  * [#4248](https://github.com/leanprover/lean4/pull/4248) fixes implicitness of typeclass arguments in `HashMap.ofList`.
-* `IO`
-  * [#4036](https://github.com/leanprover/lean4/pull/4036) adds `IO.Process.getCurrentDir` and `IO.Process.setCurrentDir` for adjusting the current process's working directory.
-* **Cleanup:** [#4077](https://github.com/leanprover/lean4/pull/4077), [#4189](https://github.com/leanprover/lean4/pull/4189),
-  [#4304](https://github.com/leanprover/lean4/pull/4304).
-* **Docs:** [#4001](https://github.com/leanprover/lean4/pull/4001), [#4166](https://github.com/leanprover/lean4/pull/4166),
-  [#4332](https://github.com/leanprover/lean4/pull/4332).
-
-### Lean internals
-* **Defeq and WHNF algorithms**
-  * [#4029](https://github.com/leanprover/lean4/pull/4029) remove unnecessary `checkpointDefEq`
-  * [#4206](https://github.com/leanprover/lean4/pull/4206) fixes `isReadOnlyOrSyntheticOpaque` to respect metavariable depth.
-  * [#4217](https://github.com/leanprover/lean4/pull/4217) fixes missing occurs check for delayed assignments.
-* **Definition transparency**
-  * [#4052](https://github.com/leanprover/lean4/pull/4052) adds validation to application of `@[reducible]`/`@[semireducible]`/`@[irreducible]` attributes (with `local`/`scoped` modifiers as well).
-    Setting `set_option allowUnsafeReductibility true` turns this validation off.
-* **Inductive types**
-  * [#3591](https://github.com/leanprover/lean4/pull/3591) fixes a bug where indices could be incorrectly promoted to parameters.
-  * [#3398](https://github.com/leanprover/lean4/pull/3398) fixes a bug in the injectivity theorem generator.
-  * [#4342](https://github.com/leanprover/lean4/pull/4342) fixes elaboration of mutual inductives with instance parameters.
-* **Diagnostics and profiling**
-  * [#3986](https://github.com/leanprover/lean4/pull/3986) adds option `trace.profiler.useHeartbeats` to switch `trace.profiler.threshold` to being in terms of heartbeats instead of milliseconds.
-  * [#4082](https://github.com/leanprover/lean4/pull/4082) makes `set_option diagnostics true` report kernel diagnostic information.
-* **Typeclass resolution**
-  * [#4119](https://github.com/leanprover/lean4/pull/4119) fixes multiple issues with TC caching interacting with `synthPendingDepth`, adds `maxSynthPendingDepth` option with default value `1`.
-  * [#4210](https://github.com/leanprover/lean4/pull/4210) ensures local instance cache does not contain multiple copies of the same instance.
-  * [#4216](https://github.com/leanprover/lean4/pull/4216) fix handling of metavariables, to avoid needing to set the option `backward.synthInstance.canonInstances` to `false`.
-* **Other fixes or improvements**
-  * [#4080](https://github.com/leanprover/lean4/pull/4080) fixes propagation of state for `Lean.Elab.Command.liftCoreM` and `Lean.Elab.Command.liftTermElabM`.
-  * [#3944](https://github.com/leanprover/lean4/pull/3944) makes the `Repr` deriving handler be consistent between `structure` and `inductive` for how types and proofs are erased.
-  * [#4113](https://github.com/leanprover/lean4/pull/4113) propagates `maxHeartbeats` to kernel to control "(kernel) deterministic timeout" error.
-  * [#4125](https://github.com/leanprover/lean4/pull/4125) reverts [#3970](https://github.com/leanprover/lean4/pull/3970) (monadic generalization of `FindExpr`).
-  * [#4128](https://github.com/leanprover/lean4/pull/4128) catches stack overflow in auto-bound implicits feature.
-  * [#4129](https://github.com/leanprover/lean4/pull/4129) adds `tryCatchRuntimeEx` combinator to replace `catchRuntimeEx` reader state.
-  * [#4155](https://github.com/leanprover/lean4/pull/4155) simplifies the expression canonicalizer.
-  * [#4151](https://github.com/leanprover/lean4/pull/4151) and [#4369](https://github.com/leanprover/lean4/pull/4369)
-    add many missing trace classes.
-  * [#4185](https://github.com/leanprover/lean4/pull/4185) makes congruence theorem generators clean up type annotations of argument types.
-  * [#4192](https://github.com/leanprover/lean4/pull/4192) fixes restoration of infotrees when auto-bound implicit feature is activated,
-    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.
-  * 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).
-
-### Compiler, runtime, and FFI
-* [#4100](https://github.com/leanprover/lean4/pull/4100) improves reset/reuse algorithm; it now runs a second pass relaxing the constraint that reused memory cells must only be for the exact same constructor.
-* [#2903](https://github.com/leanprover/lean4/pull/2903) fixes segfault in old compiler from mishandling `noConfusion` applications.
-* [#4311](https://github.com/leanprover/lean4/pull/4311) fixes bug in constant folding.
-* [#3915](https://github.com/leanprover/lean4/pull/3915) documents the runtime memory layout for inductive types.
-
-### Lake
-* [#4518](https://github.com/leanprover/lean4/pull/4518) makes trace reading more robust. Lake now rebuilds if trace files are invalid or unreadable and is backwards compatible with previous pure numeric traces.
-* [#4057](https://github.com/leanprover/lean4/pull/4057) adds support for docstrings on `require` commands.
-* [#4088](https://github.com/leanprover/lean4/pull/4088) improves hovers for `family_def` and `library_data` commands.
-* [#4147](https://github.com/leanprover/lean4/pull/4147) adds default `README.md` to package templates
-* [#4261](https://github.com/leanprover/lean4/pull/4261) extends `lake test` help page, adds help page for `lake check-test`,
-  adds `lake lint` and tag `@[lint_driver]`, adds support for specifying test and lint drivers from dependencies,
-  adds `testDriverArgs` and `lintDriverArgs` options, adds support for library test drivers,
-  makes `lake check-test` and `lake check-lint` only load the package without dependencies.
-* [#4270](https://github.com/leanprover/lean4/pull/4270) adds `lake pack` and `lake unpack` for packing and unpacking Lake build artifacts from an archive.
-* [#4083](https://github.com/leanprover/lean4/pull/4083)
-  Switches the manifest format to use `major.minor.patch` semantic
-  versions. Major version increments indicate breaking changes (e.g., new
-  required fields and semantic changes to existing fields). Minor version
-  increments (after `0.x`) indicate backwards-compatible extensions (e.g.,
-  adding optional fields, removing fields). This change is backwards
-  compatible. Lake will still successfully read old manifests with numeric
-  versions. It will treat the numeric version `N` as semantic version
-  `0.N.0`. Lake will also accept manifest versions with `-` suffixes
-  (e.g., `x.y.z-foo`) and then ignore the suffix.
-* [#4273](https://github.com/leanprover/lean4/pull/4273) adds a lift from `JobM` to `FetchM` for backwards compatibility reasons.
-* [#4351](https://github.com/leanprover/lean4/pull/4351) fixes `LogIO`-to-`CliM`-lifting performance issues.
-* [#4343](https://github.com/leanprover/lean4/pull/4343) make Lake store the dependency trace for a build in
-  the cached build long and then verifies that it matches the trace of the current build before replaying the log.
-* [#4402](https://github.com/leanprover/lean4/pull/4402) moves the cached log into the trace file (no more `.log.json`).
-  This means logs are no longer cached on fatal errors and this ensures that an out-of-date log is not associated with an up-to-date trace.
-  Separately, `.hash` file generation was changed to be more reliable as well.
-  The `.hash` files are deleted as part of the build and always regenerate with `--rehash`.
-* **Other fixes or improvements**
-  * [#4056](https://github.com/leanprover/lean4/pull/4056) cleans up tests
-  * [#4244](https://github.com/leanprover/lean4/pull/4244) fixes `noRelease` test when Lean repo is tagged
-  * [#4346](https://github.com/leanprover/lean4/pull/4346) improves `tests/serve`
-  * [#4356](https://github.com/leanprover/lean4/pull/4356) adds build log path to the warning for a missing or invalid build log.
-
-### DevOps
-* [#3984](https://github.com/leanprover/lean4/pull/3984) adds a script (`script/rebase-stage0.sh`) for `git rebase -i` that automatically updates each stage0.
-* [#4108](https://github.com/leanprover/lean4/pull/4108) finishes renamings from transition to Std to Batteries.
-* [#4109](https://github.com/leanprover/lean4/pull/4109) adjusts the Github bug template to mention testing using [live.lean-lang.org](https://live.lean-lang.org).
-* [#4136](https://github.com/leanprover/lean4/pull/4136) makes CI rerun only when `full-ci` label is added or removed.
-* [#4175](https://github.com/leanprover/lean4/pull/4175) and [72b345](https://github.com/leanprover/lean4/commit/72b345c621a9a06d3a5a656da2b793a5eea5f168)
-  switch to using `#guard_msgs` to run tests as much as possible.
-* [#3125](https://github.com/leanprover/lean4/pull/3125) explains the Lean4 `pygments` lexer.
-* [#4247](https://github.com/leanprover/lean4/pull/4247) sets up a procedure for preparing release notes.
-* [#4032](https://github.com/leanprover/lean4/pull/4032) modernizes build instructions and workflows.
-* [#4255](https://github.com/leanprover/lean4/pull/4255) moves some expensive checks from merge queue to releases.
-* [#4265](https://github.com/leanprover/lean4/pull/4265) adds aarch64 macOS as native compilation target for CI.
-* [f05a82](https://github.com/leanprover/lean4/commit/f05a82799a01569edeb5e2594cd7d56282320f9e) restores macOS aarch64 install suffix in CI
-* [#4317](https://github.com/leanprover/lean4/pull/4317) updates build instructions for macOS.
-* [#4333](https://github.com/leanprover/lean4/pull/4333) adjusts workflow to update Batteries in manifest when creating `lean-pr-testing-NNNN` Mathlib branches.
-* [#4355](https://github.com/leanprover/lean4/pull/4355) simplifies `lean4checker` step of release checklist.
-* [#4361](https://github.com/leanprover/lean4/pull/4361) adds installing elan to `pr-release` CI step.
-* [#4628](https://github.com/leanprover/lean4/pull/4628) fixes the Windows build, which was missing an exported symbol.
-
-### Breaking changes
-While most changes could be considered to be a breaking change, this section makes special note of API changes.
-
-* `Nat.zero_or` and `Nat.or_zero` have been swapped ([#4094](https://github.com/leanprover/lean4/pull/4094)).
-* `IsLawfulSingleton` is now `LawfulSingleton` ([#4350](https://github.com/leanprover/lean4/pull/4350)).
-* The `BitVec` literal notation is now `<num>#<term>` rather than `<term>#<term>`, and it is global rather than scoped. Use `BitVec.ofNat w x` rather than `x#w` when `x` is a not a numeric literal ([0d3051](https://github.com/leanprover/lean4/commit/0d30517dca094a07bcb462252f718e713b93ffba)).
-* `BitVec.rotateLeft` and `BitVec.rotateRight` now take the shift modulo the bitwidth ([#4229](https://github.com/leanprover/lean4/pull/4229)).
-* These are no longer simp lemmas:
-  `List.length_pos` ([#4172](https://github.com/leanprover/lean4/pull/4172)),
-  `Option.bind_eq_some` ([#4314](https://github.com/leanprover/lean4/pull/4314)).
-* Types in `let` and `have` (both the expressions and tactics) may fail to elaborate due to new restrictions on what sorts of elaboration problems may be postponed ([#4096](https://github.com/leanprover/lean4/pull/4096)).
-  In particular, tactics embedded in the type will no longer make use of the type of `value` in expressions such as `let x : type := value; body`.
-* Now functions defined by well-founded recursion are marked with `@[irreducible]` by default ([#4061](https://github.com/leanprover/lean4/pull/4061)).
-  Existing proofs that hold by definitional equality (e.g. `rfl`) can be
-  rewritten to explicitly unfold the function definition (using `simp`,
-  `unfold`, `rw`), or the recursive function can be temporarily made
-  semireducible (using `unseal f in` before the command), or the function
-  definition itself can be marked as `@[semireducible]` to get the previous
-  behavior.
-* Due to [#3929](https://github.com/leanprover/lean4/pull/3929):
-  * The `MessageData.ofPPFormat` constructor has been removed.
-    Its functionality has been split into two:
-
-    - for lazy structured messages, please use `MessageData.lazy`;
-    - for embedding `Format` or `FormatWithInfos`, use `MessageData.ofFormatWithInfos`.
-
-    An example migration can be found in [#3929](https://github.com/leanprover/lean4/pull/3929/files#diff-5910592ab7452a0e1b2616c62d22202d2291a9ebb463145f198685aed6299867L109).
-
-  * The `MessageData.ofFormat` constructor has been turned into a function.
-    If you need to inspect `MessageData`, you can pattern-match on `MessageData.ofFormatWithInfos`.

releases_drafts/README.md

@@ -1,22 +1,19 @@
 Draft release notes
 -------------------
 
-This folder contains drafts of release notes for inclusion in `RELEASES.md`.
+This folder contains drafts of release notes for the upcoming version.
 During the process to create a release candidate, we look through all the commits that make up the release
 to prepare the release notes, and in that process we take these drafts into account.
 
 Guidelines:
-- You should prefer adding release notes to commit messages over adding anything to this folder.
-  A release note should briefly explain the impact of a change from a user's point of view.
-  Please mark these parts out with words such as **release notes** and/or **breaking changes**.
-- It is not necessary to add anything to this folder. It is meant for larger features that span multiple PRs,
+- Write good commit messages
+  The first paragraph should briefly explain the impact of a change from a user's point of view.
+  (Recall: the first paragraph, which should begin with "This PR",
+  is automatically incorporated into the release notes by `script/release_notes.py`.
+  See `doc/dev/release_checklist.md` for more details.).
+- This folder is only needed for larger features that span multiple PRs,
   or for anything that would be helpful when preparing the release notes that might be missed
   by someone reading through the change log.
-- If the PR that adds a feature simultaneously adds a draft release note, including the PR number is not required
-  since it can be obtained from the git history for the file.
 
-When release notes are prepared, all the draft release notes are deleted from this folder.
-For release candidates beyond the first one, you can either update `RELEASE.md` directly
-or continue to add drafts.
-
-When a release is finalized, we will copy the completed release notes from `RELEASE.md` to the `master` branch.
+When notes from this folder are incorporated into the [Lean Language Reference](https://lean-lang.org/doc/reference/latest/releases/#release-notes),
+they should then be deleted from here.

releases_drafts/environment.md

@@ -0,0 +1,6 @@
+**Breaking Changes**
+
+* The functions `Lean.Environment.importModules` and `Lean.Environment.finalizeImport` have been extended with a new parameter `loadExts : Bool := false` that enables environment extension state loading.
+  Their previous behavior corresponds to setting the flag to `true` but is only safe to do in combination with `enableInitializersExecution`; see also the `importModules` docstring.
+  The new default value `false` ensures the functions can be used correctly multiple times within the same process when environment extension access is not needed.
+  The wrapper function `Lean.Environment.withImportModules` now always calls `importModules` with `loadExts := false` as it is incompatible with extension loading.

script/benchReelabRss.lean

@@ -0,0 +1,70 @@
+import Lean.Data.Lsp
+open Lean
+open Lean.Lsp
+open Lean.JsonRpc
+
+/-!
+Tests language server memory use by repeatedly re-elaborate a given file.
+
+NOTE: only works on Linux for now.
+
+HACK: The line that is to be prepended with a space is hard-coded below to be sufficiently far down
+not to touch the imports for usual files.
+-/
+
+def main (args : List String) : IO Unit := do
+  let leanCmd :: file :: iters :: args := args | panic! "usage: script <lean> <file> <#iterations> <server-args>..."
+  let uri := s!"file:///{file}"
+  Ipc.runWith leanCmd (#["--worker", "-DstderrAsMessages=false"] ++ args ++ #[uri]) do
+  -- for use with heaptrack:
+  --Ipc.runWith "heaptrack" (#[leanCmd, "--worker", "-DstderrAsMessages=false"] ++ args ++ #[uri]) do
+  --  -- heaptrack has no quiet mode??
+  --  let _ ← (← Ipc.stdout).getLine
+  --  let _ ← (← Ipc.stdout).getLine
+    let capabilities := {
+      textDocument? := some {
+        completion? := some {
+          completionItem? := some {
+            insertReplaceSupport? := true
+          }
+        }
+      }
+    }
+    Ipc.writeRequest ⟨0, "initialize", { capabilities : InitializeParams }⟩
+
+    let text ← IO.FS.readFile file
+    let mut requestNo : Nat := 1
+    let mut versionNo : Nat := 1
+    Ipc.writeNotification ⟨"textDocument/didOpen", {
+      textDocument := { uri := uri, languageId := "lean", version := 1, text := text } : DidOpenTextDocumentParams }⟩
+    for i in [0:iters.toNat!] do
+      if i > 0 then
+        versionNo := versionNo + 1
+        let pos := { line := 19, character := 0 }
+        let params : DidChangeTextDocumentParams := {
+          textDocument := {
+            uri      := uri
+            version? := versionNo
+          }
+          contentChanges := #[TextDocumentContentChangeEvent.rangeChange {
+            start := pos
+            «end» := pos
+          } " "]
+        }
+        let params := toJson params
+        Ipc.writeNotification ⟨"textDocument/didChange", params⟩
+        requestNo := requestNo + 1
+
+      let diags ← Ipc.collectDiagnostics requestNo uri versionNo
+      if let some diags := diags then
+        for diag in diags.param.diagnostics do
+          IO.eprintln diag.message
+      requestNo := requestNo + 1
+
+      let status ← IO.FS.readFile s!"/proc/{(← read).pid}/status"
+      for line in status.splitOn "\n" |>.filter (·.startsWith "RssAnon") do
+        IO.eprintln line
+
+    let _ ← Ipc.collectDiagnostics requestNo uri versionNo
+    (← Ipc.stdin).writeLspMessage (Message.notification "exit" none)
+    discard <| Ipc.waitForExit

script/merge_remote.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+
+"""
+Merge a tag into a branch on a GitHub repository.
+
+This script checks if a specified tag can be merged cleanly into a branch and performs
+the merge if possible. If the merge cannot be done cleanly, it prints a helpful message.
+
+Usage:
+    python3 merge_remote.py <org/repo> <branch> <tag>
+
+Arguments:
+    org/repo: GitHub repository in the format 'organization/repository'
+    branch: The target branch to merge into
+    tag: The tag to merge from
+
+Example:
+    python3 merge_remote.py leanprover/mathlib4 stable v4.6.0
+
+The script uses the GitHub CLI (`gh`), so make sure it's installed and authenticated.
+"""
+
+import argparse
+import subprocess
+import sys
+import tempfile
+import os
+import shutil
+
+
+def run_command(command, check=True, capture_output=True):
+    """Run a shell command and return the result."""
+    try:
+        result = subprocess.run(
+            command,
+            check=check,
+            shell=True,
+            text=True,
+            capture_output=capture_output
+        )
+        return result
+    except subprocess.CalledProcessError as e:
+        if capture_output:
+            print(f"Command failed: {command}")
+            print(f"Error: {e.stderr}")
+        return e
+
+
+def clone_repo(repo, temp_dir):
+    """Clone the repository to a temporary directory using shallow clone."""
+    print(f"Shallow cloning {repo}...")
+    # Keep the shallow clone for efficiency
+    clone_result = run_command(f"gh repo clone {repo} {temp_dir} -- --depth=1", check=False)
+    if clone_result.returncode != 0:
+        print(f"Failed to clone repository {repo}.")
+        print(f"Error: {clone_result.stderr}")
+        return False
+    return True
+
+
+def check_and_merge(repo, branch, tag, temp_dir):
+    """Check if tag can be merged into branch and perform the merge if possible."""
+    # Change to the temporary directory
+    os.chdir(temp_dir)
+    
+    # First fetch the specific remote branch with its history
+    print(f"Fetching branch '{branch}'...")
+    fetch_branch = run_command(f"git fetch origin {branch}:refs/remotes/origin/{branch} --update-head-ok")
+    if fetch_branch.returncode != 0:
+        print(f"Error: Failed to fetch branch '{branch}'.")
+        return False
+    
+    # Then fetch the specific tag
+    print(f"Fetching tag '{tag}'...")
+    fetch_tag = run_command(f"git fetch origin tag {tag}")
+    if fetch_tag.returncode != 0:
+        print(f"Error: Failed to fetch tag '{tag}'.")
+        return False
+    
+    # Check if branch exists now that we've fetched it
+    branch_check = run_command(f"git branch -r | grep origin/{branch}")
+    if branch_check.returncode != 0:
+        print(f"Error: Branch '{branch}' does not exist in repository.")
+        return False
+
+    # Check if tag exists
+    tag_check = run_command(f"git tag -l {tag}")
+    if tag_check.returncode != 0 or not tag_check.stdout.strip():
+        print(f"Error: Tag '{tag}' does not exist in repository.")
+        return False
+
+    # Checkout the branch
+    print(f"Checking out branch '{branch}'...")
+    checkout_result = run_command(f"git checkout -b {branch} origin/{branch}")
+    if checkout_result.returncode != 0:
+        return False
+
+    # Try merging the tag in a dry-run to check if it can be merged cleanly
+    print(f"Checking if {tag} can be merged cleanly into {branch}...")
+    merge_check = run_command(f"git merge --no-commit --no-ff {tag}", check=False)
+    
+    if merge_check.returncode != 0:
+        print(f"Cannot merge {tag} cleanly into {branch}.")
+        print("Merge conflicts would occur. Aborting merge.")
+        run_command("git merge --abort")
+        return False
+    
+    # Abort the test merge
+    run_command("git reset --hard HEAD")
+    
+    # Now perform the actual merge and push to remote
+    print(f"Merging {tag} into {branch}...")
+    merge_result = run_command(f"git merge {tag} --no-edit")
+    if merge_result.returncode != 0:
+        print(f"Failed to merge {tag} into {branch}.")
+        return False
+    
+    print(f"Pushing changes to remote...")
+    push_result = run_command(f"git push origin {branch}")
+    if push_result.returncode != 0:
+        print(f"Failed to push changes to remote.")
+        return False
+    
+    print(f"Successfully merged {tag} into {branch} and pushed to remote.")
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Merge a tag into a branch on a GitHub repository.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s leanprover/mathlib4 stable v4.6.0    Merge tag v4.6.0 into stable branch
+
+The script will:
+1. Clone the repository
+2. Check if the tag and branch exist
+3. Check if the tag can be merged cleanly into the branch
+4. Perform the merge and push to remote if possible
+        """
+    )
+    parser.add_argument("repo", help="GitHub repository in the format 'organization/repository'")
+    parser.add_argument("branch", help="The target branch to merge into")
+    parser.add_argument("tag", help="The tag to merge from")
+    
+    args = parser.parse_args()
+    
+    # Create a temporary directory for the repository
+    temp_dir = tempfile.mkdtemp()
+    try:
+        # Clone the repository
+        if not clone_repo(args.repo, temp_dir):
+            sys.exit(1)
+        
+        # Check if the tag can be merged and perform the merge
+        if not check_and_merge(args.repo, args.branch, args.tag, temp_dir):
+            sys.exit(1)
+        
+    finally:
+        # Clean up the temporary directory
+        print(f"Cleaning up temporary files...")
+        shutil.rmtree(temp_dir)
+
+
+if __name__ == "__main__":
+    main() 

script/release_checklist.py

@@ -7,6 +7,13 @@ import base64
 import subprocess
 import sys
 import os
+# Import run_command from merge_remote.py
+from merge_remote import run_command
+
+def debug(verbose, message):
+    """Print debug message if verbose mode is enabled."""
+    if verbose:
+        print(f"    [DEBUG] {message}")
 
 def parse_repos_config(file_path):
     with open(file_path, "r") as f:
@@ -85,9 +92,12 @@ def parse_version(version_str):
 
 def is_version_gte(version1, version2):
     """Check if version1 >= version2, including proper handling of release candidates."""
+    # Check if version1 is a nightly toolchain
+    if version1.startswith("leanprover/lean4:nightly-"):
+        return False
     return parse_version(version1) >= parse_version(version2)
 
-def is_merged_into_stable(repo_url, tag_name, stable_branch, github_token):
+def is_merged_into_stable(repo_url, tag_name, stable_branch, github_token, verbose=False):
     # First get the commit SHA for the tag
     api_base = repo_url.replace("https://github.com/", "https://api.github.com/repos/")
     headers = {'Authorization': f'token {github_token}'} if github_token else {}
@@ -95,6 +105,7 @@ def is_merged_into_stable(repo_url, tag_name, stable_branch, github_token):
     # Get tag's commit SHA
     tag_response = requests.get(f"{api_base}/git/refs/tags/{tag_name}", headers=headers)
     if tag_response.status_code != 200:
+        debug(verbose, f"Could not fetch tag {tag_name}, status code: {tag_response.status_code}")
         return False
     
     # Handle both single object and array responses
@@ -103,22 +114,48 @@ def is_merged_into_stable(repo_url, tag_name, stable_branch, github_token):
         # Find the exact matching tag in the list
         matching_tags = [tag for tag in tag_data if tag['ref'] == f'refs/tags/{tag_name}']
         if not matching_tags:
+            debug(verbose, f"No matching tag found for {tag_name} in response list")
             return False
         tag_sha = matching_tags[0]['object']['sha']
     else:
         tag_sha = tag_data['object']['sha']
-
+    
+    # Check if the tag is an annotated tag and get the actual commit SHA
+    if tag_data.get('object', {}).get('type') == 'tag' or (
+        isinstance(tag_data, list) and 
+        matching_tags and 
+        matching_tags[0].get('object', {}).get('type') == 'tag'):
+        
+        # Get the commit that this tag points to
+        tag_obj_response = requests.get(f"{api_base}/git/tags/{tag_sha}", headers=headers)
+        if tag_obj_response.status_code == 200:
+            tag_obj = tag_obj_response.json()
+            if 'object' in tag_obj and tag_obj['object']['type'] == 'commit':
+                commit_sha = tag_obj['object']['sha']
+                debug(verbose, f"Tag is annotated. Resolved commit SHA: {commit_sha}")
+                tag_sha = commit_sha  # Use the actual commit SHA
+    
     # Get commits on stable branch containing this SHA
     commits_response = requests.get(
         f"{api_base}/commits?sha={stable_branch}&per_page=100",
         headers=headers
     )
     if commits_response.status_code != 200:
+        debug(verbose, f"Could not fetch commits for branch {stable_branch}, status code: {commits_response.status_code}")
         return False
 
     # Check if any commit in stable's history matches our tag's SHA
     stable_commits = [commit['sha'] for commit in commits_response.json()]
-    return tag_sha in stable_commits
+    
+    is_merged = tag_sha in stable_commits
+    
+    debug(verbose, f"Tag SHA: {tag_sha}")
+    debug(verbose, f"First 5 stable commits: {stable_commits[:5]}")
+    debug(verbose, f"Total stable commits fetched: {len(stable_commits)}")
+    if not is_merged:
+        debug(verbose, f"Tag SHA not found in first {len(stable_commits)} commits of stable branch")
+    
+    return is_merged
 
 def is_release_candidate(version):
     return "-rc" in version
@@ -178,51 +215,75 @@ def check_bump_branch_toolchain(url, bump_branch, github_token):
     print(f"  ✅ Bump branch correctly uses toolchain: {content}")
     return True
 
+def pr_exists_with_title(repo_url, title, github_token):
+    api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + "/pulls"
+    headers = {'Authorization': f'token {github_token}'} if github_token else {}
+    params = {'state': 'open'}
+    response = requests.get(api_url, headers=headers, params=params)
+    if response.status_code != 200:
+        return None
+    pull_requests = response.json()
+    for pr in pull_requests:
+        if pr['title'] == title:
+            return pr['number'], pr['html_url']
+    return None
+
 def main():
+    parser = argparse.ArgumentParser(description="Check release status of Lean4 repositories")
+    parser.add_argument("toolchain", help="The toolchain version to check (e.g., v4.6.0)")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose debugging output")
+    parser.add_argument("--dry-run", action="store_true", help="Dry run mode (no actions taken)")
+    args = parser.parse_args()
+
     github_token = get_github_token()
-
-    if len(sys.argv) != 2:
-        print("Usage: python3 release_checklist.py <toolchain>")
-        sys.exit(1)
-
-    toolchain = sys.argv[1]
+    toolchain = args.toolchain
+    verbose = args.verbose
+    # dry_run = args.dry_run  # Not used yet but available for future implementation
+    
     stripped_toolchain = strip_rc_suffix(toolchain)
     lean_repo_url = "https://github.com/leanprover/lean4"
 
-    # Preliminary checks
+    # Track repository status
+    repo_status = {}  # Will store True for success, False for failure
+
+    # Preliminary checks for lean4 itself
     print("\nPerforming preliminary checks...")
+    lean4_success = True
 
     # Check for branch releases/v4.Y.0
     version_major, version_minor, _ = map(int, stripped_toolchain.lstrip('v').split('.'))
     branch_name = f"releases/v{version_major}.{version_minor}.0"
-    if branch_exists(lean_repo_url, branch_name, github_token):
-        print(f"  ✅ Branch {branch_name} exists")
-
-        # Check CMake version settings
-        check_cmake_version(lean_repo_url, branch_name, version_major, version_minor, github_token)
-    else:
+    if not branch_exists(lean_repo_url, branch_name, github_token):
         print(f"  ❌ Branch {branch_name} does not exist")
-
-    # Check for tag v4.X.Y(-rcZ)
-    if tag_exists(lean_repo_url, toolchain, github_token):
-        print(f"  ✅ Tag {toolchain} exists")
+        lean4_success = False
     else:
+        print(f"  ✅ Branch {branch_name} exists")
+        # Check CMake version settings
+        if not check_cmake_version(lean_repo_url, branch_name, version_major, version_minor, github_token):
+            lean4_success = False
+
+    # Check for tag and release page
+    if not tag_exists(lean_repo_url, toolchain, github_token):
         print(f"  ❌ Tag {toolchain} does not exist.")
+        lean4_success = False
+    else:
+        print(f"  ✅ Tag {toolchain} exists")
 
-    # Check for release page
-    if release_page_exists(lean_repo_url, toolchain, github_token):
+    if not release_page_exists(lean_repo_url, toolchain, github_token):
+        print(f"  ❌ Release page for {toolchain} does not exist")
+        lean4_success = False
+    else:
         print(f"  ✅ Release page for {toolchain} exists")
-
-        # Check the first line of the release notes
         release_notes = get_release_notes(lean_repo_url, toolchain, github_token)
-        if release_notes and toolchain in release_notes.splitlines()[0].strip():
-            print(f"  ✅ Release notes look good.")
-        else:
+        if not (release_notes and toolchain in release_notes.splitlines()[0].strip()):
             previous_minor_version = version_minor - 1
             previous_release = f"v{version_major}.{previous_minor_version}.0"
             print(f"  ❌ Release notes not published. Please run `script/release_notes.py --since {previous_release}` on branch `{branch_name}`.")
-    else:
-        print(f"  ❌ Release page for {toolchain} does not exist")
+            lean4_success = False
+        else:
+            print(f"  ✅ Release notes look good.")
+
+    repo_status["lean4"] = lean4_success
 
     # Load repositories and perform further checks
     print("\nChecking repositories...")
@@ -233,50 +294,100 @@ def main():
     for repo in repos:
         name = repo["name"]
         url = repo["url"]
+        org_repo = extract_org_repo_from_url(url)
         branch = repo["branch"]
         check_stable = repo["stable-branch"]
         check_tag = repo.get("toolchain-tag", True)
         check_bump = repo.get("bump-branch", False)
+        dependencies = repo.get("dependencies", [])
 
         print(f"\nRepository: {name}")
 
+        # Check if any dependencies have failed
+        failed_deps = [dep for dep in dependencies if dep in repo_status and not repo_status[dep]]
+        if failed_deps:
+            print(f"  🟡  Dependencies not ready: {', '.join(failed_deps)}")
+            repo_status[name] = False
+            continue
+
+        # Initialize success flag for this repo
+        success = True
+
         # Check if branch is on at least the target toolchain
         lean_toolchain_content = get_branch_content(url, branch, "lean-toolchain", github_token)
         if lean_toolchain_content is None:
             print(f"  ❌ No lean-toolchain file found in {branch} branch")
+            repo_status[name] = False
             continue
-
+        
         on_target_toolchain = is_version_gte(lean_toolchain_content.strip(), toolchain)
         if not on_target_toolchain:
             print(f"  ❌ Not on target toolchain (needs ≥ {toolchain}, but {branch} is on {lean_toolchain_content.strip()})")
+            pr_title = f"chore: bump toolchain to {toolchain}"
+            pr_info = pr_exists_with_title(url, pr_title, github_token)
+            if pr_info:
+                pr_number, pr_url = pr_info
+                print(f"  ✅ PR with title '{pr_title}' exists: #{pr_number} ({pr_url})")
+            else:
+                print(f"  ❌ PR with title '{pr_title}' does not exist")
+                print(f"     Run `script/release_steps.py {toolchain} {name}` to create it")
+            repo_status[name] = False
             continue
         print(f"  ✅ On compatible toolchain (>= {toolchain})")
 
-        # Only check for tag if toolchain-tag is true
         if check_tag:
-            if not tag_exists(url, toolchain, github_token):
-                print(f"  ❌ Tag {toolchain} does not exist. Run `script/push_repo_release_tag.py {extract_org_repo_from_url(url)} {branch} {toolchain}`.")
-            else:
-                print(f"  ✅ Tag {toolchain} exists")
+            tag_exists_initially = tag_exists(url, toolchain, github_token)
+            if not tag_exists_initially:                
+                if args.dry_run:
+                    print(f"  ❌ Tag {toolchain} does not exist. Run `script/push_repo_release_tag.py {org_repo} {branch} {toolchain}`.")
+                    repo_status[name] = False
+                    continue
+                else:
+                    print(f"  … Tag {toolchain} does not exist. Running `script/push_repo_release_tag.py {org_repo} {branch} {toolchain}`...")
+                    
+                    # Run the script to create the tag
+                    subprocess.run(["script/push_repo_release_tag.py", org_repo, branch, toolchain])
+                    
+                    # Check again if the tag exists now
+                    if not tag_exists(url, toolchain, github_token):
+                        print(f"  ❌ Manual intervention required.")
+                        repo_status[name] = False
+                        continue
+            
+            # This will print in all successful cases - whether tag existed initially or was created successfully
+            print(f"  ✅ Tag {toolchain} exists")
 
-        # Only check merging into stable if stable-branch is true and not a release candidate
         if check_stable and not is_release_candidate(toolchain):
-            if not is_merged_into_stable(url, toolchain, "stable", github_token):
+            if not is_merged_into_stable(url, toolchain, "stable", github_token, verbose):
+                org_repo = extract_org_repo_from_url(url)
                 print(f"  ❌ Tag {toolchain} is not merged into stable")
-            else:
-                print(f"  ✅ Tag {toolchain} is merged into stable")
+                print(f"     Run `script/merge_remote.py {org_repo} stable {toolchain}` to merge it")
+                repo_status[name] = False
+                continue
+            print(f"  ✅ Tag {toolchain} is merged into stable")
 
-        # Check for bump branch if configured
         if check_bump:
             next_version = get_next_version(toolchain)
             bump_branch = f"bump/{next_version}"
-            if branch_exists(url, bump_branch, github_token):
-                print(f"  ✅ Bump branch {bump_branch} exists")
-                check_bump_branch_toolchain(url, bump_branch, github_token)
-            else:
-                print(f"  ❌ Bump branch {bump_branch} does not exist")
+            if not branch_exists(url, bump_branch, github_token):
+                if args.dry_run:
+                    print(f"  ❌ Bump branch {bump_branch} does not exist. Run `gh api -X POST /repos/{org_repo}/git/refs -f ref=refs/heads/{bump_branch} -f sha=$(gh api /repos/{org_repo}/git/refs/heads/{branch} --jq .object.sha)` to create it.")
+                    repo_status[name] = False
+                    continue
+                print(f"  … Bump branch {bump_branch} does not exist. Creating it...")
+                result = run_command(f"gh api -X POST /repos/{org_repo}/git/refs -f ref=refs/heads/{bump_branch} -f sha=$(gh api /repos/{org_repo}/git/refs/heads/{branch} --jq .object.sha)", check=False)
+                if result.returncode != 0:
+                    print(f"  ❌ Failed to create bump branch {bump_branch}")
+                    repo_status[name] = False
+                    continue
+            print(f"  ✅ Bump branch {bump_branch} exists")
+            if not check_bump_branch_toolchain(url, bump_branch, github_token):
+                repo_status[name] = False
+                continue
 
-    # Check lean4 master branch for next development cycle
+        repo_status[name] = success
+
+    # Final check for lean4 master branch
     print("\nChecking lean4 master branch configuration...")
     next_version = get_next_version(toolchain)
     next_minor = int(next_version.split('.')[1])

script/release_repos.yml

@@ -1,5 +1,5 @@
 repositories:
-  - name: Batteries
+  - name: batteries
     url: https://github.com/leanprover-community/batteries
     toolchain-tag: true
     stable-branch: true
@@ -28,14 +28,21 @@ repositories:
     branch: main
     dependencies: []
 
-  - name: Verso
+  - name: verso
     url: https://github.com/leanprover/verso
     toolchain-tag: true
     stable-branch: false
     branch: main
     dependencies: []
 
-  - name: Cli
+  - name: reference-manual
+    url: https://github.com/leanprover/reference-manual
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies: [verso]
+
+  - name: lean4-cli
     url: https://github.com/leanprover/lean4-cli
     toolchain-tag: true
     stable-branch: false
@@ -50,7 +57,7 @@ repositories:
     dependencies:
       - Batteries
 
-  - name: Aesop
+  - name: aesop
     url: https://github.com/leanprover-community/aesop
     toolchain-tag: true
     stable-branch: true
@@ -63,7 +70,9 @@ repositories:
     toolchain-tag: true
     stable-branch: false
     branch: main
-    dependencies: []
+    dependencies:
+      - Cli
+      - Batteries
 
   - name: plausible
     url: https://github.com/leanprover-community/plausible
@@ -72,7 +81,7 @@ repositories:
     branch: main
     dependencies: []
 
-  - name: Mathlib
+  - name: mathlib4
     url: https://github.com/leanprover-community/mathlib4
     toolchain-tag: true
     stable-branch: true
@@ -85,8 +94,9 @@ repositories:
       - Batteries
       - doc-gen4
       - import-graph
+      - plausible
 
-  - name: REPL
+  - name: repl
     url: https://github.com/leanprover-community/repl
     toolchain-tag: true
     stable-branch: true

script/release_steps.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+
+"""
+Generate release steps script for Lean4 repositories.
+
+This script helps automate the release process for Lean4 and its dependent repositories
+by generating step-by-step instructions for updating toolchains, creating tags,
+and managing branches.
+
+Usage:
+    python3 release_steps.py <version> <repo>
+
+Arguments:
+    version: The version to set in the lean-toolchain file (e.g., v4.6.0)
+    repo: A substring of the repository name as specified in release_repos.yml
+
+Example:
+    python3 release_steps.py v4.6.0 mathlib
+    python3 release_steps.py v4.6.0 batt
+
+The script reads repository configurations from release_repos.yml in the same directory.
+Each repository may have specific requirements for:
+- Branch management
+- Toolchain updates
+- Dependency updates
+- Tagging conventions
+- Stable branch handling
+"""
+
+import argparse
+import yaml
+import os
+import sys
+import re
+
+def load_repos_config(file_path):
+    with open(file_path, "r") as f:
+        return yaml.safe_load(f)["repositories"]
+
+def find_repo(repo_substring, config):
+    pattern = re.compile(re.escape(repo_substring), re.IGNORECASE)
+    matching_repos = [r for r in config if pattern.search(r["name"])]
+    if not matching_repos:
+        print(f"Error: No repository matching '{repo_substring}' found in configuration.")
+        sys.exit(1)
+    if len(matching_repos) > 1:
+        print(f"Error: Multiple repositories matching '{repo_substring}' found in configuration: {', '.join(r['name'] for r in matching_repos)}")
+        sys.exit(1)
+    return matching_repos[0]
+
+def generate_script(repo, version, config):
+    repo_config = find_repo(repo, config)
+    repo_name = repo_config['name']
+    repo_url = repo_config['url']
+    # Extract the last component of the URL, removing the .git extension if present
+    repo_dir = repo_url.split('/')[-1].replace('.git', '')
+    default_branch = repo_config.get("branch", "main")
+    dependencies = repo_config.get("dependencies", [])
+    requires_tagging = repo_config.get("toolchain-tag", True)
+    has_stable_branch = repo_config.get("stable-branch", True)
+
+    script_lines = [
+        f"cd {repo_dir}",
+        "git fetch",
+        f"git checkout {default_branch} && git pull",
+        f"git checkout -b bump_to_{version}",
+        f"echo leanprover/lean4:{version} > lean-toolchain",
+    ]
+
+    # Special cases for specific repositories
+    if repo_name == "REPL":
+        script_lines.extend([
+            "lake update",
+            "cd test/Mathlib",
+            f"perl -pi -e 's/rev = \"v\\d+\\.\\d+\\.\\d+(-rc\\d+)?\"/rev = \"{version}\"/g' lakefile.toml",
+            f"echo leanprover/lean4:{version} > lean-toolchain",
+            "lake update",
+            "cd ../..",
+            "./test.sh"
+        ])
+    elif dependencies:
+        script_lines.append('echo "Please update the dependencies in lakefile.{lean,toml}"')
+        script_lines.append("lake update")
+
+    script_lines.append("")
+
+    script_lines.extend([
+        f'git commit -am "chore: bump toolchain to {version}"',
+        ""
+    ])
+
+    if re.search(r'rc\d+$', version) and repo_name in ["Batteries", "Mathlib"]:
+        script_lines.extend([
+            "echo 'This repo has nightly-testing infrastructure'",
+            f"git merge origin/bump/{version.split('-rc')[0]}",
+            "echo 'Please resolve any conflicts.'",
+            ""
+        ])
+    if repo_name != "Mathlib":
+        script_lines.extend([
+            "lake build && if lake check-test; then lake test; fi",
+            ""
+        ])
+
+    script_lines.extend([
+        'gh pr create --title "chore: bump toolchain to ' + version + '" --body ""',
+        "echo 'Please review the PR and merge it.'",
+        ""
+    ])
+
+    return "\n".join(script_lines)
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate release steps script for Lean4 repositories.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s v4.6.0 mathlib    Generate steps for updating Mathlib to v4.6.0
+  %(prog)s v4.6.0 batt       Generate steps for updating Batteries to v4.6.0
+  
+The script will generate shell commands to:
+1. Update the lean-toolchain file
+2. Create appropriate branches and commits
+3. Create pull requests
+
+(Note that the steps of creating toolchain version tags, and merging these into `stable` branches,
+are handled by `script/release_checklist.py`.)
+"""
+    )
+    parser.add_argument("version", help="The version to set in the lean-toolchain file (e.g., v4.6.0)")
+    parser.add_argument("repo", help="A substring of the repository name as specified in release_repos.yml")
+    args = parser.parse_args()
+
+    config_path = os.path.join(os.path.dirname(__file__), "release_repos.yml")
+    config = load_repos_config(config_path)
+
+    script = generate_script(args.repo, args.version, config)
+    print(script)
+
+if __name__ == "__main__":
+    main()

src/CMakeLists.txt

@@ -10,7 +10,7 @@ endif()
 include(ExternalProject)
 project(LEAN CXX C)
 set(LEAN_VERSION_MAJOR 4)
-set(LEAN_VERSION_MINOR 19)
+set(LEAN_VERSION_MINOR 20)
 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'")
@@ -20,6 +20,11 @@ if (LEAN_SPECIAL_VERSION_DESC)
 elseif (NOT LEAN_VERSION_IS_RELEASE)
   string(APPEND LEAN_VERSION_STRING "-pre")
 endif()
+if (LEAN_VERSION_IS_RELEASE)
+  set(LEAN_MANUAL_ROOT "https://lean-lang.org/doc/reference/${LEAN_VERSION_STRING}/")
+else()
+  set(LEAN_MANUAL_ROOT "")
+endif()
 
 set(LEAN_PLATFORM_TARGET "" CACHE STRING "LLVM triple of the target platform")
 if (NOT LEAN_PLATFORM_TARGET)
@@ -69,12 +74,13 @@ option(TRACK_LIVE_EXPRS    "TRACK_LIVE_EXPRS" OFF)
 option(CUSTOM_ALLOCATORS   "CUSTOM_ALLOCATORS" ON)
 option(SAVE_SNAPSHOT       "SAVE_SNAPSHOT" ON)
 option(SAVE_INFO           "SAVE_INFO" ON)
-option(SMALL_ALLOCATOR     "SMALL_ALLOCATOR" ON)
+option(SMALL_ALLOCATOR     "SMALL_ALLOCATOR" OFF)
 option(MMAP                "MMAP" ON)
 option(LAZY_RC             "LAZY_RC" OFF)
 option(RUNTIME_STATS       "RUNTIME_STATS" OFF)
 option(BSYMBOLIC "Link with -Bsymbolic to reduce call overhead in shared libraries (Linux)" ON)
 option(USE_GMP "USE_GMP" ON)
+option(USE_MIMALLOC "use mimalloc" ON)
 
 # development-specific options
 option(CHECK_OLEAN_VERSION "Only load .olean files compiled with the current version of Lean" OFF)
@@ -87,6 +93,11 @@ if ("${LAZY_RC}" MATCHES "ON")
   set(LEAN_LAZY_RC "#define LEAN_LAZY_RC")
 endif()
 
+if (USE_MIMALLOC)
+  set(SMALL_ALLOCATOR OFF)
+  set(LEAN_MIMALLOC "#define LEAN_MIMALLOC")
+endif()
+
 if ("${SMALL_ALLOCATOR}" MATCHES "ON")
   set(LEAN_SMALL_ALLOCATOR "#define LEAN_SMALL_ALLOCATOR")
 endif()
@@ -543,6 +554,9 @@ else()
   set(LEAN_IS_STAGE0 "#define LEAN_IS_STAGE0 0")
 endif()
 configure_file("${LEAN_SOURCE_DIR}/config.h.in" "${LEAN_BINARY_DIR}/include/lean/config.h")
+if (USE_MIMALLOC)
+  file(COPY "${LEAN_BINARY_DIR}/../mimalloc/src/mimalloc/include/mimalloc.h" DESTINATION "${LEAN_BINARY_DIR}/include/lean")
+endif()
 install(DIRECTORY ${LEAN_BINARY_DIR}/include/ DESTINATION include)
 configure_file(${LEAN_SOURCE_DIR}/lean.mk.in ${LEAN_BINARY_DIR}/share/lean/lean.mk)
 install(DIRECTORY ${LEAN_BINARY_DIR}/share/ DESTINATION share)
@@ -766,12 +780,11 @@ add_custom_target(clean-olean
   DEPENDS clean-stdlib)
 
 install(DIRECTORY "${CMAKE_BINARY_DIR}/lib/" DESTINATION lib
-  PATTERN temp
-  PATTERN "*.export"
-  PATTERN "*.hash"
-  PATTERN "*.trace"
-  PATTERN "*.rsp"
-  EXCLUDE)
+  PATTERN temp EXCLUDE
+  PATTERN "*.export" EXCLUDE
+  PATTERN "*.hash" EXCLUDE
+  PATTERN "*.trace" EXCLUDE
+  PATTERN "*.rsp" EXCLUDE)
 
 # symlink source into expected installation location for go-to-definition, if file system allows it
 file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/src)

src/Init/Control/Basic.lean

@@ -36,13 +36,17 @@ instance (priority := 500) instForInOfForIn' [ForIn' m ρ α d] : ForIn m ρ α
   simp [h]
   rfl
 
-@[wf_preprocess] theorem forIn_eq_forin' [d : Membership α ρ] [ForIn' m ρ α d] {β} [Monad m]
+@[wf_preprocess] theorem forIn_eq_forIn' [d : Membership α ρ] [ForIn' m ρ α d] {β} [Monad m]
     (x : ρ) (b : β) (f : (a : α) → β → m (ForInStep β)) :
     forIn x b f = forIn' x b (fun x h => binderNameHint x f <| binderNameHint h () <| f x) := by
-  simp [binderNameHint]
-  rfl -- very strange why `simp` did not close it
+  rfl
 
-/-- Extract the value from a `ForInStep`, ignoring whether it is `done` or `yield`. -/
+@[deprecated forIn_eq_forIn' (since := "2025-04-04")]
+abbrev forIn_eq_forin' := @forIn_eq_forIn'
+
+/--
+Extracts the value from a `ForInStep`, ignoring whether it is `ForInStep.done` or `ForInStep.yield`.
+-/
 def ForInStep.value (x : ForInStep α) : α :=
   match x with
   | ForInStep.done b => b
@@ -172,7 +176,7 @@ recommended_spelling "andM" for "<&&>" in [andM, «term_<&&>_»]
 /--
 Runs a monadic action and returns the negation of its result.
 -/
-@[macro_inline] def notM {m : Type → Type v} [Applicative m] (x : m Bool) : m Bool :=
+@[macro_inline] def notM {m : Type → Type v} [Functor m] (x : m Bool) : m Bool :=
   not <$> x
 
 /-!
@@ -385,14 +389,20 @@ def control {m : Type u → Type v} {n : Type u → Type w} [MonadControlT m n]
   controlAt m f
 
 /--
-  Typeclass for the polymorphic `forM` operation described in the "do unchained" paper.
-  Remark:
-  - `γ` is a "container" type of elements of type `α`.
-  - `α` is treated as an output parameter by the typeclass resolution procedure.
-    That is, it tries to find an instance using only `m` and `γ`.
+Overloaded monadic iteration over some container type.
+
+An instance of `ForM m γ α` describes how to iterate a monadic operator over a container of type `γ`
+with elements of type `α` in the monad `m`. The element type should be uniquely determined by the
+monad and the container.
+
+Use `ForM.forIn` to construct a `ForIn` instance from a `ForM` instance, thus enabling the use of
+the `for` operator in `do`-notation.
 -/
 class ForM (m : Type u → Type v) (γ : Type w₁) (α : outParam (Type w₂)) where
-  forM [Monad m] : γ → (α → m PUnit) → m PUnit
+  /--
+  Runs the monadic action `f` on each element of the collection `coll`.
+  -/
+  forM [Monad m] (coll : γ) (f : α → m PUnit) : m PUnit
 
 export ForM (forM)
 

src/Init/Control/EState.lean

@@ -29,8 +29,11 @@ namespace EStateM
 
 variable {ε σ α β : Type u}
 
-/-- Alternative orElse operator that allows to select which exception should be used.
-    The default is to use the first exception since the standard `orElse` uses the second. -/
+/--
+Alternative orElse operator that allows callers to select which exception should be used when both
+operations fail. The default is to use the first exception since the standard `orElse` uses the
+second.
+-/
 @[always_inline, inline]
 protected def orElse' {δ} [Backtrackable δ σ] (x₁ x₂ : EStateM ε σ α) (useFirstEx := true) : EStateM ε σ α := fun s =>
   let d := Backtrackable.save s;
@@ -54,6 +57,11 @@ instance : MonadFinally (EStateM ε σ) := {
       | Result.error e₂ s => Result.error e₂ s
 }
 
+/--
+Converts a state monad action into a state monad action with exceptions.
+
+The resulting action does not throw an exception.
+-/
 @[always_inline, inline] def fromStateM {ε σ α : Type} (x : StateM σ α) : EStateM ε σ α := fun s =>
   match x.run s with
   | (a, s') => EStateM.Result.ok a s'

src/Init/Control/Lawful/Basic.lean

@@ -39,13 +39,16 @@ export LawfulFunctor (map_const id_map comp_map)
 
 attribute [simp] id_map
 
-@[simp] theorem id_map' [Functor m] [LawfulFunctor m] (x : m α) : (fun a => a) <$> x = x :=
+@[simp] theorem id_map' [Functor f] [LawfulFunctor f] (x : f α) : (fun a => a) <$> x = x :=
   id_map x
 
 @[simp] theorem Functor.map_map [Functor f] [LawfulFunctor f] (m : α → β) (g : β → γ) (x : f α) :
     g <$> m <$> x = (fun a => g (m a)) <$> x :=
   (comp_map _ _ _).symm
 
+theorem Functor.map_unit [Functor f] [LawfulFunctor f] {a : f PUnit} : (fun _ => PUnit.unit) <$> a = a := by
+  simp [map]
+
 /--
 An applicative functor satisfies the laws of an applicative functor.
 
@@ -184,9 +187,6 @@ theorem seqLeft_eq_bind [Monad m] [LawfulMonad m] (x : m α) (y : m β) : x <* y
   rw [← bind_pure_comp]
   simp only [bind_assoc, pure_bind]
 
-theorem Functor.map_unit [Monad m] [LawfulMonad m] {a : m PUnit} : (fun _ => PUnit.unit) <$> a = a := by
-  simp [map]
-
 /--
 This is just a duplicate of `LawfulApplicative.map_pure`,
 but sometimes applies when that doesn't.

src/Init/Control/Lawful/Instances.lean

@@ -124,7 +124,7 @@ namespace ReaderT
 @[simp] theorem run_monadLift [MonadLiftT n m] (x : n α) (ctx : ρ)
     : (monadLift x : ReaderT ρ m α).run ctx = (monadLift x : m α) := rfl
 
-@[simp] theorem run_monadMap [MonadFunctor n m] (f : {β : Type u} → n β → n β) (x : ReaderT ρ m α) (ctx : ρ)
+@[simp] theorem run_monadMap [MonadFunctorT n m] (f : {β : Type u} → n β → n β) (x : ReaderT ρ m α) (ctx : ρ)
     : (monadMap @f x : ReaderT ρ m α).run ctx = monadMap @f (x.run ctx) := rfl
 
 @[simp] theorem run_read [Monad m] (ctx : ρ) : (ReaderT.read : ReaderT ρ m ρ).run ctx = pure ctx := rfl
@@ -199,7 +199,7 @@ theorem run_bind_lift {α σ : Type u} [Monad m] [LawfulMonad m] (x : m α) (f :
 
 @[simp] theorem run_monadLift {α σ : Type u} [Monad m] [MonadLiftT n m] (x : n α) (s : σ) : (monadLift x : StateT σ m α).run s = (monadLift x : m α) >>= fun a => pure (a, s) := rfl
 
-@[simp] theorem run_monadMap [MonadFunctor n m] (f : {β : Type u} → n β → n β) (x : StateT σ m α) (s : σ) :
+@[simp] theorem run_monadMap [MonadFunctorT n m] (f : {β : Type u} → n β → n β) (x : StateT σ m α) (s : σ) :
     (monadMap @f x : StateT σ m α).run s = monadMap @f (x.run s) := rfl
 
 @[simp] theorem run_seq {α β σ : Type u} [Monad m] [LawfulMonad m] (f : StateT σ m (α → β)) (x : StateT σ m α) (s : σ) : (f <*> x).run s = (f.run s >>= fun fs => (fun (p : α × σ) => (fs.1 p.1, p.2)) <$> x.run fs.2) := by

src/Init/Control/Option.lean

@@ -59,6 +59,9 @@ instance : Monad (OptionT m) where
   pure := OptionT.pure
   bind := OptionT.bind
 
+instance {m : Type u → Type v} [Pure m] : Inhabited (OptionT m α) where
+  default := pure (f:=m) default
+
 /--
 Recovers from failures. Typically used via the `<|>` operator.
 -/

src/Init/Control/State.lean

@@ -159,7 +159,9 @@ instance (ε) [MonadExceptOf ε m] : MonadExceptOf ε (StateT σ m) := {
 end
 end StateT
 
-/-- Adapter to create a ForIn instance from a ForM instance -/
+/--
+Creates a suitable implementation of `ForIn.forIn` from a `ForM` instance.
+-/
 @[always_inline, inline]
 def ForM.forIn [Monad m] [ForM (StateT β (ExceptT β m)) ρ α]
     (x : ρ) (b : β) (f : α → β → m (ForInStep β)) : m β := do

src/Init/Conv.lean

@@ -97,7 +97,7 @@ syntax (name := arg) "arg " argArg : conv
 
 /-- `ext x` traverses into a binder (a `fun x => e` or `∀ x, e` expression)
 to target `e`, introducing name `x` in the process. -/
-syntax (name := ext) "ext" (ppSpace colGt ident)* : conv
+syntax (name := ext) "ext" (ppSpace colGt binderIdent)* : conv
 
 /-- `change t'` replaces the target `t` with `t'`,
 assuming `t` and `t'` are definitionally equal. -/
@@ -281,9 +281,9 @@ macro "left" : conv => `(conv| lhs)
 /-- `right` traverses into the right argument. Synonym for `rhs`. -/
 macro "right" : conv => `(conv| rhs)
 /-- `intro` traverses into binders. Synonym for `ext`. -/
-macro "intro" xs:(ppSpace colGt ident)* : conv => `(conv| ext $xs*)
+macro "intro" xs:(ppSpace colGt binderIdent)* : conv => `(conv| ext $xs*)
 
-syntax enterArg := ident <|> argArg
+syntax enterArg := binderIdent <|> argArg
 
 /-- `enter [arg, ...]` is a compact way to describe a path to a subterm.
 It is a shorthand for other conv tactics as follows:
@@ -306,6 +306,10 @@ syntax (name := first) "first " withPosition((ppDedent(ppLine) colGe "| " convSe
 /-- `try tac` runs `tac` and succeeds even if `tac` failed. -/
 macro "try " t:convSeq : conv => `(conv| first | $t | skip)
 
+/--
+`tac <;> tac'` runs `tac` on the main goal and `tac'` on each produced goal, concatenating all goals
+produced by `tac'`.
+-/
 macro:1 x:conv tk:" <;> " y:conv:0 : conv =>
   `(conv| tactic' => (conv' => $x:conv) <;>%$tk (conv' => $y:conv))
 

src/Init/Core.lean

@@ -294,68 +294,78 @@ inductive Exists {α : Sort u} (p : α → Prop) : Prop where
   | intro (w : α) (h : p w) : Exists p
 
 /--
-Auxiliary type used to compile `for x in xs` notation.
+An indication of whether a loop's body terminated early that's used to compile the `for x in xs`
+notation.
 
-This is the return value of the body of a `ForIn` call,
-representing the body of a for loop. It can be:
-
-* `.yield (a : α)`, meaning that we should continue the loop and `a` is the new state.
-  `.yield` is produced by `continue` and reaching the bottom of the loop body.
-* `.done (a : α)`, meaning that we should early-exit the loop with state `a`.
-  `.done` is produced by calls to `break` or `return` in the loop,
+A collection's `ForIn` or `ForIn'` instance describe's how to iterate over its elements. The monadic
+action that represents the body of the loop returns a `ForInStep α`, where `α` is the local state
+used to implement features such as `let mut`.
 -/
 inductive ForInStep (α : Type u) where
-  /-- `.done a` means that we should early-exit the loop.
-  `.done` is produced by calls to `break` or `return` in the loop. -/
+  /--
+  The loop should terminate early.
+
+  `ForInStep.done` is produced by uses of `break` or `return` in the loop body.
+  -/
   | done  : α → ForInStep α
-  /-- `.yield a` means that we should continue the loop.
-  `.yield` is produced by `continue` and reaching the bottom of the loop body. -/
+  /--
+  The loop should continue with the next iteration, using the returned state.
+
+  `ForInStep.yield` is produced by `continue` and by reaching the bottom of the loop body.
+  -/
   | yield : α → ForInStep α
   deriving Inhabited
 
 /--
-`ForIn m ρ α` is the typeclass which supports `for x in xs` notation.
-Here `xs : ρ` is the type of the collection to iterate over, `x : α`
-is the element type which is made available inside the loop, and `m` is the monad
-for the encompassing `do` block.
+Monadic iteration in `do`-blocks, using the `for x in xs` notation.
+
+The parameter `m` is the monad of the `do`-block in which iteration is performed, `ρ` is the type of
+the collection being iterated over, and `α` is the type of elements.
 -/
 class ForIn (m : Type u₁ → Type u₂) (ρ : Type u) (α : outParam (Type v)) where
-  /-- `forIn x b f : m β` runs a for-loop in the monad `m` with additional state `β`.
-  This traverses over the "contents" of `x`, and passes the elements `a : α` to
-  `f : α → β → m (ForInStep β)`. `b : β` is the initial state, and the return value
-  of `f` is the new state as well as a directive `.done` or `.yield`
-  which indicates whether to abort early or continue iteration.
+  /--
+  Monadically iterates over the contents of a collection `xs`, with a local state `b` and the
+  possibility of early termination.
 
-  The expression
-  ```
-  let mut b := ...
-  for x in xs do
-    b ← foo x b
-  ```
-  in a `do` block is syntactic sugar for:
-  ```
-  let b := ...
-  let b ← forIn xs b (fun x b => do
-    let b ← foo x b
-    return .yield b)
-  ```
-  (Here `b` corresponds to the variables mutated in the loop.) -/
-  forIn {β} [Monad m] (x : ρ) (b : β) (f : α → β → m (ForInStep β)) : m β
+  Because a `do` block supports local mutable bindings along with `return`, and `break`, the monadic
+  action passed to `ForIn.forIn` takes a starting state in addition to the current element of the
+  collection and returns an updated state together with an indication of whether iteration should
+  continue or terminate. If the action returns `ForInStep.done`, then `ForIn.forIn` should stop
+  iteration and return the updated state. If the action returns `ForInStep.yield`, then
+  `ForIn.forIn` should continue iterating if there are further elements, passing the updated state
+  to the action.
+
+  More information about the translation of `for` loops into `ForIn.forIn` is available in [the Lean
+  reference manual](lean-manual://section/monad-iteration-syntax).
+  -/
+  forIn {β} [Monad m] (xs : ρ) (b : β) (f : α → β → m (ForInStep β)) : m β
 
 export ForIn (forIn)
 
 /--
-`ForIn' m ρ α d` is a variation on the `ForIn m ρ α` typeclass which supports the
-`for h : x in xs` notation. It is the same as `for x in xs` except that `h : x ∈ xs`
-is provided as an additional argument to the body of the for-loop.
+Monadic iteration in `do`-blocks with a membership proof, using the `for h : x in xs` notation.
+
+The parameter `m` is the monad of the `do`-block in which iteration is performed, `ρ` is the type of
+the collection being iterated over, `α` is the type of elements, and `d` is the specific membership
+predicate to provide.
 -/
-class ForIn' (m : Type u₁ → Type u₂) (ρ : Type u) (α : outParam (Type v)) (d : outParam $ Membership α ρ) where
-  /-- `forIn' x b f : m β` runs a for-loop in the monad `m` with additional state `β`.
-  This traverses over the "contents" of `x`, and passes the elements `a : α` along
-  with a proof that `a ∈ x` to `f : (a : α) → a ∈ x → β → m (ForInStep β)`.
-  `b : β` is the initial state, and the return value
-  of `f` is the new state as well as a directive `.done` or `.yield`
-  which indicates whether to abort early or continue iteration. -/
+class ForIn' (m : Type u₁ → Type u₂) (ρ : Type u) (α : outParam (Type v)) (d : outParam (Membership α ρ)) where
+  /--
+  Monadically iterates over the contents of a collection `xs`, with a local state `b` and the
+  possibility of early termination. At each iteration, the body of the loop is provided with a proof
+  that the current element is in the collection.
+
+  Because a `do` block supports local mutable bindings along with `return`, and `break`, the monadic
+  action passed to `ForIn'.forIn'` takes a starting state in addition to the current element of the
+  collection with its membership proof. The action returns an updated state together with an
+  indication of whether iteration should continue or terminate. If the action returns
+  `ForInStep.done`, then `ForIn'.forIn'` should stop iteration and return the updated state. If the
+  action returns `ForInStep.yield`, then `ForIn'.forIn'` should continue iterating if there are
+  further elements, passing the updated state to the action.
+
+  More information about the translation of `for` loops into `ForIn'.forIn'` is available in [the
+  Lean reference manual](lean-manual://section/monad-iteration-syntax).
+  -/
   forIn' {β} [Monad m] (x : ρ) (b : β) (f : (a : α) → a ∈ x → β → m (ForInStep β)) : m β
 
 export ForIn' (forIn')
@@ -587,7 +597,10 @@ structure Task (α : Type u) : Type u where
   many tasks have finished.
 
   `Task.map` and `Task.bind` should be preferred over `Task.get` for setting up task dependencies
-  where possible as they do not require temporarily growing the threadpool in this way.
+  where possible as they do not require temporarily growing the threadpool in this way. In
+  particular, calling `Task.get` in a task continuation with `(sync := true)` will panic as the
+  continuation is decidedly not "cheap" in this case and deadlocks may otherwise occur. The
+  waited-upon task should instead be returned and unwrapped using `Task.bind/IO.bindTask`.
   -/
   get : α
   deriving Inhabited, Nonempty
@@ -725,6 +738,20 @@ Unlike `x ≠ y` (which is notation for `Ne x y`), this is `Bool` valued instead
 
 recommended_spelling "bne" for "!=" in [bne, «term_!=_»]
 
+/-- `ReflBEq α` says that the `BEq` implementation is reflexive. -/
+class ReflBEq (α) [BEq α] : Prop where
+  /-- `==` is reflexive, that is, `(a == a) = true`. -/
+  protected rfl {a : α} : a == a
+
+@[simp] theorem BEq.rfl [BEq α] [ReflBEq α] {a : α} : a == a := ReflBEq.rfl
+theorem BEq.refl [BEq α] [ReflBEq α] (a : α) : a == a := BEq.rfl
+
+theorem beq_of_eq [BEq α] [ReflBEq α] {a b : α} : a = b → a == b
+  | rfl => BEq.rfl
+
+theorem not_eq_of_beq_eq_false [BEq α] [ReflBEq α] {a b : α} (h : (a == b) = false) : ¬a = b := by
+  intro h'; subst h'; have : true = false := BEq.rfl.symm.trans h; contradiction
+
 /--
 A Boolean equality test coincides with propositional equality.
 
@@ -732,11 +759,9 @@ In other words:
  * `a == b` implies `a = b`.
  * `a == a` is true.
 -/
-class LawfulBEq (α : Type u) [BEq α] : Prop where
+class LawfulBEq (α : Type u) [BEq α] : Prop extends ReflBEq α where
   /-- If `a == b` evaluates to `true`, then `a` and `b` are equal in the logic. -/
   eq_of_beq : {a b : α} → a == b → a = b
-  /-- `==` is reflexive, that is, `(a == a) = true`. -/
-  protected rfl : {a : α} → a == a
 
 export LawfulBEq (eq_of_beq)
 
@@ -748,6 +773,15 @@ instance [DecidableEq α] : LawfulBEq α where
   eq_of_beq := of_decide_eq_true
   rfl := of_decide_eq_self_eq_true _
 
+/--
+Non-instance for `DecidableEq` from `LawfulBEq`.
+To use this, add `attribute [local instance 5] instDecidableEqOfLawfulBEq` at the top of a file.
+-/
+def instDecidableEqOfLawfulBEq [BEq α] [LawfulBEq α] : DecidableEq α := fun x y =>
+  match h : x == y with
+  | false => .isFalse (not_eq_of_beq_eq_false h)
+  | true => .isTrue (eq_of_beq h)
+
 instance : LawfulBEq Char := inferInstance
 
 instance : LawfulBEq String := inferInstance
@@ -842,8 +876,8 @@ theorem Bool.of_not_eq_false : {b : Bool} → ¬ (b = false) → b = true
   | true,  _ => rfl
   | false, h => absurd rfl h
 
-theorem ne_of_beq_false [BEq α] [LawfulBEq α] {a b : α} (h : (a == b) = false) : a ≠ b := by
-  intro h'; subst h'; have : true = false := Eq.trans LawfulBEq.rfl.symm h; contradiction
+theorem ne_of_beq_false [BEq α] [ReflBEq α] {a b : α} (h : (a == b) = false) : a ≠ b :=
+  not_eq_of_beq_eq_false h
 
 theorem beq_false_of_ne [BEq α] [LawfulBEq α] {a b : α} (h : a ≠ b) : (a == b) = false :=
   have : ¬ (a == b) = true := by
@@ -989,11 +1023,19 @@ set_option linter.missingDocs false in
 theorem toBoolUsing_eq_true {p : Prop} (d : Decidable p) (h : p) : toBoolUsing d = true :=
   decide_eq_true (inst := d) h
 
-theorem ofBoolUsing_eq_true {p : Prop} {d : Decidable p} (h : toBoolUsing d = true) : p :=
-  of_decide_eq_true (inst := d) h
+theorem of_toBoolUsing_eq_true {p : Prop} {d : Decidable p} (h : toBoolUsing d = true) : p :=
+  of_decide_eq_true h
 
-theorem ofBoolUsing_eq_false {p : Prop} {d : Decidable p} (h : toBoolUsing d = false) : ¬ p :=
-  of_decide_eq_false (inst := d) h
+theorem of_toBoolUsing_eq_false {p : Prop} {d : Decidable p} (h : toBoolUsing d = false) : ¬p :=
+  of_decide_eq_false h
+
+set_option linter.missingDocs false in
+@[deprecated of_toBoolUsing_eq_true (since := "2025-04-04")]
+abbrev ofBoolUsing_eq_true := @of_toBoolUsing_eq_true
+
+set_option linter.missingDocs false in
+@[deprecated of_toBoolUsing_eq_false (since := "2025-04-04")]
+abbrev ofBoolUsing_eq_false := @of_toBoolUsing_eq_false
 
 instance : Decidable True :=
   isTrue trivial
@@ -1259,9 +1301,13 @@ theorem Relation.TransGen.trans {α : Sort u} {r : α → α → Prop} {a b c} :
 
 namespace Subtype
 
-theorem existsOfSubtype {α : Type u} {p : α → Prop} : { x // p x } → Exists (fun x => p x)
+theorem exists_of_subtype {α : Type u} {p : α → Prop} : { x // p x } → Exists (fun x => p x)
   | ⟨a, h⟩ => ⟨a, h⟩
 
+set_option linter.missingDocs false in
+@[deprecated exists_of_subtype (since := "2025-04-04")]
+abbrev existsOfSubtype := @exists_of_subtype
+
 variable {α : Type u} {p : α → Prop}
 
 protected theorem eq : ∀ {a1 a2 : {x // p x}}, val a1 = val a2 → a1 = a2
@@ -1271,6 +1317,15 @@ theorem eta (a : {x // p x}) (h : p (val a)) : mk (val a) h = a := by
   cases a
   exact rfl
 
+instance {α : Type u} {p : α → Prop} [BEq α] : BEq {x : α // p x} :=
+  ⟨fun x y => x.1 == y.1⟩
+
+instance {α : Type u} {p : α → Prop} [BEq α] [ReflBEq α] : ReflBEq {x : α // p x} where
+  rfl {x} := BEq.refl x.1
+
+instance {α : Type u} {p : α → Prop} [BEq α] [LawfulBEq α] : LawfulBEq {x : α // p x} where
+  eq_of_beq h := Subtype.eq (eq_of_beq h)
+
 instance {α : Type u} {p : α → Prop} [DecidableEq α] : DecidableEq {x : α // p x} :=
   fun ⟨a, h₁⟩ ⟨b, h₂⟩ =>
     if h : a = b then isTrue (by subst h; exact rfl)
@@ -1539,7 +1594,7 @@ 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 :=
-  ⟨eq_of_beq, by intro h; subst h; exact LawfulBEq.rfl⟩
+  ⟨eq_of_beq, beq_of_eq⟩
 
 /-! # Prop lemmas -/
 

src/Init/Data.lean

@@ -34,7 +34,6 @@ import Init.Data.Stream
 import Init.Data.Prod
 import Init.Data.AC
 import Init.Data.Queue
-import Init.Data.Channel
 import Init.Data.Sum
 import Init.Data.BEq
 import Init.Data.Subtype

src/Init/Data/Array/Attach.lean

@@ -109,7 +109,7 @@ well-founded recursion mechanism to prove that the function terminates.
   simp
 
 @[simp]
-theorem pmap_eq_map (p : α → Prop) (f : α → β) (xs : Array α) (H) :
+theorem pmap_eq_map {p : α → Prop} {f : α → β} {xs : Array α} (H) :
     @pmap _ _ p (fun a _ => f a) xs H = map f xs := by
   cases xs; simp
 
@@ -120,13 +120,13 @@ theorem pmap_congr_left {p q : α → Prop} {f : ∀ a, p a → β} {g : ∀ a,
   simp only [List.pmap_toArray, mk.injEq]
   rw [List.pmap_congr_left _ h]
 
-theorem map_pmap {p : α → Prop} (g : β → γ) (f : ∀ a, p a → β) (xs H) :
+theorem map_pmap {p : α → Prop} {g : β → γ} {f : ∀ a, p a → β} {xs : Array α} (H) :
     map g (pmap f xs H) = pmap (fun a h => g (f a h)) xs H := by
   cases xs
   simp [List.map_pmap]
 
-theorem pmap_map {p : β → Prop} (g : ∀ b, p b → γ) (f : α → β) (xs H) :
-    pmap g (map f xs) H = pmap (fun a h => g (f a) h) xs fun _ h => H _ (mem_map_of_mem _ h) := by
+theorem pmap_map {p : β → Prop} {g : ∀ b, p b → γ} {f : α → β} {xs : Array α} (H) :
+    pmap g (map f xs) H = pmap (fun a h => g (f a) h) xs fun _ h => H _ (mem_map_of_mem h) := by
   cases xs
   simp [List.pmap_map]
 
@@ -153,13 +153,13 @@ theorem attachWith_congr {xs ys : Array α} (w : xs = ys) {P : α → Prop} {H :
   cases xs
   simp [attachWith_congr (List.push_toArray _ _)]
 
-theorem pmap_eq_map_attach {p : α → Prop} (f : ∀ a, p a → β) (xs H) :
+theorem pmap_eq_map_attach {p : α → Prop} {f : ∀ a, p a → β} {xs : Array α} (H) :
     pmap f xs H = xs.attach.map fun x => f x.1 (H _ x.2) := by
   cases xs
   simp [List.pmap_eq_map_attach]
 
 @[simp]
-theorem pmap_eq_attachWith {p q : α → Prop} (f : ∀ a, p a → q a) (xs H) :
+theorem pmap_eq_attachWith {p q : α → Prop} {f : ∀ a, p a → q a} {xs : Array α} (H) :
     pmap (fun a h => ⟨a, f a h⟩) xs H = xs.attachWith q (fun x h => f x (H x h)) := by
   cases xs
   simp [List.pmap_eq_attachWith]
@@ -172,17 +172,18 @@ theorem attach_map_val (xs : Array α) (f : α → β) :
 @[deprecated attach_map_val (since := "2025-02-17")]
 abbrev attach_map_coe := @attach_map_val
 
+-- The argument `xs : Array α` is explicit to allow rewriting from right to left.
 theorem attach_map_subtype_val (xs : Array α) : xs.attach.map Subtype.val = xs := by
   cases xs; simp
 
-theorem attachWith_map_val {p : α → Prop} (f : α → β) (xs : Array α) (H : ∀ a ∈ xs, p a) :
+theorem attachWith_map_val {p : α → Prop} {f : α → β} {xs : Array α} (H : ∀ a ∈ xs, p a) :
     ((xs.attachWith p H).map fun (i : { i // p i}) => f i) = xs.map f := by
   cases xs; simp
 
 @[deprecated attachWith_map_val (since := "2025-02-17")]
 abbrev attachWith_map_coe := @attachWith_map_val
 
-theorem attachWith_map_subtype_val {p : α → Prop} (xs : Array α) (H : ∀ a ∈ xs, p a) :
+theorem attachWith_map_subtype_val {p : α → Prop} {xs : Array α} (H : ∀ a ∈ xs, p a) :
     (xs.attachWith p H).map Subtype.val = xs := by
   cases xs; simp
 
@@ -194,7 +195,7 @@ theorem mem_attach (xs : Array α) : ∀ x, x ∈ xs.attach
     exact m
 
 @[simp]
-theorem mem_attachWith (xs : Array α) {q : α → Prop} (H) (x : {x // q x}) :
+theorem mem_attachWith {xs : Array α} {q : α → Prop} (H) (x : {x // q x}) :
     x ∈ xs.attachWith q H ↔ x.1 ∈ xs := by
   cases xs
   simp
@@ -250,10 +251,11 @@ theorem attachWith_ne_empty_iff {xs : Array α} {P : α → Prop} {H : ∀ a ∈
   cases xs; simp
 
 @[simp]
-theorem getElem?_pmap {p : α → Prop} (f : ∀ a, p a → β) {xs : Array α} (h : ∀ a ∈ xs, p a) (i : Nat) :
+theorem getElem?_pmap {p : α → Prop} {f : ∀ a, p a → β} {xs : Array α} (h : ∀ a ∈ xs, p a) (i : Nat) :
     (pmap f xs h)[i]? = Option.pmap f xs[i]? fun x H => h x (mem_of_getElem? H) := by
   cases xs; simp
 
+-- The argument `f` is explicit to allow rewriting from right to left.
 @[simp]
 theorem getElem_pmap {p : α → Prop} (f : ∀ a, p a → β) {xs : Array α} (h : ∀ a ∈ xs, p a) {i : Nat}
     (hi : i < (pmap f xs h).size) :
@@ -283,37 +285,37 @@ theorem getElem_attach {xs : Array α} {i : Nat} (h : i < xs.attach.size) :
     xs.attach[i] = ⟨xs[i]'(by simpa using h), getElem_mem (by simpa using h)⟩ :=
   getElem_attachWith h
 
-@[simp] theorem pmap_attach (xs : Array α) {p : {x // x ∈ xs} → Prop} (f : ∀ a, p a → β) (H) :
+@[simp] theorem pmap_attach {xs : Array α} {p : {x // x ∈ xs} → Prop} {f : ∀ a, p a → β} (H) :
     pmap f xs.attach H =
       xs.pmap (P := fun a => ∃ h : a ∈ xs, p ⟨a, h⟩)
         (fun a h => f ⟨a, h.1⟩ h.2) (fun a h => ⟨h, H ⟨a, h⟩ (by simp)⟩) := by
   ext <;> simp
 
-@[simp] theorem pmap_attachWith (xs : Array α) {p : {x // q x} → Prop} (f : ∀ a, p a → β) (H₁ H₂) :
+@[simp] theorem pmap_attachWith {xs : Array α} {p : {x // q x} → Prop} {f : ∀ a, p a → β} (H₁ H₂) :
     pmap f (xs.attachWith q H₁) H₂ =
       xs.pmap (P := fun a => ∃ h : q a, p ⟨a, h⟩)
         (fun a h => f ⟨a, h.1⟩ h.2) (fun a h => ⟨H₁ _ h, H₂ ⟨a, H₁ _ h⟩ (by simpa)⟩) := by
   ext <;> simp
 
-theorem foldl_pmap (xs : Array α) {P : α → Prop} (f : (a : α) → P a → β)
-  (H : ∀ (a : α), a ∈ xs → P a) (g : γ → β → γ) (x : γ) :
+theorem foldl_pmap {xs : Array α} {P : α → Prop} {f : (a : α) → P a → β}
+    (H : ∀ (a : α), a ∈ xs → P a) (g : γ → β → γ) (x : γ) :
     (xs.pmap f H).foldl g x = xs.attach.foldl (fun acc a => g acc (f a.1 (H _ a.2))) x := by
   rw [pmap_eq_map_attach, foldl_map]
 
-theorem foldr_pmap (xs : Array α) {P : α → Prop} (f : (a : α) → P a → β)
-  (H : ∀ (a : α), a ∈ xs → P a) (g : β → γ → γ) (x : γ) :
+theorem foldr_pmap {xs : Array α} {P : α → Prop} {f : (a : α) → P a → β}
+    (H : ∀ (a : α), a ∈ xs → P a) (g : β → γ → γ) (x : γ) :
     (xs.pmap f H).foldr g x = xs.attach.foldr (fun a acc => g (f a.1 (H _ a.2)) acc) x := by
   rw [pmap_eq_map_attach, foldr_map]
 
 @[simp] theorem foldl_attachWith
-    (xs : Array α) {q : α → Prop} (H : ∀ a, a ∈ xs → q a) {f : β → { x // q x} → β} {b} (w : stop = xs.size) :
+    {xs : Array α} {q : α → Prop} (H : ∀ a, a ∈ xs → q a) {f : β → { x // q x} → β} {b} (w : stop = xs.size) :
     (xs.attachWith q H).foldl f b 0 stop = xs.attach.foldl (fun b ⟨a, h⟩ => f b ⟨a, H _ h⟩) b := by
   subst w
   rcases xs with ⟨xs⟩
   simp [List.foldl_attachWith, List.foldl_map]
 
 @[simp] theorem foldr_attachWith
-    (xs : Array α) {q : α → Prop} (H : ∀ a, a ∈ xs → q a) {f : { x // q x} → β → β} {b} (w : start = xs.size) :
+    {xs : Array α} {q : α → Prop} (H : ∀ a, a ∈ xs → q a) {f : { x // q x} → β → β} {b} (w : start = xs.size) :
     (xs.attachWith q H).foldr f b start 0 = xs.attach.foldr (fun a acc => f ⟨a.1, H _ a.2⟩ acc) b := by
   subst w
   rcases xs with ⟨xs⟩
@@ -329,7 +331,7 @@ Unfortunately this can't be applied by `simp` because of the higher order unific
 and even when rewriting we need to specify the function explicitly.
 See however `foldl_subtype` below.
 -/
-theorem foldl_attach (xs : Array α) (f : β → α → β) (b : β) :
+theorem foldl_attach {xs : Array α} {f : β → α → β} {b : β} :
     xs.attach.foldl (fun acc t => f acc t.1) b = xs.foldl f b := by
   rcases xs with ⟨xs⟩
   simp only [List.attach_toArray, List.attachWith_mem_toArray, List.size_toArray,
@@ -348,7 +350,7 @@ Unfortunately this can't be applied by `simp` because of the higher order unific
 and even when rewriting we need to specify the function explicitly.
 See however `foldr_subtype` below.
 -/
-theorem foldr_attach (xs : Array α) (f : α → β → β) (b : β) :
+theorem foldr_attach {xs : Array α} {f : α → β → β} {b : β} :
     xs.attach.foldr (fun t acc => f t.1 acc) b = xs.foldr f b := by
   rcases xs with ⟨xs⟩
   simp only [List.attach_toArray, List.attachWith_mem_toArray, List.size_toArray,
@@ -357,31 +359,31 @@ theorem foldr_attach (xs : Array α) (f : α → β → β) (b : β) :
   ext
   simpa using fun a => List.mem_of_getElem? a
 
-theorem attach_map {xs : Array α} (f : α → β) :
-    (xs.map f).attach = xs.attach.map (fun ⟨x, h⟩ => ⟨f x, mem_map_of_mem f h⟩) := by
+theorem attach_map {xs : Array α} {f : α → β} :
+    (xs.map f).attach = xs.attach.map (fun ⟨x, h⟩ => ⟨f x, mem_map_of_mem h⟩) := by
   cases xs
   ext <;> simp
 
-theorem attachWith_map {xs : Array α} (f : α → β) {P : β → Prop} {H : ∀ (b : β), b ∈ xs.map f → P b} :
-    (xs.map f).attachWith P H = (xs.attachWith (P ∘ f) (fun _ h => H _ (mem_map_of_mem f h))).map
+theorem attachWith_map {xs : Array α} {f : α → β} {P : β → Prop} (H : ∀ (b : β), b ∈ xs.map f → P b) :
+    (xs.map f).attachWith P H = (xs.attachWith (P ∘ f) (fun _ h => H _ (mem_map_of_mem h))).map
       fun ⟨x, h⟩ => ⟨f x, h⟩ := by
   cases xs
   simp [List.attachWith_map]
 
 @[simp] theorem map_attachWith {xs : Array α} {P : α → Prop} {H : ∀ (a : α), a ∈ xs → P a}
-    (f : { x // P x } → β) :
+    {f : { x // P x } → β} :
     (xs.attachWith P H).map f = xs.attach.map fun ⟨x, h⟩ => f ⟨x, H _ h⟩ := by
   cases xs <;> simp_all
 
 theorem map_attachWith_eq_pmap {xs : Array α} {P : α → Prop} {H : ∀ (a : α), a ∈ xs → P a}
-    (f : { x // P x } → β) :
+    {f : { x // P x } → β} :
     (xs.attachWith P H).map f =
       xs.pmap (fun a (h : a ∈ xs ∧ P a) => f ⟨a, H _ h.1⟩) (fun a h => ⟨h, H a h⟩) := by
   cases xs
   ext <;> simp
 
 /-- See also `pmap_eq_map_attach` for writing `pmap` in terms of `map` and `attach`. -/
-theorem map_attach_eq_pmap {xs : Array α} (f : { x // x ∈ xs } → β) :
+theorem map_attach_eq_pmap {xs : Array α} {f : { x // x ∈ xs } → β} :
     xs.attach.map f = xs.pmap (fun a h => f ⟨a, h⟩) (fun _ => id) := by
   cases xs
   ext <;> simp
@@ -393,14 +395,14 @@ theorem attach_filterMap {xs : Array α} {f : α → Option β} :
     (xs.filterMap f).attach = xs.attach.filterMap
       fun ⟨x, h⟩ => (f x).pbind (fun b m => some ⟨b, mem_filterMap.mpr ⟨x, h, m⟩⟩) := by
   cases xs
-  rw [attach_congr (List.filterMap_toArray f _)]
+  rw [attach_congr List.filterMap_toArray]
   simp [List.attach_filterMap, List.map_filterMap, Function.comp_def]
 
 theorem attach_filter {xs : Array α} (p : α → Bool) :
     (xs.filter p).attach = xs.attach.filterMap
       fun x => if w : p x.1 then some ⟨x.1, mem_filter.mpr ⟨x.2, w⟩⟩ else none := by
   cases xs
-  rw [attach_congr (List.filter_toArray p _)]
+  rw [attach_congr List.filter_toArray]
   simp [List.attach_filter, List.map_filterMap, Function.comp_def]
 
 -- We are still missing here `attachWith_filterMap` and `attachWith_filter`.
@@ -422,14 +424,14 @@ theorem filter_attachWith {q : α → Prop} {xs : Array α} {p : {x // q x} →
   cases xs
   simp [Function.comp_def, List.filter_map]
 
-theorem pmap_pmap {p : α → Prop} {q : β → Prop} (g : ∀ a, p a → β) (f : ∀ b, q b → γ) (xs H₁ H₂) :
+theorem pmap_pmap {p : α → Prop} {q : β → Prop} {g : ∀ a, p a → β} {f : ∀ b, q b → γ} {xs} (H₁ H₂) :
     pmap f (pmap g xs H₁) H₂ =
       pmap (α := { x // x ∈ xs }) (fun a h => f (g a h) (H₂ (g a h) (mem_pmap_of_mem a.2))) xs.attach
         (fun a _ => H₁ a a.2) := by
   cases xs
   simp [List.pmap_pmap, List.pmap_map]
 
-@[simp] theorem pmap_append {p : ι → Prop} (f : ∀ a : ι, p a → α) (xs ys : Array ι)
+@[simp] theorem pmap_append {p : ι → Prop} {f : ∀ a : ι, p a → α} {xs ys : Array ι}
     (h : ∀ a ∈ xs ++ ys, p a) :
     (xs ++ ys).pmap f h =
       (xs.pmap f fun a ha => h a (mem_append_left ys ha)) ++
@@ -438,13 +440,13 @@ theorem pmap_pmap {p : α → Prop} {q : β → Prop} (g : ∀ a, p a → β) (f
   cases ys
   simp
 
-theorem pmap_append' {p : α → Prop} (f : ∀ a : α, p a → β) (xs ys : Array α)
+theorem pmap_append' {p : α → Prop} {f : ∀ a : α, p a → β} {xs ys : Array α}
     (h₁ : ∀ a ∈ xs, p a) (h₂ : ∀ a ∈ ys, p a) :
     ((xs ++ ys).pmap f fun a ha => (mem_append.1 ha).elim (h₁ a) (h₂ a)) =
       xs.pmap f h₁ ++ ys.pmap f h₂ :=
-  pmap_append f xs ys _
+  pmap_append _
 
-@[simp] theorem attach_append (xs ys : Array α) :
+@[simp] theorem attach_append {xs ys : Array α} :
     (xs ++ ys).attach = xs.attach.map (fun ⟨x, h⟩ => ⟨x, mem_append_left ys h⟩) ++
       ys.attach.map fun ⟨x, h⟩ => ⟨x, mem_append_right xs h⟩ := by
   cases xs
@@ -458,12 +460,12 @@ theorem pmap_append' {p : α → Prop} (f : ∀ a : α, p a → β) (xs ys : Arr
       ys.attachWith P (fun a h => H a (mem_append_right xs h)) := by
   simp [attachWith, attach_append, map_pmap, pmap_append]
 
-@[simp] theorem pmap_reverse {P : α → Prop} (f : (a : α) → P a → β) (xs : Array α)
+@[simp] theorem pmap_reverse {P : α → Prop} {f : (a : α) → P a → β} {xs : Array α}
     (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 : Array α)
+theorem reverse_pmap {P : α → Prop} {f : (a : α) → P a → β} {xs : Array α}
     (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]
@@ -481,18 +483,18 @@ theorem reverse_attachWith {P : α → Prop} {xs : Array α}
   cases xs
   simp
 
-@[simp] theorem attach_reverse (xs : Array α) :
+@[simp] theorem attach_reverse {xs : Array α} :
     xs.reverse.attach = xs.attach.reverse.map fun ⟨x, h⟩ => ⟨x, by simpa using h⟩ := by
   cases xs
-  rw [attach_congr (List.reverse_toArray _)]
+  rw [attach_congr List.reverse_toArray]
   simp
 
-theorem reverse_attach (xs : Array α) :
+theorem reverse_attach {xs : Array α} :
     xs.attach.reverse = xs.reverse.attach.map fun ⟨x, h⟩ => ⟨x, by simpa using h⟩ := by
   cases xs
   simp
 
-@[simp] theorem back?_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : Array α)
+@[simp] theorem back?_pmap {P : α → Prop} {f : (a : α) → P a → β} {xs : Array α}
     (H : ∀ (a : α), a ∈ xs → P a) :
     (xs.pmap f H).back? = xs.attach.back?.map fun ⟨a, m⟩ => f a (H a m) := by
   cases xs
@@ -511,19 +513,19 @@ theorem back?_attach {xs : Array α} :
   simp
 
 @[simp]
-theorem countP_attach (xs : Array α) (p : α → Bool) :
+theorem countP_attach {xs : Array α} {p : α → Bool} :
     xs.attach.countP (fun a : {x // x ∈ xs} => p a) = xs.countP p := by
   cases xs
   simp [Function.comp_def]
 
 @[simp]
-theorem countP_attachWith {p : α → Prop} (xs : Array α) (H : ∀ a ∈ xs, p a) (q : α → Bool) :
+theorem countP_attachWith {p : α → Prop} {q : α → Bool} {xs : Array α} {H : ∀ a ∈ xs, p a} :
     (xs.attachWith p H).countP (fun a : {x // p x} => q a) = xs.countP q := by
   cases xs
   simp
 
 @[simp]
-theorem count_attach [DecidableEq α] (xs : Array α) (a : {x // x ∈ xs}) :
+theorem count_attach [BEq α] {xs : Array α} {a : {x // x ∈ xs}} :
     xs.attach.count a = xs.count ↑a := by
   rcases xs with ⟨xs⟩
   simp only [List.attach_toArray, List.attachWith_mem_toArray, List.count_toArray]
@@ -532,12 +534,12 @@ theorem count_attach [DecidableEq α] (xs : Array α) (a : {x // x ∈ xs}) :
   rw [List.countP_pmap, List.countP_attach (p := (fun x => x == a.1)), List.count]
 
 @[simp]
-theorem count_attachWith [DecidableEq α] {p : α → Prop} (xs : Array α) (H : ∀ a ∈ xs, p a) (a : {x // p x}) :
+theorem count_attachWith [BEq α] {p : α → Prop} {xs : Array α} (H : ∀ a ∈ xs, p a) {a : {x // p x}} :
     (xs.attachWith p H).count a = xs.count ↑a := by
   cases xs
   simp
 
-@[simp] theorem countP_pmap {p : α → Prop} (g : ∀ a, p a → β) (f : β → Bool) (xs : Array α) (H₁) :
+@[simp] theorem countP_pmap {p : α → Prop} {g : ∀ a, p a → β} {f : β → Bool} {xs : Array α} (H₁) :
     (xs.pmap g H₁).countP f =
       xs.attach.countP (fun ⟨a, m⟩ => f (g a (H₁ a m))) := by
   simp [pmap_eq_map_attach, countP_map, Function.comp_def]
@@ -752,65 +754,64 @@ abbrev unattach_mkArray := @unattach_replicate
 
 /-! ### Well-founded recursion preprocessing setup -/
 
-@[wf_preprocess] theorem Array.map_wfParam (xs : Array α) (f : α → β) :
+@[wf_preprocess] theorem map_wfParam {xs : Array α} {f : α → β} :
     (wfParam xs).map f = xs.attach.unattach.map f := by
   simp [wfParam]
 
-@[wf_preprocess] theorem Array.map_unattach (P : α → Prop) (xs : Array (Subtype P)) (f : α → β) :
+@[wf_preprocess] theorem map_unattach {P : α → Prop} {xs : Array (Subtype P)} {f : α → β} :
     xs.unattach.map f = xs.map fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x) := by
   simp [wfParam]
 
-@[wf_preprocess] theorem foldl_wfParam (xs : Array α) (f : β → α → β) (x : β) :
+@[wf_preprocess] theorem foldl_wfParam {xs : Array α} {f : β → α → β} {x : β} :
     (wfParam xs).foldl f x = xs.attach.unattach.foldl f x := by
   simp [wfParam]
 
-@[wf_preprocess] theorem foldl_unattach (P : α → Prop) (xs : Array (Subtype P)) (f : β → α → β) (x : β):
+@[wf_preprocess] theorem foldl_unattach {P : α → Prop} {xs : Array (Subtype P)} {f : β → α → β} {x : β} :
     xs.unattach.foldl f x = xs.foldl (fun s ⟨x, h⟩ =>
       binderNameHint s f <| binderNameHint x (f s) <| binderNameHint h () <| f s (wfParam x)) x := by
   simp [wfParam]
 
-@[wf_preprocess] theorem foldr_wfParam (xs : Array α) (f : α → β → β) (x : β) :
+@[wf_preprocess] theorem foldr_wfParam {xs : Array α} {f : α → β → β} {x : β} :
     (wfParam xs).foldr f x = xs.attach.unattach.foldr f x := by
   simp [wfParam]
 
-@[wf_preprocess] theorem foldr_unattach (P : α → Prop) (xs : Array (Subtype P)) (f : α → β → β) (x : β):
+@[wf_preprocess] theorem foldr_unattach {P : α → Prop} {xs : Array (Subtype P)} {f : α → β → β} {x : β} :
     xs.unattach.foldr f x = xs.foldr (fun ⟨x, h⟩ s =>
       binderNameHint x f <| binderNameHint s (f x) <| binderNameHint h () <| f (wfParam x) s) x := by
   simp [wfParam]
 
-@[wf_preprocess] theorem filter_wfParam (xs : Array α) (f : α → Bool) :
+@[wf_preprocess] theorem filter_wfParam {xs : Array α} {f : α → Bool} :
     (wfParam xs).filter f = xs.attach.unattach.filter f:= by
   simp [wfParam]
 
-@[wf_preprocess] theorem filter_unattach (P : α → Prop) (xs : Array (Subtype P)) (f : α → Bool) :
+@[wf_preprocess] theorem filter_unattach {P : α → Prop} {xs : Array (Subtype P)} {f : α → Bool} :
     xs.unattach.filter f = (xs.filter (fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x))).unattach := by
   simp [wfParam]
 
-@[wf_preprocess] theorem reverse_wfParam (xs : Array α) :
+@[wf_preprocess] theorem reverse_wfParam {xs : Array α} :
     (wfParam xs).reverse = xs.attach.unattach.reverse := by simp [wfParam]
 
-@[wf_preprocess] theorem reverse_unattach (P : α → Prop) (xs : Array (Subtype P)) :
+@[wf_preprocess] theorem reverse_unattach {P : α → Prop} {xs : Array (Subtype P)} :
     xs.unattach.reverse = xs.reverse.unattach := by simp
 
-@[wf_preprocess] theorem filterMap_wfParam (xs : Array α) (f : α → Option β) :
+@[wf_preprocess] theorem filterMap_wfParam {xs : Array α} {f : α → Option β} :
     (wfParam xs).filterMap f = xs.attach.unattach.filterMap f := by
   simp [wfParam]
 
-@[wf_preprocess] theorem filterMap_unattach (P : α → Prop) (xs : Array (Subtype P)) (f : α → Option β) :
+@[wf_preprocess] theorem filterMap_unattach {P : α → Prop} {xs : Array (Subtype P)} {f : α → Option β} :
     xs.unattach.filterMap f = xs.filterMap fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x) := by
   simp [wfParam]
 
-@[wf_preprocess] theorem flatMap_wfParam (xs : Array α) (f : α → Array β) :
+@[wf_preprocess] theorem flatMap_wfParam {xs : Array α} {f : α → Array β} :
     (wfParam xs).flatMap f = xs.attach.unattach.flatMap f := by
   simp [wfParam]
 
-@[wf_preprocess] theorem flatMap_unattach (P : α → Prop) (xs : Array (Subtype P)) (f : α → Array β) :
+@[wf_preprocess] theorem flatMap_unattach {P : α → Prop} {xs : Array (Subtype P)} {f : α → Array β} :
     xs.unattach.flatMap f = xs.flatMap fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x) := by
   simp [wfParam]
 
-
 end Array

src/Init/Data/Array/Basic.lean

@@ -38,14 +38,14 @@ namespace Array
 
 /-! ### Preliminary theorems -/
 
-@[simp] theorem size_set (xs : Array α) (i : Nat) (v : α) (h : i < xs.size) :
+@[simp] theorem size_set {xs : Array α} {i : Nat} {v : α} (h : i < xs.size) :
     (set xs i v h).size = xs.size :=
   List.length_set ..
 
-@[simp] theorem size_push (xs : Array α) (v : α) : (push xs v).size = xs.size + 1 :=
+@[simp] theorem size_push {xs : Array α} (v : α) : (push xs v).size = xs.size + 1 :=
   List.length_concat ..
 
-theorem ext (xs ys : Array α)
+theorem ext {xs ys : Array α}
     (h₁ : xs.size = ys.size)
     (h₂ : (i : Nat) → (hi₁ : i < xs.size) → (hi₂ : i < ys.size) → xs[i] = ys[i])
     : xs = ys := by
@@ -83,10 +83,10 @@ theorem ext (xs ys : Array α)
 theorem ext' {xs ys : Array α} (h : xs.toList = ys.toList) : xs = ys := by
   cases xs; cases ys; 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).toList = acc.toList ++ as := by
   induction as generalizing acc <;> simp [*, List.toArrayAux, Array.push, List.append_assoc, List.concat_eq_append]
 
-@[simp] theorem toArray_toList (xs : Array α) : xs.toList.toArray = xs := rfl
+@[simp] theorem toArray_toList {xs : Array α} : xs.toList.toArray = xs := rfl
 
 @[simp] theorem getElem_toList {xs : Array α} {i : Nat} (h : i < xs.size) : xs.toList[i] = xs[i] := rfl
 
@@ -120,12 +120,12 @@ namespace List
 abbrev toArray_toList := @Array.toArray_toList
 
 -- This does not need to be a simp lemma, as already after the `whnfR` the right hand side is `as`.
-theorem toList_toArray (as : List α) : as.toArray.toList = as := rfl
+theorem toList_toArray {as : List α} : as.toArray.toList = as := rfl
 
 @[deprecated toList_toArray (since := "2025-02-17")]
 abbrev _root_.Array.toList_toArray := @List.toList_toArray
 
-@[simp] theorem size_toArray (as : List α) : as.toArray.size = as.length := by simp [Array.size]
+@[simp] theorem size_toArray {as : List α} : as.toArray.size = as.length := by simp [Array.size]
 
 @[deprecated size_toArray (since := "2025-02-17")]
 abbrev _root_.Array.size_toArray := @List.size_toArray
@@ -144,7 +144,7 @@ end List
 
 namespace Array
 
-theorem size_eq_length_toList (xs : Array α) : xs.size = xs.toList.length := rfl
+theorem size_eq_length_toList {xs : Array α} : xs.size = xs.toList.length := rfl
 
 @[deprecated toList_toArray (since := "2024-09-09")] abbrev data_toArray := @List.toList_toArray
 
@@ -192,7 +192,7 @@ Examples:
 def pop (xs : Array α) : Array α where
   toList := xs.toList.dropLast
 
-@[simp] theorem size_pop (xs : Array α) : xs.pop.size = xs.size - 1 := by
+@[simp] theorem size_pop {xs : Array α} : xs.pop.size = xs.size - 1 := by
   match xs with
   | ⟨[]⟩ => rfl
   | ⟨a::as⟩ => simp [pop, Nat.succ_sub_succ_eq_sub, size]
@@ -240,11 +240,11 @@ def swap (xs : Array α) (i j : @& Nat) (hi : i < xs.size := by get_elem_tactic)
   let v₁ := xs[i]
   let v₂ := xs[j]
   let xs'  := xs.set i v₂
-  xs'.set j v₁ (Nat.lt_of_lt_of_eq hj (size_set xs i v₂ _).symm)
+  xs'.set j v₁ (Nat.lt_of_lt_of_eq hj (size_set _).symm)
 
-@[simp] theorem size_swap (xs : Array α) (i j : Nat) {hi hj} : (xs.swap i j hi hj).size = xs.size := by
+@[simp] theorem size_swap {xs : Array α} {i j : Nat} {hi hj} : (xs.swap i j hi hj).size = xs.size := by
   show ((xs.set i xs[j]).set j xs[i]
-    (Nat.lt_of_lt_of_eq hj (size_set xs i xs[j] _).symm)).size = xs.size
+    (Nat.lt_of_lt_of_eq hj (size_set _).symm)).size = xs.size
   rw [size_set, size_set]
 
 /--
@@ -465,7 +465,7 @@ Examples:
 -/
 abbrev take (xs : Array α) (i : Nat) : Array α := extract xs 0 i
 
-@[simp] theorem take_eq_extract (xs : Array α) (i : Nat) : xs.take i = xs.extract 0 i := rfl
+@[simp] theorem take_eq_extract {xs : Array α} {i : Nat} : xs.take i = xs.extract 0 i := rfl
 
 /--
 Removes the first `i` elements of `xs`. If `xs` has fewer than `i` elements, the new array is empty.
@@ -479,7 +479,7 @@ Examples:
 -/
 abbrev drop (xs : Array α) (i : Nat) : Array α := extract xs i xs.size
 
-@[simp] theorem drop_eq_extract (xs : Array α) (i : Nat) : xs.drop i = xs.extract i xs.size := rfl
+@[simp] theorem drop_eq_extract {xs : Array α} {i : Nat} : xs.drop i = xs.extract i xs.size := rfl
 
 @[inline]
 unsafe def modifyMUnsafe [Monad m] (xs : Array α) (i : Nat) (f : α → m α) : m (Array α) := do
@@ -490,7 +490,7 @@ unsafe def modifyMUnsafe [Monad m] (xs : Array α) (i : Nat) (f : α → m α) :
     -- of the element type, and that it is valid to store `box(0)` in any array.
     let xs'               := xs.set i (unsafeCast ())
     let v ← f v
-    pure <| xs'.set i v (Nat.lt_of_lt_of_eq h (size_set xs ..).symm)
+    pure <| xs'.set i v (Nat.lt_of_lt_of_eq h (size_set ..).symm)
   else
     pure xs
 
@@ -1026,7 +1026,7 @@ instance : ForM m (Array α) α where
   forM xs f := Array.forM f xs
 
 -- We simplify `Array.forM` to `forM`.
-@[simp] theorem forM_eq_forM [Monad m] (f : α → m PUnit) :
+@[simp] theorem forM_eq_forM [Monad m] {f : α → m PUnit} :
     Array.forM f as 0 as.size = forM as f := rfl
 
 /--
@@ -1735,7 +1735,7 @@ def popWhile (p : α → Bool) (as : Array α) : Array α :=
     as
 decreasing_by simp_wf; decreasing_trivial_pre_omega
 
-@[simp] theorem popWhile_empty (p : α → Bool) :
+@[simp] theorem popWhile_empty {p : α → Bool} :
     popWhile p #[] = #[] := by
   simp [popWhile]
 
@@ -1784,7 +1784,7 @@ termination_by xs.size - i
 decreasing_by simp_wf; exact Nat.sub_succ_lt_self _ _ h
 
 -- This is required in `Lean.Data.PersistentHashMap`.
-@[simp] theorem size_eraseIdx (xs : Array α) (i : Nat) (h) : (xs.eraseIdx i h).size = xs.size - 1 := by
+@[simp] theorem size_eraseIdx {xs : Array α} (i : Nat) (h) : (xs.eraseIdx i h).size = xs.size - 1 := by
   induction xs, i, h using Array.eraseIdx.induct with
   | @case1 xs i h h' xs' ih =>
     unfold eraseIdx

src/Init/Data/Array/BasicAux.lean

@@ -17,7 +17,7 @@ theorem Array.of_push_eq_push {as bs : Array α} (h : as.push a = bs.push b) : a
   cases as; cases bs
   simp_all
 
-private theorem List.size_toArrayAux (as : List α) (bs : Array α) : (as.toArrayAux bs).size = as.length + bs.size := by
+private theorem List.size_toArrayAux {as : List α} {bs : Array α} : (as.toArrayAux bs).size = as.length + bs.size := by
   induction as generalizing bs with
   | nil => simp [toArrayAux]
   | cons a as ih => simp +arith [toArrayAux, *]
@@ -35,7 +35,7 @@ private theorem List.of_toArrayAux_eq_toArrayAux {as bs : List α} {cs ds : Arra
     have := Array.of_push_eq_push ih₂
     simp [this]
 
-theorem List.toArray_eq_toArray_eq (as bs : List α) : (as.toArray = bs.toArray) = (as = bs) := by
+theorem List.toArray_eq_toArray_eq {as bs : List α} : (as.toArray = bs.toArray) = (as = bs) := by
   simp
 
 /--

src/Init/Data/Array/Bootstrap.lean

@@ -42,35 +42,35 @@ def get! {α : Type u} [Inhabited α] (a : @& Array α) (i : @& Nat) : α :=
   Array.getD a i default
 
 theorem foldlM_toList.aux [Monad m]
-    (f : β → α → m β) (xs : Array α) (i j) (H : xs.size ≤ i + j) (b) :
+    {f : β → α → m β} {xs : Array α} {i j} (H : xs.size ≤ i + j) {b} :
     foldlM.loop f xs xs.size (Nat.le_refl _) i j b = (xs.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_toList.aux f xs i (j+1) H]
+    simp [foldlM_toList.aux (j := j+1) H]
     rw (occs := [2]) [← List.getElem_cons_drop_succ_eq_drop ‹_›]
     rfl
   · rw [List.drop_of_length_le (Nat.ge_of_not_lt ‹_›)]; rfl
 
 @[simp] theorem foldlM_toList [Monad m]
-    (f : β → α → m β) (init : β) (xs : Array α) :
+    {f : β → α → m β} {init : β} {xs : Array α} :
     xs.toList.foldlM f init = xs.foldlM f init := by
   simp [foldlM, foldlM_toList.aux]
 
-@[simp] theorem foldl_toList (f : β → α → β) (init : β) (xs : Array α) :
+@[simp] theorem foldl_toList (f : β → α → β) {init : β} {xs : Array α} :
     xs.toList.foldl f init = xs.foldl f init :=
   List.foldl_eq_foldlM .. ▸ foldlM_toList ..
 
 theorem foldrM_eq_reverse_foldlM_toList.aux [Monad m]
-    (f : α → β → m β) (xs : Array α) (init : β) (i h) :
+    {f : α → β → m β} {xs : Array α} {init : β} {i} (h) :
     (xs.toList.take i).reverse.foldlM (fun x y => f y x) init = foldrM.fold f xs 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 xs · i)]
+  | i+1 => rw [← List.take_concat_get h]; simp [← aux]
 
-theorem foldrM_eq_reverse_foldlM_toList [Monad m] (f : α → β → m β) (init : β) (xs : Array α) :
+theorem foldrM_eq_reverse_foldlM_toList [Monad m] {f : α → β → m β} {init : β} {xs : Array α} :
     xs.foldrM f init = xs.toList.reverse.foldlM (fun x y => f y x) init := by
   have : xs = #[] ∨ 0 < xs.size :=
     match xs with | ⟨[]⟩ => .inl rfl | ⟨a::l⟩ => .inr (Nat.zero_lt_succ _)
@@ -78,31 +78,31 @@ theorem foldrM_eq_reverse_foldlM_toList [Monad m] (f : α → β → m β) (init
   simp [foldrM, h, ← foldrM_eq_reverse_foldlM_toList.aux, List.take_length]
 
 @[simp] theorem foldrM_toList [Monad m]
-    (f : α → β → m β) (init : β) (xs : Array α) :
+    {f : α → β → m β} {init : β} {xs : Array α} :
     xs.toList.foldrM f init = xs.foldrM f init := by
   rw [foldrM_eq_reverse_foldlM_toList, List.foldlM_reverse]
 
-@[simp] theorem foldr_toList (f : α → β → β) (init : β) (xs : Array α) :
+@[simp] theorem foldr_toList (f : α → β → β) {init : β} {xs : Array α} :
     xs.toList.foldr f init = xs.foldr f init :=
   List.foldr_eq_foldrM .. ▸ foldrM_toList ..
 
-@[simp] theorem push_toList (xs : Array α) (a : α) : (xs.push a).toList = xs.toList ++ [a] := by
+@[simp] theorem push_toList {xs : Array α} {a : α} : (xs.push a).toList = xs.toList ++ [a] := by
   simp [push, List.concat_eq_append]
 
-@[simp] theorem toListAppend_eq (xs : Array α) (l : List α) : xs.toListAppend l = xs.toList ++ l := by
+@[simp] theorem toListAppend_eq {xs : Array α} {l : List α} : xs.toListAppend l = xs.toList ++ l := by
   simp [toListAppend, ← foldr_toList]
 
-@[simp] theorem toListImpl_eq (xs : Array α) : xs.toListImpl = xs.toList := by
+@[simp] theorem toListImpl_eq {xs : Array α} : xs.toListImpl = xs.toList := by
   simp [toListImpl, ← foldr_toList]
 
-@[simp] theorem toList_pop (xs : Array α) : xs.pop.toList = xs.toList.dropLast := rfl
+@[simp] theorem toList_pop {xs : Array α} : xs.pop.toList = xs.toList.dropLast := rfl
 
 @[deprecated toList_pop (since := "2025-02-17")]
 abbrev pop_toList := @Array.toList_pop
 
-@[simp] theorem append_eq_append (xs ys : Array α) : xs.append ys = xs ++ ys := rfl
+@[simp] theorem append_eq_append {xs ys : Array α} : xs.append ys = xs ++ ys := rfl
 
-@[simp] theorem toList_append (xs ys : Array α) :
+@[simp] theorem toList_append {xs ys : Array α} :
     (xs ++ ys).toList = xs.toList ++ ys.toList := by
   rw [← append_eq_append]; unfold Array.append
   rw [← foldl_toList]
@@ -110,25 +110,24 @@ abbrev pop_toList := @Array.toList_pop
 
 @[simp] theorem toList_empty : (#[] : Array α).toList = [] := rfl
 
-@[simp] theorem append_empty (xs : Array α) : xs ++ #[] = xs := by
+@[simp] theorem append_empty {xs : Array α} : xs ++ #[] = xs := by
   apply ext'; simp only [toList_append, toList_empty, List.append_nil]
 
 @[deprecated append_empty (since := "2025-01-13")]
 abbrev append_nil := @append_empty
 
-@[simp] theorem empty_append (xs : Array α) : #[] ++ xs = xs := by
+@[simp] theorem empty_append {xs : Array α} : #[] ++ xs = xs := by
   apply ext'; simp only [toList_append, toList_empty, List.nil_append]
 
 @[deprecated empty_append (since := "2025-01-13")]
 abbrev nil_append := @empty_append
 
-@[simp] theorem append_assoc (xs ys zs : Array α) : xs ++ ys ++ zs = xs ++ (ys ++ zs) := by
+@[simp] theorem append_assoc {xs ys zs : Array α} : xs ++ ys ++ zs = xs ++ (ys ++ zs) := by
   apply ext'; simp only [toList_append, List.append_assoc]
 
-@[simp] theorem appendList_eq_append
-    (xs : Array α) (l : List α) : xs.appendList l = xs ++ l := rfl
+@[simp] theorem appendList_eq_append {xs : Array α} {l : List α} : xs.appendList l = xs ++ l := rfl
 
-@[simp] theorem toList_appendList (xs : Array α) (l : List α) :
+@[simp] theorem toList_appendList {xs : Array α} {l : List α} :
     (xs ++ l).toList = xs.toList ++ l := by
   rw [← appendList_eq_append]; unfold Array.appendList
   induction l generalizing xs <;> simp [*]
@@ -138,25 +137,23 @@ abbrev appendList_toList := @toList_appendList
 
 @[deprecated "Use the reverse direction of `foldrM_toList`." (since := "2024-11-13")]
 theorem foldrM_eq_foldrM_toList [Monad m]
-    (f : α → β → m β) (init : β) (xs : Array α) :
+    {f : α → β → m β} {init : β} {xs : Array α} :
     xs.foldrM f init = xs.toList.foldrM f init := by
   simp
 
 @[deprecated "Use the reverse direction of `foldlM_toList`." (since := "2024-11-13")]
 theorem foldlM_eq_foldlM_toList [Monad m]
-    (f : β → α → m β) (init : β) (xs : Array α) :
+    {f : β → α → m β} {init : β} {xs : Array α} :
     xs.foldlM f init = xs.toList.foldlM f init:= by
   simp
 
 @[deprecated "Use the reverse direction of `foldr_toList`." (since := "2024-11-13")]
-theorem foldr_eq_foldr_toList
-    (f : α → β → β) (init : β) (xs : Array α) :
+theorem foldr_eq_foldr_toList {f : α → β → β} {init : β} {xs : Array α} :
     xs.foldr f init = xs.toList.foldr f init := by
   simp
 
 @[deprecated "Use the reverse direction of `foldl_toList`." (since := "2024-11-13")]
-theorem foldl_eq_foldl_toList
-    (f : β → α → β) (init : β) (xs : Array α) :
+theorem foldl_eq_foldl_toList {f : β → α → β} {init : β} {xs : Array α} :
     xs.foldl f init = xs.toList.foldl f init:= by
   simp
 

src/Init/Data/Array/Count.lean

@@ -21,9 +21,9 @@ open Nat
 /-! ### countP -/
 section countP
 
-variable (p q : α → Bool)
+variable {p q : α → Bool}
 
-@[simp] theorem _root_.List.countP_toArray (l : List α) : countP p l.toArray = l.countP p := by
+@[simp] theorem _root_.List.countP_toArray {l : List α} : countP p l.toArray = l.countP p := by
   simp [countP]
   induction l with
   | nil => rfl
@@ -31,32 +31,32 @@ variable (p q : α → Bool)
     simp only [List.foldr_cons, ih, List.countP_cons]
     split <;> simp_all
 
-@[simp] theorem countP_toList (xs : Array α) : xs.toList.countP p = countP p xs := by
+@[simp] theorem countP_toList {xs : Array α} : xs.toList.countP p = countP p xs := by
   cases xs
   simp
 
 @[simp] theorem countP_empty : countP p #[] = 0 := rfl
 
-@[simp] theorem countP_push_of_pos (xs) (pa : p a) : countP p (xs.push a) = countP p xs + 1 := by
+@[simp] theorem countP_push_of_pos {xs : Array α} (pa : p a) : countP p (xs.push a) = countP p xs + 1 := by
   rcases xs with ⟨xs⟩
   simp_all
 
-@[simp] theorem countP_push_of_neg (xs) (pa : ¬p a) : countP p (xs.push a) = countP p xs := by
+@[simp] theorem countP_push_of_neg {xs : Array α} (pa : ¬p a) : countP p (xs.push a) = countP p xs := by
   rcases xs with ⟨xs⟩
   simp_all
 
-theorem countP_push (a : α) (xs) : countP p (xs.push a) = countP p xs + if p a then 1 else 0 := by
+theorem countP_push {a : α} {xs : Array α} : countP p (xs.push a) = countP p xs + if p a then 1 else 0 := by
   rcases xs with ⟨xs⟩
   simp_all
 
-@[simp] theorem countP_singleton (a : α) : countP p #[a] = if p a then 1 else 0 := by
+@[simp] theorem countP_singleton {a : α} : countP p #[a] = if p a then 1 else 0 := by
   simp [countP_push]
 
-theorem size_eq_countP_add_countP (xs) : xs.size = countP p xs + countP (fun a => ¬p a) xs := by
+theorem size_eq_countP_add_countP {xs : Array α} : xs.size = countP p xs + countP (fun a => ¬p a) xs := by
   rcases xs with ⟨xs⟩
   simp [List.length_eq_countP_add_countP (p := p)]
 
-theorem countP_eq_size_filter (xs) : countP p xs = (filter p xs).size := by
+theorem countP_eq_size_filter {xs : Array α} : countP p xs = (filter p xs).size := by
   rcases xs with ⟨xs⟩
   simp [List.countP_eq_length_filter]
 
@@ -68,7 +68,7 @@ theorem countP_le_size : countP p xs ≤ xs.size := by
   simp only [countP_eq_size_filter]
   apply size_filter_le
 
-@[simp] theorem countP_append (xs ys) : countP p (xs ++ ys) = countP p xs + countP p ys := by
+@[simp] theorem countP_append {xs ys : Array α} : countP p (xs ++ ys) = countP p xs + countP p ys := by
   rcases xs with ⟨xs⟩
   rcases ys with ⟨ys⟩
   simp
@@ -88,24 +88,23 @@ theorem countP_le_size : countP p xs ≤ xs.size := by
   rcases xs with ⟨xs⟩
   simp
 
-theorem countP_replicate (p : α → Bool) (a : α) (n : Nat) :
-    countP p (replicate n a) = if p a then n else 0 := by
+theorem countP_replicate {a : α} {n : Nat} : countP p (replicate n a) = if p a then n else 0 := by
   simp [← List.toArray_replicate, List.countP_replicate]
 
 @[deprecated countP_replicate (since := "2025-03-18")]
 abbrev countP_mkArray := @countP_replicate
 
-theorem boole_getElem_le_countP (p : α → Bool) (xs : Array α) (i : Nat) (h : i < xs.size) :
+theorem boole_getElem_le_countP {xs : Array α} {i : Nat} (h : i < xs.size) :
     (if p xs[i] then 1 else 0) ≤ xs.countP p := by
   rcases xs with ⟨xs⟩
   simp [List.boole_getElem_le_countP]
 
-theorem countP_set (p : α → Bool) (xs : Array α) (i : Nat) (a : α) (h : i < xs.size) :
+theorem countP_set {xs : Array α} {i : Nat} {a : α} (h : i < xs.size) :
     (xs.set i a).countP p = xs.countP p - (if p xs[i] then 1 else 0) + (if p a then 1 else 0) := by
   rcases xs with ⟨xs⟩
   simp [List.countP_set, h]
 
-theorem countP_filter (xs : Array α) :
+theorem countP_filter {xs : Array α} :
     countP p (filter q xs) = countP (fun a => p a && q a) xs := by
   rcases xs with ⟨xs⟩
   simp [List.countP_filter]
@@ -118,37 +117,35 @@ theorem countP_filter (xs : Array α) :
   funext xs
   simp
 
-@[simp] theorem countP_map (p : β → Bool) (f : α → β) (xs : Array α) :
+@[simp] theorem countP_map {p : β → Bool} {f : α → β} {xs : Array α} :
     countP p (map f xs) = countP (p ∘ f) xs := by
   rcases xs with ⟨xs⟩
   simp
 
-theorem size_filterMap_eq_countP (f : α → Option β) (xs : Array α) :
+theorem size_filterMap_eq_countP {f : α → Option β} {xs : Array α} :
     (filterMap f xs).size = countP (fun a => (f a).isSome) xs := by
   rcases xs with ⟨xs⟩
   simp [List.length_filterMap_eq_countP]
 
-theorem countP_filterMap (p : β → Bool) (f : α → Option β) (xs : Array α) :
+theorem countP_filterMap {p : β → Bool} {f : α → Option β} {xs : Array α} :
     countP p (filterMap f xs) = countP (fun a => ((f a).map p).getD false) xs := by
   rcases xs with ⟨xs⟩
   simp [List.countP_filterMap]
 
-@[simp] theorem countP_flatten (xss : Array (Array α)) :
+@[simp] theorem countP_flatten {xss : Array (Array α)} :
     countP p xss.flatten = (xss.map (countP p)).sum := by
   cases xss using array₂_induction
   simp [List.countP_flatten, Function.comp_def]
 
-theorem countP_flatMap (p : β → Bool) (xs : Array α) (f : α → Array β) :
+theorem countP_flatMap {p : β → Bool} {xs : Array α} {f : α → Array β} :
     countP p (xs.flatMap f) = sum (map (countP p ∘ f) xs) := by
   rcases xs with ⟨xs⟩
   simp [List.countP_flatMap, Function.comp_def]
 
-@[simp] theorem countP_reverse (xs : Array α) : countP p xs.reverse = countP p xs := by
+@[simp] theorem countP_reverse {xs : Array α} : countP p xs.reverse = countP p xs := by
   rcases xs with ⟨xs⟩
   simp [List.countP_reverse]
 
-variable {p q}
-
 theorem countP_mono_left (h : ∀ x ∈ xs, p x → q x) : countP p xs ≤ countP q xs := by
   rcases xs with ⟨xs⟩
   simpa using List.countP_mono_left (by simpa using h)
@@ -165,62 +162,62 @@ section count
 
 variable [BEq α]
 
-@[simp] theorem _root_.List.count_toArray (l : List α) (a : α) : count a l.toArray = l.count a := by
+@[simp] theorem _root_.List.count_toArray {l : List α} {a : α} : count a l.toArray = l.count a := by
   simp [count, List.count_eq_countP]
 
-@[simp] theorem count_toList (xs : Array α) (a : α) : xs.toList.count a = xs.count a := by
+@[simp] theorem count_toList {xs : Array α} {a : α} : xs.toList.count a = xs.count a := by
   cases xs
   simp
 
-@[simp] theorem count_empty (a : α) : count a #[] = 0 := rfl
+@[simp] theorem count_empty {a : α} : count a #[] = 0 := rfl
 
-theorem count_push (a b : α) (xs : Array α) :
+theorem count_push {a b : α} {xs : Array α} :
     count a (xs.push b) = count a xs + if b == a then 1 else 0 := by
   simp [count, countP_push]
 
-theorem count_eq_countP (a : α) (xs : Array α) : count a xs = countP (· == a) xs := rfl
+theorem count_eq_countP {a : α} {xs : Array α} : count a xs = countP (· == a) xs := rfl
 theorem count_eq_countP' {a : α} : count a = countP (· == a) := by
   funext xs
   apply count_eq_countP
 
-theorem count_le_size (a : α) (xs : Array α) : count a xs ≤ xs.size := countP_le_size _
+theorem count_le_size {a : α} {xs : Array α} : count a xs ≤ xs.size := countP_le_size
 
-theorem count_le_count_push (a b : α) (xs : Array α) : count a xs ≤ count a (xs.push b) := by
+theorem count_le_count_push {a b : α} {xs : Array α} : count a xs ≤ count a (xs.push b) := by
   simp [count_push]
 
-theorem count_singleton (a b : α) : count a #[b] = if b == a then 1 else 0 := by
+theorem count_singleton {a b : α} : count a #[b] = if b == a then 1 else 0 := by
   simp [count_eq_countP]
 
-@[simp] theorem count_append (a : α) : ∀ xs ys, count a (xs ++ ys) = count a xs + count a ys :=
-  countP_append _
+@[simp] theorem count_append {a : α} {xs ys : Array α} : count a (xs ++ ys) = count a xs + count a ys :=
+  countP_append
 
-@[simp] theorem count_flatten (a : α) (xss : Array (Array α)) :
+@[simp] theorem count_flatten {a : α} {xss : Array (Array α)} :
     count a xss.flatten = (xss.map (count a)).sum := by
   cases xss using array₂_induction
   simp [List.count_flatten, Function.comp_def]
 
-@[simp] theorem count_reverse (a : α) (xs : Array α) : count a xs.reverse = count a xs := by
+@[simp] theorem count_reverse {a : α} {xs : Array α} : count a xs.reverse = count a xs := by
   rcases xs with ⟨xs⟩
   simp
 
-theorem boole_getElem_le_count (a : α) (xs : Array α) (i : Nat) (h : i < xs.size) :
+theorem boole_getElem_le_count {xs : Array α} {i : Nat} {a : α} (h : i < xs.size) :
     (if xs[i] == a then 1 else 0) ≤ xs.count a := by
   rw [count_eq_countP]
-  apply boole_getElem_le_countP (· == a)
+  apply boole_getElem_le_countP (p := (· == a))
 
-theorem count_set (a b : α) (xs : Array α) (i : Nat) (h : i < xs.size) :
+theorem count_set {xs : Array α} {i : Nat} {a b : α} (h : i < xs.size) :
     (xs.set i a).count b = xs.count b - (if xs[i] == b then 1 else 0) + (if a == b then 1 else 0) := by
   simp [count_eq_countP, countP_set, h]
 
 variable [LawfulBEq α]
 
-@[simp] theorem count_push_self (a : α) (xs : Array α) : count a (xs.push a) = count a xs + 1 := by
+@[simp] theorem count_push_self {a : α} {xs : Array α} : count a (xs.push a) = count a xs + 1 := by
   simp [count_push]
 
-@[simp] theorem count_push_of_ne (h : b ≠ a) (xs : Array α) : count a (xs.push b) = count a xs := by
+@[simp] theorem count_push_of_ne {xs : Array α} (h : b ≠ a) : count a (xs.push b) = count a xs := by
   simp_all [count_push, h]
 
-theorem count_singleton_self (a : α) : count a #[a] = 1 := by simp
+theorem count_singleton_self {a : α} : count a #[a] = 1 := by simp
 
 @[simp]
 theorem count_pos_iff {a : α} {xs : Array α} : 0 < count a xs ↔ a ∈ xs := by
@@ -244,24 +241,24 @@ theorem count_eq_size {xs : Array α} : count a xs = xs.size ↔ ∀ b ∈ xs, a
   · simpa using h b hb
   · rw [h b hb, beq_self_eq_true]
 
-@[simp] theorem count_replicate_self (a : α) (n : Nat) : count a (replicate n a) = n := by
+@[simp] theorem count_replicate_self {a : α} {n : Nat} : count a (replicate n a) = n := by
   simp [← List.toArray_replicate]
 
 @[deprecated count_replicate_self (since := "2025-03-18")]
 abbrev count_mkArray_self := @count_replicate_self
 
-theorem count_replicate (a b : α) (n : Nat) : count a (replicate n b) = if b == a then n else 0 := by
+theorem count_replicate {a b : α} {n : Nat} : count a (replicate n b) = if b == a then n else 0 := by
   simp [← List.toArray_replicate, List.count_replicate]
 
 @[deprecated count_replicate (since := "2025-03-18")]
 abbrev count_mkArray := @count_replicate
 
-theorem filter_beq (xs : Array α) (a : α) : xs.filter (· == a) = replicate (count a xs) a := by
+theorem filter_beq {xs : Array α} (a : α) : xs.filter (· == a) = replicate (count a xs) a := by
   rcases xs with ⟨xs⟩
   simp [List.filter_beq]
 
-theorem filter_eq {α} [DecidableEq α] (xs : Array α) (a : α) : xs.filter (· = a) = replicate (count a xs) a :=
-  filter_beq xs a
+theorem filter_eq {α} [BEq α] [LawfulBEq α] [DecidableEq α] {xs : Array α} (a : α) : xs.filter (· = a) = replicate (count a xs) a :=
+  funext (Bool.beq_eq_decide_eq · a) ▸ filter_beq a
 
 theorem replicate_count_eq_of_count_eq_size {xs : Array α} (h : count a xs = xs.size) :
     replicate (count a xs) a = xs := by
@@ -276,30 +273,40 @@ abbrev mkArray_count_eq_of_count_eq_size := @replicate_count_eq_of_count_eq_size
   rcases xs with ⟨xs⟩
   simp [List.count_filter, h]
 
-theorem count_le_count_map [DecidableEq β] (xs : Array α) (f : α → β) (x : α) :
+theorem count_le_count_map [BEq β] [LawfulBEq β] {xs : Array α} {f : α → β} {x : α} :
     count x xs ≤ count (f x) (map f xs) := by
   rcases xs with ⟨xs⟩
   simp [List.count_le_count_map, countP_map]
 
-theorem count_filterMap {α} [BEq β] (b : β) (f : α → Option β) (xs : Array α) :
+theorem count_filterMap {α} [BEq β] {b : β} {f : α → Option β} {xs : Array α} :
     count b (filterMap f xs) = countP (fun a => f a == some b) xs := by
   rcases xs with ⟨xs⟩
   simp [List.count_filterMap, countP_filterMap]
 
-theorem count_flatMap {α} [BEq β] (xs : Array α) (f : α → Array β) (x : β) :
+theorem count_flatMap {α} [BEq β] {xs : Array α} {f : α → Array β} {x : β} :
     count x (xs.flatMap f) = sum (map (count x ∘ f) xs) := by
   rcases xs with ⟨xs⟩
   simp [List.count_flatMap, countP_flatMap, Function.comp_def]
 
--- FIXME these theorems can be restored once `List.erase` and `Array.erase` have been related.
+theorem countP_replace {a b : α} {xs : Array α} {p : α → Bool} :
+    (xs.replace a b).countP p =
+      if xs.contains a then xs.countP p + (if p b then 1 else 0) - (if p a then 1 else 0) else xs.countP p := by
+  rcases xs with ⟨xs⟩
+  simp [List.countP_replace]
 
--- theorem count_erase (a b : α) (l : Array α) : count a (l.erase b) = count a l - if b == a then 1 else 0 := by
---   sorry
+theorem count_replace {a b c : α} {xs : Array α} :
+    (xs.replace a b).count c =
+      if xs.contains a then xs.count c + (if b == c then 1 else 0) - (if a == c then 1 else 0) else xs.count c := by
+  simp [count_eq_countP, countP_replace]
 
--- @[simp] theorem count_erase_self (a : α) (l : Array α) :
---     count a (l.erase a) = count a l - 1 := by rw [count_erase, if_pos (by simp)]
+theorem count_erase (a b : α) (xs : Array α) : count a (xs.erase b) = count a xs - if b == a then 1 else 0 := by
+  rcases xs with ⟨l⟩
+  simp [List.count_erase]
 
--- @[simp] theorem count_erase_of_ne (ab : a ≠ b) (l : Array α) : count a (l.erase b) = count a l := by
---   rw [count_erase, if_neg (by simpa using ab.symm), Nat.sub_zero]
+@[simp] theorem count_erase_self (a : α) (xs : Array α) :
+    count a (xs.erase a) = count a xs - 1 := by rw [count_erase, if_pos (by simp)]
+
+@[simp] theorem count_erase_of_ne (ab : a ≠ b) (xs : Array α) : count a (xs.erase b) = count a xs := by
+  rw [count_erase, if_neg (by simpa using ab.symm), Nat.sub_zero]
 
 end count

src/Init/Data/Array/DecidableEq.lean

@@ -71,7 +71,7 @@ theorem isEqv_eq_decide (xs ys : Array α) (r) :
 
 theorem eq_of_isEqv [DecidableEq α] (xs ys : Array α) (h : Array.isEqv xs ys (fun x y => x = y)) : xs = ys := by
   have ⟨h, h'⟩ := rel_of_isEqv h
-  exact ext _ _ h (fun i lt _ => by simpa using h' i lt)
+  exact ext h (fun i lt _ => by simpa using h' i lt)
 
 private theorem isEqvAux_self (r : α → α → Bool) (hr : ∀ a, r a a) (xs : Array α) (i : Nat) (h : i ≤ xs.size) :
     Array.isEqvAux xs xs rfl r i h = true := by
@@ -114,8 +114,10 @@ end List
 
 namespace Array
 
-instance [BEq α] [LawfulBEq α] : LawfulBEq (Array α) where
+instance [BEq α] [ReflBEq α] : ReflBEq (Array α) where
   rfl := by simp [BEq.beq, isEqv_self_beq]
+
+instance [BEq α] [LawfulBEq α] : LawfulBEq (Array α) where
   eq_of_beq := by
     rintro ⟨_⟩ ⟨_⟩ h
     simpa using h

src/Init/Data/Array/Erase.lean

@@ -46,6 +46,7 @@ theorem exists_of_eraseP {xs : Array α} {a} (hm : a ∈ xs) (hp : p a) :
   obtain ⟨a, l₁, l₂, h₁, h₂, rfl, h₃⟩ := List.exists_of_eraseP (by simpa using hm) (hp)
   refine ⟨a, ⟨l₁⟩, ⟨l₂⟩, by simpa using h₁, h₂, by simp, by simpa using h₃⟩
 
+-- The arguments are explicit here, so this lemma can be used as a case split.
 theorem exists_or_eq_self_of_eraseP (p) (xs : Array α) :
     xs.eraseP p = xs ∨
     ∃ a ys zs, (∀ b ∈ ys, ¬p b) ∧ p a ∧ xs = ys.push a ++ zs ∧ xs.eraseP p = ys ++ zs :=
@@ -58,7 +59,7 @@ theorem exists_or_eq_self_of_eraseP (p) (xs : Array α) :
 @[simp] theorem size_eraseP_of_mem {xs : Array α} (al : a ∈ xs) (pa : p a) :
     (xs.eraseP p).size = xs.size - 1 := by
   let ⟨_, ys, zs, _, _, e₁, e₂⟩ := exists_of_eraseP al pa
-  rw [e₂]; simp [size_append, e₁]; omega
+  rw [e₂]; simp [size_append, e₁]
 
 theorem size_eraseP {xs : Array α} : (xs.eraseP p).size = if xs.any p then xs.size - 1 else xs.size := by
   split <;> rename_i h
@@ -69,13 +70,13 @@ theorem size_eraseP {xs : Array α} : (xs.eraseP p).size = if xs.any p then xs.s
     rw [eraseP_of_forall_getElem_not]
     simp_all
 
-theorem size_eraseP_le (xs : Array α) : (xs.eraseP p).size ≤ xs.size := by
+theorem size_eraseP_le {xs : Array α} : (xs.eraseP p).size ≤ xs.size := by
   rcases xs with ⟨xs⟩
-  simpa using List.length_eraseP_le xs
+  simpa using List.length_eraseP_le
 
-theorem le_size_eraseP (xs : Array α) : xs.size - 1 ≤ (xs.eraseP p).size := by
+theorem le_size_eraseP {xs : Array α} : xs.size - 1 ≤ (xs.eraseP p).size := by
   rcases xs with ⟨xs⟩
-  simpa using List.le_length_eraseP xs
+  simpa using List.le_length_eraseP
 
 theorem mem_of_mem_eraseP {xs : Array α} : a ∈ xs.eraseP p → a ∈ xs := by
   rcases xs with ⟨xs⟩
@@ -89,19 +90,19 @@ theorem mem_of_mem_eraseP {xs : Array α} : a ∈ xs.eraseP p → a ∈ xs := by
   rcases xs with ⟨xs⟩
   simp
 
-theorem eraseP_map (f : β → α) (xs : Array β) : (xs.map f).eraseP p = (xs.eraseP (p ∘ f)).map f := by
+theorem eraseP_map {f : β → α} {xs : Array β} : (xs.map f).eraseP p = (xs.eraseP (p ∘ f)).map f := by
   rcases xs with ⟨xs⟩
-  simpa using List.eraseP_map f xs
+  simpa using List.eraseP_map
 
-theorem eraseP_filterMap (f : α → Option β) (xs : Array α) :
+theorem eraseP_filterMap {f : α → Option β} {xs : Array α} :
     (filterMap f xs).eraseP p = filterMap f (xs.eraseP (fun x => match f x with | some y => p y | none => false)) := by
   rcases xs with ⟨xs⟩
-  simpa using List.eraseP_filterMap f xs
+  simpa using List.eraseP_filterMap
 
-theorem eraseP_filter (f : α → Bool) (xs : Array α) :
+theorem eraseP_filter {f : α → Bool} {xs : Array α} :
     (filter f xs).eraseP p = filter f (xs.eraseP (fun x => p x && f x)) := by
   rcases xs with ⟨xs⟩
-  simpa using List.eraseP_filter f xs
+  simpa using List.eraseP_filter
 
 theorem eraseP_append_left {a : α} (pa : p a) {xs : Array α} {ys : Array α} (h : a ∈ xs) :
     (xs ++ ys).eraseP p = xs.eraseP p ++ ys := by
@@ -122,7 +123,7 @@ theorem eraseP_append {xs : Array α} {ys : Array α} :
   simp only [List.append_toArray, List.eraseP_toArray, List.eraseP_append, List.any_toArray]
   split <;> simp
 
-theorem eraseP_replicate (n : Nat) (a : α) (p : α → Bool) :
+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
   simp only [← List.toArray_replicate, List.eraseP_toArray, List.eraseP_replicate]
   split <;> simp
@@ -175,10 +176,12 @@ theorem erase_of_not_mem [LawfulBEq α] {a : α} {xs : Array α} (h : a ∉ xs)
   rcases xs with ⟨xs⟩
   simp [List.erase_of_not_mem (by simpa using h)]
 
+-- The arguments are intentionally explicit.
 theorem erase_eq_eraseP' (a : α) (xs : Array α) : xs.erase a = xs.eraseP (· == a) := by
   rcases xs with ⟨xs⟩
   simp [List.erase_eq_eraseP']
 
+-- The arguments are intentionally explicit.
 theorem erase_eq_eraseP [LawfulBEq α] (a : α) (xs : Array α) : xs.erase a = xs.eraseP (a == ·) := by
   rcases xs with ⟨xs⟩
   simp [List.erase_eq_eraseP]
@@ -202,19 +205,19 @@ theorem exists_erase_eq [LawfulBEq α] {a : α} {xs : Array α} (h : a ∈ xs) :
     (xs.erase a).size = xs.size - 1 := by
   rw [erase_eq_eraseP]; exact size_eraseP_of_mem h (beq_self_eq_true a)
 
-theorem size_erase [LawfulBEq α] (a : α) (xs : Array α) :
+theorem size_erase [LawfulBEq α] {a : α} {xs : Array α} :
     (xs.erase a).size = if a ∈ xs then xs.size - 1 else xs.size := by
   rw [erase_eq_eraseP, size_eraseP]
   congr
   simp [mem_iff_getElem, eq_comm (a := a)]
 
-theorem size_erase_le (a : α) (xs : Array α) : (xs.erase a).size ≤ xs.size := by
+theorem size_erase_le {a : α} {xs : Array α} : (xs.erase a).size ≤ xs.size := by
   rcases xs with ⟨xs⟩
-  simpa using List.length_erase_le a xs
+  simpa using List.length_erase_le
 
-theorem le_size_erase [LawfulBEq α] (a : α) (xs : Array α) : xs.size - 1 ≤ (xs.erase a).size := by
+theorem le_size_erase [LawfulBEq α] {a : α} {xs : Array α} : xs.size - 1 ≤ (xs.erase a).size := by
   rcases xs with ⟨xs⟩
-  simpa using List.le_length_erase a xs
+  simpa using List.le_length_erase
 
 theorem mem_of_mem_erase {a b : α} {xs : Array α} (h : a ∈ xs.erase b) : a ∈ xs := by
   rcases xs with ⟨xs⟩
@@ -228,10 +231,10 @@ theorem mem_of_mem_erase {a b : α} {xs : Array α} (h : a ∈ xs.erase b) : a
   rw [erase_eq_eraseP', eraseP_eq_self_iff]
   simp [forall_mem_ne']
 
-theorem erase_filter [LawfulBEq α] (f : α → Bool) (xs : Array α) :
+theorem erase_filter [LawfulBEq α] {f : α → Bool} {xs : Array α} :
     (filter f xs).erase a = filter f (xs.erase a) := by
   rcases xs with ⟨xs⟩
-  simpa using List.erase_filter f xs
+  simpa using List.erase_filter
 
 theorem erase_append_left [LawfulBEq α] {xs : Array α} (ys) (h : a ∈ xs) :
     (xs ++ ys).erase a = xs.erase a ++ ys := by
@@ -252,7 +255,7 @@ theorem erase_append [LawfulBEq α] {a : α} {xs ys : Array α} :
   simp only [List.append_toArray, List.erase_toArray, List.erase_append, mem_toArray]
   split <;> simp
 
-theorem erase_replicate [LawfulBEq α] (n : Nat) (a b : α) :
+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
   simp only [← List.toArray_replicate, List.erase_toArray]
   simp only [List.erase_replicate, beq_iff_eq, List.toArray_replicate]
@@ -261,10 +264,12 @@ theorem erase_replicate [LawfulBEq α] (n : Nat) (a b : α) :
 @[deprecated erase_replicate (since := "2025-03-18")]
 abbrev erase_mkArray := @erase_replicate
 
-theorem erase_comm [LawfulBEq α] (a b : α) (xs : Array α) :
+-- The arguments `a b` are explicit,
+-- so they can be specified to prevent `simp` repeatedly applying the lemma.
+theorem erase_comm [LawfulBEq α] (a b : α) {xs : Array α} :
     (xs.erase a).erase b = (xs.erase b).erase a := by
   rcases xs with ⟨xs⟩
-  simpa using List.erase_comm a b xs
+  simpa using List.erase_comm a b
 
 theorem erase_eq_iff [LawfulBEq α] {a : α} {xs : Array α} :
     xs.erase a = ys ↔
@@ -304,7 +309,8 @@ theorem eraseIdx_eq_eraseIdxIfInBounds {xs : Array α} {i : Nat} (h : i < xs.siz
     xs.eraseIdx i h = xs.eraseIdxIfInBounds i := by
   simp [eraseIdxIfInBounds, h]
 
-theorem eraseIdx_eq_take_drop_succ (xs : Array α) (i : Nat) (h) : xs.eraseIdx i = xs.take i ++ xs.drop (i + 1) := by
+theorem eraseIdx_eq_take_drop_succ {xs : Array α} {i : Nat} (h) :
+    xs.eraseIdx i h = xs.take i ++ xs.drop (i + 1) := by
   rcases xs with ⟨xs⟩
   simp only [List.size_toArray] at h
   simp only [List.eraseIdx_toArray, List.eraseIdx_eq_take_drop_succ, take_eq_extract,
@@ -313,24 +319,24 @@ theorem eraseIdx_eq_take_drop_succ (xs : Array α) (i : Nat) (h) : xs.eraseIdx i
   rw [List.take_of_length_le]
   simp
 
-theorem getElem?_eraseIdx (xs : Array α) (i : Nat) (h : i < xs.size) (j : Nat) :
+theorem getElem?_eraseIdx {xs : Array α} {i : Nat} (h : i < xs.size) {j : Nat} :
     (xs.eraseIdx i)[j]? = if j < i then xs[j]? else xs[j + 1]? := by
   rcases xs with ⟨xs⟩
   simp [List.getElem?_eraseIdx]
 
-theorem getElem?_eraseIdx_of_lt (xs : Array α) (i : Nat) (h : i < xs.size) (j : Nat) (h' : j < i) :
+theorem getElem?_eraseIdx_of_lt {xs : Array α} {i : Nat} (h : i < xs.size) {j : Nat} (h' : j < i) :
     (xs.eraseIdx i)[j]? = xs[j]? := by
   rw [getElem?_eraseIdx]
   simp [h']
 
-theorem getElem?_eraseIdx_of_ge (xs : Array α) (i : Nat) (h : i < xs.size) (j : Nat) (h' : i ≤ j) :
+theorem getElem?_eraseIdx_of_ge {xs : Array α} {i : Nat} (h : i < xs.size) {j : Nat} (h' : i ≤ j) :
     (xs.eraseIdx i)[j]? = xs[j + 1]? := by
   rw [getElem?_eraseIdx]
   simp only [dite_eq_ite, ite_eq_right_iff]
   intro h'
   omega
 
-theorem getElem_eraseIdx (xs : Array α) (i : Nat) (h : i < xs.size) (j : Nat) (h' : j < (xs.eraseIdx i).size) :
+theorem getElem_eraseIdx {xs : Array α} {i : Nat} (h : i < xs.size) {j : Nat} (h' : j < (xs.eraseIdx i).size) :
     (xs.eraseIdx i)[j] = if h'' : j < i then
         xs[j]
       else
@@ -388,18 +394,18 @@ theorem mem_eraseIdx_iff_getElem? {x : α} {xs : Array α} {k} {h} : x ∈ xs.er
   rcases xs with ⟨xs⟩
   simp [List.mem_eraseIdx_iff_getElem?, *]
 
-theorem erase_eq_eraseIdx_of_idxOf [BEq α] [LawfulBEq α] (xs : Array α) (a : α) (i : Nat) (w : xs.idxOf a = i) (h : i < xs.size) :
+theorem erase_eq_eraseIdx_of_idxOf [BEq α] [LawfulBEq α] {xs : Array α} {a : α} {i : Nat} (w : xs.idxOf a = i) (h : i < xs.size) :
     xs.erase a = xs.eraseIdx i := by
   rcases xs with ⟨xs⟩
   simp at w
   simp [List.erase_eq_eraseIdx_of_idxOf, *]
 
-theorem getElem_eraseIdx_of_lt (xs : Array α) (i : Nat) (w : i < xs.size) (j : Nat) (h : j < (xs.eraseIdx i).size) (h' : j < i) :
+theorem getElem_eraseIdx_of_lt {xs : Array α} {i : Nat} (w : i < xs.size) {j : Nat} (h : j < (xs.eraseIdx i).size) (h' : j < i) :
     (xs.eraseIdx i)[j] = xs[j] := by
   rcases xs with ⟨xs⟩
   simp [List.getElem_eraseIdx_of_lt, *]
 
-theorem getElem_eraseIdx_of_ge (xs : Array α) (i : Nat) (w : i < xs.size) (j : Nat) (h : j < (xs.eraseIdx i).size) (h' : i ≤ j) :
+theorem getElem_eraseIdx_of_ge {xs : Array α} {i : Nat} (w : i < xs.size) {j : Nat} (h : j < (xs.eraseIdx i).size) (h' : i ≤ j) :
     (xs.eraseIdx i)[j] = xs[j + 1]'(by simp at h; omega) := by
   rcases xs with ⟨xs⟩
   simp [List.getElem_eraseIdx_of_ge, *]

src/Init/Data/Array/Extract.lean

@@ -322,32 +322,32 @@ theorem reverse_extract {as : Array α} {i j : Nat} :
 
 /-! ### takeWhile -/
 
-theorem takeWhile_map (f : α → β) (p : β → Bool) (as : Array α) :
+theorem takeWhile_map {f : α → β} {p : β → Bool} {as : Array α} :
     (as.map f).takeWhile p = (as.takeWhile (p ∘ f)).map f := by
   rcases as with ⟨as⟩
   simp [List.takeWhile_map]
 
-theorem popWhile_map (f : α → β) (p : β → Bool) (as : Array α) :
+theorem popWhile_map {f : α → β} {p : β → Bool} {as : Array α} :
     (as.map f).popWhile p = (as.popWhile (p ∘ f)).map f := by
   rcases as with ⟨as⟩
   simp [List.dropWhile_map, ← List.map_reverse]
 
-theorem takeWhile_filterMap (f : α → Option β) (p : β → Bool) (as : Array α) :
+theorem takeWhile_filterMap {f : α → Option β} {p : β → Bool} {as : Array α} :
     (as.filterMap f).takeWhile p = (as.takeWhile fun a => (f a).all p).filterMap f := by
   rcases as with ⟨as⟩
   simp [List.takeWhile_filterMap]
 
-theorem popWhile_filterMap (f : α → Option β) (p : β → Bool) (as : Array α) :
+theorem popWhile_filterMap {f : α → Option β} {p : β → Bool} {as : Array α} :
     (as.filterMap f).popWhile p = (as.popWhile fun a => (f a).all p).filterMap f := by
   rcases as with ⟨as⟩
   simp [List.dropWhile_filterMap, ← List.filterMap_reverse]
 
-theorem takeWhile_filter (p q : α → Bool) (as : Array α) :
+theorem takeWhile_filter {p q : α → Bool} {as : Array α} :
     (as.filter p).takeWhile q = (as.takeWhile fun a => !p a || q a).filter p := by
   rcases as with ⟨as⟩
   simp [List.takeWhile_filter]
 
-theorem popWhile_filter (p q : α → Bool) (as : Array α) :
+theorem popWhile_filter {p q : α → Bool} {as : Array α} :
     (as.filter p).popWhile q = (as.popWhile fun a => !p a || q a).filter p := by
   rcases as with ⟨as⟩
   simp [List.dropWhile_filter, ← List.filter_reverse]
@@ -390,28 +390,28 @@ theorem popWhile_append {xs ys : Array α} :
   rw [List.dropWhile_append_of_pos]
   simpa
 
-@[simp] theorem takeWhile_replicate_eq_filter (p : α → Bool) :
+@[simp] theorem takeWhile_replicate_eq_filter {p : α → Bool} :
     (replicate n a).takeWhile p = (replicate n a).filter p := by
   simp [← List.toArray_replicate]
 
 @[deprecated takeWhile_replicate_eq_filter (since := "2025-03-18")]
 abbrev takeWhile_mkArray_eq_filter := @takeWhile_replicate_eq_filter
 
-theorem takeWhile_replicate (p : α → Bool) :
+theorem takeWhile_replicate {p : α → Bool} :
     (replicate n a).takeWhile p = if p a then replicate n a else #[] := by
   simp [takeWhile_replicate_eq_filter, filter_replicate]
 
 @[deprecated takeWhile_replicate (since := "2025-03-18")]
 abbrev takeWhile_mkArray := @takeWhile_replicate
 
-@[simp] theorem popWhile_replicate_eq_filter_not (p : α → Bool) :
+@[simp] theorem popWhile_replicate_eq_filter_not {p : α → Bool} :
     (replicate n a).popWhile p = (replicate n a).filter (fun a => !p a) := by
   simp [← List.toArray_replicate, ← List.filter_reverse]
 
 @[deprecated popWhile_replicate_eq_filter_not (since := "2025-03-18")]
 abbrev popWhile_mkArray_eq_filter_not := @popWhile_replicate_eq_filter_not
 
-theorem popWhile_replicate (p : α → Bool) :
+theorem popWhile_replicate {p : α → Bool} :
     (replicate n a).popWhile p = if p a then #[] else replicate n a := by
   simp only [popWhile_replicate_eq_filter_not, size_replicate, filter_replicate, Bool.not_eq_eq_eq_not,
     Bool.not_true]

src/Init/Data/Array/FinRange.lean

@@ -21,23 +21,23 @@ Examples:
 -/
 protected def finRange (n : Nat) : Array (Fin n) := ofFn fun i => i
 
-@[simp] theorem size_finRange (n) : (Array.finRange n).size = n := by
+@[simp] theorem size_finRange {n} : (Array.finRange n).size = n := by
   simp [Array.finRange]
 
-@[simp] theorem getElem_finRange (i : Nat) (h : i < (Array.finRange n).size) :
-    (Array.finRange n)[i] = Fin.cast (size_finRange n) ⟨i, h⟩ := by
+@[simp] theorem getElem_finRange {i : Nat} (h : i < (Array.finRange n).size) :
+    (Array.finRange n)[i] = Fin.cast size_finRange ⟨i, h⟩ := by
   simp [Array.finRange]
 
 @[simp] theorem finRange_zero : Array.finRange 0 = #[] := by simp [Array.finRange]
 
-theorem finRange_succ (n) : Array.finRange (n+1) = #[0] ++ (Array.finRange n).map Fin.succ := by
+theorem finRange_succ {n} : Array.finRange (n+1) = #[0] ++ (Array.finRange n).map Fin.succ := by
   ext
   · simp [Nat.add_comm]
   · simp [getElem_append]
     split <;>
     · simp; omega
 
-theorem finRange_succ_last (n) :
+theorem finRange_succ_last {n} :
     Array.finRange (n+1) = (Array.finRange n).map Fin.castSucc ++ #[Fin.last n] := by
   ext
   · simp
@@ -47,7 +47,7 @@ theorem finRange_succ_last (n) :
     · simp_all
       omega
 
-theorem finRange_reverse (n) : (Array.finRange n).reverse = (Array.finRange n).map Fin.rev := by
+theorem finRange_reverse {n} : (Array.finRange n).reverse = (Array.finRange n).map Fin.rev := by
   ext i h
   · simp
   · simp

src/Init/Data/Array/Find.lean

@@ -21,10 +21,10 @@ open Nat
 
 /-! ### findSome? -/
 
-@[simp] theorem findSomeRev?_push_of_isSome (xs : Array α) (h : (f a).isSome) : (xs.push a).findSomeRev? f = f a := by
+@[simp] theorem findSomeRev?_push_of_isSome {xs : Array α} (h : (f a).isSome) : (xs.push a).findSomeRev? f = f a := by
   cases xs; simp_all
 
-@[simp] theorem findSomeRev?_push_of_isNone (xs : Array α) (h : (f a).isNone) : (xs.push a).findSomeRev? f = xs.findSomeRev? f := by
+@[simp] theorem findSomeRev?_push_of_isNone {xs : Array α} (h : (f a).isNone) : (xs.push a).findSomeRev? f = xs.findSomeRev? f := by
   cases xs; simp_all
 
 theorem exists_of_findSome?_eq_some {f : α → Option β} {xs : Array α} (w : xs.findSome? f = some b) :
@@ -48,31 +48,31 @@ theorem findSome?_eq_some_iff {f : α → Option β} {xs : Array α} {b : β} :
   · rintro ⟨xs, a, ys, h₀, h₁, h₂⟩
     exact ⟨xs.toList, a, ys.toList, by simpa using congrArg toList h₀, h₁, by simpa⟩
 
-@[simp] theorem findSome?_guard (xs : Array α) : findSome? (Option.guard fun x => p x) xs = find? p xs := by
+@[simp] theorem findSome?_guard {xs : Array α} : findSome? (Option.guard fun x => p x) xs = find? p xs := by
   cases xs; simp
 
-theorem find?_eq_findSome?_guard (xs : Array α) : find? p xs = findSome? (Option.guard fun x => p x) xs :=
-  (findSome?_guard xs).symm
+theorem find?_eq_findSome?_guard {xs : Array α} : find? p xs = findSome? (Option.guard fun x => p x) xs :=
+  findSome?_guard.symm
 
-@[simp] theorem getElem?_zero_filterMap (f : α → Option β) (xs : Array α) : (xs.filterMap f)[0]? = xs.findSome? f := by
+@[simp] theorem getElem?_zero_filterMap {f : α → Option β} {xs : Array α} : (xs.filterMap f)[0]? = xs.findSome? f := by
   cases xs; simp [← List.head?_eq_getElem?]
 
-@[simp] theorem getElem_zero_filterMap (f : α → Option β) (xs : Array α) (h) :
+@[simp] theorem getElem_zero_filterMap {f : α → Option β} {xs : Array α} (h) :
     (xs.filterMap f)[0] = (xs.findSome? f).get (by cases xs; simpa [List.length_filterMap_eq_countP] using h) := by
   cases xs; simp [← List.head_eq_getElem, ← getElem?_zero_filterMap]
 
-@[simp] theorem back?_filterMap (f : α → Option β) (xs : Array α) : (xs.filterMap f).back? = xs.findSomeRev? f := by
+@[simp] theorem back?_filterMap {f : α → Option β} {xs : Array α} : (xs.filterMap f).back? = xs.findSomeRev? f := by
   cases xs; simp
 
-@[simp] theorem back!_filterMap [Inhabited β] (f : α → Option β) (xs : Array α) :
+@[simp] theorem back!_filterMap [Inhabited β] {f : α → Option β} {xs : Array α} :
     (xs.filterMap f).back! = (xs.findSomeRev? f).getD default := by
   cases xs; simp
 
-@[simp] theorem map_findSome? (f : α → Option β) (g : β → γ) (xs : Array α) :
+@[simp] theorem map_findSome? {f : α → Option β} {g : β → γ} {xs : Array α} :
     (xs.findSome? f).map g = xs.findSome? (Option.map g ∘ f) := by
   cases xs; simp
 
-theorem findSome?_map (f : β → γ) (xs : Array β) : findSome? p (xs.map f) = xs.findSome? (p ∘ f) := by
+theorem findSome?_map {f : β → γ} {xs : Array β} : findSome? p (xs.map f) = xs.findSome? (p ∘ f) := by
   cases xs; simp [List.findSome?_map]
 
 theorem findSome?_append {xs ys : Array α} : (xs ++ ys).findSome? f = (xs.findSome? f).or (ys.findSome? f) := by
@@ -129,15 +129,15 @@ abbrev findSome?_mkArray_of_isNone := @findSome?_replicate_of_isNone
 
 /-! ### find? -/
 
-@[simp] theorem find?_singleton (a : α) (p : α → Bool) :
+@[simp] theorem find?_singleton {a : α} {p : α → Bool} :
     #[a].find? p = if p a then some a else none := by
   simp [singleton_eq_toArray_singleton]
 
-@[simp] theorem findRev?_push_of_pos (xs : Array α) (h : p a) :
+@[simp] theorem findRev?_push_of_pos {xs : Array α} (h : p a) :
     findRev? p (xs.push a) = some a := by
   cases xs; simp [h]
 
-@[simp] theorem findRev?_cons_of_neg (xs : Array α) (h : ¬p a) :
+@[simp] theorem findRev?_cons_of_neg {xs : Array α} (h : ¬p a) :
     findRev? p (xs.push a) = findRev? p xs := by
   cases xs; simp [h]
 
@@ -183,28 +183,28 @@ theorem get_find?_mem {xs : Array α} (h) : (xs.find? p).get h ∈ xs := by
     (xs.filter p).find? q = xs.find? (fun a => p a ∧ q a) := by
   cases xs; simp
 
-@[simp] theorem getElem?_zero_filter (p : α → Bool) (xs : Array α) :
+@[simp] theorem getElem?_zero_filter {p : α → Bool} {xs : Array α} :
     (xs.filter p)[0]? = xs.find? p := by
   cases xs; simp [← List.head?_eq_getElem?]
 
-@[simp] theorem getElem_zero_filter (p : α → Bool) (xs : Array α) (h) :
+@[simp] theorem getElem_zero_filter {p : α → Bool} {xs : Array α} (h) :
     (xs.filter p)[0] =
       (xs.find? p).get (by cases xs; simpa [← List.countP_eq_length_filter] using h) := by
   cases xs
   simp [List.getElem_zero_eq_head]
 
-@[simp] theorem back?_filter (p : α → Bool) (xs : Array α) : (xs.filter p).back? = xs.findRev? p := by
+@[simp] theorem back?_filter {p : α → Bool} {xs : Array α} : (xs.filter p).back? = xs.findRev? p := by
   cases xs; simp
 
-@[simp] theorem back!_filter [Inhabited α] (p : α → Bool) (xs : Array α) :
+@[simp] theorem back!_filter [Inhabited α] {p : α → Bool} {xs : Array α} :
     (xs.filter p).back! = (xs.findRev? p).get! := by
   cases xs; simp [Option.get!_eq_getD]
 
-@[simp] theorem find?_filterMap (xs : Array α) (f : α → Option β) (p : β → Bool) :
+@[simp] theorem find?_filterMap {xs : Array α} {f : α → Option β} {p : β → Bool} :
     (xs.filterMap f).find? p = (xs.find? (fun a => (f a).any p)).bind f := by
   cases xs; simp
 
-@[simp] theorem find?_map (f : β → α) (xs : Array β) :
+@[simp] theorem find?_map {f : β → α} {xs : Array β} :
     find? p (xs.map f) = (xs.find? (p ∘ f)).map f := by
   cases xs; simp
 
@@ -214,7 +214,7 @@ theorem get_find?_mem {xs : Array α} (h) : (xs.find? p).get h ∈ xs := by
   cases ys
   simp
 
-@[simp] theorem find?_flatten (xss : Array (Array α)) (p : α → Bool) :
+@[simp] theorem find?_flatten {xss : Array (Array α)} {p : α → Bool} :
     xss.flatten.find? p = xss.findSome? (·.find? p) := by
   cases xss using array₂_induction
   simp [List.findSome?_map, Function.comp_def]
@@ -254,7 +254,7 @@ theorem find?_flatten_eq_some_iff {xss : Array (Array α)} {p : α → Bool} {a
 @[deprecated find?_flatten_eq_some_iff (since := "2025-02-03")]
 abbrev find?_flatten_eq_some := @find?_flatten_eq_some_iff
 
-@[simp] theorem find?_flatMap (xs : Array α) (f : α → Array β) (p : β → Bool) :
+@[simp] theorem find?_flatMap {xs : Array α} {f : α → Array β} {p : β → Bool} :
     (xs.flatMap f).find? p = xs.findSome? (fun x => (f x).find? p) := by
   cases xs
   simp [List.find?_flatMap, Array.flatMap_toArray]
@@ -311,15 +311,15 @@ abbrev find?_mkArray_eq_some_iff := @find?_replicate_eq_some_iff
 @[deprecated find?_replicate_eq_some_iff (since := "2025-02-03")]
 abbrev find?_mkArray_eq_some := @find?_replicate_eq_some_iff
 
-@[simp] theorem get_find?_replicate (n : Nat) (a : α) (p : α → Bool) (h) :
+@[simp] theorem get_find?_replicate {n : Nat} {a : α} {p : α → Bool} (h) :
     ((replicate n a).find? p).get h = a := by
   simp [← List.toArray_replicate]
 
 @[deprecated get_find?_replicate (since := "2025-03-18")]
 abbrev get_find?_mkArray := @get_find?_replicate
 
-theorem find?_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : Array α)
-    (H : ∀ (a : α), a ∈ xs → P a) (p : β → Bool) :
+theorem find?_pmap {P : α → Prop} {f : (a : α) → P a → β} {xs : Array α}
+    (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
@@ -359,7 +359,7 @@ theorem findIdx_eq_size_of_false {p : α → Bool} {xs : Array α} (h : ∀ x
   rcases xs with ⟨xs⟩
   simp_all
 
-theorem findIdx_le_size (p : α → Bool) {xs : Array α} : xs.findIdx p ≤ xs.size := by
+theorem findIdx_le_size {p : α → Bool} {xs : Array α} : xs.findIdx p ≤ xs.size := by
   by_cases e : ∃ x ∈ xs, p x
   · exact Nat.le_of_lt (findIdx_lt_size_of_exists e)
   · simp at e
@@ -373,7 +373,7 @@ theorem findIdx_lt_size {p : α → Bool} {xs : Array α} :
 
 /-- `p` does not hold for elements with indices less than `xs.findIdx p`. -/
 theorem not_of_lt_findIdx {p : α → Bool} {xs : Array α} {i : Nat} (h : i < xs.findIdx p) :
-    p (xs[i]'(Nat.le_trans h (findIdx_le_size p))) = false := by
+    p (xs[i]'(Nat.le_trans h findIdx_le_size)) = false := by
   rcases xs with ⟨xs⟩
   simpa using List.not_of_lt_findIdx (by simpa using h)
 
@@ -404,7 +404,7 @@ theorem findIdx_eq {p : α → Bool} {xs : Array α} {i : Nat} (h : i < xs.size)
   simp at h3
   simp_all [not_of_lt_findIdx h3]
 
-theorem findIdx_append (p : α → Bool) (xs ys : Array α) :
+theorem findIdx_append {p : α → Bool} {xs ys : Array α} :
     (xs ++ ys).findIdx p =
       if xs.findIdx p < xs.size then xs.findIdx p else ys.findIdx p + xs.size := by
   rcases xs with ⟨xs⟩
@@ -446,11 +446,13 @@ theorem findIdx?_eq_none_iff {xs : Array α} {p : α → Bool} :
   rcases xs with ⟨xs⟩
   simp
 
+@[simp]
 theorem findIdx?_isSome {xs : Array α} {p : α → Bool} :
     (xs.findIdx? p).isSome = xs.any p := by
   rcases xs with ⟨xs⟩
   simp [List.findIdx?_isSome]
 
+@[simp]
 theorem findIdx?_isNone {xs : Array α} {p : α → Bool} :
     (xs.findIdx? p).isNone = xs.all (¬p ·) := by
   rcases xs with ⟨xs⟩
@@ -492,7 +494,8 @@ theorem of_findIdx?_eq_none {xs : Array α} {p : α → Bool} (w : xs.findIdx? p
   rcases xs with ⟨xs⟩
   simpa using List.of_findIdx?_eq_none (by simpa using w)
 
-@[simp] theorem findIdx?_map (f : β → α) (xs : Array β) : findIdx? p (xs.map f) = xs.findIdx? (p ∘ f) := by
+@[simp] theorem findIdx?_map {f : β → α} {xs : Array β} {p : α → Bool} :
+    findIdx? p (xs.map f) = xs.findIdx? (p ∘ f) := by
   rcases xs with ⟨xs⟩
   simp [List.findIdx?_map]
 
@@ -583,13 +586,25 @@ theorem findFinIdx?_eq_some_iff {xs : Array α} {p : α → Bool} {i : Fin xs.si
     xs.findFinIdx? p = some i ↔
       p xs[i] ∧ ∀ j (hji : j < i), ¬p (xs[j]'(Nat.lt_trans hji i.2)) := by
   simp only [findFinIdx?_eq_pmap_findIdx?, Option.pmap_eq_some_iff, findIdx?_eq_some_iff_getElem,
-    Bool.not_eq_true, Option.mem_def, exists_and_left, and_exists_self, Fin.getElem_fin]
+    Bool.not_eq_true, exists_and_left, and_exists_self, Fin.getElem_fin]
   constructor
   · rintro ⟨a, ⟨h, w₁, w₂⟩, rfl⟩
     exact ⟨w₁, fun j hji => by simpa using w₂ j hji⟩
   · rintro ⟨h, w⟩
     exact ⟨i, ⟨i.2, h, fun j hji => w ⟨j, by omega⟩ hji⟩, rfl⟩
 
+@[simp]
+theorem isSome_findFinIdx? {xs : Array α} {p : α → Bool} :
+    (xs.findFinIdx? p).isSome = xs.any p := by
+  rcases xs with ⟨xs⟩
+  simp
+
+@[simp]
+theorem isNone_findFinIdx? {xs : Array α} {p : α → Bool} :
+    (xs.findFinIdx? p).isNone = xs.all (fun x => ¬ p x) := by
+  rcases xs with ⟨xs⟩
+  simp
+
 @[simp] theorem findFinIdx?_subtype {p : α → Prop} {xs : Array { x // p x }}
     {f : { x // p x } → Bool} {g : α → Bool} (hf : ∀ x h, f ⟨x, h⟩ = g x) :
     xs.findFinIdx? f = (xs.unattach.findFinIdx? g).map (fun i => i.cast (by simp)) := by
@@ -635,6 +650,20 @@ The lemmas below should be made consistent with those for `findIdx?` (and proved
   rcases xs with ⟨xs⟩
   simp [List.idxOf?_eq_none_iff]
 
+@[simp]
+theorem isSome_idxOf? [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
+    (xs.idxOf? a).isSome ↔ a ∈ xs := by
+  rcases xs with ⟨xs⟩
+  simp
+
+@[simp]
+theorem isNone_idxOf? [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
+    (xs.idxOf? a).isNone = ¬ a ∈ xs := by
+  rcases xs with ⟨xs⟩
+  simp
+
+
+
 /-! ### finIdxOf?
 
 The verification API for `finIdxOf?` is still incomplete.
@@ -657,4 +686,16 @@ theorem idxOf?_eq_map_finIdxOf?_val [BEq α] {xs : Array α} {a : α} :
   rcases xs with ⟨xs⟩
   simp [List.finIdxOf?_eq_some_iff]
 
+@[simp]
+theorem isSome_finIdxOf? [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
+    (xs.finIdxOf? a).isSome ↔ a ∈ xs := by
+  rcases xs with ⟨xs⟩
+  simp
+
+@[simp]
+theorem isNone_finIdxOf? [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
+    (xs.finIdxOf? a).isNone = ¬ a ∈ xs := by
+  rcases xs with ⟨xs⟩
+  simp
+
 end Array

src/Init/Data/Array/GetLit.lean

@@ -23,7 +23,7 @@ theorem extLit {n : Nat}
     (xs ys : Array α)
     (hsz₁ : xs.size = n) (hsz₂ : ys.size = n)
     (h : (i : Nat) → (hi : i < n) → xs.getLit i hsz₁ hi = ys.getLit i hsz₂ hi) : xs = ys :=
-  Array.ext xs ys (hsz₁.trans hsz₂.symm) fun i hi₁ _ => h i (hsz₁ ▸ hi₁)
+  Array.ext (hsz₁.trans hsz₂.symm) fun i hi₁ _ => h i (hsz₁ ▸ hi₁)
 
 def toListLitAux (xs : Array α) (n : Nat) (hsz : xs.size = n) : ∀ (i : Nat), i ≤ xs.size → List α → List α
   | 0,     _,  acc => acc

src/Init/Data/Array/InsertIdx.lean

@@ -30,13 +30,13 @@ section InsertIdx
 
 variable {a : α}
 
-@[simp] theorem toList_insertIdx (xs : Array α) (i x) (h) :
+@[simp] theorem toList_insertIdx {xs : Array α} {i : Nat} {x : α} (h : i ≤ xs.size) :
     (xs.insertIdx i x h).toList = xs.toList.insertIdx i x := by
   rcases xs with ⟨xs⟩
   simp
 
 @[simp]
-theorem insertIdx_zero (xs : Array α) (x : α) : xs.insertIdx 0 x = #[x] ++ xs := by
+theorem insertIdx_zero {xs : Array α} {x : α} : xs.insertIdx 0 x = #[x] ++ xs := by
   rcases xs with ⟨xs⟩
   simp
 
@@ -44,7 +44,7 @@ theorem insertIdx_zero (xs : Array α) (x : α) : xs.insertIdx 0 x = #[x] ++ xs
   rcases xs with ⟨xs⟩
   simp [List.length_insertIdx, h]
 
-theorem eraseIdx_insertIdx (i : Nat) (xs : Array α) (h : i ≤ xs.size) :
+theorem eraseIdx_insertIdx {i : Nat} {xs : Array α} (h : i ≤ xs.size) :
     (xs.insertIdx i a).eraseIdx i (by simp; omega) = xs := by
   rcases xs with ⟨xs⟩
   simp_all
@@ -54,27 +54,27 @@ theorem insertIdx_eraseIdx_of_ge {as : Array α}
     (as.eraseIdx i).insertIdx j a =
       (as.insertIdx (j + 1) a (by simp at w₂; omega)).eraseIdx i (by simp_all; omega) := by
   cases as
-  simpa using List.insertIdx_eraseIdx_of_ge _ _ _ (by simpa) (by simpa)
+  simpa using List.insertIdx_eraseIdx_of_ge (by simpa) (by simpa)
 
 theorem insertIdx_eraseIdx_of_le {as : Array α}
     (w₁ : i < as.size) (w₂ : j ≤ (as.eraseIdx i).size) (h : j ≤ i) :
     (as.eraseIdx i).insertIdx j a =
       (as.insertIdx j a (by simp at w₂; omega)).eraseIdx (i + 1) (by simp_all) := by
   cases as
-  simpa using List.insertIdx_eraseIdx_of_le _ _ _ (by simpa) (by simpa)
+  simpa using List.insertIdx_eraseIdx_of_le (by simpa) (by simpa)
 
-theorem insertIdx_comm (a b : α) (i j : Nat) (xs : Array α) (_ : i ≤ j) (_ : j ≤ xs.size) :
+theorem insertIdx_comm (a b : α) {i j : Nat} {xs : Array α} (_ : i ≤ j) (_ : j ≤ xs.size) :
     (xs.insertIdx i a).insertIdx (j + 1) b (by simpa) =
       (xs.insertIdx j b).insertIdx i a (by simp; omega) := by
   rcases xs with ⟨xs⟩
-  simpa using List.insertIdx_comm a b i j _ (by simpa) (by simpa)
+  simpa using List.insertIdx_comm a b (by simpa) (by simpa)
 
 theorem mem_insertIdx {xs : Array α} {h : i ≤ xs.size} : a ∈ xs.insertIdx i b h ↔ a = b ∨ a ∈ xs := by
   rcases xs with ⟨xs⟩
   simpa using List.mem_insertIdx (by simpa)
 
 @[simp]
-theorem insertIdx_size_self (xs : Array α) (x : α) : xs.insertIdx xs.size x = xs.push x := by
+theorem insertIdx_size_self {xs : Array α} {x : α} : xs.insertIdx xs.size x = xs.push x := by
   rcases xs with ⟨xs⟩
   simp
 

src/Init/Data/Array/Lex/Lemmas.lean

@@ -14,18 +14,18 @@ namespace Array
 
 /-! ### Lexicographic ordering -/
 
-@[simp] theorem _root_.List.lt_toArray [LT α] (l₁ l₂ : List α) : l₁.toArray < l₂.toArray ↔ l₁ < l₂ := Iff.rfl
-@[simp] theorem _root_.List.le_toArray [LT α] (l₁ l₂ : List α) : l₁.toArray ≤ l₂.toArray ↔ l₁ ≤ l₂ := Iff.rfl
+@[simp] theorem _root_.List.lt_toArray [LT α] {l₁ l₂ : List α} : l₁.toArray < l₂.toArray ↔ l₁ < l₂ := Iff.rfl
+@[simp] theorem _root_.List.le_toArray [LT α] {l₁ l₂ : List α} : l₁.toArray ≤ l₂.toArray ↔ l₁ ≤ l₂ := Iff.rfl
 
-@[simp] theorem lt_toList [LT α] (xs ys : Array α) : xs.toList < ys.toList ↔ xs < ys := Iff.rfl
-@[simp] theorem le_toList [LT α] (xs ys : Array α) : xs.toList ≤ ys.toList ↔ xs ≤ ys := Iff.rfl
+@[simp] theorem lt_toList [LT α] {xs ys : Array α} : xs.toList < ys.toList ↔ xs < ys := Iff.rfl
+@[simp] theorem le_toList [LT α] {xs ys : Array α} : xs.toList ≤ ys.toList ↔ xs ≤ ys := Iff.rfl
 
-protected theorem not_lt_iff_ge [LT α] (l₁ l₂ : List α) : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
-protected theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] (l₁ l₂ : List α) :
+protected theorem not_lt_iff_ge [LT α] {l₁ l₂ : List α} : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
+protected theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : List α} :
     ¬ l₁ ≤ l₂ ↔ l₂ < l₁ :=
   Decidable.not_not
 
-@[simp] theorem lex_empty [BEq α] {lt : α → α → Bool} (xs : Array α) : xs.lex #[] lt = false := by
+@[simp] theorem lex_empty [BEq α] {lt : α → α → Bool} {xs : Array α} : xs.lex #[] lt = false := by
   simp [lex, Id.run]
 
 @[simp] theorem singleton_lex_singleton [BEq α] {lt : α → α → Bool} : #[a].lex #[b] lt = lt a b := by
@@ -45,7 +45,7 @@ private theorem cons_lex_cons [BEq α] {lt : α → α → Bool} {a b : α} {xs
     cases a == b <;> simp
   · simp
 
-@[simp] theorem _root_.List.lex_toArray [BEq α] (lt : α → α → Bool) (l₁ l₂ : List α) :
+@[simp] theorem _root_.List.lex_toArray [BEq α] {lt : α → α → Bool} {l₁ l₂ : List α} :
     l₁.toArray.lex l₂.toArray lt = l₁.lex l₂ lt := by
   induction l₁ generalizing l₂ with
   | nil => cases l₂ <;> simp [lex, Id.run]
@@ -55,7 +55,7 @@ private theorem cons_lex_cons [BEq α] {lt : α → α → Bool} {a b : α} {xs
     | cons y l₂ =>
       rw [List.toArray_cons, List.toArray_cons y, cons_lex_cons, List.lex, ih]
 
-@[simp] theorem lex_toList [BEq α] (lt : α → α → Bool) (xs ys : Array α) :
+@[simp] theorem lex_toList [BEq α] {lt : α → α → Bool} {xs ys : Array α} :
     xs.toList.lex ys.toList lt = xs.lex ys lt := by
   cases xs <;> cases ys <;> simp
 
@@ -68,7 +68,7 @@ instance ltIrrefl [LT α] [Std.Irrefl (· < · : α → α → Prop)] : Std.Irre
 @[simp] theorem not_lt_empty [LT α] (xs : Array α) : ¬ xs < #[] := List.not_lt_nil xs.toList
 @[simp] theorem empty_le [LT α] (xs : Array α) : #[] ≤ xs := List.nil_le xs.toList
 
-@[simp] theorem le_empty [LT α] (xs : Array α) : xs ≤ #[] ↔ xs = #[] := by
+@[simp] theorem le_empty [LT α] {xs : Array α} : xs ≤ #[] ↔ xs = #[] := by
   cases xs
   simp
 
@@ -150,13 +150,13 @@ instance [DecidableEq α] [LT α] [DecidableLT α]
     Std.Total (· ≤ · : Array α → Array α → Prop) where
   total := Array.le_total
 
-@[simp] theorem lex_eq_true_iff_lt [DecidableEq α] [LT α] [DecidableLT α]
+@[simp] theorem lex_eq_true_iff_lt [BEq α] [LawfulBEq α] [LT α] [DecidableLT α]
     {xs ys : Array α} : lex xs ys = true ↔ xs < ys := by
   cases xs
   cases ys
   simp
 
-@[simp] theorem lex_eq_false_iff_ge [DecidableEq α] [LT α] [DecidableLT α]
+@[simp] theorem lex_eq_false_iff_ge [BEq α] [LawfulBEq α] [LT α] [DecidableLT α]
     {xs ys : Array α} : lex xs ys = false ↔ ys ≤ xs := by
   cases xs
   cases ys
@@ -198,7 +198,7 @@ This formulation requires that `==` and `lt` are compatible in the following sen
 - `==` is symmetric
   (we unnecessarily further assume it is transitive, to make use of the existing typeclasses)
 - `lt` is irreflexive with respect to `==` (i.e. if `x == y` then `lt x y = false`
-- `lt` is asymmmetric  (i.e. `lt x y = true → lt y x = false`)
+- `lt` is asymmetric  (i.e. `lt x y = true → lt y x = false`)
 - `lt` is antisymmetric with respect to `==` (i.e. `lt x y = false → lt y x = false → x == y`)
 -/
 theorem lex_eq_false_iff_exists [BEq α] [PartialEquivBEq α] (lt : α → α → Bool)

src/Init/Data/Array/MapIdx.lean

@@ -42,66 +42,66 @@ theorem mapFinIdx_induction (xs : Array α) (f : (i : Nat) → α → (h : i < x
       · exact (hs j (by omega) hm).2
   simp [mapFinIdx, mapFinIdxM]; exact go rfl nofun h0
 
-theorem mapFinIdx_spec (xs : Array α) (f : (i : Nat) → α → (h : i < xs.size) → β)
-    (p : (i : Nat) → β → (h : i < xs.size) → Prop) (hs : ∀ i h, p i (f i xs[i] h) h) :
+theorem mapFinIdx_spec {xs : Array α} {f : (i : Nat) → α → (h : i < xs.size) → β}
+    {p : (i : Nat) → β → (h : i < xs.size) → Prop} (hs : ∀ i h, p i (f i xs[i] h) h) :
     ∃ eq : (Array.mapFinIdx xs f).size = xs.size,
       ∀ i h, p i ((Array.mapFinIdx xs f)[i]) h :=
   (mapFinIdx_induction _ _ (fun _ => True) trivial p fun _ _ _ => ⟨hs .., trivial⟩).2
 
-@[simp] theorem size_mapFinIdx (xs : Array α) (f : (i : Nat) → α → (h : i < xs.size) → β) :
+@[simp] theorem size_mapFinIdx {xs : Array α} {f : (i : Nat) → α → (h : i < xs.size) → β} :
     (xs.mapFinIdx f).size = xs.size :=
   (mapFinIdx_spec (p := fun _ _ _ => True) (hs := fun _ _ => trivial)).1
 
-@[simp] theorem size_zipIdx (xs : Array α) (k : Nat) : (xs.zipIdx k).size = xs.size :=
-  Array.size_mapFinIdx _ _
+@[simp] theorem size_zipIdx {xs : Array α} {k : Nat} : (xs.zipIdx k).size = xs.size :=
+  Array.size_mapFinIdx
 
 @[deprecated size_zipIdx (since := "2025-01-21")] abbrev size_zipWithIndex := @size_zipIdx
 
-@[simp] theorem getElem_mapFinIdx (xs : Array α) (f : (i : Nat) → α → (h : i < xs.size) → β) (i : Nat)
+@[simp] theorem getElem_mapFinIdx {xs : Array α} {f : (i : Nat) → α → (h : i < xs.size) → β} {i : Nat}
     (h : i < (xs.mapFinIdx f).size) :
     (xs.mapFinIdx f)[i] = f i (xs[i]'(by simp_all)) (by simp_all) :=
-  (mapFinIdx_spec _ _ (fun i b h => b = f i xs[i] h) fun _ _ => rfl).2 i _
+  (mapFinIdx_spec (p := fun i b h => b = f i xs[i] h) fun _ _ => rfl).2 i _
 
-@[simp] theorem getElem?_mapFinIdx (xs : Array α) (f : (i : Nat) → α → (h : i < xs.size) → β) (i : Nat) :
+@[simp] theorem getElem?_mapFinIdx {xs : Array α} {f : (i : Nat) → α → (h : i < xs.size) → β} {i : Nat} :
     (xs.mapFinIdx f)[i]? =
       xs[i]?.pbind fun b h => f i b (getElem?_eq_some_iff.1 h).1 := by
   simp only [getElem?_def, size_mapFinIdx, getElem_mapFinIdx]
   split <;> simp_all
 
-@[simp] theorem toList_mapFinIdx (xs : Array α) (f : (i : Nat) → α → (h : i < xs.size) → β) :
+@[simp] theorem toList_mapFinIdx {xs : Array α} {f : (i : Nat) → α → (h : i < xs.size) → β} :
     (xs.mapFinIdx f).toList = xs.toList.mapFinIdx (fun i a h => f i a (by simpa)) := by
   apply List.ext_getElem <;> simp
 
 /-! ### mapIdx -/
 
-theorem mapIdx_induction (f : Nat → α → β) (xs : Array α)
-    (motive : Nat → Prop) (h0 : motive 0)
-    (p : (i : Nat) → β → (h : i < xs.size) → Prop)
+theorem mapIdx_induction {f : Nat → α → β} {xs : Array α}
+    {motive : Nat → Prop} (h0 : motive 0)
+    {p : (i : Nat) → β → (h : i < xs.size) → Prop}
     (hs : ∀ i h, motive i → p i (f i xs[i]) h ∧ motive (i + 1)) :
     motive xs.size ∧ ∃ eq : (xs.mapIdx f).size = xs.size,
       ∀ i h, p i ((xs.mapIdx f)[i]) h :=
   mapFinIdx_induction xs (fun i a _ => f i a) motive h0 p hs
 
-theorem mapIdx_spec (f : Nat → α → β) (xs : Array α)
-    (p : (i : Nat) → β → (h : i < xs.size) → Prop) (hs : ∀ i h, p i (f i xs[i]) h) :
+theorem mapIdx_spec {f : Nat → α → β} {xs : Array α}
+    {p : (i : Nat) → β → (h : i < xs.size) → Prop} (hs : ∀ i h, p i (f i xs[i]) h) :
     ∃ eq : (xs.mapIdx f).size = xs.size,
       ∀ i h, p i ((xs.mapIdx f)[i]) h :=
-  (mapIdx_induction _ _ (fun _ => True) trivial p fun _ _ _ => ⟨hs .., trivial⟩).2
+  (mapIdx_induction (motive := fun _ => True) trivial fun _ _ _ => ⟨hs .., trivial⟩).2
 
-@[simp] theorem size_mapIdx (f : Nat → α → β) (xs : Array α) : (xs.mapIdx f).size = xs.size :=
+@[simp] theorem size_mapIdx {f : Nat → α → β} {xs : Array α} : (xs.mapIdx f).size = xs.size :=
   (mapIdx_spec (p := fun _ _ _ => True) (hs := fun _ _ => trivial)).1
 
-@[simp] theorem getElem_mapIdx (f : Nat → α → β) (xs : Array α) (i : Nat)
+@[simp] theorem getElem_mapIdx {f : Nat → α → β} {xs : Array α} {i : Nat}
     (h : i < (xs.mapIdx f).size) :
     (xs.mapIdx f)[i] = f i (xs[i]'(by simp_all)) :=
-  (mapIdx_spec _ _ (fun i b h => b = f i xs[i]) fun _ _ => rfl).2 i (by simp_all)
+  (mapIdx_spec (p := fun i b h => b = f i xs[i]) fun _ _ => rfl).2 i (by simp_all)
 
-@[simp] theorem getElem?_mapIdx (f : Nat → α → β) (xs : Array α) (i : Nat) :
+@[simp] theorem getElem?_mapIdx {f : Nat → α → β} {xs : Array α} {i : Nat} :
     (xs.mapIdx f)[i]? =
       xs[i]?.map (f i) := by
   simp [getElem?_def, size_mapIdx, getElem_mapIdx]
 
-@[simp] theorem toList_mapIdx (f : Nat → α → β) (xs : Array α) :
+@[simp] theorem toList_mapIdx {f : Nat → α → β} {xs : Array α} :
     (xs.mapIdx f).toList = xs.toList.mapIdx (fun i a => f i a) := by
   apply List.ext_getElem <;> simp
 
@@ -109,11 +109,11 @@ end Array
 
 namespace List
 
-@[simp] theorem mapFinIdx_toArray (l : List α) (f : (i : Nat) → α → (h : i < l.length) → β) :
+@[simp] theorem mapFinIdx_toArray {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} :
     l.toArray.mapFinIdx f = (l.mapFinIdx f).toArray := by
   ext <;> simp
 
-@[simp] theorem mapIdx_toArray (f : Nat → α → β) (l : List α) :
+@[simp] theorem mapIdx_toArray {f : Nat → α → β} {l : List α} :
     l.toArray.mapIdx f = (l.mapIdx f).toArray := by
   ext <;> simp
 
@@ -123,7 +123,7 @@ namespace Array
 
 /-! ### zipIdx -/
 
-@[simp] theorem getElem_zipIdx (xs : Array α) (k : Nat) (i : Nat) (h : i < (xs.zipIdx k).size) :
+@[simp] theorem getElem_zipIdx {xs : Array α} {k : Nat} {i : Nat} (h : i < (xs.zipIdx k).size) :
     (xs.zipIdx k)[i] = (xs[i]'(by simp_all), k + i) := by
   simp [zipIdx]
 
@@ -137,7 +137,7 @@ abbrev getElem_zipWithIndex := @getElem_zipIdx
 @[deprecated zipIdx_toArray (since := "2025-01-21")]
 abbrev zipWithIndex_toArray := @zipIdx_toArray
 
-@[simp] theorem toList_zipIdx (xs : Array α) (k : Nat) :
+@[simp] theorem toList_zipIdx {xs : Array α} {k : Nat} :
     (xs.zipIdx k).toList = xs.toList.zipIdx k := by
   rcases xs with ⟨xs⟩
   simp
@@ -452,8 +452,8 @@ end Array
 
 namespace List
 
-theorem mapFinIdxM_toArray [Monad m] [LawfulMonad m] (l : List α)
-    (f : (i : Nat) → α → (h : i < l.length) → m β) :
+theorem mapFinIdxM_toArray [Monad m] [LawfulMonad m] {l : List α}
+    {f : (i : Nat) → α → (h : i < l.length) → m β} :
     l.toArray.mapFinIdxM f = toArray <$> l.mapFinIdxM f := by
   let rec go (i : Nat) (acc : Array β) (inv : i + acc.size = l.length) :
       Array.mapFinIdxM.map l.toArray f i acc.size inv acc
@@ -464,17 +464,17 @@ theorem mapFinIdxM_toArray [Monad m] [LawfulMonad m] (l : List α)
       rw [Nat.zero_add] at inv
       simp only [Array.mapFinIdxM.map, inv, drop_length, mapFinIdxM.go, map_pure]
     | k + 1 =>
-      conv => enter [2, 2, 3]; rw [← getElem_cons_drop l acc.size (by omega)]
+      conv => enter [2, 2, 3]; rw [← getElem_cons_drop (by omega)]
       simp only [Array.mapFinIdxM.map, mapFinIdxM.go, _root_.map_bind]
       congr; funext x
-      conv => enter [1, 4]; rw [← Array.size_push _ x]
-      conv => enter [2, 2, 3]; rw [← Array.size_push _ x]
+      conv => enter [1, 4]; rw [← Array.size_push x]
+      conv => enter [2, 2, 3]; rw [← Array.size_push x]
       refine go k (acc.push x) _
   simp only [Array.mapFinIdxM, mapFinIdxM]
   exact go _ #[] _
 
-theorem mapIdxM_toArray [Monad m] [LawfulMonad m] (l : List α)
-    (f : Nat → α → m β) :
+theorem mapIdxM_toArray [Monad m] [LawfulMonad m] {l : List α}
+    {f : Nat → α → m β} :
     l.toArray.mapIdxM f = toArray <$> l.mapIdxM f := by
   let rec go (bs : List α) (acc : Array β) (inv : bs.length + acc.size = l.length) :
       mapFinIdxM.go l (fun i a h => f i a) bs acc inv = mapIdxM.go f bs acc := by
@@ -490,14 +490,14 @@ end List
 
 namespace Array
 
-theorem toList_mapFinIdxM [Monad m] [LawfulMonad m] (xs : Array α)
-    (f : (i : Nat) → α → (h : i < xs.size) → m β) :
+theorem toList_mapFinIdxM [Monad m] [LawfulMonad m] {xs : Array α}
+    {f : (i : Nat) → α → (h : i < xs.size) → m β} :
     toList <$> xs.mapFinIdxM f = xs.toList.mapFinIdxM f := by
   rw [List.mapFinIdxM_toArray]
   simp only [Functor.map_map, id_map']
 
-theorem toList_mapIdxM [Monad m] [LawfulMonad m] (xs : Array α)
-    (f : Nat → α → m β) :
+theorem toList_mapIdxM [Monad m] [LawfulMonad m] {xs : Array α}
+    {f : Nat → α → m β} :
     toList <$> xs.mapIdxM f = xs.toList.mapIdxM f := by
   rw [List.mapIdxM_toArray]
   simp only [Functor.map_map, id_map']

src/Init/Data/Array/Monadic.lean

@@ -23,20 +23,20 @@ open Nat
 
 /-! ### mapM -/
 
-@[simp] theorem mapM_pure [Monad m] [LawfulMonad m] (xs : Array α) (f : α → β) :
+@[simp] theorem mapM_pure [Monad m] [LawfulMonad m] {xs : Array α} {f : α → β} :
     xs.mapM (m := m) (pure <| f ·) = pure (xs.map f) := by
   induction xs; simp_all
 
 @[simp] theorem mapM_id {xs : Array α} {f : α → Id β} : xs.mapM f = xs.map f :=
-  mapM_pure _ _
+  mapM_pure
 
-@[simp] theorem mapM_append [Monad m] [LawfulMonad m] (f : α → m β) {xs ys : Array α} :
+@[simp] theorem mapM_append [Monad m] [LawfulMonad m] {f : α → m β} {xs ys : Array α} :
     (xs ++ ys).mapM f = (return (← xs.mapM f) ++ (← ys.mapM f)) := by
   rcases xs with ⟨xs⟩
   rcases ys with ⟨ys⟩
   simp
 
-theorem mapM_eq_foldlM_push [Monad m] [LawfulMonad m] (f : α → m β) (xs : Array α) :
+theorem mapM_eq_foldlM_push [Monad m] [LawfulMonad m] {f : α → m β} {xs : Array α} :
     mapM f xs = xs.foldlM (fun acc a => return (acc.push (← f a))) #[] := by
   rcases xs with ⟨xs⟩
   simp only [List.mapM_toArray, bind_pure_comp, List.size_toArray, List.foldlM_toArray']
@@ -53,21 +53,21 @@ theorem mapM_eq_foldlM_push [Monad m] [LawfulMonad m] (f : α → m β) (xs : Ar
 
 /-! ### foldlM and foldrM -/
 
-theorem foldlM_map [Monad m] (f : β₁ → β₂) (g : α → β₂ → m α) (xs : Array β₁) (init : α) (w : stop = xs.size) :
+theorem foldlM_map [Monad m] {f : β₁ → β₂} {g : α → β₂ → m α} {xs : Array β₁} {init : α} {w : stop = xs.size} :
     (xs.map f).foldlM g init 0 stop = xs.foldlM (fun x y => g x (f y)) init 0 stop := by
   subst w
   cases xs
   simp [List.foldlM_map]
 
-theorem foldrM_map [Monad m] [LawfulMonad m] (f : β₁ → β₂) (g : β₂ → α → m α) (xs : Array β₁)
-    (init : α) (w : start = xs.size) :
+theorem foldrM_map [Monad m] [LawfulMonad m] {f : β₁ → β₂} {g : β₂ → α → m α} {xs : Array β₁}
+    {init : α} {w : start = xs.size} :
     (xs.map f).foldrM g init start 0 = xs.foldrM (fun x y => g (f x) y) init start 0 := by
   subst w
   cases xs
   simp [List.foldrM_map]
 
-theorem foldlM_filterMap [Monad m] [LawfulMonad m] (f : α → Option β) (g : γ → β → m γ)
-    (xs : Array α) (init : γ) (w : stop = (xs.filterMap f).size) :
+theorem foldlM_filterMap [Monad m] [LawfulMonad m] {f : α → Option β} {g : γ → β → m γ} {xs : Array α}
+    {init : γ} {w : stop = (xs.filterMap f).size} :
     (xs.filterMap f).foldlM g init 0 stop =
       xs.foldlM (fun x y => match f y with | some b => g x b | none => pure x) init := by
   subst w
@@ -75,8 +75,8 @@ theorem foldlM_filterMap [Monad m] [LawfulMonad m] (f : α → Option β) (g :
   simp [List.foldlM_filterMap]
   rfl
 
-theorem foldrM_filterMap [Monad m] [LawfulMonad m] (f : α → Option β) (g : β → γ → m γ)
-    (xs : Array α) (init : γ) (w : start = (xs.filterMap f).size) :
+theorem foldrM_filterMap [Monad m] [LawfulMonad m] {f : α → Option β} {g : β → γ → m γ} {xs : Array α}
+    {init : γ} {w : start = (xs.filterMap f).size} :
     (xs.filterMap f).foldrM g init start 0 =
       xs.foldrM (fun x y => match f x with | some b => g b y | none => pure y) init := by
   subst w
@@ -84,16 +84,16 @@ theorem foldrM_filterMap [Monad m] [LawfulMonad m] (f : α → Option β) (g :
   simp [List.foldrM_filterMap]
   rfl
 
-theorem foldlM_filter [Monad m] [LawfulMonad m] (p : α → Bool) (g : β → α → m β)
-    (xs : Array α) (init : β) (w : stop = (xs.filter p).size) :
+theorem foldlM_filter [Monad m] [LawfulMonad m] {p : α → Bool} {g : β → α → m β} {xs : Array α}
+    {init : β} {w : stop = (xs.filter p).size} :
     (xs.filter p).foldlM g init 0 stop =
       xs.foldlM (fun x y => if p y then g x y else pure x) init := by
   subst w
   cases xs
   simp [List.foldlM_filter]
 
-theorem foldrM_filter [Monad m] [LawfulMonad m] (p : α → Bool) (g : α → β → m β)
-    (xs : Array α) (init : β) (w : start = (xs.filter p).size) :
+theorem foldrM_filter [Monad m] [LawfulMonad m] {p : α → Bool} {g : α → β → m β} {xs : Array α}
+    {init : β} {w : start = (xs.filter p).size} :
     (xs.filter p).foldrM g init start 0 =
       xs.foldrM (fun x y => if p x then g x y else pure y) init := by
   subst w
@@ -101,7 +101,7 @@ theorem foldrM_filter [Monad m] [LawfulMonad m] (p : α → Bool) (g : α → β
   simp [List.foldrM_filter]
 
 @[simp] theorem foldlM_attachWith [Monad m]
-    (xs : Array α) {q : α → Prop} (H : ∀ a, a ∈ xs → q a) {f : β → { x // q x} → m β} {b} (w : stop = xs.size):
+    {xs : Array α} {q : α → Prop} (H : ∀ a, a ∈ xs → q a) {f : β → { x // q x} → m β} {b} (w : stop = xs.size):
     (xs.attachWith q H).foldlM f b 0 stop =
       xs.attach.foldlM (fun b ⟨a, h⟩ => f b ⟨a, H _ h⟩) b := by
   subst w
@@ -109,7 +109,8 @@ theorem foldrM_filter [Monad m] [LawfulMonad m] (p : α → Bool) (g : α → β
   simp [List.foldlM_map]
 
 @[simp] theorem foldrM_attachWith [Monad m] [LawfulMonad m]
-    (xs : Array α) {q : α → Prop} (H : ∀ a, a ∈ xs → q a) {f : { x // q x} → β → m β} {b} (w : start = xs.size):
+    {xs : Array α} {q : α → Prop} (H : ∀ a, a ∈ xs → q a) {f : { x // q x} → β → m β} {b}
+    {w : start = xs.size} :
     (xs.attachWith q H).foldrM f b start 0 =
       xs.attach.foldrM (fun a acc => f ⟨a.1, H _ a.2⟩ acc) b := by
   subst w
@@ -124,13 +125,13 @@ theorem foldrM_filter [Monad m] [LawfulMonad m] (p : α → Bool) (g : α → β
   cases as <;> cases bs
   simp_all
 
-@[simp] theorem forM_append [Monad m] [LawfulMonad m] (xs ys : Array α) (f : α → m PUnit) :
+@[simp] theorem forM_append [Monad m] [LawfulMonad m] {xs ys : Array α} {f : α → m PUnit} :
     forM (xs ++ ys) f = (do forM xs f; forM ys f) := by
   rcases xs with ⟨xs⟩
   rcases ys with ⟨ys⟩
   simp
 
-@[simp] theorem forM_map [Monad m] [LawfulMonad m] (xs : Array α) (g : α → β) (f : β → m PUnit) :
+@[simp] theorem forM_map [Monad m] [LawfulMonad m] {xs : Array α} {g : α → β} {f : β → m PUnit} :
     forM (xs.map g) f = forM xs (fun a => f (g a)) := by
   rcases xs with ⟨xs⟩
   simp
@@ -152,7 +153,7 @@ We can express a for loop over an array as a fold,
 in which whenever we reach `.done b` we keep that value through the rest of the fold.
 -/
 theorem forIn'_eq_foldlM [Monad m] [LawfulMonad m]
-    (xs : Array α) (f : (a : α) → a ∈ xs → β → m (ForInStep β)) (init : β) :
+    {xs : Array α} (f : (a : α) → a ∈ xs → β → m (ForInStep β)) (init : β) :
     forIn' xs init f = ForInStep.value <$>
       xs.attach.foldlM (fun b ⟨a, m⟩ => match b with
         | .yield b => f a m b
@@ -163,29 +164,29 @@ theorem forIn'_eq_foldlM [Monad m] [LawfulMonad m]
 
 /-- We can express a for loop over an array which always yields as a fold. -/
 @[simp] theorem forIn'_yield_eq_foldlM [Monad m] [LawfulMonad m]
-    (xs : Array α) (f : (a : α) → a ∈ xs → β → m γ) (g : (a : α) → a ∈ xs → β → γ → β) (init : β) :
+    {xs : Array α} (f : (a : α) → a ∈ xs → β → m γ) (g : (a : α) → a ∈ xs → β → γ → β) (init : β) :
     forIn' xs init (fun a m b => (fun c => .yield (g a m b c)) <$> f a m b) =
       xs.attach.foldlM (fun b ⟨a, m⟩ => g a m b <$> f a m b) init := by
   rcases xs with ⟨xs⟩
   simp [List.foldlM_map]
 
 @[simp] theorem forIn'_pure_yield_eq_foldl [Monad m] [LawfulMonad m]
-    (xs : Array α) (f : (a : α) → a ∈ xs → β → β) (init : β) :
+    {xs : Array α} (f : (a : α) → a ∈ xs → β → β) (init : β) :
     forIn' xs init (fun a m b => pure (.yield (f a m b))) =
       pure (f := m) (xs.attach.foldl (fun b ⟨a, h⟩ => f a h b) init) := by
   rcases xs with ⟨xs⟩
   simp [List.forIn'_pure_yield_eq_foldl, List.foldl_map]
 
 @[simp] theorem forIn'_yield_eq_foldl
-    (xs : Array α) (f : (a : α) → a ∈ xs → β → β) (init : β) :
+    {xs : Array α} (f : (a : α) → a ∈ xs → β → β) (init : β) :
     forIn' (m := Id) xs init (fun a m b => .yield (f a m b)) =
       xs.attach.foldl (fun b ⟨a, h⟩ => f a h b) init := by
   rcases xs with ⟨xs⟩
   simp [List.foldl_map]
 
 @[simp] theorem forIn'_map [Monad m] [LawfulMonad m]
-    (xs : Array α) (g : α → β) (f : (b : β) → b ∈ xs.map g → γ → m (ForInStep γ)) :
-    forIn' (xs.map g) init f = forIn' xs init fun a h y => f (g a) (mem_map_of_mem g h) y := by
+    {xs : Array α} (g : α → β) (f : (b : β) → b ∈ xs.map g → γ → m (ForInStep γ)) :
+    forIn' (xs.map g) init f = forIn' xs init fun a h y => f (g a) (mem_map_of_mem h) y := by
   rcases xs with ⟨xs⟩
   simp
 
@@ -194,7 +195,7 @@ We can express a for loop over an array as a fold,
 in which whenever we reach `.done b` we keep that value through the rest of the fold.
 -/
 theorem forIn_eq_foldlM [Monad m] [LawfulMonad m]
-    (f : α → β → m (ForInStep β)) (init : β) (xs : Array α) :
+    {xs : Array α} (f : α → β → m (ForInStep β)) (init : β) :
     forIn xs init f = ForInStep.value <$>
       xs.foldlM (fun b a => match b with
         | .yield b => f a b
@@ -205,40 +206,40 @@ theorem forIn_eq_foldlM [Monad m] [LawfulMonad m]
 
 /-- We can express a for loop over an array which always yields as a fold. -/
 @[simp] theorem forIn_yield_eq_foldlM [Monad m] [LawfulMonad m]
-    (xs : Array α) (f : α → β → m γ) (g : α → β → γ → β) (init : β) :
+    {xs : Array α} (f : α → β → m γ) (g : α → β → γ → β) (init : β) :
     forIn xs init (fun a b => (fun c => .yield (g a b c)) <$> f a b) =
       xs.foldlM (fun b a => g a b <$> f a b) init := by
   rcases xs with ⟨xs⟩
   simp [List.foldlM_map]
 
 @[simp] theorem forIn_pure_yield_eq_foldl [Monad m] [LawfulMonad m]
-    (xs : Array α) (f : α → β → β) (init : β) :
+    {xs : Array α} (f : α → β → β) (init : β) :
     forIn xs init (fun a b => pure (.yield (f a b))) =
       pure (f := m) (xs.foldl (fun b a => f a b) init) := by
   rcases xs with ⟨xs⟩
   simp [List.forIn_pure_yield_eq_foldl, List.foldl_map]
 
 @[simp] theorem forIn_yield_eq_foldl
-    (xs : Array α) (f : α → β → β) (init : β) :
+    {xs : Array α} (f : α → β → β) (init : β) :
     forIn (m := Id) xs init (fun a b => .yield (f a b)) =
       xs.foldl (fun b a => f a b) init := by
   rcases xs with ⟨xs⟩
   simp [List.foldl_map]
 
 @[simp] theorem forIn_map [Monad m] [LawfulMonad m]
-    (xs : Array α) (g : α → β) (f : β → γ → m (ForInStep γ)) :
+    {xs : Array α} {g : α → β} {f : β → γ → m (ForInStep γ)} :
     forIn (xs.map g) init f = forIn xs init fun a y => f (g a) y := by
   rcases xs with ⟨xs⟩
   simp
 
 /-! ### allM and anyM -/
 
-@[simp] theorem anyM_pure [Monad m] [LawfulMonad m] (p : α → Bool) (xs : Array α) :
+@[simp] theorem anyM_pure [Monad m] [LawfulMonad m] {p : α → Bool} {xs : Array α} :
     xs.anyM (m := m) (pure <| p ·) = pure (xs.any p) := by
   cases xs
   simp
 
-@[simp] theorem allM_pure [Monad m] [LawfulMonad m] (p : α → Bool) (xs : Array α) :
+@[simp] theorem allM_pure [Monad m] [LawfulMonad m] {p : α → Bool} {xs : Array α} :
     xs.allM (m := m) (pure <| p ·) = pure (xs.all p) := by
   cases xs
   simp
@@ -246,13 +247,13 @@ theorem forIn_eq_foldlM [Monad m] [LawfulMonad m]
 /-! ### findM? and findSomeM? -/
 
 @[simp]
-theorem findM?_pure {m} [Monad m] [LawfulMonad m] (p : α → Bool) (xs : Array α) :
+theorem findM?_pure {m} [Monad m] [LawfulMonad m] {p : α → Bool} {xs : Array α} :
     findM? (m := m) (pure <| p ·) xs = pure (xs.find? p) := by
   cases xs
   simp
 
 @[simp]
-theorem findSomeM?_pure [Monad m] [LawfulMonad m] (f : α → Option β) (xs : Array α) :
+theorem findSomeM?_pure [Monad m] [LawfulMonad m] {f : α → Option β} {xs : Array α} :
     findSomeM? (m := m) (pure <| f ·) xs = pure (xs.findSome? f) := by
   cases xs
   simp
@@ -261,7 +262,7 @@ end Array
 
 namespace List
 
-theorem filterM_toArray [Monad m] [LawfulMonad m] (l : List α) (p : α → m Bool) :
+theorem filterM_toArray [Monad m] [LawfulMonad m] {l : List α} {p : α → m Bool} :
     l.toArray.filterM p = toArray <$> l.filterM p := by
   simp only [Array.filterM, filterM, foldlM_toArray, bind_pure_comp, Functor.map_map]
   conv => lhs; rw [← reverse_nil]
@@ -276,24 +277,24 @@ theorem filterM_toArray [Monad m] [LawfulMonad m] (l : List α) (p : α → m Bo
       exact ih (x :: acc)
 
 /-- Variant of `filterM_toArray` with a side condition for the stop position. -/
-@[simp] theorem filterM_toArray' [Monad m] [LawfulMonad m] (l : List α) (p : α → m Bool) (w : stop = l.length) :
+@[simp] theorem filterM_toArray' [Monad m] [LawfulMonad m] {l : List α} {p : α → m Bool} (w : stop = l.length) :
     l.toArray.filterM p 0 stop = toArray <$> l.filterM p := by
   subst w
   rw [filterM_toArray]
 
-theorem filterRevM_toArray [Monad m] [LawfulMonad m] (l : List α) (p : α → m Bool) :
+theorem filterRevM_toArray [Monad m] [LawfulMonad m] {l : List α} {p : α → m Bool} :
     l.toArray.filterRevM p = toArray <$> l.filterRevM p := by
   simp [Array.filterRevM, filterRevM]
   rw [← foldlM_reverse, ← foldlM_toArray, ← Array.filterM, filterM_toArray]
   simp only [filterM, bind_pure_comp, Functor.map_map, reverse_toArray, reverse_reverse]
 
 /-- Variant of `filterRevM_toArray` with a side condition for the start position. -/
-@[simp] theorem filterRevM_toArray' [Monad m] [LawfulMonad m] (l : List α) (p : α → m Bool) (w : start = l.length) :
+@[simp] theorem filterRevM_toArray' [Monad m] [LawfulMonad m] {l : List α} {p : α → m Bool} (w : start = l.length) :
     l.toArray.filterRevM p start 0 = toArray <$> l.filterRevM p := by
   subst w
   rw [filterRevM_toArray]
 
-theorem filterMapM_toArray [Monad m] [LawfulMonad m] (l : List α) (f : α → m (Option β)) :
+theorem filterMapM_toArray [Monad m] [LawfulMonad m] {l : List α} {f : α → m (Option β)} :
     l.toArray.filterMapM f = toArray <$> l.filterMapM f := by
   simp [Array.filterMapM, filterMapM]
   conv => lhs; rw [← reverse_nil]
@@ -306,12 +307,12 @@ theorem filterMapM_toArray [Monad m] [LawfulMonad m] (l : List α) (f : α → m
     · simp only [pure_bind]; rw [← List.reverse_cons]; exact ih _
 
 /-- Variant of `filterMapM_toArray` with a side condition for the stop position. -/
-@[simp] theorem filterMapM_toArray' [Monad m] [LawfulMonad m] (l : List α) (f : α → m (Option β)) (w : stop = l.length) :
+@[simp] theorem filterMapM_toArray' [Monad m] [LawfulMonad m] {l : List α} {f : α → m (Option β)} (w : stop = l.length) :
     l.toArray.filterMapM f 0 stop = toArray <$> l.filterMapM f := by
   subst w
   rw [filterMapM_toArray]
 
-@[simp] theorem flatMapM_toArray [Monad m] [LawfulMonad m] (l : List α) (f : α → m (Array β)) :
+@[simp] theorem flatMapM_toArray [Monad m] [LawfulMonad m] {l : List α} {f : α → m (Array β)} :
     l.toArray.flatMapM f = toArray <$> l.flatMapM (fun a => Array.toList <$> f a) := by
   simp only [Array.flatMapM, bind_pure_comp, foldlM_toArray, flatMapM]
   conv => lhs; arg 2; change [].reverse.flatten.toArray
@@ -352,22 +353,22 @@ namespace Array
   subst w
   simp [flatMapM, h]
 
-theorem toList_filterM [Monad m] [LawfulMonad m] (xs : Array α) (p : α → m Bool) :
+theorem toList_filterM [Monad m] [LawfulMonad m] {xs : Array α} {p : α → m Bool} :
     toList <$> xs.filterM p = xs.toList.filterM p := by
   rw [List.filterM_toArray]
   simp only [Functor.map_map, id_map']
 
-theorem toList_filterRevM [Monad m] [LawfulMonad m] (xs : Array α) (p : α → m Bool) :
+theorem toList_filterRevM [Monad m] [LawfulMonad m] {xs : Array α} {p : α → m Bool} :
     toList <$> xs.filterRevM p = xs.toList.filterRevM p := by
   rw [List.filterRevM_toArray]
   simp only [Functor.map_map, id_map']
 
-theorem toList_filterMapM [Monad m] [LawfulMonad m] (xs : Array α) (f : α → m (Option β)) :
+theorem toList_filterMapM [Monad m] [LawfulMonad m] {xs : Array α} {f : α → m (Option β)} :
     toList <$> xs.filterMapM f = xs.toList.filterMapM f := by
   rw [List.filterMapM_toArray]
   simp only [Functor.map_map, id_map']
 
-theorem toList_flatMapM [Monad m] [LawfulMonad m] (xs : Array α) (f : α → m (Array β)) :
+theorem toList_flatMapM [Monad m] [LawfulMonad m] {xs : Array α} {f : α → m (Array β)} :
     toList <$> xs.flatMapM f = xs.toList.flatMapM (fun a => toList <$> f a) := by
   rw [List.flatMapM_toArray]
   simp only [Functor.map_map, id_map']
@@ -387,11 +388,11 @@ and simplifies these to the function directly taking the value.
   simp
   rw [List.foldlM_subtype hf]
 
-@[wf_preprocess] theorem foldlM_wfParam [Monad m] (xs : Array α) (f : β → α → m β) (init : β) :
+@[wf_preprocess] theorem foldlM_wfParam [Monad m] {xs : Array α} {f : β → α → m β} {init : β} :
     (wfParam xs).foldlM f init = xs.attach.unattach.foldlM f init := by
   simp [wfParam]
 
-@[wf_preprocess] theorem foldlM_unattach [Monad m] (P : α → Prop) (xs : Array (Subtype P)) (f : β → α → m β) (init : β) :
+@[wf_preprocess] theorem foldlM_unattach [Monad m] {P : α → Prop} {xs : Array (Subtype P)} {f : β → α → m β} {init : β} :
     xs.unattach.foldlM f init = xs.foldlM (init := init) fun b ⟨x, h⟩ =>
       binderNameHint b f <| binderNameHint x (f b) <| binderNameHint h () <|
       f b (wfParam x) := by
@@ -411,11 +412,11 @@ and simplifies these to the function directly taking the value.
   rw [List.foldrM_subtype hf]
 
 
-@[wf_preprocess] theorem foldrM_wfParam [Monad m] [LawfulMonad m] (xs : Array α) (f : α → β → m β) (init : β) :
+@[wf_preprocess] theorem foldrM_wfParam [Monad m] [LawfulMonad m] {xs : Array α} {f : α → β → m β} {init : β} :
     (wfParam xs).foldrM f init = xs.attach.unattach.foldrM f init := by
   simp [wfParam]
 
-@[wf_preprocess] theorem foldrM_unattach [Monad m] [LawfulMonad m] (P : α → Prop) (xs : Array (Subtype P)) (f : α → β → m β) (init : β):
+@[wf_preprocess] theorem foldrM_unattach [Monad m] [LawfulMonad m] {P : α → Prop} {xs : Array (Subtype P)} {f : α → β → m β} {init : β} :
     xs.unattach.foldrM f init = xs.foldrM (init := init) fun ⟨x, h⟩ b =>
       binderNameHint x f <| binderNameHint h () <| binderNameHint b (f x) <|
       f (wfParam x) b := by
@@ -432,11 +433,11 @@ and simplifies these to the function directly taking the value.
   simp
   rw [List.mapM_subtype hf]
 
-@[wf_preprocess] theorem mapM_wfParam [Monad m] [LawfulMonad m] (xs : Array α) (f : α → m β) :
+@[wf_preprocess] theorem mapM_wfParam [Monad m] [LawfulMonad m] {xs : Array α} {f : α → m β} :
     (wfParam xs).mapM f = xs.attach.unattach.mapM f := by
   simp [wfParam]
 
-@[wf_preprocess] theorem mapM_unattach [Monad m] [LawfulMonad m] (P : α → Prop) (xs : Array (Subtype P)) (f : α → m β) :
+@[wf_preprocess] theorem mapM_unattach [Monad m] [LawfulMonad m] {P : α → Prop} {xs : Array (Subtype P)} {f : α → m β} :
     xs.unattach.mapM f = xs.mapM fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x) := by
   simp [wfParam]
@@ -451,12 +452,12 @@ and simplifies these to the function directly taking the value.
 
 
 @[wf_preprocess] theorem filterMapM_wfParam [Monad m] [LawfulMonad m]
-    (xs : Array α) (f : α → m (Option β)) :
+    {xs : Array α} {f : α → m (Option β)} :
     (wfParam xs).filterMapM f = xs.attach.unattach.filterMapM f := by
   simp [wfParam]
 
 @[wf_preprocess] theorem filterMapM_unattach [Monad m] [LawfulMonad m]
-    (P : α → Prop) (xs : Array (Subtype P)) (f : α → m (Option β)) :
+    {P : α → Prop} {xs : Array (Subtype P)} {f : α → m (Option β)} :
     xs.unattach.filterMapM f = xs.filterMapM fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x) := by
   simp [wfParam]
@@ -470,12 +471,12 @@ and simplifies these to the function directly taking the value.
   simp [hf]
 
 @[wf_preprocess] theorem flatMapM_wfParam [Monad m] [LawfulMonad m]
-    (xs : Array α) (f : α → m (Array β)) :
+    {xs : Array α} {f : α → m (Array β)} :
     (wfParam xs).flatMapM f = xs.attach.unattach.flatMapM f := by
   simp [wfParam]
 
 @[wf_preprocess] theorem flatMapM_unattach [Monad m] [LawfulMonad m]
-    (P : α → Prop) (xs : Array (Subtype P)) (f : α → m (Array β)) :
+    {P : α → Prop} {xs : Array (Subtype P)} {f : α → m (Array β)} :
     xs.unattach.flatMapM f = xs.flatMapM fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x) := by
   simp [wfParam]

src/Init/Data/Array/OfFn.lean

@@ -16,10 +16,10 @@ set_option linter.indexVariables true -- Enforce naming conventions for index va
 
 namespace Array
 
-@[simp] theorem ofFn_zero (f : Fin 0 → α) : ofFn f = #[] := by
+@[simp] theorem ofFn_zero {f : Fin 0 → α} : ofFn f = #[] := by
   simp [ofFn, ofFn.go]
 
-theorem ofFn_succ (f : Fin (n+1) → α) :
+theorem ofFn_succ {f : Fin (n+1) → α} :
     ofFn f = (ofFn (fun (i : Fin n) => f i.castSucc)).push (f ⟨n, by omega⟩) := by
   ext i h₁ h₂
   · simp
@@ -30,10 +30,10 @@ theorem ofFn_succ (f : Fin (n+1) → α) :
       simp at h₁ h₂
       omega
 
-@[simp] theorem _rooy_.List.toArray_ofFn (f : Fin n → α) : (List.ofFn f).toArray = Array.ofFn f := by
+@[simp] theorem _root_.List.toArray_ofFn {f : Fin n → α} : (List.ofFn f).toArray = Array.ofFn f := by
   ext <;> simp
 
-@[simp] theorem toList_ofFn (f : Fin n → α) : (Array.ofFn f).toList = List.ofFn f := by
+@[simp] theorem toList_ofFn {f : Fin n → α} : (Array.ofFn f).toList = List.ofFn f := by
   apply List.ext_getElem <;> simp
 
 @[simp]
@@ -42,7 +42,7 @@ theorem ofFn_eq_empty_iff {f : Fin n → α} : ofFn f = #[] ↔ n = 0 := by
   simp
 
 @[simp 500]
-theorem mem_ofFn {n} (f : Fin n → α) (a : α) : a ∈ ofFn f ↔ ∃ i, f i = a := by
+theorem mem_ofFn {n} {f : Fin n → α} {a : α} : a ∈ ofFn f ↔ ∃ i, f i = a := by
   constructor
   · intro w
     obtain ⟨i, h, rfl⟩ := getElem_of_mem w

src/Init/Data/Array/Perm.lean

@@ -34,7 +34,7 @@ theorem perm_iff_toList_perm {as bs : Array α} : as ~ bs ↔ as.toList ~ bs.toL
   cases xs
   simp
 
-protected theorem Perm.rfl {xs : List α} : xs ~ xs := .refl _
+protected theorem Perm.rfl {xs : Array α} : xs ~ xs := .refl _
 
 theorem Perm.of_eq {xs ys : Array α} (h : xs = ys) : xs ~ ys := h ▸ .rfl
 
@@ -53,6 +53,17 @@ instance : Trans (Perm (α := α)) (Perm (α := α)) (Perm (α := α)) where
 
 theorem perm_comm {xs ys : Array α} : xs ~ ys ↔ ys ~ xs := ⟨Perm.symm, Perm.symm⟩
 
+theorem Perm.length_eq {xs ys : Array α} (p : xs ~ ys) : xs.size = ys.size := by
+  cases xs; cases ys
+  simp only [perm_toArray] at p
+  simpa using p.length_eq
+
+theorem Perm.mem_iff {a : α} {xs ys : Array α} (p : xs ~ ys) : a ∈ xs ↔ a ∈ ys := by
+  rcases xs with ⟨xs⟩
+  rcases ys with ⟨ys⟩
+  simp at p
+  simpa using p.mem_iff
+
 theorem Perm.push (x y : α) {xs ys : Array α} (p : xs ~ ys) :
     (xs.push x).push y ~ (ys.push y).push x := by
   cases xs; cases ys
@@ -65,4 +76,20 @@ theorem swap_perm {xs : Array α} {i j : Nat} (h₁ : i < xs.size) (h₂ : j < x
   simp only [swap, perm_iff_toList_perm, toList_set]
   apply set_set_perm
 
+namespace Perm
+
+set_option linter.indexVariables false in
+theorem extract {xs ys : Array α} (h : xs ~ ys) {lo hi : Nat}
+    (wlo : ∀ i, i < lo → xs[i]? = ys[i]?) (whi : ∀ i, hi ≤ i → xs[i]? = ys[i]?) :
+    (xs.extract lo hi) ~ (ys.extract lo hi) := by
+  rcases xs with ⟨xs⟩
+  rcases ys with ⟨ys⟩
+  simp_all only [perm_toArray, List.getElem?_toArray, List.extract_toArray,
+    List.extract_eq_drop_take]
+  apply List.Perm.take_of_getElem? (w := fun i h => by simpa using whi (lo + i) (by omega))
+  apply List.Perm.drop_of_getElem? (w := wlo)
+  exact h
+
+end Perm
+
 end Array

src/Init/Data/Array/Range.lean

@@ -26,14 +26,14 @@ open Nat
 
 /-! ### range' -/
 
-theorem range'_succ (s n step) : range' s (n + 1) step = #[s] ++ range' (s + step) n step := by
+theorem range'_succ {s n step} : range' s (n + 1) step = #[s] ++ range' (s + step) n step := by
   rw [← toList_inj]
   simp [List.range'_succ]
 
 @[simp] theorem range'_eq_empty_iff : range' s n step = #[] ↔ n = 0 := by
   rw [← size_eq_zero_iff, size_range']
 
-theorem range'_ne_empty_iff (s : Nat) {n step : Nat} : range' s n step ≠ #[] ↔ n ≠ 0 := by
+theorem range'_ne_empty_iff : range' s n step ≠ #[] ↔ n ≠ 0 := by
   cases n <;> simp
 
 @[simp] theorem range'_zero : range' s 0 step = #[] := by
@@ -57,13 +57,13 @@ theorem mem_range' {n} : m ∈ range' s n step ↔ ∃ i < n, m = s + step * i :
 theorem pop_range' : (range' s n step).pop = range' s (n - 1) step := by
   ext <;> simp
 
-theorem map_add_range' (a) (s n step) : map (a + ·) (range' s n step) = range' (a + s) n step := by
+theorem map_add_range' {a} (s n step) : map (a + ·) (range' s n step) = range' (a + s) n step := by
   ext <;> simp <;> omega
 
 theorem range'_succ_left : range' (s + 1) n step = (range' s n step).map (· + 1) := by
   ext <;> simp <;> omega
 
-theorem range'_append (s m n step : Nat) :
+theorem range'_append {s m n step : Nat} :
     range' s m step ++ range' (s + step * m) n step = range' s (m + n) step := by
   ext i h₁ h₂
   · simp
@@ -74,13 +74,13 @@ theorem range'_append (s m n step : Nat) :
     have : step * m ≤ step * i := by exact mul_le_mul_left step h
     omega
 
-@[simp] theorem range'_append_1 (s m n : Nat) :
-    range' s m ++ range' (s + m) n = range' s (m + n) := by simpa using range'_append s m n 1
+@[simp] theorem range'_append_1 {s m n : Nat} :
+    range' s m ++ range' (s + m) n = range' s (m + n) := by simpa using range'_append (step := 1)
 
-theorem range'_concat (s n : Nat) : range' s (n + 1) step = range' s n step ++ #[s + step * n] := by
-  simpa using (range'_append s n 1 step).symm
+theorem range'_concat {s n : Nat} : range' s (n + 1) step = range' s n step ++ #[s + step * n] := by
+  simpa using range'_append.symm
 
-theorem range'_1_concat (s n : Nat) : range' s (n + 1) = range' s n ++ #[s + n] := by
+theorem range'_1_concat {s n : Nat} : range' s (n + 1) = range' s n ++ #[s + n] := by
   simp [range'_concat]
 
 @[simp] theorem mem_range'_1 : m ∈ range' s n ↔ s ≤ m ∧ m < s + n := by
@@ -88,7 +88,7 @@ theorem range'_1_concat (s n : Nat) : range' s (n + 1) = range' s n ++ #[s + n]
     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 map_sub_range' (a s n : Nat) (h : a ≤ s) :
+theorem map_sub_range' {a s : Nat} (h : a ≤ s) (n : Nat) :
     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]
@@ -121,10 +121,10 @@ theorem erase_range' :
 
 /-! ### range -/
 
-theorem range_eq_range' (n : Nat) : range n = range' 0 n := by
+theorem range_eq_range' {n : Nat} : range n = range' 0 n := by
   simp [range, range']
 
-theorem range_succ_eq_map (n : Nat) : range (n + 1) = #[0] ++ map succ (range n) := by
+theorem range_succ_eq_map {n : Nat} : range (n + 1) = #[0] ++ map succ (range n) := by
   ext i h₁ h₂
   · simp
     omega
@@ -133,7 +133,7 @@ theorem range_succ_eq_map (n : Nat) : range (n + 1) = #[0] ++ map succ (range n)
       succ_eq_add_one, dite_eq_ite]
     split <;> omega
 
-theorem range'_eq_map_range (s n : Nat) : range' s n = map (s + ·) (range n) := by
+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 range_eq_empty_iff {n : Nat} : range n = #[] ↔ n = 0 := by
@@ -142,7 +142,7 @@ theorem range'_eq_map_range (s n : Nat) : range' s n = map (s + ·) (range n) :=
 theorem range_ne_empty_iff {n : Nat} : range n ≠ #[] ↔ n ≠ 0 := by
   cases n <;> simp
 
-theorem range_succ (n : Nat) : range (succ n) = range n ++ #[n] := by
+theorem range_succ {n : Nat} : range (succ n) = range n ++ #[n] := by
   ext i h₁ h₂
   · simp
   · simp only [succ_eq_add_one, size_range] at h₁
@@ -150,11 +150,11 @@ theorem range_succ (n : Nat) : range (succ n) = range n ++ #[n] := by
       dite_eq_ite]
     split <;> omega
 
-theorem range_add (n m : Nat) : range (n + m) = range n ++ (range m).map (n + ·) := by
+theorem range_add {n m : Nat} : range (n + m) = range n ++ (range m).map (n + ·) := by
   rw [← range'_eq_map_range]
-  simpa [range_eq_range', Nat.add_comm] using (range'_append_1 0 n m).symm
+  simpa [range_eq_range', Nat.add_comm] using (range'_append_1 (s := 0)).symm
 
-theorem reverse_range' (s n : Nat) : reverse (range' s n) = map (s + n - 1 - ·) (range n) := by
+theorem reverse_range' {s n : Nat} : reverse (range' s n) = map (s + n - 1 - ·) (range n) := by
   simp [← toList_inj, List.reverse_range']
 
 @[simp]
@@ -163,9 +163,9 @@ theorem mem_range {m n : Nat} : m ∈ range n ↔ m < n := by
 
 theorem not_mem_range_self {n : Nat} : n ∉ range n := by simp
 
-theorem self_mem_range_succ (n : Nat) : n ∈ range (n + 1) := by simp
+theorem self_mem_range_succ {n : Nat} : n ∈ range (n + 1) := by simp
 
-@[simp] theorem take_range (i n : Nat) : take (range n) i = range (min i n) := by
+@[simp] theorem take_range {i n : Nat} : take (range n) i = range (min i n) := by
   ext <;> simp
 
 @[simp] theorem find?_range_eq_some {n : Nat} {i : Nat} {p : Nat → Bool} :
@@ -188,48 +188,50 @@ theorem zipIdx_eq_empty_iff {xs : Array α} {i : Nat} : xs.zipIdx i = #[] ↔ xs
   simp
 
 @[simp]
-theorem getElem?_zipIdx (xs : Array α) (i j) : (zipIdx xs i)[j]? = xs[j]?.map fun a => (a, i + j) := by
+theorem getElem?_zipIdx {xs : Array α} {i j} : (zipIdx xs i)[j]? = xs[j]?.map fun a => (a, i + j) := by
   simp [getElem?_def]
 
-theorem map_snd_add_zipIdx_eq_zipIdx (xs : Array α) (n k : Nat) :
+theorem map_snd_add_zipIdx_eq_zipIdx {xs : Array α} {n k : Nat} :
     map (Prod.map id (· + n)) (zipIdx xs k) = zipIdx xs (n + k) :=
   ext_getElem? fun i ↦ by simp [(· ∘ ·), Nat.add_comm, Nat.add_left_comm]; rfl
 
+-- Arguments are explicit for parity with `zipIdx_map_fst`.
 @[simp]
 theorem zipIdx_map_snd (i) (xs : Array α) : map Prod.snd (zipIdx xs i) = range' i xs.size := by
   cases xs
   simp
 
+-- Arguments are explicit so we can rewrite from right to left.
 @[simp]
 theorem zipIdx_map_fst (i) (xs : Array α) : map Prod.fst (zipIdx xs i) = xs := by
   cases xs
   simp
 
-theorem zipIdx_eq_zip_range' (xs : Array α) {i : Nat} : xs.zipIdx i = xs.zip (range' i xs.size) := by
+theorem zipIdx_eq_zip_range' {xs : Array α} {i : Nat} : xs.zipIdx i = xs.zip (range' i xs.size) := by
   simp [zip_of_prod (zipIdx_map_fst _ _) (zipIdx_map_snd _ _)]
 
 @[simp]
-theorem unzip_zipIdx_eq_prod (xs : Array α) {i : Nat} :
+theorem unzip_zipIdx_eq_prod {xs : Array α} {i : Nat} :
     (xs.zipIdx i).unzip = (xs, range' i xs.size) := by
   simp only [zipIdx_eq_zip_range', unzip_zip, size_range']
 
 /-- Replace `zipIdx` with a starting index `n+1` with `zipIdx` starting from `n`,
 followed by a `map` increasing the indices by one. -/
-theorem zipIdx_succ (xs : Array α) (i : Nat) :
+theorem zipIdx_succ {xs : Array α} {i : Nat} :
     xs.zipIdx (i + 1) = (xs.zipIdx i).map (fun ⟨a, j⟩ => (a, j + 1)) := by
   cases xs
   simp [List.zipIdx_succ]
 
 /-- Replace `zipIdx` with a starting index with `zipIdx` starting from 0,
 followed by a `map` increasing the indices. -/
-theorem zipIdx_eq_map_add (xs : Array α) (i : Nat) :
+theorem zipIdx_eq_map_add {xs : Array α} {i : Nat} :
     xs.zipIdx i = (xs.zipIdx 0).map (fun ⟨a, j⟩ => (a, i + j)) := by
   cases xs
   simp only [zipIdx_toArray, List.map_toArray, mk.injEq]
   rw [List.zipIdx_eq_map_add]
 
 @[simp]
-theorem zipIdx_singleton (x : α) (k : Nat) : zipIdx #[x] k = #[(x, k)] :=
+theorem zipIdx_singleton {x : α} {k : Nat} : zipIdx #[x] k = #[(x, k)] :=
   rfl
 
 theorem mk_add_mem_zipIdx_iff_getElem? {k i : Nat} {x : α} {xs : Array α} :
@@ -248,13 +250,13 @@ theorem snd_lt_add_of_mem_zipIdx {x : α × Nat} {k : Nat} {xs : Array α} (h :
 theorem snd_lt_of_mem_zipIdx {x : α × Nat} {k : Nat} {xs : Array α} (h : x ∈ zipIdx xs k) : x.2 < xs.size + k := by
   simpa [Nat.add_comm] using snd_lt_add_of_mem_zipIdx h
 
-theorem map_zipIdx (f : α → β) (xs : Array α) (k : Nat) :
+theorem map_zipIdx {f : α → β} {xs : Array α} {k : Nat} :
     map (Prod.map f id) (zipIdx xs k) = zipIdx (xs.map f) k := by
   cases xs
   simp [List.map_zipIdx]
 
 theorem fst_mem_of_mem_zipIdx {x : α × Nat} {xs : Array α} {k : Nat} (h : x ∈ zipIdx xs k) : x.1 ∈ xs :=
-  zipIdx_map_fst k xs ▸ mem_map_of_mem _ h
+  zipIdx_map_fst k xs ▸ mem_map_of_mem h
 
 theorem fst_eq_of_mem_zipIdx {x : α × Nat} {xs : Array α} {k : Nat} (h : x ∈ zipIdx xs k) :
     x.1 = xs[x.2 - k]'(by have := le_snd_of_mem_zipIdx h; have := snd_lt_add_of_mem_zipIdx h; omega) := by
@@ -271,12 +273,12 @@ theorem mem_zipIdx' {x : α} {i : Nat} {xs : Array α} (h : (x, i) ∈ xs.zipIdx
     i < xs.size ∧ x = xs[i]'(by have := le_snd_of_mem_zipIdx h; have := snd_lt_add_of_mem_zipIdx h; omega) :=
   ⟨by simpa using snd_lt_add_of_mem_zipIdx h, fst_eq_of_mem_zipIdx h⟩
 
-theorem zipIdx_map (xs : Array α) (k : Nat) (f : α → β) :
+theorem zipIdx_map {xs : Array α} {k : Nat} {f : α → β} :
     zipIdx (xs.map f) k = (zipIdx xs k).map (Prod.map f id) := by
   cases xs
   simp [List.zipIdx_map]
 
-theorem zipIdx_append (xs ys : Array α) (k : Nat) :
+theorem zipIdx_append {xs ys : Array α} {k : Nat} :
     zipIdx (xs ++ ys) k = zipIdx xs k ++ zipIdx ys (k + xs.size) := by
   cases xs
   cases ys

src/Init/Data/Array/TakeDrop.lean

@@ -26,7 +26,7 @@ end List
 
 namespace Array
 
-theorem exists_of_uset (xs : Array α) (i d h) :
+theorem exists_of_uset {xs : Array α} {i d} (h) :
     ∃ l₁ l₂, xs.toList = l₁ ++ xs[i] :: l₂ ∧ List.length l₁ = i.toNat ∧
       (xs.uset i d h).toList = l₁ ++ d :: l₂ := by
   simpa only [ugetElem_eq_getElem, ← getElem_toList, uset, toList_set] using

src/Init/Data/Array/Zip.lean

@@ -22,19 +22,19 @@ open Nat
 
 /-! ### zipWith -/
 
-theorem zipWith_comm (f : α → β → γ) (as : Array α) (bs : Array β) :
+theorem zipWith_comm {f : α → β → γ} {as : Array α} {bs : Array β} :
     zipWith f as bs = zipWith (fun b a => f a b) bs as := by
   cases as
   cases bs
-  simpa using List.zipWith_comm _ _ _
+  simpa using List.zipWith_comm
 
-theorem zipWith_comm_of_comm (f : α → α → β) (comm : ∀ x y : α, f x y = f y x) (xs ys : Array α) :
+theorem zipWith_comm_of_comm {f : α → α → β} (comm : ∀ x y : α, f x y = f y x) {xs ys : Array α} :
     zipWith f xs ys = zipWith f ys xs := by
   rw [zipWith_comm]
   simp only [comm]
 
 @[simp]
-theorem zipWith_self (f : α → α → δ) (xs : Array α) : zipWith f xs xs = xs.map fun a => f a a := by
+theorem zipWith_self {f : α → α → δ} {xs : Array α} : zipWith f xs xs = xs.map fun a => f a a := by
   cases xs
   simp
 
@@ -74,31 +74,31 @@ theorem getElem?_zip_eq_some {as : Array α} {bs : Array β} {z : α × β} {i :
     exact ⟨_, _, h₀, h₁, rfl⟩
 
 @[simp]
-theorem zipWith_map {μ} (f : γ → δ → μ) (g : α → γ) (h : β → δ) (as : Array α) (bs : Array β) :
+theorem zipWith_map {μ} {f : γ → δ → μ} {g : α → γ} {h : β → δ} {as : Array α} {bs : Array β} :
     zipWith f (as.map g) (bs.map h) = zipWith (fun a b => f (g a) (h b)) as bs := by
   cases as
   cases bs
   simp [List.zipWith_map]
 
-theorem zipWith_map_left (as : Array α) (bs : Array β) (f : α → α') (g : α' → β → γ) :
+theorem zipWith_map_left {as : Array α} {bs : Array β} {f : α → α'} {g : α' → β → γ} :
     zipWith g (as.map f) bs = zipWith (fun a b => g (f a) b) as bs := by
   cases as
   cases bs
   simp [List.zipWith_map_left]
 
-theorem zipWith_map_right (as : Array α) (bs : Array β) (f : β → β') (g : α → β' → γ) :
+theorem zipWith_map_right {as : Array α} {bs : Array β} {f : β → β'} {g : α → β' → γ} :
     zipWith g as (bs.map f) = zipWith (fun a b => g a (f b)) as bs := by
   cases as
   cases bs
   simp [List.zipWith_map_right]
 
-theorem zipWith_foldr_eq_zip_foldr {f : α → β → γ} (i : δ):
+theorem zipWith_foldr_eq_zip_foldr {f : α → β → γ} {i : δ} :
     (zipWith f as bs).foldr g i = (zip as bs).foldr (fun p r => g (f p.1 p.2) r) i := by
   cases as
   cases bs
   simp [List.zipWith_foldr_eq_zip_foldr]
 
-theorem zipWith_foldl_eq_zip_foldl {f : α → β → γ} (i : δ):
+theorem zipWith_foldl_eq_zip_foldl {f : α → β → γ} {i : δ} :
     (zipWith f as bs).foldl g i = (zip as bs).foldl (fun r p => g r (f p.1 p.2)) i := by
   cases as
   cases bs
@@ -108,7 +108,7 @@ theorem zipWith_foldl_eq_zip_foldl {f : α → β → γ} (i : δ):
 theorem zipWith_eq_empty_iff {f : α → β → γ} {as : Array α} {bs : Array β} : zipWith f as bs = #[] ↔ as = #[] ∨ bs = #[] := by
   cases as <;> cases bs <;> simp
 
-theorem map_zipWith {δ : Type _} (f : α → β) (g : γ → δ → α) (cs : Array γ) (ds : Array δ) :
+theorem map_zipWith {δ : Type _} {f : α → β} {g : γ → δ → α} {cs : Array γ} {ds : Array δ} :
     map f (zipWith g cs ds) = zipWith (fun x y => f (g x y)) cs ds := by
   cases cs
   cases ds
@@ -124,7 +124,7 @@ theorem extract_zipWith : (zipWith f as bs).extract i j = zipWith f (as.extract
   cases bs
   simp [List.drop_zipWith, List.take_zipWith]
 
-theorem zipWith_append (f : α → β → γ) (as as' : Array α) (bs bs' : Array β)
+theorem zipWith_append {f : α → β → γ} {as as' : Array α} {bs bs' : Array β}
     (h : as.size = bs.size) :
     zipWith f (as ++ as') (bs ++ bs') = zipWith f as bs ++ zipWith f as' bs' := by
   cases as
@@ -156,13 +156,13 @@ theorem zipWith_eq_append_iff {f : α → β → γ} {as : Array α} {bs : Array
 @[deprecated zipWith_replicate (since := "2025-03-18")]
 abbrev zipWith_mkArray := @zipWith_replicate
 
-theorem map_uncurry_zip_eq_zipWith (f : α → β → γ) (as : Array α) (bs : Array β) :
+theorem map_uncurry_zip_eq_zipWith {f : α → β → γ} {as : Array α} {bs : Array β} :
     map (Function.uncurry f) (as.zip bs) = zipWith f as bs := by
   cases as
   cases bs
   simp [List.map_uncurry_zip_eq_zipWith]
 
-theorem map_zip_eq_zipWith (f : α × β → γ) (as : Array α) (bs : Array β) :
+theorem map_zip_eq_zipWith {f : α × β → γ} {as : Array α} {bs : Array β} :
     map f (as.zip bs) = zipWith (Function.curry f) as bs := by
   cases as
   cases bs
@@ -203,21 +203,21 @@ theorem getElem_zip {as : Array α} {bs : Array β} {i : Nat} {h : i < (zip as b
       (as[i]'(lt_size_left_of_zip h), bs[i]'(lt_size_right_of_zip h)) :=
   getElem_zipWith (hi := by simpa using h)
 
-theorem zip_eq_zipWith (as : Array α) (bs : Array β) : zip as bs = zipWith Prod.mk as bs := by
+theorem zip_eq_zipWith {as : Array α} {bs : Array β} : zip as bs = zipWith Prod.mk as bs := by
   cases as
   cases bs
   simp [List.zip_eq_zipWith]
 
-theorem zip_map (f : α → γ) (g : β → δ) (as : Array α) (bs : Array β) :
+theorem zip_map {f : α → γ} {g : β → δ} {as : Array α} {bs : Array β} :
     zip (as.map f) (bs.map g) = (zip as bs).map (Prod.map f g) := by
   cases as
   cases bs
   simp [List.zip_map]
 
-theorem zip_map_left (f : α → γ) (as : Array α) (bs : Array β) :
+theorem zip_map_left {f : α → γ} {as : Array α} {bs : Array β} :
     zip (as.map f) bs = (zip as bs).map (Prod.map f id) := by rw [← zip_map, map_id]
 
-theorem zip_map_right (f : β → γ) (as : Array α) (bs : Array β) :
+theorem zip_map_right {f : β → γ} {as : Array α} {bs : Array β} :
     zip as (bs.map f) = (zip as bs).map (Prod.map id f) := by rw [← zip_map, map_id]
 
 theorem zip_append {as bs : Array α} {cs ds : Array β} (_h : as.size = cs.size) :
@@ -228,7 +228,7 @@ theorem zip_append {as bs : Array α} {cs ds : Array β} (_h : as.size = cs.size
   cases ds
   simp_all [List.zip_append]
 
-theorem zip_map' (f : α → β) (g : α → γ) (xs : Array α) :
+theorem zip_map' {f : α → β} {g : α → γ} {xs : Array α} :
     zip (xs.map f) (xs.map g) = xs.map fun a => (f a, g a) := by
   cases xs
   simp [List.zip_map']
@@ -238,25 +238,25 @@ theorem of_mem_zip {a b} {as : Array α} {bs : Array β} : (a, b) ∈ zip as bs
   cases bs
   simpa using List.of_mem_zip
 
-theorem map_fst_zip (as : Array α) (bs : Array β) (h : as.size ≤ bs.size) :
+theorem map_fst_zip {as : Array α} {bs : Array β} (h : as.size ≤ bs.size) :
     map Prod.fst (zip as bs) = as := by
   cases as
   cases bs
   simp_all [List.map_fst_zip]
 
-theorem map_snd_zip (as : Array α) (bs : Array β) (h : bs.size ≤ as.size) :
+theorem map_snd_zip {as : Array α} {bs : Array β} (h : bs.size ≤ as.size) :
     map Prod.snd (zip as bs) = bs := by
   cases as
   cases bs
   simp_all [List.map_snd_zip]
 
-theorem map_prod_left_eq_zip {xs : Array α} (f : α → β) :
+theorem map_prod_left_eq_zip {xs : Array α} {f : α → β} :
     (xs.map fun x => (x, f x)) = xs.zip (xs.map f) := by
   rw [← zip_map']
   congr
   simp
 
-theorem map_prod_right_eq_zip {xs : Array α} (f : α → β) :
+theorem map_prod_right_eq_zip {xs : Array α} {f : α → β} :
     (xs.map fun x => (f x, x)) = (xs.map f).zip xs := by
   rw [← zip_map']
   congr
@@ -280,7 +280,7 @@ theorem zip_eq_append_iff {as : Array α} {bs : Array β} :
 @[deprecated zip_replicate (since := "2025-03-18")]
 abbrev zip_mkArray := @zip_replicate
 
-theorem zip_eq_zip_take_min (as : Array α) (bs : Array β) :
+theorem zip_eq_zip_take_min {as : Array α} {bs : Array β} :
     zip as bs = zip (as.take (min as.size bs.size)) (bs.take (min as.size bs.size)) := by
   cases as
   cases bs
@@ -298,25 +298,25 @@ theorem getElem?_zipWithAll {f : Option α → Option β → γ} {i : Nat} :
   simp [List.getElem?_zipWithAll]
   rfl
 
-theorem zipWithAll_map {μ} (f : Option γ → Option δ → μ) (g : α → γ) (h : β → δ) (as : Array α) (bs : Array β) :
+theorem zipWithAll_map {μ} {f : Option γ → Option δ → μ} {g : α → γ} {h : β → δ} {as : Array α} {bs : Array β} :
     zipWithAll f (as.map g) (bs.map h) = zipWithAll (fun a b => f (g <$> a) (h <$> b)) as bs := by
   cases as
   cases bs
   simp [List.zipWithAll_map]
 
-theorem zipWithAll_map_left (as : Array α) (bs : Array β) (f : α → α') (g : Option α' → Option β → γ) :
+theorem zipWithAll_map_left {as : Array α} {bs : Array β} {f : α → α'} {g : Option α' → Option β → γ} :
     zipWithAll g (as.map f) bs = zipWithAll (fun a b => g (f <$> a) b) as bs := by
   cases as
   cases bs
   simp [List.zipWithAll_map_left]
 
-theorem zipWithAll_map_right (as : Array α) (bs : Array β) (f : β → β') (g : Option α → Option β' → γ) :
+theorem zipWithAll_map_right {as : Array α} {bs : Array β} {f : β → β'} {g : Option α → Option β' → γ} :
     zipWithAll g as (bs.map f) = zipWithAll (fun a b => g a (f <$> b)) as bs := by
   cases as
   cases bs
   simp [List.zipWithAll_map_right]
 
-theorem map_zipWithAll {δ : Type _} (f : α → β) (g : Option γ → Option δ → α) (cs : Array γ) (ds : Array δ) :
+theorem map_zipWithAll {δ : Type _} {f : α → β} {g : Option γ → Option δ → α} {cs : Array γ} {ds : Array δ} :
     map f (zipWithAll g cs ds) = zipWithAll (fun x y => f (g x y)) cs ds := by
   cases cs
   cases ds
@@ -337,10 +337,11 @@ abbrev zipWithAll_mkArray := @zipWithAll_replicate
 @[simp] theorem unzip_snd : (unzip l).snd = l.map Prod.snd := by
   induction l <;> simp_all
 
-theorem unzip_eq_map (xs : Array (α × β)) : unzip xs = (xs.map Prod.fst, xs.map Prod.snd) := by
+theorem unzip_eq_map {xs : Array (α × β)} : unzip xs = (xs.map Prod.fst, xs.map Prod.snd) := by
   cases xs
   simp [List.unzip_eq_map]
 
+-- The argument `xs` is explicit so we can rewrite from right to left.
 theorem zip_unzip (xs : Array (α × β)) : zip (unzip xs).1 (unzip xs).2 = xs := by
   cases xs
   simp only [List.unzip_toArray, Prod.map_fst, Prod.map_snd, List.zip_toArray, List.zip_unzip]

src/Init/Data/BEq.lean

@@ -19,21 +19,9 @@ class PartialEquivBEq (α) [BEq α] : Prop where
   /-- Transitivity for `BEq`. If `a == b` and `b == c` then `a == c`. -/
   trans : (a : α) == b → b == c → a == c
 
-/-- `ReflBEq α` says that the `BEq` implementation is reflexive. -/
-class ReflBEq (α) [BEq α] : Prop where
-  /-- Reflexivity for `BEq`. -/
-  refl : (a : α) == a
-
 /-- `EquivBEq` says that the `BEq` implementation is an equivalence relation. -/
 class EquivBEq (α) [BEq α] : Prop extends PartialEquivBEq α, ReflBEq α
 
-@[simp]
-theorem BEq.refl [BEq α] [ReflBEq α] {a : α} : a == a :=
-  ReflBEq.refl
-
-theorem beq_of_eq [BEq α] [ReflBEq α] {a b : α} : a = b → a == b
-  | rfl => BEq.refl
-
 theorem BEq.symm [BEq α] [PartialEquivBEq α] {a b : α} : a == b → b == a :=
   PartialEquivBEq.symm
 
@@ -66,6 +54,5 @@ theorem BEq.neq_of_beq_of_neq [BEq α] [PartialEquivBEq α] {a b c : α} :
   fun h₁ h₂ => Bool.eq_false_iff.2 fun h₃ => Bool.eq_false_iff.1 h₂ (BEq.trans (BEq.symm h₁) h₃)
 
 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

src/Init/Data/BitVec/Basic.lean

@@ -33,7 +33,7 @@ section Nat
 
 instance natCastInst : NatCast (BitVec w) := ⟨BitVec.ofNat w⟩
 
-/-- Theorem for normalizing the bit vector literal representation. -/
+/-- Theorem for normalizing the bitvector literal representation. -/
 -- TODO: This needs more usage data to assess which direction the simp should go.
 @[simp, bitvec_to_nat] theorem ofNat_eq_ofNat : @OfNat.ofNat (BitVec n) i _ = .ofNat n i := rfl
 
@@ -48,7 +48,7 @@ section subsingleton
 instance : Subsingleton (BitVec 0) where
   allEq := by intro ⟨0, _⟩ ⟨0, _⟩; rfl
 
-/-- The empty bitvector -/
+/-- The empty bitvector. -/
 abbrev nil : BitVec 0 := 0
 
 /-- Every bitvector of length 0 is equal to `nil`, i.e., there is only one empty bitvector -/
@@ -58,11 +58,11 @@ end subsingleton
 
 section zero_allOnes
 
-/-- Return a bitvector `0` of size `n`. This is the bitvector with all zero bits. -/
+/-- Returns a bitvector of size `n` where all bits are `0`. -/
 protected def zero (n : Nat) : BitVec n := .ofNatLT 0 (Nat.two_pow_pos n)
 instance : Inhabited (BitVec n) where default := .zero n
 
-/-- Bit vector of size `n` where all bits are `1`s -/
+/-- Returns a bitvector of size `n` where all bits are `1`. -/
 def allOnes (n : Nat) : BitVec n :=
   .ofNatLT (2^n - 1) (Nat.le_of_eq (Nat.sub_add_cancel (Nat.two_pow_pos n)))
 
@@ -71,36 +71,36 @@ end zero_allOnes
 section getXsb
 
 /--
-Return the `i`-th least significant bit.
+Returns 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`. -/
+/-- Returns 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.
+Returns the `i`th most significant bit.
 
-This will be renamed `getMsb` after the existing deprecated alias is removed.
+This will be renamed `BitVec.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`. -/
+/-- Returns 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`. -/
+/-- Returns the `i`th least significant bit or `false` if `i ≥ w`. -/
 @[inline] def getLsbD (x : BitVec w) (i : Nat) : Bool :=
   x.toNat.testBit i
 
-/-- Return the `i`-th most significant bit or `false` if `i ≥ w`. -/
+/-- Returns 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)
 
-/-- Return most-significant bit in bitvector. -/
+/-- Returns the most significant bit in a bitvector. -/
 @[inline] protected def msb (x : BitVec n) : Bool := getMsbD x 0
 
 end getXsb
@@ -129,14 +129,22 @@ end getElem
 
 section Int
 
-/-- Interpret the bitvector as an integer stored in two's complement form. -/
+/--
+Interprets 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
   else
     (x.toNat : Int) - (2^n : Nat)
 
-/-- The `BitVec` with value `(2^n + (i mod 2^n)) mod 2^n`.  -/
+/--
+Converts an integer to its two's complement representation as a bitvector of the given width `n`,
+over- and underflowing as needed.
+
+The underlying `Nat` is `(2^n + (i mod 2^n)) mod 2^n`. Converting the bitvector back to an `Int`
+with `BitVec.toInt` results in the value `i.bmod (2^n)`.
+-/
 protected def ofInt (n : Nat) (i : Int) : BitVec n := .ofNatLT (i % (Int.ofNat (2^n))).toNat (by
   apply (Int.toNat_lt _).mpr
   · apply Int.emod_lt_of_pos
@@ -152,7 +160,7 @@ end Int
 
 section Syntax
 
-/-- Notation for bit vector literals. `i#n` is a shorthand for `BitVec.ofNat n i`. -/
+/-- Notation for bitvector literals. `i#n` is a shorthand for `BitVec.ofNat n i`. -/
 syntax:max num noWs "#" noWs term:max : term
 macro_rules | `($i:num#$n) => `(BitVec.ofNat $n $i)
 
@@ -161,16 +169,16 @@ recommended_spelling "zero" for "0#n" in [BitVec.ofNat, «term__#__»]
 /-- not `ofNat_one` -/
 recommended_spelling "one" for "1#n" in [BitVec.ofNat, «term__#__»]
 
-/-- Unexpander for bit vector literals. -/
+/-- Unexpander for bitvector literals. -/
 @[app_unexpander BitVec.ofNat] def unexpandBitVecOfNat : Lean.PrettyPrinter.Unexpander
   | `($(_) $n $i:num) => `($i:num#$n)
   | _ => throw ()
 
-/-- Notation for bit vector literals without truncation. `i#'lt` is a shorthand for `BitVec.ofNatLT i lt`. -/
+/-- Notation for bitvector literals without truncation. `i#'lt` is a shorthand for `BitVec.ofNatLT i lt`. -/
 scoped syntax:max term:max noWs "#'" noWs term:max : term
 macro_rules | `($i#'$p) => `(BitVec.ofNatLT $i $p)
 
-/-- Unexpander for bit vector literals without truncation. -/
+/-- Unexpander for bitvector literals without truncation. -/
 @[app_unexpander BitVec.ofNatLT] def unexpandBitVecOfNatLt : Lean.PrettyPrinter.Unexpander
   | `($(_) $i $p) => `($i#'$p)
   | _ => throw ()
@@ -179,7 +187,11 @@ end Syntax
 
 section repr_toString
 
-/-- Convert bitvector into a fixed-width hex number. -/
+/--
+Converts a bitvector into a fixed-width hexadecimal number with enough digits to represent it.
+
+If `n` is `0`, then one digit is returned. Otherwise, `⌊(n + 3) / 4⌋` digits are returned.
+-/
 protected def toHex {n : Nat} (x : BitVec n) : String :=
   let s := (Nat.toDigits 16 x.toNat).asString
   let t := (List.replicate ((n+3) / 4 - s.length) '0').asString
@@ -193,8 +205,8 @@ end repr_toString
 section arithmetic
 
 /--
-Negation for bit vectors. This can be interpreted as either signed or unsigned negation
-modulo `2^n`.
+Negation of bitvectors. This can be interpreted as either signed or unsigned negation modulo `2^n`.
+Usually accessed via the `-` prefix operator.
 
 SMT-LIB name: `bvneg`.
 -/
@@ -202,13 +214,13 @@ protected def neg (x : BitVec n) : BitVec n := .ofNat n (2^n - x.toNat)
 instance : Neg (BitVec n) := ⟨.neg⟩
 
 /--
-Return the absolute value of a signed bitvector.
+Returns the absolute value of a signed bitvector.
 -/
 protected def abs (x : BitVec n) : BitVec n := if x.msb then .neg x else x
 
 /--
-Multiplication for bit vectors. This can be interpreted as either signed or unsigned
-multiplication modulo `2^n`.
+Multiplies two bitvectors. This can be interpreted as either signed or unsigned multiplication
+modulo `2^n`. Usually accessed via the `*` operator.
 
 SMT-LIB name: `bvmul`.
 -/
@@ -216,14 +228,29 @@ protected def mul (x y : BitVec n) : BitVec n := BitVec.ofNat n (x.toNat * y.toN
 instance : Mul (BitVec n) := ⟨.mul⟩
 
 /--
-Unsigned division for bit vectors using the Lean convention where division by zero returns zero.
+Raises a bitvector to a natural number power. Usually accessed via the `^` operator.
+
+Note that this is currently an inefficient implementation,
+and should be replaced via an `@[extern]` with a native implementation.
+See https://github.com/leanprover/lean4/issues/7887.
+-/
+protected def pow (x : BitVec n) (y : Nat) : BitVec n :=
+  match y with
+  | 0 => 1
+  | y + 1 => x.pow y * x
+instance : Pow (BitVec n) Nat where
+  pow x y := x.pow y
+
+/--
+Unsigned division of bitvectors using the Lean convention where division by zero returns zero.
+Usually accessed via the `/` operator.
 -/
 def udiv (x y : BitVec n) : BitVec n :=
   (x.toNat / y.toNat)#'(Nat.lt_of_le_of_lt (Nat.div_le_self _ _) x.isLt)
 instance : Div (BitVec n) := ⟨.udiv⟩
 
 /--
-Unsigned modulo for bit vectors.
+Unsigned modulo for bitvectors. Usually accessed via the `%` operator.
 
 SMT-LIB name: `bvurem`.
 -/
@@ -232,24 +259,23 @@ def umod (x y : BitVec n) : BitVec n :=
 instance : Mod (BitVec n) := ⟨.umod⟩
 
 /--
-Unsigned division for bit vectors using the
-[SMT-LIB convention](http://smtlib.cs.uiowa.edu/theories-FixedSizeBitVectors.shtml)
-where division by zero returns the `allOnes` bitvector.
+Unsigned division of bitvectors using the
+[SMT-LIB convention](http://smtlib.cs.uiowa.edu/theories-FixedSizeBitVectors.shtml),
+where division by zero returns `BitVector.allOnes n`.
 
 SMT-LIB name: `bvudiv`.
 -/
 def smtUDiv (x y : BitVec n) : BitVec n := if y = 0 then allOnes n else udiv x y
 
 /--
-Signed t-division for bit vectors using the Lean convention where division
-by zero returns zero.
+Signed T-division (using the truncating rounding convention) for bitvectors. This function obeys the
+Lean convention that division by zero returns zero.
 
-```lean
-sdiv 7#4 2 = 3#4
-sdiv (-9#4) 2 = -4#4
-sdiv 5#4 -2 = -2#4
-sdiv (-7#4) (-2) = 3#4
-```
+Examples:
+* `(7#4).sdiv 2 = 3#4`
+* `(-9#4).sdiv 2 = -4#4`
+* `(5#4).sdiv -2 = -2#4`
+* `(-7#4).sdiv (-2) = 3#4`
 -/
 def sdiv (x y : BitVec n) : BitVec n :=
   match x.msb, y.msb with
@@ -259,9 +285,11 @@ def sdiv (x y : BitVec n) : BitVec n :=
   | true,  true  => udiv (.neg x) (.neg y)
 
 /--
-Signed division for bit vectors using SMT-LIB rules for division by zero.
+Signed division for bitvectors using the SMT-LIB using the
+[SMT-LIB convention](http://smtlib.cs.uiowa.edu/theories-FixedSizeBitVectors.shtml),
+where division by zero returns `BitVector.allOnes n`.
 
-Specifically, `smtSDiv x 0 = if x >= 0 then -1 else 1`
+Specifically, `x.smtSDiv 0 = if x >= 0 then -1 else 1`
 
 SMT-LIB name: `bvsdiv`.
 -/
@@ -305,7 +333,7 @@ end arithmetic
 
 section bool
 
-/-- Turn a `Bool` into a bitvector of length `1` -/
+/-- Turns a `Bool` into a bitvector of length `1`. -/
 def ofBool (b : Bool) : BitVec 1 := cond b 1 0
 
 @[simp] theorem ofBool_false : ofBool false = 0 := by trivial
@@ -319,32 +347,32 @@ end bool
 section relations
 
 /--
-Unsigned less-than for bit vectors.
+Unsigned less-than for bitvectors.
 
 SMT-LIB name: `bvult`.
 -/
 protected def ult (x y : BitVec n) : Bool := x.toNat < y.toNat
 
 /--
-Unsigned less-than-or-equal-to for bit vectors.
+Unsigned less-than-or-equal-to for bitvectors.
 
 SMT-LIB name: `bvule`.
 -/
 protected def ule (x y : BitVec n) : Bool := x.toNat ≤ y.toNat
 
 /--
-Signed less-than for bit vectors.
+Signed less-than for bitvectors.
 
-```lean
-BitVec.slt 6#4 7 = true
-BitVec.slt 7#4 8 = false
-```
 SMT-LIB name: `bvslt`.
+
+Examples:
+ * `BitVec.slt 6#4 7 = true`
+ * `BitVec.slt 7#4 8 = false`
 -/
 protected def slt (x y : BitVec n) : Bool := x.toInt < y.toInt
 
 /--
-Signed less-than-or-equal-to for bit vectors.
+Signed less-than-or-equal-to for bitvectors.
 
 SMT-LIB name: `bvsle`.
 -/
@@ -354,7 +382,13 @@ end relations
 
 section cast
 
-/-- `cast eq x` embeds `x` into an equal `BitVec` type. -/
+/--
+If two natural numbers `n` and `m` are equal, then a bitvector of width `n` is also a bitvector of
+width `m`.
+
+Using `x.cast eq` should be preferred over `eq ▸ x` because there are special-purpose `simp` lemmas
+that can more consistently simplify `BitVec.cast` away.
+-/
 @[inline] protected def cast (eq : n = m) (x : BitVec n) : BitVec m := .ofNatLT x.toNat (eq ▸ x.isLt)
 
 @[simp] theorem cast_ofNat {n m : Nat} (h : n = m) (x : Nat) :
@@ -368,23 +402,26 @@ section cast
 @[simp] theorem cast_eq {n : Nat} (h : n = n) (x : BitVec n) : x.cast h = x := rfl
 
 /--
-Extraction of bits `start` to `start + len - 1` from a bit vector of size `n` to yield a
-new bitvector of size `len`. If `start + len > n`, then the vector will be zero-padded in the
-high bits.
+Extracts the bits `start` to `start + len - 1` from a bitvector of size `n` to yield a
+new bitvector of size `len`. If `start + len > n`, then the bitvector is zero-extended.
 -/
 def extractLsb' (start len : Nat) (x : BitVec n) : BitVec len := .ofNat _ (x.toNat >>> start)
 
 /--
-Extraction of bits `hi` (inclusive) down to `lo` (inclusive) from a bit vector of size `n` to
-yield a new bitvector of size `hi - lo + 1`.
+Extracts the bits from `hi` down to `lo` (both inclusive) from a bitvector, which is implicitly
+zero-extended if necessary.
+
+The resulting bitvector has size `hi - lo + 1`.
 
 SMT-LIB name: `extract`.
 -/
 def extractLsb (hi lo : Nat) (x : BitVec n) : BitVec (hi - lo + 1) := extractLsb' lo _ x
 
 /--
-A version of `setWidth` that requires a proof the new width is at least as large,
-and is a computational noop.
+Increases the width of a bitvector to one that is at least as large by zero-extending it.
+
+This is a constant-time operation because the underlying `Nat` is unmodified; because the new width
+is at least as large as the old one, no overflow is possible.
 -/
 def setWidth' {n w : Nat} (le : n ≤ w) (x : BitVec n) : BitVec w :=
   x.toNat#'(by
@@ -394,8 +431,7 @@ def setWidth' {n w : Nat} (le : n ≤ w) (x : BitVec n) : BitVec w :=
 @[deprecated setWidth' (since := "2024-09-18"), inherit_doc setWidth'] abbrev zeroExtend' := @setWidth'
 
 /--
-`shiftLeftZeroExtend x n` returns `zeroExtend (w+n) x <<< n` without
-needing to compute `x % 2^(2+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
@@ -404,10 +440,18 @@ def shiftLeftZeroExtend (msbs : BitVec w) (m : Nat) : BitVec (w + m) :=
         exact (Nat.two_pow_pos m)
   (msbs.toNat <<< m)#'(shiftLeftLt msbs.isLt m)
 
+
 /--
-Transform `x` of length `w` into a bitvector of length `v`, by either:
-- zero extending, that is, adding zeros in the high bits until it has length `v`, if `v > w`, or
-- truncating the high bits, if `v < w`.
+Transforms a bitvector of length `w` into a bitvector of length `v`, padding with `0` as needed.
+
+The specific behavior depends on the relationship between the starting width `w` and the final width
+`v`:
+ * If `v > w`, it is zero-extended; the high bits are padded with zeroes until the bitvector has `v`
+   bits.
+ * If `v = w`, the bitvector is returned unchanged.
+ * If `v < w`, the high bits are truncated.
+
+`BitVec.setWidth`, `BitVec.zeroExtend`, and `BitVec.truncate` are aliases for this operation.
 
 SMT-LIB name: `zero_extend`.
 -/
@@ -417,27 +461,17 @@ def setWidth (v : Nat) (x : BitVec w) : BitVec v :=
   else
     .ofNat v x.toNat
 
-/--
-Transform `x` of length `w` into a bitvector of length `v`, by either:
-- zero extending, that is, adding zeros in the high bits until it has length `v`, if `v > w`, or
-- truncating the high bits, if `v < w`.
-
-SMT-LIB name: `zero_extend`.
--/
+@[inherit_doc setWidth]
 abbrev zeroExtend := @setWidth
 
-/--
-Transform `x` of length `w` into a bitvector of length `v`, by either:
-- zero extending, that is, adding zeros in the high bits until it has length `v`, if `v > w`, or
-- truncating the high bits, if `v < w`.
-
-SMT-LIB name: `zero_extend`.
--/
+@[inherit_doc setWidth]
 abbrev truncate := @setWidth
 
 /--
-Sign extend a vector of length `w`, extending with `i` additional copies of the most significant
-bit in `x`. If `x` is an empty vector, then the sign is treated as zero.
+Transforms a bitvector of length `w` into a bitvector of length `v`, padding as needed with the most
+significant bit's value.
+
+If `x` is an empty bitvector, then the sign is treated as zero.
 
 SMT-LIB name: `sign_extend`.
 -/
@@ -448,57 +482,54 @@ end cast
 section bitwise
 
 /--
-Bitwise AND for bit vectors.
-
-```lean
-0b1010#4 &&& 0b0110#4 = 0b0010#4
-```
+Bitwise and for bitvectors. Usually accessed via the `&&&` operator.
 
 SMT-LIB name: `bvand`.
+
+Example:
+ * `0b1010#4 &&& 0b0110#4 = 0b0010#4`
 -/
 protected def and (x y : BitVec n) : BitVec n :=
   (x.toNat &&& y.toNat)#'(Nat.and_lt_two_pow x.toNat y.isLt)
 instance : AndOp (BitVec w) := ⟨.and⟩
 
 /--
-Bitwise OR for bit vectors.
-
-```lean
-0b1010#4 ||| 0b0110#4 = 0b1110#4
-```
+Bitwise or for bitvectors. Usually accessed via the `|||` operator.
 
 SMT-LIB name: `bvor`.
+
+Example:
+ * `0b1010#4 ||| 0b0110#4 = 0b1110#4`
 -/
 protected def or (x y : BitVec n) : BitVec n :=
   (x.toNat ||| y.toNat)#'(Nat.or_lt_two_pow x.isLt y.isLt)
 instance : OrOp (BitVec w) := ⟨.or⟩
 
 /--
- Bitwise XOR for bit vectors.
-
-```lean
-0b1010#4 ^^^ 0b0110#4 = 0b1100#4
-```
+Bitwise xor for bitvectors. Usually accessed via the `^^^` operator.
 
 SMT-LIB name: `bvxor`.
+
+Example:
+ * `0b1010#4 ^^^ 0b0110#4 = 0b1100#4`
 -/
 protected def xor (x y : BitVec n) : BitVec n :=
   (x.toNat ^^^ y.toNat)#'(Nat.xor_lt_two_pow x.isLt y.isLt)
 instance : Xor (BitVec w) := ⟨.xor⟩
 
 /--
-Bitwise NOT for bit vectors.
+Bitwise complement for bitvectors. Usually accessed via the `~~~` prefix operator.
 
-```lean
-~~~(0b0101#4) == 0b1010
-```
 SMT-LIB name: `bvnot`.
+
+Example:
+ * `~~~(0b0101#4) == 0b1010`
 -/
 protected def not (x : BitVec n) : BitVec n := allOnes n ^^^ x
 instance : Complement (BitVec w) := ⟨.not⟩
 
 /--
-Left shift for bit vectors. The low bits are filled with zeros. As a numeric operation, this is
+Shifts a bitvector to the left. The low bits are filled with zeros. As a numeric operation, this is
 equivalent to `x * 2^s`, modulo `2^n`.
 
 SMT-LIB name: `bvshl` except this operator uses a `Nat` shift value.
@@ -507,7 +538,9 @@ protected def shiftLeft (x : BitVec n) (s : Nat) : BitVec n := BitVec.ofNat n (x
 instance : HShiftLeft (BitVec w) Nat (BitVec w) := ⟨.shiftLeft⟩
 
 /--
-(Logical) right shift for bit vectors. The high bits are filled with zeros.
+Shifts a bitvector to the right. This is a logical right shift - the high bits are filled with
+zeros.
+
 As a numeric operation, this is equivalent to `x / 2^s`, rounding down.
 
 SMT-LIB name: `bvlshr` except this operator uses a `Nat` shift value.
@@ -522,8 +555,9 @@ def ushiftRight (x : BitVec n) (s : Nat) : BitVec n :=
 instance : HShiftRight (BitVec w) Nat (BitVec w) := ⟨.ushiftRight⟩
 
 /--
-Arithmetic right shift for bit vectors. The high bits are filled with the
-most-significant bit.
+Shifts a bitvector to the right. This is an arithmetic right shift - the high bits are filled with
+most significant bit's value.
+
 As a numeric operation, this is equivalent to `x.toInt >>> s`.
 
 SMT-LIB name: `bvashr` except this operator uses a `Nat` shift value.
@@ -534,8 +568,9 @@ instance {n} : HShiftLeft  (BitVec m) (BitVec n) (BitVec m) := ⟨fun x y => x <
 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.
+Shifts a bitvector to the right. This is an arithmetic right shift - the high bits are filled with
+most significant bit's value.
+
 As a numeric operation, this is equivalent to `a.toInt >>> s.toNat`.
 
 SMT-LIB name: `bvashr`.
@@ -548,13 +583,15 @@ def rotateLeftAux (x : BitVec w) (n : Nat) : BitVec w :=
   x <<< n ||| x >>> (w - n)
 
 /--
-Rotate left for bit vectors. All the bits of `x` are shifted to higher positions, with the top `n`
-bits wrapping around to fill the low bits.
+Rotates the bits in a bitvector to the left.
 
-```lean
-rotateLeft  0b0011#4 3 = 0b1001
-```
-SMT-LIB name: `rotate_left` except this operator uses a `Nat` shift amount.
+All the bits of `x` are shifted to higher positions, with the top `n` bits wrapping around to fill
+the vacated low bits.
+
+SMT-LIB name: `rotate_left`, except this operator uses a `Nat` shift amount.
+
+Example:
+ * `(0b0011#4).rotateLeft 3 = 0b1001`
 -/
 def rotateLeft (x : BitVec w) (n : Nat) : BitVec w := rotateLeftAux x (n % w)
 
@@ -567,21 +604,26 @@ def rotateRightAux (x : BitVec w) (n : Nat) : BitVec w :=
   x >>> n ||| x <<< (w - n)
 
 /--
-Rotate right for bit vectors. All the bits of `x` are shifted to lower positions, with the
-bottom `n` bits wrapping around to fill the high bits.
+Rotates the bits in a bitvector to the right.
 
-```lean
-rotateRight 0b01001#5 1 = 0b10100
-```
-SMT-LIB name: `rotate_right` except this operator uses a `Nat` shift amount.
+All the bits of `x` are shifted to lower positions, with the bottom `n` bits wrapping around to fill
+the vacated high bits.
+
+SMT-LIB name: `rotate_right`, except this operator uses a `Nat` shift amount.
+
+Example:
+ * `rotateRight 0b01001#5 1 = 0b10100`
 -/
 def rotateRight (x : BitVec w) (n : Nat) : BitVec w := rotateRightAux x (n % w)
 
 /--
-Concatenation of bitvectors. This uses the "big endian" convention that the more significant
-input is on the left, so `0xAB#8 ++ 0xCD#8 = 0xABCD#16`.
+Concatenates two bitvectors using the “big-endian” convention that the more significant
+input is on the left. Usually accessed via the `++` operator.
 
 SMT-LIB name: `concat`.
+
+Example:
+ * `0xAB#8 ++ 0xCD#8 = 0xABCD#16`.
 -/
 def append (msbs : BitVec n) (lsbs : BitVec m) : BitVec (n+m) :=
   shiftLeftZeroExtend msbs m ||| setWidth' (Nat.le_add_left m n) lsbs
@@ -589,7 +631,7 @@ def append (msbs : BitVec n) (lsbs : BitVec m) : BitVec (n+m) :=
 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`. -/
+/-- 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
   | n+1, x =>
@@ -608,14 +650,18 @@ result of appending a single bit to the front in the naive implementation).
 def concat {n} (msbs : BitVec n) (lsb : Bool) : BitVec (n+1) := msbs ++ (ofBool lsb)
 
 /--
-`x.shiftConcat b` shifts all bits of `x` to the left by `1` and sets the least significant bit to `b`.
-It is a non-dependent version of `concat` that does not change the total bitwidth.
+Shifts all bits of `x` to the left by `1` and sets the least significant bit to `b`.
+
+This is a non-dependent version of `BitVec.concat` that does not change the total bitwidth.
 -/
 def shiftConcat (x : BitVec n) (b : Bool) : BitVec n :=
   (x.concat b).truncate n
 
-/-- Prepend a single bit to the front of a bitvector, using big endian order (see `append`).
-    That is, the new bit is the most significant bit. -/
+/--
+Prepends a single bit to the front of a bitvector, using big-endian order (see `append`).
+
+The new bit is the most significant bit.
+-/
 def cons {n} (msb : Bool) (lsbs : BitVec n) : BitVec (n+1) :=
   ((ofBool msb) ++ lsbs).cast (Nat.add_comm ..)
 
@@ -628,15 +674,18 @@ theorem ofBool_append (msb : Bool) (lsbs : BitVec w) :
   rfl
 
 /--
-`twoPow w i` is the bitvector `2^i` if `i < w`, and `0` otherwise.
-That is, 2 to the power `i`.
-For the bitwise point of view, it has the `i`th bit as `1` and all other bits as `0`.
+`twoPow w i` is the bitvector `2^i` if `i < w`, and `0` otherwise. In other words, it is 2 to the
+power `i`.
+
+From the bitwise point of view, it has the `i`th bit as `1` and all other bits as `0`.
 -/
 def twoPow (w : Nat) (i : Nat) : BitVec w := 1#w <<< i
 
 end bitwise
 
-/-- Compute a hash of a bitvector, combining 64-bit words using `mixHash`. -/
+/--
+Computes a hash of a bitvector, combining 64-bit words using `mixHash`.
+-/
 def hash (bv : BitVec n) : UInt64 :=
   if n ≤ 64 then
     bv.toFin.val.toUInt64
@@ -664,45 +713,80 @@ section normalization_eqs
 @[simp] theorem zero_eq                                   : BitVec.zero n = 0#n               := rfl
 end normalization_eqs
 
-/-- Converts a list of `Bool`s to a big-endian `BitVec`. -/
+/-- Converts a list of `Bool`s into a big-endian `BitVec`. -/
 def ofBoolListBE : (bs : List Bool) → BitVec bs.length
 | [] => 0#0
 | b :: bs => cons b (ofBoolListBE bs)
 
-/-- Converts a list of `Bool`s to a little-endian `BitVec`. -/
+/-- Converts a list of `Bool`s into a little-endian `BitVec`. -/
 def ofBoolListLE : (bs : List Bool) → BitVec bs.length
 | [] => 0#0
 | b :: bs => concat (ofBoolListLE bs) b
 
 /-! ## Overflow -/
 
-/-- `uaddOverflow x y` returns `true` if addition of `x` and `y` results in *unsigned* overflow.
+/--
+Checks whether addition of `x` and `y` results in *unsigned* overflow.
 
-  SMT-LIB name: `bvuaddo`.
+SMT-LIB name: `bvuaddo`.
 -/
 def uaddOverflow {w : Nat} (x y : BitVec w) : Bool := x.toNat + y.toNat ≥ 2 ^ w
 
-/-- `saddOverflow x y` returns `true` if addition of `x` and `y` results in *signed* overflow,
-treating `x` and `y` as 2's complement signed bitvectors.
+/--
+Checks whether addition of `x` and `y` results in *signed* overflow, treating `x` and `y` as 2's
+complement signed bitvectors.
 
-  SMT-LIB name: `bvsaddo`.
+SMT-LIB name: `bvsaddo`.
 -/
 def saddOverflow {w : Nat} (x y : BitVec w) : Bool :=
   (x.toInt + y.toInt ≥ 2 ^ (w - 1)) || (x.toInt + y.toInt < - 2 ^ (w - 1))
 
-/-- `negOverflow x` returns `true` if the negation of `x` results in overflow. 
-For a BitVec `x` with width `0 < w`, this only happens if `x = intMin`. 
+/--
+Checks whether subtraction of `x` and `y` results in *unsigned* overflow.
 
-  SMT-Lib name: `bvnego`.
+SMT-Lib name: `bvusubo`.
+-/
+def usubOverflow {w : Nat} (x y : BitVec w) : Bool := x.toNat < y.toNat
+
+/--
+Checks whether the subtraction of `x` and `y` results in *signed* overflow, treating `x` and `y` as
+2's complement signed bitvectors.
+
+SMT-Lib name: `bvssubo`.
+-/
+def ssubOverflow {w : Nat} (x y : BitVec w) : Bool :=
+  (x.toInt - y.toInt ≥ 2 ^ (w - 1)) || (x.toInt - y.toInt < - 2 ^ (w - 1))
+
+/--
+Checks whether the negation of a bitvector results in overflow.
+
+For a bitvector `x` with nonzero width, this only happens if `x = intMin`.
+
+SMT-Lib name: `bvnego`.
 -/
 def negOverflow {w : Nat} (x : BitVec w) : Bool :=
   x.toInt == - 2 ^ (w - 1)
 
 /- ### reverse -/
 
-/-- Reverse the bits in a bitvector. -/
+/-- Reverses the bits in a bitvector. -/
 def reverse : {w : Nat} → BitVec w → BitVec w
   | 0, x => x
   | w + 1, x => concat (reverse (x.truncate w)) (x.msb)
 
+/--  `umulOverflow x y` returns `true` if multiplying `x` and `y` results in *unsigned* overflow.
+
+  SMT-Lib name: `bvumulo`.
+-/
+def umulOverflow {w : Nat} (x y : BitVec w) : Bool := x.toNat * y.toNat ≥ 2 ^ w
+
+/-- `smulOverflow x y` returns `true` if multiplying `x` and `y` results in *signed* overflow,
+treating `x` and `y` as 2's complement signed bitvectors.
+
+  SMT-Lib name: `bvsmulo`.
+-/
+
+def smulOverflow {w : Nat} (x y : BitVec w) : Bool :=
+  (x.toInt * y.toInt ≥ 2 ^ (w - 1)) || (x.toInt * y.toInt < - 2 ^ (w - 1))
+
 end BitVec

src/Init/Data/BitVec/BasicAux.lean

@@ -17,7 +17,9 @@ namespace BitVec
 
 section Nat
 
-/-- The `BitVec` with value `i mod 2^n`. -/
+/--
+The bitvector with value `i mod 2^n`.
+-/
 @[match_pattern]
 protected def ofNat (n : Nat) (i : Nat) : BitVec n where
   toFin := Fin.ofNat' (2^n) i
@@ -32,8 +34,8 @@ end Nat
 section arithmetic
 
 /--
-Addition for bit vectors. This can be interpreted as either signed or unsigned addition
-modulo `2^n`.
+Adds two bitvectors. This can be interpreted as either signed or unsigned addition modulo `2^n`.
+Usually accessed via the `+` operator.
 
 SMT-LIB name: `bvadd`.
 -/
@@ -41,8 +43,9 @@ protected def add (x y : BitVec n) : BitVec n := .ofNat n (x.toNat + y.toNat)
 instance : Add (BitVec n) := ⟨BitVec.add⟩
 
 /--
-Subtraction for bit vectors. This can be interpreted as either signed or unsigned subtraction
-modulo `2^n`.
+Subtracts one bitvector from another. This can be interpreted as either signed or unsigned subtraction
+modulo `2^n`. Usually accessed via the `-` operator.
+
 -/
 protected def sub (x y : BitVec n) : BitVec n := .ofNat n ((2^n - y.toNat) + x.toNat)
 instance : Sub (BitVec n) := ⟨BitVec.sub⟩

src/Init/Data/BitVec/Bitblast.lean

@@ -7,9 +7,10 @@ prelude
 import Init.Data.BitVec.Folds
 import Init.Data.Nat.Mod
 import Init.Data.Int.LemmasAux
+import Init.Data.BitVec.Lemmas
 
 /-!
-# Bitblasting of bitvectors
+# Bit blasting of bitvectors
 
 This module provides theorems for showing the equivalence between BitVec operations using
 the `Fin 2^n` representation and Boolean vectors.  It is still under development, but
@@ -19,21 +20,21 @@ as vectors of bits into proofs about Lean `BitVec` values.
 The module is named for the bit-blasting operation in an SMT solver that converts bitvector
 expressions into expressions about individual bits in each vector.
 
-### Example: How bitblasting works for multiplication
+### Example: How bit blasting works for multiplication
 
-We explain how the lemmas here are used for bitblasting,
+We explain how the lemmas here are used for bit blasting,
 by using multiplication as a prototypical example.
-Other bitblasters for other operations follow the same pattern.
-To bitblast a multiplication of the form `x * y`,
+Other bit blasters for other operations follow the same pattern.
+To bit blast a multiplication of the form `x * y`,
 we must unfold the above into a form that the SAT solver understands.
 
-We assume that the solver already knows how to bitblast addition.
+We assume that the solver already knows how to bit blast addition.
 This is known to `bv_decide`, by exploiting the lemma `add_eq_adc`,
 which says that `x + y : BitVec w` equals `(adc x y false).2`,
 where `adc` builds an add-carry circuit in terms of the primitive operations
 (bitwise and, bitwise or, bitwise xor) that bv_decide already understands.
-In this way, we layer bitblasters on top of each other,
-by reducing the multiplication bitblaster to an addition operation.
+In this way, we layer bit blasters on top of each other,
+by reducing the multiplication bit blaster to an addition operation.
 
 The core lemma is given by `getLsbD_mul`:
 
@@ -65,7 +66,7 @@ mulRec_succ_eq
 By repeatedly applying the lemmas `mulRec_zero_eq` and `mulRec_succ_eq`,
 one obtains a circuit for multiplication.
 Note that this circuit uses `BitVec.add`, `BitVec.getLsbD`, `BitVec.shiftLeft`.
-Here, `BitVec.add` and `BitVec.shiftLeft` are (recursively) bitblasted by `bv_decide`,
+Here, `BitVec.add` and `BitVec.shiftLeft` are (recursively) bit blasted by `bv_decide`,
 using the lemmas `add_eq_adc` and `shiftLeft_eq_shiftLeftRec`,
 and `BitVec.getLsbD` is a primitive that `bv_decide` knows how to reduce to SAT.
 
@@ -88,10 +89,10 @@ computes the correct value for multiplication.
 
 To zoom out, therefore, we follow two steps:
 First, we prove bitvector lemmas to unfold a high-level operation (such as multiplication)
-into already bitblastable operations (such as addition and left shift).
+into already bit blastable operations (such as addition and left shift).
 We then use these lemmas to prove the correctness of the circuit that `bv_decide` builds.
 
-We use this workflow to implement bitblasting for all SMT-LIB v2 operations.
+We use this workflow to implement bit blasting for all SMT-LIB v2 operations.
 
 ## Main results
 * `x + y : BitVec w` is `(adc x y false).2`.
@@ -134,14 +135,14 @@ private theorem testBit_limit {x i : Nat} (x_lt_succ : x < 2^(i+1)) :
     testBit x i = decide (x ≥ 2^i) := by
   cases xi : testBit x i with
   | true =>
-    simp [testBit_implies_ge xi]
+    simp [Nat.ge_two_pow_of_testBit xi]
   | false =>
     simp
     cases Nat.lt_or_ge x (2^i) with
     | inl x_lt =>
       exact x_lt
     | inr x_ge =>
-      have ⟨j, ⟨j_ge, jp⟩⟩  := ge_two_pow_implies_high_bit_true x_ge
+      have ⟨j, ⟨j_ge, jp⟩⟩  := exists_ge_and_testBit_of_ge_two_pow x_ge
       cases Nat.lt_or_eq_of_le j_ge with
       | inr x_eq =>
         simp [x_eq, jp] at xi
@@ -150,7 +151,7 @@ private theorem testBit_limit {x i : Nat} (x_lt_succ : x < 2^(i+1)) :
         apply Nat.lt_irrefl
         calc x < 2^(i+1) := x_lt_succ
              _ ≤ 2 ^ j := Nat.pow_le_pow_right Nat.zero_lt_two x_lt
-             _ ≤ x := testBit_implies_ge jp
+             _ ≤ x := ge_two_pow_of_testBit jp
 
 private theorem mod_two_pow_succ (x i : Nat) :
     x % 2^(i+1) = 2^i*(x.testBit i).toNat + x % (2 ^ i):= by
@@ -261,7 +262,7 @@ theorem getLsbD_add_add_bool {i : Nat} (i_lt : i < w) (x y : BitVec w) (c : Bool
       Nat.add_left_comm (_%_) (_ * _) _,
       testBit_limit (mod_two_pow_add_mod_two_pow_add_bool_lt_two_pow_succ x y i c)
     ]
-  simp [testBit_to_div_mod, carry, Nat.add_assoc]
+  simp [testBit_eq_decide_div_mod_eq, carry, Nat.add_assoc]
 
 theorem getLsbD_add {i : Nat} (i_lt : i < w) (x y : BitVec w) :
     getLsbD (x + y) i =
@@ -342,13 +343,13 @@ theorem add_eq_or_of_and_eq_zero {w : Nat} (x y : BitVec w)
 theorem getLsbD_sub {i : Nat} {i_lt : i < w} {x y : BitVec w} :
     (x - y).getLsbD i
       = (x.getLsbD i ^^ ((~~~y + 1#w).getLsbD i ^^ carry i x (~~~y + 1#w) false)) := by
-  rw [sub_toAdd, BitVec.neg_eq_not_add, getLsbD_add]
+  rw [sub_eq_add_neg, BitVec.neg_eq_not_add, getLsbD_add]
   omega
 
 theorem getMsbD_sub {i : Nat} {i_lt : i < w} {x y : BitVec w} :
     (x - y).getMsbD i =
       (x.getMsbD i ^^ ((~~~y + 1).getMsbD i ^^ carry (w - 1 - i) x (~~~y + 1) false)) := by
-  rw [sub_toAdd, neg_eq_not_add, getMsbD_add]
+  rw [sub_eq_add_neg, neg_eq_not_add, getMsbD_add]
   · rfl
   · omega
 
@@ -359,7 +360,7 @@ theorem getElem_sub {i : Nat} {x y : BitVec w} (h : i < w) :
 theorem msb_sub {x y: BitVec w} :
     (x - y).msb
       = (x.msb ^^ ((~~~y + 1#w).msb ^^ carry (w - 1 - 0) x (~~~y + 1#w) false)) := by
-  simp [sub_toAdd, BitVec.neg_eq_not_add, msb_add]
+  simp [sub_eq_add_neg, BitVec.neg_eq_not_add, msb_add]
 
 /-! ### Negation -/
 
@@ -374,17 +375,17 @@ theorem bit_not_add_self (x : BitVec w) :
   intro i; simp only [adcb, Fin.is_lt, getLsbD_eq_getElem, atLeastTwo_false_right, bne_false,
     ofNat_eq_ofNat, Fin.getElem_fin, Prod.mk.injEq, and_eq_false_imp]
   rw [iunfoldr_replace_snd (fun _ => ()) (((iunfoldr (fun i c => (c, !(x[i.val])))) ()).snd)]
-  <;> simp [bit_not_testBit, negOne_eq_allOnes, getElem_allOnes]
+  <;> simp [bit_not_testBit, neg_one_eq_allOnes, getElem_allOnes]
 
 theorem bit_not_eq_not (x : BitVec w) :
   ((iunfoldr (fun i c => (c, !(x[i])))) ()).snd = ~~~ x := by
-  simp [←allOnes_sub_eq_not, BitVec.eq_sub_iff_add_eq.mpr (bit_not_add_self x), ←negOne_eq_allOnes]
+  simp [←allOnes_sub_eq_not, BitVec.eq_sub_iff_add_eq.mpr (bit_not_add_self x), ←neg_one_eq_allOnes]
 
 theorem bit_neg_eq_neg (x : BitVec w) : -x = (adc (((iunfoldr (fun (i : Fin w) c => (c, !(x[i.val])))) ()).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[i.val])))) ()).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]
+  · rw [BitVec.eq_sub_iff_add_eq.mpr (bit_not_add_self x), sub_eq_add_neg, BitVec.add_comm _ (-x)]
+    simp [← sub_eq_add_neg, BitVec.sub_add_cancel]
   · simp [bit_not_testBit x _]
 
 /--
@@ -419,7 +420,7 @@ theorem getLsbD_neg {i : Nat} {x : BitVec w} :
       · rintro h j hj; exact And.right <| h j (by omega)
       · rintro h j hj; exact ⟨by omega, h j (by omega)⟩
   · have h_ge : w ≤ i := by omega
-    simp [getLsbD_ge _ _ h_ge, h_ge, hi]
+    simp [getLsbD_of_ge _ _ h_ge, h_ge, hi]
 
 theorem getElem_neg {i : Nat} {x : BitVec w} (h : i < w) :
     (-x)[i] = (x[i] ^^ decide (∃ j < i, x.getLsbD j = true)) := by
@@ -565,21 +566,21 @@ theorem ult_eq_msb_of_msb_neq {x y : BitVec w} (h : x.msb ≠ y.msb) :
 theorem slt_eq_not_ult_of_msb_neq {x y : BitVec w} (h : x.msb ≠ y.msb) :
     x.slt y = !x.ult y := by
   simp only [BitVec.slt, toInt_eq_msb_cond, Bool.eq_not_of_ne h, ult_eq_msb_of_msb_neq h]
-  cases y.msb <;> (simp; omega)
+  cases y.msb <;> (simp [-Int.natCast_pow]; omega)
 
-theorem slt_eq_ult (x y : BitVec w) :
+theorem slt_eq_ult {x y : BitVec w} :
     x.slt y = (x.msb != y.msb).xor (x.ult y) := by
   by_cases h : x.msb = y.msb
   · simp [h, slt_eq_ult_of_msb_eq]
   · have h' : x.msb != y.msb := by simp_all
     simp [slt_eq_not_ult_of_msb_neq h, h']
 
-theorem slt_eq_not_carry (x y : BitVec w) :
+theorem slt_eq_not_carry {x y : BitVec w} :
     x.slt y = (x.msb == y.msb).xor (carry w x (~~~y) true) := by
   simp only [slt_eq_ult, bne, ult_eq_not_carry]
   cases x.msb == y.msb <;> simp
 
-theorem sle_eq_not_slt (x y : BitVec w) : x.sle y = !y.slt x := by
+theorem sle_eq_not_slt {x y : BitVec w} : x.sle y = !y.slt x := by
   simp only [BitVec.sle, BitVec.slt, ← decide_not, decide_eq_decide]; omega
 
 theorem zero_sle_eq_not_msb {w : Nat} {x : BitVec w} : BitVec.sle 0#w x = !x.msb := by
@@ -588,18 +589,43 @@ theorem zero_sle_eq_not_msb {w : Nat} {x : BitVec w} : BitVec.sle 0#w x = !x.msb
 theorem zero_sle_iff_msb_eq_false {w : Nat} {x : BitVec w} : BitVec.sle 0#w x ↔ x.msb = false := by
   simp [zero_sle_eq_not_msb]
 
-theorem toNat_toInt_of_sle {w : Nat} (b : BitVec w) (hb : BitVec.sle 0#w b) : b.toInt.toNat = b.toNat :=
-  toNat_toInt_of_msb b (zero_sle_iff_msb_eq_false.1 hb)
+theorem toNat_toInt_of_sle {w : Nat} {x : BitVec w} (hx : BitVec.sle 0#w x) : x.toInt.toNat = x.toNat :=
+  toNat_toInt_of_msb x (zero_sle_iff_msb_eq_false.1 hx)
 
-theorem sle_eq_carry (x y : BitVec w) :
+theorem sle_eq_carry {x y : BitVec w} :
     x.sle y = !((x.msb == y.msb).xor (carry w y (~~~x) true)) := by
   rw [sle_eq_not_slt, slt_eq_not_carry, beq_comm]
 
-/-! ### mul recurrence for bitblasting -/
+theorem neg_slt_zero (h : 0 < w) {x : BitVec w} :
+    (-x).slt 0#w = ((x == intMin w) || (0#w).slt x) := by
+  rw [slt_zero_eq_msb, msb_neg, slt_eq_sle_and_ne, zero_sle_eq_not_msb]
+  apply Bool.eq_iff_iff.2
+  cases hmsb : x.msb with
+  | false => simpa [ne_intMin_of_msb_eq_false h hmsb] using Decidable.not_iff_not.2 (eq_comm)
+  | true =>
+    simp only [Bool.bne_true, Bool.not_and, Bool.or_eq_true, Bool.not_eq_eq_eq_not, Bool.not_true,
+      bne_eq_false_iff_eq, Bool.false_and, Bool.or_false, beq_iff_eq,
+      _root_.or_iff_right_iff_imp]
+    rintro rfl
+    simp at hmsb
+
+theorem neg_sle_zero (h : 0 < w) {x : BitVec w} :
+    (-x).sle 0#w = (x == intMin w || (0#w).sle x) := by
+  rw [sle_eq_slt_or_eq, neg_slt_zero h, sle_eq_slt_or_eq]
+  simp [Bool.beq_eq_decide_eq (-x), Bool.beq_eq_decide_eq _ x, Eq.comm (a := x), Bool.or_assoc]
+
+theorem sle_eq_ule {x y : BitVec w} : x.sle y = (x.msb != y.msb ^^ x.ule y) := by
+  rw [sle_eq_not_slt, slt_eq_ult, ← Bool.xor_not, ← ule_eq_not_ult, bne_comm]
+
+theorem sle_eq_ule_of_msb_eq {x y : BitVec w} (h : x.msb = y.msb) : x.sle y = x.ule y := by
+  simp [BitVec.sle_eq_ule, h]
+
+/-! ### mul recurrence for bit blasting -/
 
 /--
 A recurrence that describes multiplication as repeated addition.
-Is useful for bitblasting multiplication.
+
+This function is useful for bit blasting multiplication.
 -/
 def mulRec (x y : BitVec w) (s : Nat) : BitVec w :=
   let cur := if y.getLsbD s then (x <<< s) else 0
@@ -648,7 +674,7 @@ abbrev zeroExtend_truncate_succ_eq_zeroExtend_truncate_add_twoPow :=
 /--
 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,
-and performing the multplication. -/
+and performing the multiplication. -/
 theorem mulRec_eq_mul_signExtend_setWidth (x y : BitVec w) (s : Nat) :
     mulRec x y s = x * ((y.setWidth (s + 1)).setWidth w) := by
   induction s
@@ -682,6 +708,12 @@ theorem getLsbD_mul (x y : BitVec w) (i : Nat) :
   · simp
   · omega
 
+theorem mul_eq_mulRec {x y : BitVec w} :
+    x * y = mulRec x y w := by
+  apply eq_of_getLsbD_eq
+  intro i hi
+  apply getLsbD_mul
+
 theorem getMsbD_mul (x y : BitVec w) (i : Nat) :
     (x * y).getMsbD i = (mulRec x y w).getMsbD i := by
   simp only [mulRec_eq_mul_signExtend_setWidth]
@@ -693,15 +725,16 @@ theorem getElem_mul {x y : BitVec w} {i : Nat} (h : i < w) :
     (x * y)[i] = (mulRec x y w)[i] := by
   simp [mulRec_eq_mul_signExtend_setWidth]
 
-/-! ## shiftLeft recurrence for bitblasting -/
+/-! ## shiftLeft recurrence for bit blasting -/
 
 /--
-`shiftLeftRec x y n` shifts `x` to the left by the first `n` bits of `y`.
+Shifts `x` to the left by the first `n` bits of `y`.
 
-The theorem `shiftLeft_eq_shiftLeftRec` proves the equivalence of `(x <<< y)` and `shiftLeftRec`.
+The theorem `BitVec.shiftLeft_eq_shiftLeftRec` proves the equivalence of `(x <<< y)` and
+`BitVec.shiftLeftRec x y`.
 
-Together with equations `shiftLeftRec_zero`, `shiftLeftRec_succ`,
-this allows us to unfold `shiftLeft` into a circuit for bitblasting.
+Together with equations `BitVec.shiftLeftRec_zero` and `BitVec.shiftLeftRec_succ`, this allows
+`BitVec.shiftLeft` to be unfolded into a circuit for bit blasting.
  -/
 def shiftLeftRec (x : BitVec w₁) (y : BitVec w₂) (n : Nat) : BitVec w₁ :=
   let shiftAmt := (y &&& (twoPow w₂ n))
@@ -755,7 +788,7 @@ theorem shiftLeftRec_eq {x : BitVec w₁} {y : BitVec w₂} {n : Nat} :
 
 /--
 Show that `x <<< y` can be written in terms of `shiftLeftRec`.
-This can be unfolded in terms of `shiftLeftRec_zero`, `shiftLeftRec_succ` for bitblasting.
+This can be unfolded in terms of `shiftLeftRec_zero`, `shiftLeftRec_succ` for bit blasting.
 -/
 theorem shiftLeft_eq_shiftLeftRec (x : BitVec w₁) (y : BitVec w₂) :
     x <<< y = shiftLeftRec x y (w₂ - 1) := by
@@ -763,7 +796,7 @@ theorem shiftLeft_eq_shiftLeftRec (x : BitVec w₁) (y : BitVec w₂) :
   · simp [of_length_zero]
   · simp [shiftLeftRec_eq]
 
-/-! # udiv/urem recurrence for bitblasting
+/-! # udiv/urem recurrence for bit blasting
 
 In order to prove the correctness of the division algorithm on the integers,
 one shows that `n.div d = q` and `n.mod d = r` iff `n = d * q + r` and `0 ≤ r < d`.
@@ -970,8 +1003,9 @@ def DivModState.wr_lt_w {qr : DivModState w} (h : qr.Poised args) : qr.wr < w :=
 /-! ### Division shift subtractor -/
 
 /--
-One round of the division algorithm, that tries to perform a subtract shift.
-Note that this should only be called when `r.msb = false`, so we will not overflow.
+One round of the division algorithm. It tries to perform a subtract shift.
+
+This should only be called when `r.msb = false`, so it will not overflow.
 -/
 def divSubtractShift (args : DivModArgs w) (qr : DivModState w) : DivModState w :=
   let {n, d} := args
@@ -1061,7 +1095,7 @@ theorem lawful_divSubtractShift (qr : DivModState w) (h : qr.Poised args) :
 
 /-! ### Core division algorithm circuit -/
 
-/-- A recursive definition of division for bitblasting, in terms of a shift-subtraction circuit. -/
+/-- A recursive definition of division for bit blasting, in terms of a shift-subtraction circuit. -/
 def divRec {w : Nat} (m : Nat) (args : DivModArgs w) (qr : DivModState w) :
     DivModState w :=
   match m with
@@ -1158,10 +1192,12 @@ theorem getMsbD_udiv (n d : BitVec w) (hd : 0#w < d)  (i : Nat) :
 /- ### 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.
+Shifts `x` arithmetically (signed) to the right by the first `n` bits of `y`.
+
+The theorem `BitVec.sshiftRight_eq_sshiftRightRec` proves the equivalence of `(x.sshiftRight y)` and
+`BitVec.sshiftRightRec x y`. Together with equations `BitVec.sshiftRightRec_zero`, and
+`BitVec.sshiftRightRec_succ`, this allows `BitVec.sshiftRight` to be unfolded into a circuit for
+bit blasting.
 -/
 def sshiftRightRec (x : BitVec w₁) (y : BitVec w₂) (n : Nat) : BitVec w₁ :=
   let shiftAmt := (y &&& (twoPow w₂ n))
@@ -1208,7 +1244,7 @@ theorem sshiftRightRec_eq (x : BitVec w₁) (y : BitVec w₂) (n : Nat) :
 
 /--
 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.
+This can be unfolded in terms of `sshiftRightRec_zero_eq`, `sshiftRightRec_succ_eq` for bit blasting.
 -/
 theorem sshiftRight_eq_sshiftRightRec (x : BitVec w₁) (y : BitVec w₂) :
     (x.sshiftRight' y).getLsbD i = (sshiftRightRec x y (w₂ - 1)).getLsbD i := by
@@ -1216,16 +1252,16 @@ theorem sshiftRight_eq_sshiftRightRec (x : BitVec w₁) (y : BitVec w₂) :
   · simp [of_length_zero]
   · simp [sshiftRightRec_eq]
 
-/- ### Logical shift right (ushiftRight) recurrence for bitblasting -/
+/- ### Logical shift right (ushiftRight) recurrence for bit blasting -/
 
 /--
-`ushiftRightRec x y n` shifts `x` logically to the right by the first `n` bits of `y`.
+Shifts `x` logically to the right by the first `n` bits of `y`.
 
-The theorem `shiftRight_eq_ushiftRightRec` proves the equivalence
-of `(x >>> y)` and `ushiftRightRec`.
+The theorem `BitVec.shiftRight_eq_ushiftRightRec` proves the equivalence
+of `(x >>> y)` and `BitVec.ushiftRightRec`.
 
-Together with equations `ushiftRightRec_zero`, `ushiftRightRec_succ`,
-this allows us to unfold `ushiftRight` into a circuit for bitblasting.
+Together with equations `BitVec.ushiftRightRec_zero` and `BitVec.ushiftRightRec_succ`,
+this allows `BitVec.ushiftRight` to be unfolded into a circuit for bit blasting.
 -/
 def ushiftRightRec (x : BitVec w₁) (y : BitVec w₂) (n : Nat) : BitVec w₁ :=
   let shiftAmt := (y &&& (twoPow w₂ n))
@@ -1271,7 +1307,7 @@ theorem ushiftRightRec_eq (x : BitVec w₁) (y : BitVec w₂) (n : Nat) :
 
 /--
 Show that `x >>> y` can be written in terms of `ushiftRightRec`.
-This can be unfolded in terms of `ushiftRightRec_zero`, `ushiftRightRec_succ` for bitblasting.
+This can be unfolded in terms of `ushiftRightRec_zero`, `ushiftRightRec_succ` for bit blasting.
 -/
 theorem shiftRight_eq_ushiftRightRec (x : BitVec w₁) (y : BitVec w₂) :
     x >>> y = ushiftRightRec x y (w₂ - 1) := by
@@ -1296,7 +1332,22 @@ theorem saddOverflow_eq {w : Nat} (x y : BitVec w) :
     simp only [← decide_or, msb_eq_toInt, decide_beq_decide, toInt_add, ← decide_not, ← decide_and,
       decide_eq_decide]
     rw_mod_cast [Int.bmod_neg_iff (by omega) (by omega)]
-    simp
+    simp only [Nat.add_one_sub_one, ge_iff_le]
+    omega
+
+theorem usubOverflow_eq {w : Nat} (x y : BitVec w) :
+    usubOverflow x y = decide (x < y) := rfl
+
+theorem ssubOverflow_eq {w : Nat} (x y : BitVec w) :
+    ssubOverflow x y = ((!x.msb && y.msb && (x - y).msb) || (x.msb && !y.msb && !(x - y).msb)) := by
+  simp only [ssubOverflow]
+  rcases w with _|w
+  · simp [BitVec.of_length_zero]
+  · have h₁ := BitVec.toInt_sub_toInt_lt_twoPow_iff (x := x) (y := y)
+    have h₂ := BitVec.twoPow_le_toInt_sub_toInt_iff (x := x) (y := y)
+    simp only [Nat.add_one_sub_one] at h₁ h₂
+    simp only [Nat.add_one_sub_one, ge_iff_le, msb_eq_toInt, ← decide_not, Int.not_lt, toInt_sub]
+    simp only [bool_to_prop]
     omega
 
 theorem negOverflow_eq {w : Nat} (x : BitVec w) :
@@ -1308,6 +1359,31 @@ theorem negOverflow_eq {w : Nat} (x : BitVec w) :
     simp only [toInt_intMin, Nat.add_one_sub_one, Int.ofNat_emod, Int.neg_inj]
     rw_mod_cast [Nat.mod_eq_of_lt (by simp [Nat.pow_lt_pow_succ])]
 
+theorem umulOverflow_eq {w : Nat} (x y : BitVec w) :
+    umulOverflow x y =
+      (0 < w && BitVec.twoPow (w * 2) w ≤ x.zeroExtend (w * 2) * y.zeroExtend (w * 2)) := by
+  simp only [umulOverflow, toNat_twoPow, le_def, toNat_mul, toNat_setWidth, mod_mul_mod]
+  rcases w with _|w
+  · simp [of_length_zero, toInt_zero, mul_mod_mod]
+  · simp only [ge_iff_le, show 0 < w + 1 by omega, decide_true, mul_mod_mod, Bool.true_and,
+      decide_eq_decide]
+    rw [Nat.mod_eq_of_lt BitVec.toNat_mul_toNat_lt, Nat.mod_eq_of_lt]
+    have := Nat.pow_lt_pow_of_lt (a := 2) (n := w + 1) (m := (w + 1) * 2)
+    omega
+
+theorem smulOverflow_eq {w : Nat} (x y : BitVec w) :
+    smulOverflow x y =
+      (0 < w &&
+      ((signExtend (w * 2) (intMax w)).slt (signExtend (w * 2) x * signExtend (w * 2) y) ||
+      (signExtend (w * 2) x * signExtend (w * 2) y).slt (signExtend (w * 2) (intMin w)))) := by
+  simp only [smulOverflow]
+  rcases w with _|w
+  · simp [of_length_zero, toInt_zero]
+  · have h₁ := BitVec.two_pow_le_toInt_mul_toInt_iff (x := x) (y := y)
+    have h₂ := BitVec.toInt_mul_toInt_lt_neg_two_pow_iff (x := x) (y := y)
+    simp only [Nat.add_one_sub_one] at h₁ h₂
+    simp [h₁, h₂]
+
 /- ### umod -/
 
 theorem getElem_umod {n d : BitVec w} (hi : i < w) :
@@ -1350,7 +1426,305 @@ theorem eq_iff_eq_of_inv (f : α → BitVec w) (g : BitVec w → α) (h : ∀ x,
     have := congrArg g h'
     simpa [h] using this
 
-/-! ### Lemmas that use Bitblasting circuits -/
+@[simp]
+theorem ne_intMin_of_lt_of_msb_false {x : BitVec w} (hw : 0 < w) (hx : x.msb = false) :
+    x ≠ intMin w := by
+  have := toNat_lt_of_msb_false hx
+  simp [toNat_eq, Nat.two_pow_pred_mod_two_pow hw]
+  omega
+
+@[simp]
+theorem ne_zero_of_msb_true {x : BitVec w} (hx : x.msb = true) :
+    x ≠ 0#w := by
+  have := Nat.two_pow_pos (w-1)
+  have := le_toNat_of_msb_true hx
+  simp [toNat_eq]
+  omega
+
+@[simp]
+theorem msb_neg_of_ne_intMin_of_ne_zero {x : BitVec w} (h : x ≠ intMin w) (h' : x ≠ 0#w) :
+    (-x).msb = !x.msb := by
+  simp only [msb_neg, bool_to_prop]
+  simp [h, h']
+
+@[simp]
+theorem udiv_intMin_of_msb_false {x : BitVec w} (h : x.msb = false) :
+    x / intMin w = 0#w := by
+  by_cases hw : w = 0
+  · subst hw
+    decide +revert
+  have wpos : 0 < w := by omega
+  have := Nat.two_pow_pos (w-1)
+  simp [toNat_eq, wpos]
+  exact toNat_lt_of_msb_false h
+
+theorem sdiv_intMin {x : BitVec w} :
+    x.sdiv (intMin w) = if x = intMin w then 1#w else 0#w := by
+  by_cases hw : w = 0
+  · subst hw
+    decide +revert
+  have wpos : 0 < w := by omega
+  by_cases h : x = intMin w
+  · subst h
+    simp
+    omega
+  · simp only [sdiv_eq, msb_intMin, show 0 < w by omega, h]
+    have := Nat.two_pow_pos (w-1)
+    by_cases hx : x.msb
+    · simp [msb_neg_of_ne_intMin_of_ne_zero (by simp [h])
+        (BitVec.ne_zero_of_msb_true hx), hx]
+    · simp [hx]
+
+theorem sdiv_neg {x y : BitVec w} (h : y ≠ intMin w) :
+    x.sdiv (-y) = -(x.sdiv y) := by
+  by_cases h' : y = 0#w
+  · subst h'
+    simp
+  · simp only [BitVec.sdiv, msb_neg_of_ne_intMin_of_ne_zero h (by simp [h'])]
+    cases x.msb <;> cases y.msb <;> simp
+
+theorem neg_sdiv {x y : BitVec w} (h : x ≠ intMin w) :
+    (-x).sdiv y = -(x.sdiv y) := by
+  by_cases hx0 : x = 0#w
+  · subst hx0
+    simp
+  · simp only [BitVec.sdiv, msb_neg_of_ne_intMin_of_ne_zero h (by simp [hx0])]
+    cases x.msb <;> cases y.msb <;> simp
+
+theorem neg_sdiv_neg {x y : BitVec w} (h : x ≠ intMin w) :
+    (-x).sdiv (-y) = x.sdiv y := by
+  by_cases h' : y = intMin w
+  · subst h'
+    simp [sdiv_intMin, neg_intMin]
+  · by_cases hy0 : y = 0#w
+    · subst hy0
+      simp
+    · by_cases hx0 : x = 0#w
+      · subst hx0
+        simp
+      · simp only [BitVec.sdiv,
+           msb_neg_of_ne_intMin_of_ne_zero h  (by simp [hx0]),
+           msb_neg_of_ne_intMin_of_ne_zero h' (by simp [hy0])]
+        cases x.msb <;> cases y.msb <;> simp
+
+theorem intMin_eq_neg_two_pow : intMin w = BitVec.ofInt w (-2 ^ (w - 1)) := by
+  apply BitVec.eq_of_toInt_eq
+  refine (Nat.eq_zero_or_pos w).elim (by rintro rfl; simp [BitVec.toInt_zero_length]) (fun hw => ?_)
+  rw [BitVec.toInt_intMin_of_pos hw, BitVec.toInt_ofInt_eq_self hw (Int.le_refl _)]
+  have := Nat.two_pow_pos (w - 1)
+  norm_cast
+  omega
+
+theorem toInt_intMin_eq_bmod : (intMin w).toInt = (-2 ^ (w - 1)).bmod (2 ^ w) := by
+  rw [intMin_eq_neg_two_pow, toInt_ofInt]
+
+@[simp]
+theorem toInt_bmod_cancel(b : BitVec w) : b.toInt.bmod (2 ^ w) = b.toInt := by
+  rw [toInt_eq_toNat_bmod, Int.bmod_bmod]
+
+theorem sdiv_ne_intMin_of_ne_intMin {x y : BitVec w} (h : x ≠ intMin w) :
+    x.sdiv y ≠ intMin w := by
+  by_cases hw : w = 0
+  · subst hw
+    simp [BitVec.eq_nil x] at h
+    contradiction
+  simp only [sdiv, udiv_eq, neg_eq]
+  by_cases hx : x.msb <;> by_cases hy : y.msb
+  <;> simp only [hx, hy, neg_ne_intMin_inj]
+  <;> simp only [Bool.not_eq_true] at hx hy
+  <;> apply ne_intMin_of_lt_of_msb_false (by omega)
+  <;> rw [msb_udiv]
+  <;> try simp only [hx, Bool.false_and]
+  · simp [h, ne_zero_of_msb_true, hx]
+  · simp [h, ne_zero_of_msb_true, hx]
+
+theorem toInt_eq_neg_toNat_neg_of_msb_true {x : BitVec w} (h : x.msb = true) :
+    x.toInt = -((-x).toNat) := by
+  simp only [toInt_eq_msb_cond, h, ↓reduceIte, toNat_neg, Int.ofNat_emod]
+  norm_cast
+  rw [Nat.mod_eq_of_lt]
+  · omega
+  · have := @BitVec.isLt w x
+    have ne_zero := ne_zero_of_msb_true h
+    simp only [ne_eq, toNat_eq, toNat_ofNat, zero_mod] at ne_zero
+    omega
+
+theorem toInt_eq_neg_toNat_neg_of_nonpos {x : BitVec w} (h : x = 0#w ∨ x.msb = true) :
+    x.toInt = -((-x).toNat) := by
+  cases h
+  case inl h' =>
+    simp [h']
+  case inr h' =>
+    simp [toInt_eq_neg_toNat_neg_of_msb_true h']
+
+theorem intMin_udiv_eq_intMin_iff (x : BitVec w) :
+    intMin w / x = intMin w ↔ x = 1#w := by
+  by_cases hw : w = 0;   subst hw; decide +revert
+  by_cases hx : x = 1#w; subst hx; simp
+  have wpos : 0 < w := by omega
+
+  have : 0 ≤ (2 ^ (w - 1) / x.toNat) := by simp
+  have := Nat.two_pow_pos (w - 1)
+
+  constructor
+  · intro h
+    rw [← toInt_inj, toInt_eq_msb_cond] at h
+    have : (intMin w / x).msb = false := by simp [msb_udiv, msb_intMin,  wpos, hx]
+    simp only [this, false_eq_true, ↓reduceIte, toNat_udiv, toNat_intMin, wpos,
+      Nat.two_pow_pred_mod_two_pow, Int.natCast_ediv, toInt_intMin] at h
+    omega
+  · intro h
+    subst h
+    simp
+
+theorem intMin_udiv_ne_zero_of_ne_zero {b : BitVec w} (hb : b.msb = false) (hb0 : b ≠ 0#w) :
+    intMin w / b ≠ 0#w := by
+  by_cases hw : w = 0;   subst hw; decide +revert
+  have wpos : 0 < w := by omega
+
+  simp [toNat_eq] at hb0
+  have := @Nat.div_eq_zero_iff_lt b.toNat (2 ^ (w-1)) (by omega)
+  have := toNat_lt_of_msb_false hb
+
+  simp [toNat_eq, wpos]
+  omega
+
+theorem toInt_sdiv_of_ne_or_ne (a b : BitVec w) (h : a ≠ intMin w ∨ b ≠ -1#w) :
+    (a.sdiv b).toInt = a.toInt.tdiv b.toInt := by
+  by_cases hw0 : w = 0;   subst hw0; decide +revert
+  by_cases hw1 : w = 1;   subst hw1; decide +revert
+  by_cases ha0 : a = 0#w; subst ha0; simp
+  by_cases hb0 : b = 0#w; subst hb0; simp
+  by_cases hb1 : b = 1#w; subst hb1; simp [show 1 < w by omega]
+
+  have wpos : 0 < w := by omega
+  have := Nat.two_pow_pos (w - 1)
+
+  by_cases hbintMin : b = intMin w
+  · simp only [ne_eq, Decidable.not_not] at hbintMin
+    subst hbintMin
+    have toIntA_lt := @BitVec.toInt_lt w a; norm_cast at toIntA_lt
+    have le_toIntA := @BitVec.le_toInt w a; norm_cast at le_toIntA
+    simp only [sdiv_intMin, h, ↓reduceIte, toInt_zero, toInt_intMin, wpos,
+      Nat.two_pow_pred_mod_two_pow, Int.tdiv_neg]
+    · by_cases ha_intMin : a = intMin w
+      · simp only [ha_intMin, ↓reduceIte, show 1 < w by omega, toInt_one, toInt_intMin, wpos,
+          Nat.two_pow_pred_mod_two_pow, Int.neg_tdiv, Int.neg_neg]
+        rw [Int.tdiv_self (by omega)]
+      · by_cases ha_nonneg : 0 ≤ a.toInt
+        · simp [Int.tdiv_eq_zero_of_lt ha_nonneg (by norm_cast at *), ha_intMin, -Int.natCast_pow]
+        · simp only [ne_eq, ← toInt_inj, toInt_intMin, wpos, Nat.two_pow_pred_mod_two_pow] at h
+          rw [← Int.neg_tdiv, Int.tdiv_eq_zero_of_lt (by omega)]
+          · simp [ha_intMin]
+          · simp [wpos, ← toInt_ne, toInt_intMin, -Int.natCast_pow] at ha_intMin
+            omega
+
+  · by_cases ha : a.msb <;> by_cases hb : b.msb
+    <;> simp only [not_eq_true] at ha hb
+    · simp only [sdiv_eq, ha, hb, udiv_eq]
+      rw [toInt_eq_neg_toNat_neg_of_nonpos (x := a) (by simp [ha]),
+        toInt_eq_neg_toNat_neg_of_nonpos (x := b) (by simp [hb]),
+        Int.neg_tdiv_neg, Int.tdiv_eq_ediv_of_nonneg (by omega)]
+      rw [toInt_eq_toNat_of_msb]
+      · rfl
+      · by_cases ha_intMin : a = intMin w
+        · simp only [ha_intMin, ne_eq, not_true_eq_false, _root_.false_or] at h
+          simp [msb_udiv, neg_eq_iff_eq_neg, h]
+        · simp [msb_udiv, ha_intMin, ha]
+    · have sdiv_toInt_of_msb_true_of_msb_false :
+          (a.sdiv b).toInt = -((-a).toNat / b.toNat) := by
+        simp only [sdiv_eq, ha, hb, udiv_eq]
+        rw [toInt_eq_neg_toNat_neg_of_nonpos]
+        · rw [neg_neg, toNat_udiv, toNat_neg, Int.ofNat_emod, Int.neg_inj]
+          norm_cast
+        · rw [neg_eq_zero_iff]
+          by_cases h' : -a / b = 0#w
+          · simp [h']
+          · by_cases ha_intMin : a = intMin w
+            · have ry := (intMin_udiv_eq_intMin_iff b).mp
+              simp only [hb1, imp_false] at ry
+              simp [msb_udiv, ha_intMin, hb1, ry, intMin_udiv_ne_zero_of_ne_zero, hb, hb0]
+            · have := @BitVec.ne_intMin_of_lt_of_msb_false w ((-a) / b) wpos (by simp [ha, ha0, ha_intMin])
+              simp [msb_neg, h', this, ha, ha_intMin]
+      rw [toInt_eq_toNat_of_msb hb, toInt_eq_neg_toNat_neg_of_msb_true ha, Int.neg_tdiv,
+        Int.tdiv_eq_ediv_of_nonneg (by omega), sdiv_toInt_of_msb_true_of_msb_false]
+    · rw [← @BitVec.neg_neg w (a.sdiv b), ← sdiv_neg hbintMin]
+      have hmb : (-b).msb = false := by simp [hbintMin, hb]
+      rw [toInt_neg_of_ne_intMin]
+      · simp [sdiv, ha, hmb]
+        rw [toInt_udiv_of_msb ha, toInt_eq_toNat_of_msb ha]
+        rw [toInt_eq_neg_toNat_neg_of_msb_true hb, Int.tdiv_neg, Int.tdiv_eq_ediv_of_nonneg (by omega)]
+      · apply sdiv_ne_intMin_of_ne_intMin
+        apply ne_intMin_of_lt_of_msb_false (by omega) ha
+    · rw [sdiv, Int.tdiv_cases, udiv_eq, neg_eq, if_pos (toInt_nonneg_of_msb_false ha),
+        if_pos (toInt_nonneg_of_msb_false hb), ha, hb, toInt_udiv_of_msb ha,
+        toInt_eq_toNat_of_msb ha, toInt_eq_toNat_of_msb hb]
+
+theorem intMin_sdiv_neg_one : (intMin w).sdiv (-1#w) = intMin w := by
+  refine (Nat.eq_zero_or_pos w).elim (by rintro rfl; exact Subsingleton.elim _ _) (fun hw => ?_)
+  apply BitVec.eq_of_toNat_eq
+  rw [sdiv]
+  simp [msb_intMin, hw, neg_one_eq_allOnes, msb_allOnes]
+  have : 2 ≤ 2 ^ w := Nat.pow_one 2 ▸ (Nat.pow_le_pow_iff_right (by omega)).2 (by omega)
+  rw [Nat.sub_sub_self (by omega), Nat.mod_eq_of_lt, Nat.div_one]
+  omega
+
+theorem toInt_sdiv (a b : BitVec w) : (a.sdiv b).toInt = (a.toInt.tdiv b.toInt).bmod (2 ^ w) := by
+  by_cases h : a = intMin w ∧ b = -1#w
+  · rcases h with ⟨rfl, rfl⟩
+    rw [BitVec.intMin_sdiv_neg_one]
+    refine (Nat.eq_zero_or_pos w).elim (by rintro rfl; simp [toInt_of_zero_length]) (fun hw => ?_)
+    rw [toInt_intMin_of_pos hw, neg_one_eq_allOnes, toInt_allOnes, if_pos hw, Int.tdiv_neg,
+      Int.tdiv_one, Int.neg_neg, Int.bmod_eq_neg (Int.pow_nonneg (by omega))]
+    conv => lhs; rw [(by omega: w = (w - 1) + 1)]
+    simp [Nat.pow_succ, Int.natCast_pow, Int.mul_comm]
+  · rw [← toInt_bmod_cancel]
+    rw [BitVec.toInt_sdiv_of_ne_or_ne _ _ (by simpa only [Decidable.not_and_iff_not_or_not] using h)]
+
+theorem msb_umod_eq_false_of_left {x : BitVec w} (hx : x.msb = false) (y : BitVec w) : (x % y).msb = false := by
+  rw [msb_eq_false_iff_two_mul_lt] at hx ⊢
+  rw [toNat_umod]
+  refine Nat.lt_of_le_of_lt ?_ hx
+  rw [Nat.mul_le_mul_left_iff (by decide)]
+  exact Nat.mod_le _ _
+
+theorem msb_umod_of_le_of_ne_zero_of_le {x y : BitVec w}
+    (hx : x ≤ intMin w) (hy : y ≠ 0#w) (hy' : y ≤ intMin w) : (x % y).msb = false := by
+  simp only [msb_umod, Bool.and_eq_false_imp, Bool.or_eq_false_iff, decide_eq_false_iff_not,
+    BitVec.not_lt, beq_eq_false_iff_ne, ne_eq, hy, not_false_eq_true, _root_.and_true]
+  intro h
+  rw [← intMin_le_iff_msb_eq_true (length_pos_of_ne hy)] at h
+  rwa [BitVec.le_antisymm hx h]
+
+@[simp]
+theorem toInt_srem (x y : BitVec w) : (x.srem y).toInt = x.toInt.tmod y.toInt := by
+  rw [srem_eq]
+  by_cases hyz : y = 0#w
+  · simp only [hyz, ofNat_eq_ofNat, msb_zero, umod_zero, neg_zero, neg_neg, toInt_zero, Int.tmod_zero]
+    cases x.msb <;> rfl
+  cases h : x.msb
+  · cases h' : y.msb
+    · dsimp only
+      rw [toInt_eq_toNat_of_msb (msb_umod_eq_false_of_left h y), toNat_umod]
+      rw [toInt_eq_toNat_of_msb h, toInt_eq_toNat_of_msb h', ← Int.ofNat_tmod]
+    · dsimp only
+      rw [toInt_eq_toNat_of_msb (msb_umod_eq_false_of_left h _), toNat_umod]
+      rw [toInt_eq_toNat_of_msb h, toInt_eq_neg_toNat_neg_of_msb_true h']
+      rw [Int.tmod_neg, ← Int.ofNat_tmod]
+  · cases h' : y.msb
+    · dsimp only
+      rw [toInt_eq_neg_toNat_neg_of_msb_true h, toInt_eq_toNat_of_msb h', Int.neg_tmod]
+      rw [← Int.ofNat_tmod, ← toNat_umod, toInt_neg_eq_of_msb ?msb, toInt_eq_toNat_of_msb ?msb]
+      rw [BitVec.msb_umod_of_le_of_ne_zero_of_le (neg_le_intMin_of_msb_eq_true h) hyz]
+      exact le_intMin_of_msb_eq_false h'
+    · dsimp only
+      rw [toInt_eq_neg_toNat_neg_of_msb_true h, toInt_eq_neg_toNat_neg_of_msb_true h', Int.neg_tmod, Int.tmod_neg]
+      rw [← Int.ofNat_tmod, ← toNat_umod, toInt_neg_eq_of_msb ?msb', toInt_eq_toNat_of_msb ?msb']
+      rw [BitVec.msb_umod_of_le_of_ne_zero_of_le (neg_le_intMin_of_msb_eq_true h)
+        ((not_congr neg_eq_zero_iff).mpr hyz)]
+      exact neg_le_intMin_of_msb_eq_true h'
+
+/-! ### Lemmas that use bit blasting circuits -/
 
 theorem add_sub_comm {x y : BitVec w} : x + y - z = x - z + y := by
   apply eq_of_toNat_eq
@@ -1366,7 +1740,7 @@ theorem not_add_one {x : BitVec w} : ~~~ (x + 1#w) = ~~~ x - 1#w := by
 
 theorem not_add_eq_not_neg {x y : BitVec w} : ~~~ (x + y) = ~~~ x - y := by
   rw [not_eq_neg_add, not_eq_neg_add, neg_add]
-  simp only [sub_toAdd]
+  simp only [sub_eq_add_neg]
   rw [BitVec.add_assoc, @BitVec.add_comm _ (-y), ← BitVec.add_assoc]
 
 theorem not_sub_one_eq_not_add_one {x : BitVec w} : ~~~ (x - 1#w) = ~~~ x + 1#w := by
@@ -1374,12 +1748,12 @@ theorem not_sub_one_eq_not_add_one {x : BitVec w} : ~~~ (x - 1#w) = ~~~ x + 1#w
     BitVec.add_sub_cancel, BitVec.sub_add_cancel]
 
 theorem not_sub_eq_not_add {x y : BitVec w} : ~~~ (x - y) = ~~~ x + y := by
-  rw [BitVec.sub_toAdd, not_add_eq_not_neg, sub_neg]
+  rw [BitVec.sub_eq_add_neg, not_add_eq_not_neg, sub_neg]
 
 /-- The value of `(carry i x y false)` can be computed by truncating `x` and `y`
 to `len` bits where `len ≥ i`. -/
 theorem carry_extractLsb'_eq_carry {w i len : Nat} (hi : i < len)
-    {x y : BitVec w} {b : Bool}: 
+    {x y : BitVec w} {b : Bool}:
     (carry i (extractLsb' 0 len x) (extractLsb' 0 len y) b)
     = (carry i x y b) := by
   simp only [carry, extractLsb'_toNat, shiftRight_zero, toNat_false, Nat.add_zero, ge_iff_le,
@@ -1393,10 +1767,33 @@ theorem carry_extractLsb'_eq_carry {w i len : Nat} (hi : i < len)
 The `[0..len)` low bits of `x + y` can be computed by truncating `x` and `y`
 to `len` bits and then adding.
 -/
-theorem extractLsb'_add {w len : Nat} {x y : BitVec w} (hlen : len ≤ w) : 
+theorem extractLsb'_add {w len : Nat} {x y : BitVec w} (hlen : len ≤ w) :
     (x + y).extractLsb' 0 len = x.extractLsb' 0 len + y.extractLsb' 0 len := by
   ext i hi
   rw [getElem_extractLsb', Nat.zero_add, getLsbD_add (by omega)]
   simp [getElem_add, carry_extractLsb'_eq_carry hi, getElem_extractLsb', Nat.zero_add]
 
+/-- `extractLsb'` commutes with multiplication. -/
+theorem extractLsb'_mul {w len} {x y : BitVec w} (hlen : len ≤ w) :
+    (x * y).extractLsb' 0 len = (x.extractLsb' 0 len) * (y.extractLsb' 0 len) := by
+  simp [← setWidth_eq_extractLsb' hlen, setWidth_mul _ _ hlen]
+
+/-- Adding bitvectors that are zero in complementary positions equals concatenation. -/
+theorem append_add_append_eq_append {v w : Nat} {x : BitVec v} {y : BitVec w} :
+    (x ++ 0#w) + (0#v ++ y) = x ++ y := by
+  rw [add_eq_or_of_and_eq_zero] <;> ext i <;> simp
+
+/-- Heuristically, `y <<< x` is much larger than `x`,
+and hence low bits of `y <<< x`. Thus, `x + (y <<< x) = x ||| (y <<< x).` -/
+theorem add_shiftLeft_eq_or_shiftLeft {x y : BitVec w} :
+    x + (y <<< x) =  x ||| (y <<< x) := by
+  rw [add_eq_or_of_and_eq_zero]
+  ext i hi
+  simp only [shiftLeft_eq', getElem_and, getElem_shiftLeft, getElem_zero, and_eq_false_imp,
+    not_eq_eq_eq_not, Bool.not_true, decide_eq_false_iff_not, Nat.not_lt]
+  intros hxi hxval
+  have : 2^i ≤ x.toNat := two_pow_le_toNat_of_getElem_eq_true hi hxi
+  have : i < 2^i := by exact Nat.lt_two_pow_self
+  omega
+
 end BitVec

src/Init/Data/BitVec/Folds.lean

@@ -13,15 +13,18 @@ set_option linter.missingDocs true
 namespace BitVec
 
 /--
-iunfoldr is an iterative operation that applies a function `f` repeatedly.
+Constructs a bitvector by iteratively computing a state for each bit using the function `f`,
+starting with the initial state `s`. At each step, the prior state and the current bit index are
+passed to `f`, and it produces a bit along with the next state value. These bits are assembled into
+the final bitvector.
 
-It produces a sequence of state values `[s_0, s_1 .. s_w]` and a bitvector
-`v` where `f i s_i = (s_{i+1}, b_i)` and `b_i` is bit `i`th least-significant bit
-in `v` (e.g., `getLsb v i = b_i`).
+It produces a sequence of state values `[s_0, s_1 .. s_w]` and a bitvector `v` where `f i s_i =
+(s_{i+1}, b_i)` and `b_i` is bit `i`th least-significant bit in `v` (e.g., `getLsb v i = b_i`).
 
-Theorems involving `iunfoldr` can be eliminated using `iunfoldr_replace` below.
+The theorem `iunfoldr_replace` allows uses of `BitVec.iunfoldr` to be replaced wiht declarative
+specifications that are easier to reason about.
 -/
-def iunfoldr (f : Fin w -> α → α × Bool) (s : α) : α × BitVec w :=
+def iunfoldr (f : Fin w → α → α × Bool) (s : α) : α × BitVec w :=
   Fin.hIterate (fun i => α × BitVec i) (s, nil) fun i q =>
     (fun p => ⟨p.fst, cons p.snd q.snd⟩) (f i q.fst)
 
@@ -96,7 +99,12 @@ theorem iunfoldr_getLsbD {f : Fin w → α → α × Bool} (state : Nat → α)
   exact (iunfoldr_getLsbD' state ind).1 i
 
 /--
-Correctness theorem for `iunfoldr`.
+Given a function `state` that provides the correct state for every potential iteration count and a
+function that computes these states from the correct initial state, the result of applying
+`BitVec.iunfoldr f` to the initial state is the state corresponding to the bitvector's width paired
+with the bitvector that consists of each computed bit.
+
+This theorem can be used to prove properties of functions that are defined using `BitVec.iunfoldr`.
 -/
 theorem iunfoldr_replace
     {f : Fin w → α → α × Bool} (state : Nat → α) (value : BitVec w) (a : α)

src/Init/Data/Bool.lean

@@ -103,15 +103,39 @@ 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 and_eq_left_iff_imp  : ∀ {a b : Bool}, ((a && b) = a) ↔ (a → b) := by decide
+@[simp] theorem and_eq_right_iff_imp : ∀ {a b : Bool}, ((a && b) = b) ↔ (b → a) := by decide
+@[simp] theorem eq_self_and : ∀ {a b : Bool}, (a = (a && b)) ↔ (a → b) := by decide
+@[simp] theorem eq_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
+@[deprecated and_eq_left_iff_imp (since := "2025-04-04")]
+abbrev and_iff_left_iff_imp := @and_eq_left_iff_imp
+
+@[deprecated and_eq_right_iff_imp (since := "2025-04-04")]
+abbrev and_iff_right_iff_imp := @and_eq_right_iff_imp
+
+@[deprecated eq_self_and (since := "2025-04-04")]
+abbrev iff_self_and := @eq_self_and
+
+@[deprecated eq_and_self (since := "2025-04-04")]
+abbrev iff_and_self := @eq_and_self
+
+@[simp] theorem not_and_eq_left_iff_and  : ∀ {a b : Bool}, ((!a && b) = a) ↔ !a ∧ !b := by decide
+@[simp] theorem and_not_eq_right_iff_and : ∀ {a b : Bool}, ((a && !b) = b) ↔ !a ∧ !b := by decide
+@[simp] theorem eq_not_self_and : ∀ {a b : Bool}, (a = (!a && b)) ↔ !a ∧ !b := by decide
+@[simp] theorem eq_and_not_self : ∀ {a b : Bool}, (b = (a && !b)) ↔ !a ∧ !b := by decide
+
+@[deprecated not_and_eq_left_iff_and (since := "2025-04-04")]
+abbrev not_and_iff_left_iff_imp := @not_and_eq_left_iff_and
+
+@[deprecated and_not_eq_right_iff_and (since := "2025-04-04")]
+abbrev and_not_iff_right_iff_imp := @and_not_eq_right_iff_and
+
+@[deprecated eq_not_self_and (since := "2025-04-04")]
+abbrev iff_not_self_and := @eq_not_self_and
+
+@[deprecated eq_and_not_self (since := "2025-04-04")]
+abbrev iff_and_not_self := @eq_and_not_self
 
 /-! ### or -/
 
@@ -137,15 +161,39 @@ 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 or_eq_left_iff_imp  : ∀ {a b : Bool}, ((a || b) = a) ↔ (b → a) := by decide
+@[simp] theorem or_eq_right_iff_imp : ∀ {a b : Bool}, ((a || b) = b) ↔ (a → b) := by decide
+@[simp] theorem eq_self_or : ∀ {a b : Bool}, (a = (a || b)) ↔ (b → a) := by decide
+@[simp] theorem eq_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
+@[deprecated or_eq_left_iff_imp (since := "2025-04-04")]
+abbrev or_iff_left_iff_imp := @or_eq_left_iff_imp
+
+@[deprecated or_eq_right_iff_imp (since := "2025-04-04")]
+abbrev or_iff_right_iff_imp := @or_eq_right_iff_imp
+
+@[deprecated eq_self_or (since := "2025-04-04")]
+abbrev iff_self_or := @eq_self_or
+
+@[deprecated eq_or_self (since := "2025-04-04")]
+abbrev iff_or_self := @eq_or_self
+
+@[simp] theorem not_or_eq_left_iff_and  : ∀ {a b : Bool}, ((!a || b) = a) ↔ a ∧ b := by decide
+@[simp] theorem or_not_eq_right_iff_and : ∀ {a b : Bool}, ((a || !b) = b) ↔ a ∧ b := by decide
+@[simp] theorem eq_not_self_or : ∀ {a b : Bool}, (a = (!a || b)) ↔ a ∧ b := by decide
+@[simp] theorem eq_or_not_self : ∀ {a b : Bool}, (b = (a || !b)) ↔ a ∧ b := by decide
+
+@[deprecated not_or_eq_left_iff_and (since := "2025-04-04")]
+abbrev not_or_iff_left_iff_imp := @not_or_eq_left_iff_and
+
+@[deprecated or_not_eq_right_iff_and (since := "2025-04-04")]
+abbrev or_not_iff_right_iff_imp := @or_not_eq_right_iff_and
+
+@[deprecated eq_not_self_or (since := "2025-04-04")]
+abbrev iff_not_self_or := @eq_not_self_or
+
+@[deprecated eq_or_not_self (since := "2025-04-04")]
+abbrev iff_or_not_self := @eq_or_not_self
 
 theorem or_comm : ∀ (x y : Bool), (x || y) = (y || x) := by decide
 instance : Std.Commutative (· || ·) := ⟨or_comm⟩
@@ -564,11 +612,16 @@ protected theorem cond_false {α : Sort u} {a b : α} : cond false a b = b := co
 @[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_then_not_self  : ∀ (c b : Bool), cond c (!c) b = (!c && b) := by decide
+@[simp] theorem cond_else_not_self : ∀ (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
+@[simp] theorem cond_then_self  : ∀ (c b : Bool), cond c c b = (c || b) := by decide
+@[simp] theorem cond_else_self : ∀ (c b : Bool), cond c b c = (c && b) := by decide
+
+@[deprecated cond_then_not_self (since := "2025-04-04")] abbrev cond_true_not_same := @cond_then_not_self
+@[deprecated cond_else_not_self (since := "2025-04-04")] abbrev cond_false_not_same := @cond_else_not_self
+@[deprecated cond_then_self (since := "2025-04-04")] abbrev cond_true_same := @cond_then_self
+@[deprecated cond_else_self (since := "2025-04-04")] abbrev cond_false_same := @cond_else_self
 
 theorem cond_pos {b : Bool} {a a' : α} (h : b = true) : (bif b then a else a') = a := by
   rw [h, cond_true]
@@ -637,9 +690,5 @@ def boolRelToRel : Coe (α → α → Bool) (α → α → Prop) where
 
 /-! ### subtypes -/
 
-@[simp] theorem Subtype.beq_iff {α : Type u} [DecidableEq α] {p : α → Prop} {x y : {a : α // p a}} :
-    (x == y) = (x.1 == y.1) := by
-  cases x
-  cases y
-  rw [Bool.eq_iff_iff]
-  simp [beq_iff_eq]
+@[simp] theorem Subtype.beq_iff {α : Type u} [BEq α] {p : α → Prop} {x y : {a : α // p a}} :
+    (x == y) = (x.1 == y.1) := rfl

src/Init/Data/Cast.lean

@@ -44,25 +44,26 @@ Nat → Nat → ...`. Sometimes we also need to declare the `CoeHTCT`
 instance if we need to shadow another coercion.
 -/
 
-/-- Type class for the canonical homomorphism `Nat → R`. -/
+/--
+The canonical homomorphism `Nat → R`. In most use cases, the target type will have a (semi)ring
+structure, and this homomorphism should be a (semi)ring homomorphism.
+
+`NatCast` and `IntCast` exist to allow different libraries with their own types that can be notated
+as natural numbers to have consistent `simp` normal forms without needing to create coercion
+simplification sets that are aware of all combinations. Libraries should make it easy to work with
+`NatCast` where possible. For instance, in Mathlib there will be such a homomorphism (and thus a
+`NatCast R` instance) whenever `R` is an additive monoid with a `1`.
+
+The prototypical example is `Int.ofNat`.
+-/
 class NatCast (R : Type u) where
   /-- The canonical map `Nat → R`. -/
   protected natCast : Nat → R
 
 instance : NatCast Nat where natCast n := n
 
-/--
-Canonical homomorphism from `Nat` to a type `R`.
-
-It contains just the function, with no axioms.
-In practice, the target type will likely have a (semi)ring structure,
-and this homomorphism should be a ring homomorphism.
-
-The prototypical example is `Int.ofNat`.
-
-This class and `IntCast` exist to allow different libraries with their own types that can be notated as natural numbers to have consistent `simp` normal forms without needing to create coercion simplification sets that are aware of all combinations. Libraries should make it easy to work with `NatCast` where possible. For instance, in Mathlib there will be such a homomorphism (and thus a `NatCast R` instance) whenever `R` is an additive monoid with a `1`.
--/
-@[coe, reducible, match_pattern] protected def Nat.cast {R : Type u} [NatCast R] : Nat → R :=
+@[coe, reducible, match_pattern, inherit_doc NatCast]
+protected def Nat.cast {R : Type u} [NatCast R] : Nat → R :=
   NatCast.natCast
 
 -- see the notes about coercions into arbitrary types in the module doc-string

src/Init/Data/Channel.lean

@@ -1,149 +0,0 @@
-/-
-Copyright (c) 2022 Microsoft Corporation. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Gabriel Ebner
--/
-prelude
-import Init.Data.Queue
-import Init.System.Promise
-import Init.System.Mutex
-
-set_option linter.deprecated false
-
-namespace IO
-
-/--
-Internal state of an `Channel`.
-
-We maintain the invariant that at all times either `consumers` or `values` is empty.
--/
-@[deprecated "Use Std.Channel.State from Std.Sync.Channel instead" (since := "2024-12-02")]
-structure Channel.State (α : Type) where
-  values : Std.Queue α := ∅
-  consumers : Std.Queue (Promise (Option α)) := ∅
-  closed := false
-  deriving Inhabited
-
-/--
-FIFO channel with unbounded buffer, where `recv?` returns a `Task`.
-
-A channel can be closed.  Once it is closed, all `send`s are ignored, and
-`recv?` returns `none` once the queue is empty.
--/
-@[deprecated "Use Std.Channel from Std.Sync.Channel instead" (since := "2024-12-02")]
-def Channel (α : Type) : Type := Mutex (Channel.State α)
-
-instance : Nonempty (Channel α) :=
-  inferInstanceAs (Nonempty (Mutex _))
-
-/-- Creates a new `Channel`. -/
-@[deprecated "Use Std.Channel.new from Std.Sync.Channel instead" (since := "2024-12-02")]
-def Channel.new : BaseIO (Channel α) :=
-  Mutex.new {}
-
-/--
-Sends a message on an `Channel`.
-
-This function does not block.
--/
-@[deprecated "Use Std.Channel.send from Std.Sync.Channel instead" (since := "2024-12-02")]
-def Channel.send (ch : Channel α) (v : α) : BaseIO Unit :=
-  ch.atomically do
-    let st ← get
-    if st.closed then return
-    if let some (consumer, consumers) := st.consumers.dequeue? then
-      consumer.resolve (some v)
-      set { st with consumers }
-    else
-      set { st with values := st.values.enqueue v }
-
-/--
-Closes an `Channel`.
--/
-@[deprecated "Use Std.Channel.close from Std.Sync.Channel instead" (since := "2024-12-02")]
-def Channel.close (ch : Channel α) : BaseIO Unit :=
-  ch.atomically do
-    let st ← get
-    for consumer in st.consumers.toArray do consumer.resolve none
-    set { st with closed := true, consumers := ∅ }
-
-/--
-Receives a message, without blocking.
-The returned task waits for the message.
-Every message is only received once.
-
-Returns `none` if the channel is closed and the queue is empty.
--/
-@[deprecated "Use Std.Channel.recv? from Std.Sync.Channel instead" (since := "2024-12-02")]
-def Channel.recv? (ch : Channel α) : BaseIO (Task (Option α)) :=
-  ch.atomically do
-    let st ← get
-    if let some (a, values) := st.values.dequeue? then
-      set { st with values }
-      return .pure a
-    else if !st.closed then
-      let promise ← Promise.new
-      set { st with consumers := st.consumers.enqueue promise }
-      return promise.result
-    else
-      return .pure none
-
-/--
-`ch.forAsync f` calls `f` for every messages received on `ch`.
-
-Note that if this function is called twice, each `forAsync` only gets half the messages.
--/
-@[deprecated "Use Std.Channel.forAsync from Std.Sync.Channel instead" (since := "2024-12-02")]
-partial def Channel.forAsync (f : α → BaseIO Unit) (ch : Channel α)
-    (prio : Task.Priority := .default) : BaseIO (Task Unit) := do
-  BaseIO.bindTask (prio := prio) (← ch.recv?) fun
-    | none => return .pure ()
-    | some v => do f v; ch.forAsync f prio
-
-/--
-Receives all currently queued messages from the channel.
-
-Those messages are dequeued and will not be returned by `recv?`.
--/
-@[deprecated "Use Std.Channel.recvAllCurrent from Std.Sync.Channel instead" (since := "2024-12-02")]
-def Channel.recvAllCurrent (ch : Channel α) : BaseIO (Array α) :=
-  ch.atomically do
-    modifyGet fun st => (st.values.toArray, { st with values := ∅ })
-
-/-- Type tag for synchronous (blocking) operations on a `Channel`. -/
-@[deprecated "Use Std.Channel.Sync from Std.Sync.Channel instead" (since := "2024-12-02")]
-def Channel.Sync := Channel
-
-/--
-Accesses synchronous (blocking) version of channel operations.
-
-For example, `ch.sync.recv?` blocks until the next message,
-and `for msg in ch.sync do ...` iterates synchronously over the channel.
-These functions should only be used in dedicated threads.
--/
-@[deprecated "Use Std.Channel.sync from Std.Sync.Channel instead" (since := "2024-12-02")]
-def Channel.sync (ch : Channel α) : Channel.Sync α := ch
-
-/--
-Synchronously receives a message from the channel.
-
-Every message is only received once.
-Returns `none` if the channel is closed and the queue is empty.
--/
-@[deprecated "Use Std.Channel.Sync.recv? from Std.Sync.Channel instead" (since := "2024-12-02")]
-def Channel.Sync.recv? (ch : Channel.Sync α) : BaseIO (Option α) := do
-  IO.wait (← Channel.recv? ch)
-
-@[deprecated "Use Std.Channel.Sync.forIn from Std.Sync.Channel instead" (since := "2024-12-02")]
-private partial def Channel.Sync.forIn [Monad m] [MonadLiftT BaseIO m]
-    (ch : Channel.Sync α) (f : α → β → m (ForInStep β)) : β → m β := fun b => do
-  match ← ch.recv? with
-    | some a =>
-      match ← f a b with
-        | .done b => pure b
-        | .yield b => ch.forIn f b
-    | none => pure b
-
-/-- `for msg in ch.sync do ...` receives all messages in the channel until it is closed. -/
-instance [MonadLiftT BaseIO m] : ForIn m (Channel.Sync α) α where
-  forIn ch b f := ch.forIn f b

src/Init/Data/Fin/Lemmas.lean

@@ -127,6 +127,33 @@ protected theorem ne_of_gt {a b : Fin n} (h : a < b) : b ≠ a := Fin.ne_of_val_
 
 protected theorem le_of_lt {a b : Fin n} (h : a < b) : a ≤ b := Nat.le_of_lt h
 
+protected theorem lt_of_le_of_lt {a b c : Fin n} : a ≤ b → b < c → a < c := Nat.lt_of_le_of_lt
+
+protected theorem lt_of_lt_of_le {a b c : Fin n} : a < b → b ≤ c → a < c := Nat.lt_of_lt_of_le
+
+protected theorem le_rfl {a : Fin n} : a ≤ a := Nat.le_refl _
+
+protected theorem lt_iff_le_and_ne {a b : Fin n} : a < b ↔ a ≤ b ∧ a ≠ b := by
+  rw [← val_ne_iff]; exact Nat.lt_iff_le_and_ne
+
+protected theorem lt_or_lt_of_ne {a b : Fin n} (h : a ≠ b) : a < b ∨ b < a :=
+  Nat.lt_or_lt_of_ne <| val_ne_iff.2 h
+
+protected theorem lt_or_le (a b : Fin n) : a < b ∨ b ≤ a := Nat.lt_or_ge _ _
+
+protected theorem le_or_lt (a b : Fin n) : a ≤ b ∨ b < a := (b.lt_or_le a).symm
+
+protected theorem le_of_eq {a b : Fin n} (hab : a = b) : a ≤ b :=
+  Nat.le_of_eq <| congrArg val hab
+
+protected theorem ge_of_eq {a b : Fin n} (hab : a = b) : b ≤ a := Fin.le_of_eq hab.symm
+
+protected theorem eq_or_lt_of_le {a b : Fin n} : a ≤ b → a = b ∨ a < b := by
+  rw [Fin.ext_iff]; exact Nat.eq_or_lt_of_le
+
+protected theorem lt_or_eq_of_le {a b : Fin n} : a ≤ b → a < b ∨ a = b := by
+  rw [Fin.ext_iff]; exact Nat.lt_or_eq_of_le
+
 theorem is_le (i : Fin (n + 1)) : i ≤ n := Nat.le_of_lt_succ i.is_lt
 
 @[simp] theorem is_le' {a : Fin n} : a ≤ n := Nat.le_of_lt a.is_lt
@@ -949,6 +976,16 @@ theorem coe_sub_iff_lt {a b : Fin n} : (↑(a - b) : Nat) = n + a - b ↔ a < b
 
 /-! ### mul -/
 
+theorem ofNat'_mul [NeZero n] (x : Nat) (y : Fin n) :
+    Fin.ofNat' n x * y = Fin.ofNat' n (x * y.val) := by
+  apply Fin.eq_of_val_eq
+  simp [Fin.ofNat', Fin.mul_def]
+
+theorem mul_ofNat' [NeZero n] (x : Fin n) (y : Nat) :
+    x * Fin.ofNat' n y = Fin.ofNat' n (x.val * y) := by
+  apply Fin.eq_of_val_eq
+  simp [Fin.ofNat', Fin.mul_def]
+
 theorem val_mul {n : Nat} : ∀ a b : Fin n, (a * b).val = a.val * b.val % n
   | ⟨_, _⟩, ⟨_, _⟩ => rfl
 

src/Init/Data/Float.lean

@@ -26,43 +26,97 @@ opaque floatSpec : FloatSpec := {
   decLe := fun _ _ => inferInstanceAs (Decidable True)
 }
 
-/-- Native floating point type, corresponding to the IEEE 754 *binary64* format
-(`double` in C or `f64` in Rust). -/
+/--
+64-bit floating-point numbers.
+
+`Float` corresponds to the IEEE 754 *binary64* format (`double` in C or `f64` in Rust).
+Floating-point numbers are a finite representation of a subset of the real numbers, extended with
+extra “sentinel” values that represent undefined and infinite results as well as separate positive
+and negative zeroes. Arithmetic on floating-point numbers approximates the corresponding operations
+on the real numbers by rounding the results to numbers that are representable, propagating error and
+infinite values.
+
+Floating-point numbers include [subnormal numbers](https://en.wikipedia.org/wiki/Subnormal_number).
+Their special values are:
+ * `NaN`, which denotes a class of “not a number” values that result from operations such as
+   dividing zero by zero, and
+ * `Inf` and `-Inf`, which represent positive and infinities that result from dividing non-zero
+   values by zero.
+-/
 structure Float where
   val : floatSpec.float
 
 instance : Nonempty Float := ⟨{ val := floatSpec.val }⟩
 
+/--
+Adds two 64-bit floating-point numbers according to IEEE 754. Typically used via the `+` operator.
+
+This function does not reduce in the kernel. It is compiled to the C addition operator.
+-/
 @[extern "lean_float_add"] opaque Float.add : Float → Float → Float
+/--
+Subtracts 64-bit floating-point numbers according to IEEE 754. Typically used via the `-` operator.
+
+This function does not reduce in the kernel. It is compiled to the C subtraction operator.
+-/
 @[extern "lean_float_sub"] opaque Float.sub : Float → Float → Float
+/--
+Multiplies 64-bit floating-point numbers according to IEEE 754. Typically used via the `*` operator.
+
+This function does not reduce in the kernel. It is compiled to the C multiplication operator.
+-/
 @[extern "lean_float_mul"] opaque Float.mul : Float → Float → Float
+/--
+Divides 64-bit floating-point numbers according to IEEE 754. Typically used via the `/` operator.
+
+In Lean, division by zero typically yields zero. For `Float`, it instead yields either `Inf`,
+`-Inf`, or `NaN`.
+
+This function does not reduce in the kernel. It is compiled to the C division operator.
+-/
 @[extern "lean_float_div"] opaque Float.div : Float → Float → Float
+/--
+Negates 64-bit floating-point numbers according to IEEE 754. Typically used via the `-` prefix
+operator.
+
+This function does not reduce in the kernel. It is compiled to the C negation operator.
+-/
 @[extern "lean_float_negate"] opaque Float.neg : Float → Float
 
 set_option bootstrap.genMatcherCode false
+/--
+Strict inequality of floating-point numbers. Typically used via the `<` operator.
+-/
 def Float.lt : Float → Float → Prop := fun a b =>
   match a, b with
   | ⟨a⟩, ⟨b⟩ => floatSpec.lt a b
 
+/--
+Non-strict inequality of floating-point numbers. Typically used via the `≤` operator.
+-/
 def Float.le : Float → Float → Prop := fun a b =>
   floatSpec.le a.val b.val
 
 /--
-Raw transmutation from `UInt64`.
+Bit-for-bit conversion from `UInt64`. Interprets a `UInt64` as a `Float`, ignoring the numeric value
+and treating the `UInt64`'s bit pattern as a `Float`.
 
-Floats and UInts have the same endianness on all supported platforms.
-IEEE 754 very precisely specifies the bit layout of floats.
+`Float`s and `UInt64`s have the same endianness on all supported platforms. IEEE 754 very precisely
+specifies the bit layout of floats.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float_of_bits"] opaque Float.ofBits : UInt64 → Float
 
 /--
-Raw transmutation to `UInt64`.
+Bit-for-bit conversion to `UInt64`. Interprets a `Float` as a `UInt64`, ignoring the numeric value
+and treating the `Float`'s bit pattern as a `UInt64`.
 
-Floats and UInts have the same endianness on all supported platforms.
-IEEE 754 very precisely specifies the bit layout of floats.
+`Float`s and `UInt64`s have the same endianness on all supported platforms. IEEE 754 very precisely
+specifies the bit layout of floats.
 
-Note that this function is distinct from `Float.toUInt64`, which attempts
-to preserve the numeric value, and not the bitwise value.
+This function is distinct from `Float.toUInt64`, which attempts to preserve the numeric value rather
+than reinterpreting the bit pattern.
 -/
 @[extern "lean_float_to_bits"] opaque Float.toBits : Float → UInt64
 
@@ -74,15 +128,33 @@ instance : Neg Float := ⟨Float.neg⟩
 instance : LT Float  := ⟨Float.lt⟩
 instance : LE Float  := ⟨Float.le⟩
 
-/-- Note: this is not reflexive since `NaN != NaN`.-/
+/--
+Checks whether two floating-point numbers are equal according to IEEE 754.
+
+Floating-point equality does not correspond with propositional equality. In particular, it is not
+reflexive since `NaN != NaN`, and it is not a congruence because `0.0 == -0.0`, but
+`1.0 / 0.0 != 1.0 / -0.0`.
+
+This function does not reduce in the kernel. It is compiled to the C equality operator.
+-/
 @[extern "lean_float_beq"] opaque Float.beq (a b : Float) : Bool
 
 instance : BEq Float := ⟨Float.beq⟩
 
+/--
+Compares two floating point numbers for strict inequality.
+
+This function does not reduce in the kernel. It is compiled to the C inequality operator.
+-/
 @[extern "lean_float_decLt"] opaque Float.decLt (a b : Float) : Decidable (a < b) :=
   match a, b with
   | ⟨a⟩, ⟨b⟩ => floatSpec.decLt a b
 
+/--
+Compares two floating point numbers for non-strict inequality.
+
+This function does not reduce in the kernel. It is compiled to the C inequality operator.
+-/
 @[extern "lean_float_decLe"] opaque Float.decLe (a b : Float) : Decidable (a ≤ b) :=
   match a, b with
   | ⟨a⟩, ⟨b⟩ => floatSpec.decLe a b
@@ -90,44 +162,95 @@ instance : BEq Float := ⟨Float.beq⟩
 instance floatDecLt (a b : Float) : Decidable (a < b) := Float.decLt a b
 instance floatDecLe (a b : Float) : Decidable (a ≤ b) := Float.decLe a b
 
+/--
+Converts a floating-point number to a string.
+
+This function does not reduce in the kernel.
+-/
 @[extern "lean_float_to_string"] opaque Float.toString : Float → String
-/-- If the given float is non-negative, truncates the value to the nearest non-negative integer.
-If negative or NaN, returns `0`.
-If larger than the maximum value for `UInt8` (including Inf), returns the maximum value of `UInt8`
-(i.e. `UInt8.size - 1`).
+
+/--
+Converts a floating-point number to an 8-bit unsigned integer.
+
+If the given `Float` is non-negative, truncates the value to a positive integer, rounding down and
+clamping to the range of `UInt8`. Returns `0` if the `Float` is negative or `NaN`, and returns the
+largest `UInt8` value (i.e. `UInt8.size - 1`) if the float is larger than it.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float_to_uint8"] opaque Float.toUInt8 : Float → UInt8
-/-- If the given float is non-negative, truncates the value to the nearest non-negative integer.
-If negative or NaN, returns `0`.
-If larger than the maximum value for `UInt16` (including Inf), returns the maximum value of `UInt16`
-(i.e. `UInt16.size - 1`).
+/--
+Converts a floating-point number to a 16-bit unsigned integer.
+
+If the given `Float` is non-negative, truncates the value to a positive integer, rounding down and
+clamping to the range of `UInt16`. Returns `0` if the `Float` is negative or `NaN`, and returns the
+largest `UInt16` value (i.e. `UInt16.size - 1`) if the float is larger than it.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float_to_uint16"] opaque Float.toUInt16 : Float → UInt16
-/-- If the given float is non-negative, truncates the value to the nearest non-negative integer.
-If negative or NaN, returns `0`.
-If larger than the maximum value for `UInt32` (including Inf), returns the maximum value of `UInt32`
-(i.e. `UInt32.size - 1`).
+/--
+Converts a floating-point number to a 32-bit unsigned integer.
+
+If the given `Float` is non-negative, truncates the value to a positive integer, rounding down and
+clamping to the range of `UInt32`. Returns `0` if the `Float` is negative or `NaN`, and returns the
+largest `UInt32` value (i.e. `UInt32.size - 1`) if the float is larger than it.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float_to_uint32"] opaque Float.toUInt32 : Float → UInt32
-/-- If the given float is non-negative, truncates the value to the nearest non-negative integer.
-If negative or NaN, returns `0`.
-If larger than the maximum value for `UInt64` (including Inf), returns the maximum value of `UInt64`
-(i.e. `UInt64.size - 1`).
+/--
+Converts a floating-point number to a 64-bit unsigned integer.
+
+If the given `Float` is non-negative, truncates the value to a positive integer, rounding down and
+clamping to the range of `UInt64`. Returns `0` if the `Float` is negative or `NaN`, and returns the
+largest `UInt64` value (i.e. `UInt64.size - 1`) if the float is larger than it.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float_to_uint64"] opaque Float.toUInt64 : Float → UInt64
-/-- If the given float is non-negative, truncates the value to the nearest non-negative integer.
-If negative or NaN, returns `0`.
-If larger than the maximum value for `USize` (including Inf), returns the maximum value of `USize`
-(i.e. `USize.size - 1`). This value is platform dependent).
+/--
+Converts a floating-point number to a word-sized unsigned integer.
+
+If the given `Float` is non-negative, truncates the value to a positive integer, rounding down and
+clamping to the range of `USize`. Returns `0` if the `Float` is negative or `NaN`, and returns the
+largest `USize` value (i.e. `USize.size - 1`) if the float is larger than it.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float_to_usize"] opaque Float.toUSize : Float → USize
 
+/--
+Checks whether a floating point number is `NaN` (“not a number”) value.
+
+`NaN` values result from operations that might otherwise be errors, such as dividing zero by zero.
+
+This function does not reduce in the kernel. It is compiled to the C operator `isnan`.
+-/
 @[extern "lean_float_isnan"] opaque Float.isNaN : Float → Bool
+
+/--
+Checks whether a floating-point number is finite, that is, whether it is normal, subnormal, or zero,
+but not infinite or `NaN`.
+
+This function does not reduce in the kernel. It is compiled to the C operator `isfinite`.
+-/
 @[extern "lean_float_isfinite"] opaque Float.isFinite : Float → Bool
+
+/--
+Checks whether a floating-point number is a positive or negative infinite number, but not a finite
+number or `NaN`.
+
+This function does not reduce in the kernel. It is compiled to the C operator `isinf`.
+-/
 @[extern "lean_float_isinf"] opaque Float.isInf : Float → Bool
-/-- Splits the given float `x` into a significand/exponent pair `(s, i)`
-such that `x = s * 2^i` where `s ∈ (-1;-0.5] ∪ [0.5; 1)`.
-Returns an undefined value if `x` is not finite.
+
+/--
+Splits the given float `x` into a significand/exponent pair `(s, i)` such that `x = s * 2^i` where
+`s ∈ (-1;-0.5] ∪ [0.5; 1)`. Returns an undefined value if `x` is not finite.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`frexp`.
 -/
 @[extern "lean_float_frexp"] opaque Float.frExp : Float → Float × Int
 
@@ -171,30 +294,191 @@ instance : Repr Float where
 
 instance : ReprAtom Float  := ⟨⟩
 
+/--
+Computes the sine of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`sin`.
+-/
 @[extern "sin"] opaque Float.sin : Float → Float
+/--
+Computes the cosine of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`cos`.
+-/
 @[extern "cos"] opaque Float.cos : Float → Float
+/--
+Computes the tangent of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`tan`.
+-/
 @[extern "tan"] opaque Float.tan : Float → Float
+/--
+Computes the arc sine (inverse sine) of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`asin`.
+-/
 @[extern "asin"] opaque Float.asin : Float → Float
+/--
+Computes the arc cosine (inverse cosine) of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`acos`.
+-/
 @[extern "acos"] opaque Float.acos : Float → Float
+/--
+Computes the arc tangent (inverse tangent) of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`atan`.
+-/
 @[extern "atan"] opaque Float.atan : Float → Float
-@[extern "atan2"] opaque Float.atan2 : Float → Float → Float
+/--
+Computes the arc tangent (inverse tangent) of `y / x` in radians, in the range `-π`–`π`. The signs
+of the arguments determine the quadrant of the result.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`atan2`.
+-/
+@[extern "atan2"] opaque Float.atan2 (y x : Float) : Float
+/--
+Computes the hyperbolic sine of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`sinh`.
+-/
 @[extern "sinh"] opaque Float.sinh : Float → Float
+/--
+Computes the hyperbolic cosine of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`cosh`.
+-/
 @[extern "cosh"] opaque Float.cosh : Float → Float
+/--
+Computes the hyperbolic tangent of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`tanh`.
+-/
 @[extern "tanh"] opaque Float.tanh : Float → Float
+/--
+Computes the hyperbolic arc sine (inverse sine) of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`asinh`.
+-/
 @[extern "asinh"] opaque Float.asinh : Float → Float
+/--
+Computes the hyperbolic arc cosine (inverse cosine) of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`acosh`.
+-/
 @[extern "acosh"] opaque Float.acosh : Float → Float
+/--
+Computes the hyperbolic arc tangent (inverse tangent) of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`atanh`.
+-/
 @[extern "atanh"] opaque Float.atanh : Float → Float
-@[extern "exp"] opaque Float.exp : Float → Float
-@[extern "exp2"] opaque Float.exp2 : Float → Float
-@[extern "log"] opaque Float.log : Float → Float
+/--
+Computes the exponential `e^x` of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`exp`.
+-/
+@[extern "exp"] opaque Float.exp (x : Float) : Float
+/--
+Computes the base-2 exponential `2^x` of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`exp2`.
+-/
+@[extern "exp2"] opaque Float.exp2 (x : Float) : Float
+/--
+Computes the natural logarithm `ln x` of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`log`.
+-/
+@[extern "log"] opaque Float.log (x : Float) : Float
+/--
+Computes the base-2 logarithm of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`log2`.
+-/
 @[extern "log2"] opaque Float.log2 : Float → Float
+/--
+Computes the base-10 logarithm of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`log10`.
+-/
 @[extern "log10"] opaque Float.log10 : Float → Float
+/--
+Raises one floating-point number to the power of another. Typically used via the `^` operator.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`pow`.
+-/
 @[extern "pow"] opaque Float.pow : Float → Float → Float
+/--
+Computes the square root of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`sqrt`.
+-/
 @[extern "sqrt"] opaque Float.sqrt : Float → Float
+/--
+Computes the cube root of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`cbrt`.
+-/
 @[extern "cbrt"] opaque Float.cbrt : Float → Float
+/--
+Computes the ceiling of a floating-point number, which is the smallest integer that's no smaller
+than the given number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`ceil`.
+
+Examples:
+ * `Float.ceil 1.5 = 2`
+ * `Float.ceil (-1.5) = (-1)`
+-/
 @[extern "ceil"] opaque Float.ceil : Float → Float
+/--
+Computes the floor of a floating-point number, which is the largest integer that's no larger
+than the given number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`floor`.
+
+Examples:
+ * `Float.floor 1.5 = 1`
+ * `Float.floor (-1.5) = (-2)`
+-/
 @[extern "floor"] opaque Float.floor : Float → Float
+/--
+Rounds to the nearest integer, rounding away from zero at half-way points.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`round`.
+-/
 @[extern "round"] opaque Float.round : Float → Float
+/--
+Computes the absolute value of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`fabs`.
+-/
 @[extern "fabs"] opaque Float.abs : Float → Float
 
 instance : HomogeneousPow Float := ⟨Float.pow⟩
@@ -205,6 +489,8 @@ instance : Max Float := maxOfLe
 
 /--
 Efficiently computes `x * 2^i`.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float_scaleb"]
 opaque Float.scaleB (x : Float) (i : @& Int) : Float

src/Init/Data/Float32.lean

@@ -19,43 +19,101 @@ opaque float32Spec : FloatSpec := {
   decLe := fun _ _ => inferInstanceAs (Decidable True)
 }
 
-/-- Native floating point type, corresponding to the IEEE 754 *binary32* format
-(`float` in C or `f32` in Rust). -/
+/--
+32-bit floating-point numbers.
+
+`Float32` corresponds to the IEEE 754 *binary32* format (`float` in C or `f32` in Rust).
+Floating-point numbers are a finite representation of a subset of the real numbers, extended with
+extra “sentinel” values that represent undefined and infinite results as well as separate positive
+and negative zeroes. Arithmetic on floating-point numbers approximates the corresponding operations
+on the real numbers by rounding the results to numbers that are representable, propagating error and
+infinite values.
+
+Floating-point numbers include [subnormal numbers](https://en.wikipedia.org/wiki/Subnormal_number).
+Their special values are:
+ * `NaN`, which denotes a class of “not a number” values that result from operations such as
+   dividing zero by zero, and
+ * `Inf` and `-Inf`, which represent positive and infinities that result from dividing non-zero
+   values by zero.
+
+-/
 structure Float32 where
   val : float32Spec.float
 
 instance : Nonempty Float32 := ⟨{ val := float32Spec.val }⟩
 
+/--
+Adds two 32-bit floating-point numbers according to IEEE 754. Typically used via the `+` operator.
+
+This function does not reduce in the kernel. It is compiled to the C addition operator.
+-/
 @[extern "lean_float32_add"] opaque Float32.add : Float32 → Float32 → Float32
+/--
+Subtracts 32-bit floating-point numbers according to IEEE 754. Typically used via the `-` operator.
+
+This function does not reduce in the kernel. It is compiled to the C subtraction operator.
+-/
 @[extern "lean_float32_sub"] opaque Float32.sub : Float32 → Float32 → Float32
+/--
+Multiplies 32-bit floating-point numbers according to IEEE 754. Typically used via the `*` operator.
+
+This function does not reduce in the kernel. It is compiled to the C multiplication operator.
+-/
 @[extern "lean_float32_mul"] opaque Float32.mul : Float32 → Float32 → Float32
+/--
+Divides 32-bit floating-point numbers according to IEEE 754. Typically used via the `/` operator.
+
+In Lean, division by zero typically yields zero. For `Float32`, it instead yields either `Inf`,
+`-Inf`, or `NaN`.
+
+This function does not reduce in the kernel. It is compiled to the C division operator.
+-/
 @[extern "lean_float32_div"] opaque Float32.div : Float32 → Float32 → Float32
+/--
+Negates 32-bit floating-point numbers according to IEEE 754. Typically used via the `-` prefix
+operator.
+
+This function does not reduce in the kernel. It is compiled to the C negation operator.
+-/
 @[extern "lean_float32_negate"] opaque Float32.neg : Float32 → Float32
 
 set_option bootstrap.genMatcherCode false
+/--
+Strict inequality of floating-point numbers. Typically used via the `<` operator.
+-/
 def Float32.lt : Float32 → Float32 → Prop := fun a b =>
   match a, b with
   | ⟨a⟩, ⟨b⟩ => float32Spec.lt a b
 
+/--
+Non-strict inequality of floating-point numbers. Typically used via the `≤` operator.
+-/
 def Float32.le : Float32 → Float32 → Prop := fun a b =>
   float32Spec.le a.val b.val
 
 /--
-Raw transmutation from `UInt32`.
+Bit-for-bit conversion from `UInt32`. Interprets a `UInt32` as a `Float32`, ignoring the numeric
+value and treating the `UInt32`'s bit pattern as a `Float32`.
 
-Float32s and UInts have the same endianness on all supported platforms.
-IEEE 754 very precisely specifies the bit layout of floats.
+`Float32`s and `UInt32`s have the same endianness on all supported platforms. IEEE 754 very
+precisely specifies the bit layout of floats.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float32_of_bits"] opaque Float32.ofBits : UInt32 → Float32
 
+
 /--
-Raw transmutation to `UInt32`.
+Bit-for-bit conversion to `UInt32`. Interprets a `Float32` as a `UInt32`, ignoring the numeric value
+and treating the `Float32`'s bit pattern as a `UInt32`.
 
-Float32s and UInts have the same endianness on all supported platforms.
-IEEE 754 very precisely specifies the bit layout of floats.
+`Float32`s and `UInt32`s have the same endianness on all supported platforms. IEEE 754 very
+precisely specifies the bit layout of floats.
 
-Note that this function is distinct from `Float32.toUInt32`, which attempts
-to preserve the numeric value, and not the bitwise value.
+This function is distinct from `Float.toUInt32`, which attempts to preserve the numeric value rather
+than reinterpreting the bit pattern.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float32_to_bits"] opaque Float32.toBits : Float32 → UInt32
 
@@ -67,15 +125,33 @@ instance : Neg Float32 := ⟨Float32.neg⟩
 instance : LT Float32  := ⟨Float32.lt⟩
 instance : LE Float32  := ⟨Float32.le⟩
 
-/-- Note: this is not reflexive since `NaN != NaN`.-/
+/--
+Checks whether two floating-point numbers are equal according to IEEE 754.
+
+Floating-point equality does not correspond with propositional equality. In particular, it is not
+reflexive since `NaN != NaN`, and it is not a congruence because `0.0 == -0.0`, but
+`1.0 / 0.0 != 1.0 / -0.0`.
+
+This function does not reduce in the kernel. It is compiled to the C equality operator.
+-/
 @[extern "lean_float32_beq"] opaque Float32.beq (a b : Float32) : Bool
 
 instance : BEq Float32 := ⟨Float32.beq⟩
 
+/--
+Compares two floating point numbers for strict inequality.
+
+This function does not reduce in the kernel. It is compiled to the C inequality operator.
+-/
 @[extern "lean_float32_decLt"] opaque Float32.decLt (a b : Float32) : Decidable (a < b) :=
   match a, b with
   | ⟨a⟩, ⟨b⟩ => float32Spec.decLt a b
 
+/--
+Compares two floating point numbers for non-strict inequality.
+
+This function does not reduce in the kernel. It is compiled to the C inequality operator.
+-/
 @[extern "lean_float32_decLe"] opaque Float32.decLe (a b : Float32) : Decidable (a ≤ b) :=
   match a, b with
   | ⟨a⟩, ⟨b⟩ => float32Spec.decLe a b
@@ -83,44 +159,91 @@ instance : BEq Float32 := ⟨Float32.beq⟩
 instance float32DecLt (a b : Float32) : Decidable (a < b) := Float32.decLt a b
 instance float32DecLe (a b : Float32) : Decidable (a ≤ b) := Float32.decLe a b
 
+/--
+Converts a floating-point number to a string.
+
+This function does not reduce in the kernel.
+-/
 @[extern "lean_float32_to_string"] opaque Float32.toString : Float32 → String
-/-- If the given float is non-negative, truncates the value to the nearest non-negative integer.
-If negative or NaN, returns `0`.
-If larger than the maximum value for `UInt8` (including Inf), returns the maximum value of `UInt8`
-(i.e. `UInt8.size - 1`).
+/--
+Converts a floating-point number to an 8-bit unsigned integer.
+
+If the given `Float32` is non-negative, truncates the value to a positive integer, rounding down and
+clamping to the range of `UInt8`. Returns `0` if the `Float32` is negative or `NaN`, and returns the
+largest `UInt8` value (i.e. `UInt8.size - 1`) if the float is larger than it.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float32_to_uint8"] opaque Float32.toUInt8 : Float32 → UInt8
-/-- If the given float is non-negative, truncates the value to the nearest non-negative integer.
-If negative or NaN, returns `0`.
-If larger than the maximum value for `UInt16` (including Inf), returns the maximum value of `UInt16`
-(i.e. `UInt16.size - 1`).
+/--
+Converts a floating-point number to a 16-bit unsigned integer.
+
+If the given `Float32` is non-negative, truncates the value to a positive integer, rounding down and
+clamping to the range of `UInt16`. Returns `0` if the `Float32` is negative or `NaN`, and returns
+the largest `UInt16` value (i.e. `UInt16.size - 1`) if the float is larger than it.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float32_to_uint16"] opaque Float32.toUInt16 : Float32 → UInt16
-/-- If the given float is non-negative, truncates the value to the nearest non-negative integer.
-If negative or NaN, returns `0`.
-If larger than the maximum value for `UInt32` (including Inf), returns the maximum value of `UInt32`
-(i.e. `UInt32.size - 1`).
+/--
+Converts a floating-point number to a 32-bit unsigned integer.
+
+If the given `Float32` is non-negative, truncates the value to a positive integer, rounding down and
+clamping to the range of `UInt32`. Returns `0` if the `Float32` is negative or `NaN`, and returns
+the largest `UInt32` value (i.e. `UInt32.size - 1`) if the float is larger than it.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float32_to_uint32"] opaque Float32.toUInt32 : Float32 → UInt32
-/-- If the given float is non-negative, truncates the value to the nearest non-negative integer.
-If negative or NaN, returns `0`.
-If larger than the maximum value for `UInt64` (including Inf), returns the maximum value of `UInt64`
-(i.e. `UInt64.size - 1`).
+/--
+Converts a floating-point number to a 64-bit unsigned integer.
+
+If the given `Float32` is non-negative, truncates the value to a positive integer, rounding down and
+clamping to the range of `UInt64`. Returns `0` if the `Float32` is negative or `NaN`, and returns
+the largest `UInt64` value (i.e. `UInt64.size - 1`) if the float is larger than it.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float32_to_uint64"] opaque Float32.toUInt64 : Float32 → UInt64
-/-- If the given float is non-negative, truncates the value to the nearest non-negative integer.
-If negative or NaN, returns `0`.
-If larger than the maximum value for `USize` (including Inf), returns the maximum value of `USize`
-(i.e. `USize.size - 1`). This value is platform dependent).
+/--
+Converts a floating-point number to a word-sized unsigned integer.
+
+If the given `Float32` is non-negative, truncates the value to a positive integer, rounding down and
+clamping to the range of `USize`. Returns `0` if the `Float32` is negative or `NaN`, and returns the
+largest `USize` value (i.e. `USize.size - 1`) if the float is larger than it.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float32_to_usize"] opaque Float32.toUSize : Float32 → USize
 
+/--
+Checks whether a floating point number is `NaN` ("not a number") value.
+
+`NaN` values result from operations that might otherwise be errors, such as dividing zero by zero.
+
+This function does not reduce in the kernel. It is compiled to the C operator `isnan`.
+-/
 @[extern "lean_float32_isnan"] opaque Float32.isNaN : Float32 → Bool
+/--
+Checks whether a floating-point number is finite, that is, whether it is normal, subnormal, or zero,
+but not infinite or `NaN`.
+
+This function does not reduce in the kernel. It is compiled to the C operator `isfinite`.
+-/
 @[extern "lean_float32_isfinite"] opaque Float32.isFinite : Float32 → Bool
+/--
+Checks whether a floating-point number is a positive or negative infinite number, but not a finite
+number or `NaN`.
+
+This function does not reduce in the kernel. It is compiled to the C operator `isinf`.
+-/
 @[extern "lean_float32_isinf"] opaque Float32.isInf : Float32 → Bool
-/-- Splits the given float `x` into a significand/exponent pair `(s, i)`
-such that `x = s * 2^i` where `s ∈ (-1;-0.5] ∪ [0.5; 1)`.
-Returns an undefined value if `x` is not finite.
+/--
+Splits the given float `x` into a significand/exponent pair `(s, i)` such that `x = s * 2^i` where
+`s ∈ (-1;-0.5] ∪ [0.5; 1)`. Returns an undefined value if `x` is not finite.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`frexp`.
 -/
 @[extern "lean_float32_frexp"] opaque Float32.frExp : Float32 → Float32 × Int
 
@@ -172,30 +295,191 @@ instance : Repr Float32 where
 
 instance : ReprAtom Float32  := ⟨⟩
 
+/--
+Computes the sine of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`sinf`.
+-/
 @[extern "sinf"] opaque Float32.sin : Float32 → Float32
+/--
+Computes the cosine of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`cosf`.
+-/
 @[extern "cosf"] opaque Float32.cos : Float32 → Float32
+/--
+Computes the tangent of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`tanf`.
+-/
 @[extern "tanf"] opaque Float32.tan : Float32 → Float32
+/--
+Computes the arc sine (inverse sine) of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`asinf`.
+-/
 @[extern "asinf"] opaque Float32.asin : Float32 → Float32
+/--
+Computes the arc cosine (inverse cosine) of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`acosf`.
+-/
 @[extern "acosf"] opaque Float32.acos : Float32 → Float32
+/--
+Computes the arc tangent (inverse tangent) of a floating-point number in radians.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`atanf`.
+-/
 @[extern "atanf"] opaque Float32.atan : Float32 → Float32
+/--
+Computes the arc tangent (inverse tangent) of `y / x` in radians, in the range `-π`–`π`. The signs
+of the arguments determine the quadrant of the result.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`atan2f`.
+-/
 @[extern "atan2f"] opaque Float32.atan2 : Float32 → Float32 → Float32
+/--
+Computes the hyperbolic sine of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`sinhf`.
+-/
 @[extern "sinhf"] opaque Float32.sinh : Float32 → Float32
+/--
+Computes the hyperbolic cosine of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`coshf`.
+-/
 @[extern "coshf"] opaque Float32.cosh : Float32 → Float32
+/--
+Computes the hyperbolic tangent of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`tanhf`.
+-/
 @[extern "tanhf"] opaque Float32.tanh : Float32 → Float32
+/--
+Computes the hyperbolic arc sine (inverse sine) of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`asinhf`.
+-/
 @[extern "asinhf"] opaque Float32.asinh : Float32 → Float32
+/--
+Computes the hyperbolic arc cosine (inverse cosine) of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`acoshf`.
+-/
 @[extern "acoshf"] opaque Float32.acosh : Float32 → Float32
+/--
+Computes the hyperbolic arc tangent (inverse tangent) of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`atanhf`.
+-/
 @[extern "atanhf"] opaque Float32.atanh : Float32 → Float32
+/--
+Computes the exponential `e^x` of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`expf`.
+-/
 @[extern "expf"] opaque Float32.exp : Float32 → Float32
+/--
+Computes the base-2 exponential `2^x` of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`exp2f`.
+-/
 @[extern "exp2f"] opaque Float32.exp2 : Float32 → Float32
+/--
+Computes the natural logarithm `ln x` of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`logf`.
+-/
 @[extern "logf"] opaque Float32.log : Float32 → Float32
+/--
+Computes the base-2 logarithm of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`log2f`.
+-/
 @[extern "log2f"] opaque Float32.log2 : Float32 → Float32
+/--
+Computes the base-10 logarithm of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`log10f`.
+-/
 @[extern "log10f"] opaque Float32.log10 : Float32 → Float32
+/--
+Raises one floating-point number to the power of another. Typically used via the `^` operator.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`powf`.
+-/
 @[extern "powf"] opaque Float32.pow : Float32 → Float32 → Float32
+/--
+Computes the square root of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`sqrtf`.
+-/
 @[extern "sqrtf"] opaque Float32.sqrt : Float32 → Float32
+/--
+Computes the cube root of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`cbrtf`.
+-/
 @[extern "cbrtf"] opaque Float32.cbrt : Float32 → Float32
+/--
+Computes the ceiling of a floating-point number, which is the smallest integer that's no smaller
+than the given number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`ceilf`.
+
+Examples:
+ * `Float32.ceil 1.5 = 2`
+ * `Float32.ceil (-1.5) = (-1)`
+-/
 @[extern "ceilf"] opaque Float32.ceil : Float32 → Float32
+/--
+Computes the floor of a floating-point number, which is the largest integer that's no larger
+than the given number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`floorf`.
+
+Examples:
+ * `Float32.floor 1.5 = 1`
+ * `Float32.floor (-1.5) = (-2)`
+-/
 @[extern "floorf"] opaque Float32.floor : Float32 → Float32
+/--
+Rounds to the nearest integer, rounding away from zero at half-way points.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`roundf`.
+-/
 @[extern "roundf"] opaque Float32.round : Float32 → Float32
+/--
+Computes the absolute value of a floating-point number.
+
+This function does not reduce in the kernel. It is implemented in compiled code by the C function
+`fabsf`.
+-/
 @[extern "fabsf"] opaque Float32.abs : Float32 → Float32
 
 instance : HomogeneousPow Float32 := ⟨Float32.pow⟩
@@ -206,9 +490,22 @@ instance : Max Float32 := maxOfLe
 
 /--
 Efficiently computes `x * 2^i`.
+
+This function does not reduce in the kernel.
 -/
 @[extern "lean_float32_scaleb"]
 opaque Float32.scaleB (x : Float32) (i : @& Int) : Float32
 
+/--
+Converts a 32-bit floating-point number to a 64-bit floating-point number.
+
+This function does not reduce in the kernel.
+-/
 @[extern "lean_float32_to_float"] opaque Float32.toFloat : Float32 → Float
+/--
+Converts a 64-bit floating-point number to a 32-bit floating-point number.
+This may lose precision.
+
+This function does not reduce in the kernel.
+-/
 @[extern "lean_float_to_float32"] opaque Float.toFloat32 : Float → Float32

src/Init/Data/Int.lean

@@ -6,6 +6,7 @@ Authors: Leonardo de Moura
 prelude
 import Init.Data.Int.Basic
 import Init.Data.Int.Bitwise
+import Init.Data.Int.Compare
 import Init.Data.Int.DivMod
 import Init.Data.Int.Gcd
 import Init.Data.Int.Lemmas

src/Init/Data/Int/Basic.lean

@@ -401,8 +401,14 @@ instance : Max Int := maxOfLe
 end Int
 
 /--
-The canonical homomorphism `Int → R`.
-In most use cases `R` will have a ring structure and this will be a ring homomorphism.
+The canonical homomorphism `Int → R`. In most use cases, the target type will have a ring structure,
+and this homomorphism should be a ring homomorphism.
+
+`IntCast` and `NatCast` exist to allow different libraries with their own types that can be notated
+as natural numbers to have consistent `simp` normal forms without needing to create coercion
+simplification sets that are aware of all combinations. Libraries should make it easy to work with
+`IntCast` where possible. For instance, in Mathlib there will be such a homomorphism (and thus an
+`IntCast R` instance) whenever `R` is an additive group with a `1`.
 -/
 class IntCast (R : Type u) where
   /-- The canonical map `Int → R`. -/
@@ -410,14 +416,12 @@ class IntCast (R : Type u) where
 
 instance : IntCast Int where intCast n := n
 
-/--
-Apply the canonical homomorphism from `Int` to a type `R` from an `IntCast R` instance.
-
-In Mathlib there will be such a homomorphism whenever `R` is an additive group with a `1`.
--/
-@[coe, reducible, match_pattern] protected def Int.cast {R : Type u} [IntCast R] : Int → R :=
+@[coe, reducible, match_pattern, inherit_doc IntCast]
+protected def Int.cast {R : Type u} [IntCast R] : Int → R :=
   IntCast.intCast
 
+@[simp] theorem Int.cast_eq (x : Int) : Int.cast x = x := rfl
+
 -- see the notes about coercions into arbitrary types in the module doc-string
 instance [IntCast R] : CoeTail Int R where coe := Int.cast
 

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

@@ -28,7 +28,7 @@ theorem shiftRight_eq_div_pow (m : Int) (n : Nat) :
     m >>> n = m / ((2 ^ n) : Nat) := by
   simp only [shiftRight_eq, Int.shiftRight, Nat.shiftRight_eq_div_pow]
   split
-  · simp; norm_cast
+  · simp
   · rw [negSucc_ediv _ (by norm_cast; exact Nat.pow_pos (Nat.zero_lt_two))]
     rfl
 

src/Init/Data/Int/Compare.lean

@@ -0,0 +1,71 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura, Jeremy Avigad, Mario Carneiro, Paul Reichert
+-/
+prelude
+import Init.Data.Ord
+import Init.Data.Int.Order
+
+/-! # Basic lemmas about comparing integers
+
+This file introduces some basic lemmas about `compare` as applied to integers.
+
+Import `Std.Classes.Ord` in order to obtain the `TransOrd` and `LawfulEqOrd` instances for `Int`.
+-/
+namespace Int
+
+protected theorem lt_or_eq_of_le {n m : Int} (h : n ≤ m) : n < m ∨ n = m := by
+  omega
+
+theorem compare_eq_ite_lt (a b : Int) :
+    compare a b = if a < b then .lt else if b < a then .gt else .eq := by
+  simp only [compare, compareOfLessAndEq]
+  split
+  · rfl
+  · next h =>
+    match Int.lt_or_eq_of_le (Int.not_lt.1 h) with
+    | .inl h => simp [h, Int.ne_of_gt h]
+    | .inr rfl => simp
+
+theorem compare_eq_ite_le (a b : Int) :
+    compare a b = if a ≤ b then if b ≤ a then .eq else .lt else .gt := by
+  rw [compare_eq_ite_lt]
+  split
+  · next hlt => simp [Int.le_of_lt hlt, Int.not_le.2 hlt]
+  · next hge =>
+    split
+    · next hgt => simp [Int.le_of_lt hgt, Int.not_le.2 hgt]
+    · next hle => simp [Int.not_lt.1 hge, Int.not_lt.1 hle]
+
+protected theorem compare_swap (a b : Int) : (compare a b).swap = compare b a := by
+  simp only [compare_eq_ite_le]; (repeat' split) <;> try rfl
+  next h1 h2 => cases h1 (Int.le_of_not_le h2)
+
+protected theorem compare_eq_eq {a b : Int} : compare a b = .eq ↔ a = b := by
+  rw [compare_eq_ite_lt]; (repeat' split) <;> simp [Int.ne_of_lt, Int.ne_of_gt, *]
+  next hlt hgt => exact Int.le_antisymm (Int.not_lt.1 hgt) (Int.not_lt.1 hlt)
+
+protected theorem compare_eq_lt {a b : Int} : compare a b = .lt ↔ a < b := by
+  rw [compare_eq_ite_lt]; (repeat' split) <;> simp [*]
+
+protected theorem compare_eq_gt {a b : Int} : compare a b = .gt ↔ b < a := by
+  rw [compare_eq_ite_lt]; (repeat' split) <;> simp [Int.le_of_lt, *]
+
+protected theorem compare_ne_gt {a b : Int} : compare a b ≠ .gt ↔ a ≤ b := by
+  rw [compare_eq_ite_le]; (repeat' split) <;> simp [*]
+
+protected theorem compare_ne_lt {a b : Int} : compare a b ≠ .lt ↔ b ≤ a := by
+  rw [compare_eq_ite_le]; (repeat' split) <;> simp [Int.le_of_not_le, *]
+
+protected theorem isLE_compare {a b : Int} :
+    (compare a b).isLE ↔ a ≤ b := by
+  simp only [Int.compare_eq_ite_le]
+  repeat' split <;> simp_all
+
+protected theorem isGE_compare {a b : Int} :
+    (compare a b).isGE ↔ b ≤ a := by
+  rw [← Int.compare_swap, Ordering.isGE_swap]
+  exact Int.isLE_compare
+
+end Int

src/Init/Data/Int/Cooper.lean

@@ -38,8 +38,8 @@ theorem dvd_mul_emod_add_of_dvd_mul_add {a b c d x : Int}
   obtain ⟨q, rfl⟩ := h
   rw [Int.emod_def, Int.mul_sub, Int.sub_eq_add_neg, Int.add_right_comm, w,
     Int.dvd_add_right (Int.dvd_mul_right _ _), ← Int.mul_assoc, ← Int.mul_assoc, Int.dvd_neg,
-    ← Int.mul_ediv_assoc b gcd_dvd_left, Int.mul_comm b a, Int.mul_ediv_assoc a gcd_dvd_right,
-    Int.mul_assoc, Int.mul_assoc]
+    ← Int.mul_ediv_assoc b (gcd_dvd_left ..), Int.mul_comm b a,
+    Int.mul_ediv_assoc a (gcd_dvd_right ..), Int.mul_assoc, Int.mul_assoc]
   apply Int.dvd_mul_right
 
 /--
@@ -107,7 +107,7 @@ theorem resolve_left_lt_lcm (a c d p x : Int) (a_pos : 0 < a) (d_pos : 0 < d) (h
   simp only [h₁, resolve_left_eq, resolve_left', add_of_le, Int.ofNat_lt]
   exact Nat.mod_lt _ (Nat.pos_of_ne_zero (lcm_ne_zero (Int.ne_of_gt a_pos)
     (Int.ne_of_gt (Int.ediv_pos_of_pos_of_dvd (Int.mul_pos a_pos d_pos) (Int.ofNat_nonneg _)
-      gcd_dvd_left))))
+      (gcd_dvd_left _ _)))))
 
 theorem resolve_left_ineq (a c d p x : Int) (a_pos : 0 < a) (b_pos : 0 < b)
     (h₁ : p ≤ a * x) (h₂ : b * x ≤ q) :
@@ -127,7 +127,7 @@ theorem resolve_left_dvd₁ (a c d p x : Int) (h₁ : p ≤ a * x) :
     a ∣ resolve_left a c d p x + p := by
   simp only [h₁, resolve_left_eq, resolve_left']
   obtain ⟨k', w⟩ := add_of_le h₁
-  exact Int.ofNat_emod _ _ ▸ dvd_emod_add_of_dvd_add (x := k') ⟨x, by rw [w, Int.add_comm]⟩ dvd_lcm_left
+  exact Int.ofNat_emod _ _ ▸ dvd_emod_add_of_dvd_add (x := k') ⟨x, by rw [w, Int.add_comm]⟩ (dvd_lcm_left ..)
 
 theorem resolve_left_dvd₂ (a c d p x : Int)
     (h₁ : p ≤ a * x) (h₃ : d ∣ c * x + s) :
@@ -140,7 +140,7 @@ theorem resolve_left_dvd₂ (a c d p x : Int)
     refine ⟨z, ?_⟩
     rw [Int.mul_assoc, ← r, Int.mul_add, Int.mul_comm c x, ← Int.mul_assoc, w, Int.add_mul,
       Int.mul_comm c, Int.mul_comm c, ← Int.add_assoc, Int.add_comm (p * c)]
-  · exact Int.dvd_lcm_right
+  · exact Int.dvd_lcm_right ..
 
 def resolve_left_inv (a p k : Int) : Int := (k + p) / a
 

src/Init/Data/Int/DivMod/Bootstrap.lean

@@ -45,9 +45,9 @@ protected theorem dvd_trans : ∀ {a b c : Int}, a ∣ b → b ∣ c → a ∣ c
   Iff.intro (fun ⟨k, e⟩ => by rw [e, Int.zero_mul])
             (fun h => h.symm ▸ Int.dvd_refl _)
 
-protected theorem dvd_mul_right (a b : Int) : a ∣ a * b := ⟨_, rfl⟩
+@[simp] 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 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
   constructor <;> exact fun ⟨k, e⟩ =>
@@ -59,13 +59,13 @@ protected theorem dvd_mul_left (a b : Int) : b ∣ a * b := ⟨_, Int.mul_comm .
 
 @[simp] theorem natAbs_dvd_natAbs {a b : Int} : natAbs a ∣ natAbs b ↔ a ∣ b := by
   refine ⟨fun ⟨k, hk⟩ => ?_, fun ⟨k, hk⟩ => ⟨natAbs k, hk.symm ▸ natAbs_mul a k⟩⟩
-  rw [← natAbs_ofNat k, ← natAbs_mul, natAbs_eq_natAbs_iff] at hk
+  rw [← natAbs_natCast k, ← natAbs_mul, natAbs_eq_natAbs_iff] at hk
   cases hk <;> subst b
   · apply Int.dvd_mul_right
   · rw [← Int.mul_neg]; apply Int.dvd_mul_right
 
 theorem ofNat_dvd_left {n : Nat} {z : Int} : (↑n : Int) ∣ z ↔ n ∣ z.natAbs := by
-  rw [← natAbs_dvd_natAbs, natAbs_ofNat]
+  rw [← natAbs_dvd_natAbs, natAbs_natCast]
 
 /-! ### ediv zero  -/
 
@@ -156,7 +156,7 @@ theorem add_mul_ediv_right (a b : Int) {c : Int} (H : c ≠ 0) : (a + b * c) / c
       show ediv (↑(n * succ k) + -((m : Int) + 1)) (succ k) = n + -(↑(m / succ k) + 1 : Int)
       rw [H h, H ((Nat.le_div_iff_mul_le k.succ_pos).2 h)]
       apply congrArg negSucc
-      rw [Nat.mul_comm, Nat.sub_mul_div]; rwa [Nat.mul_comm]
+      rw [Nat.mul_comm, Nat.sub_mul_div_of_le]; rwa [Nat.mul_comm]
 
 theorem add_mul_ediv_left (a : Int) {b : Int}
     (c : Int) (H : b ≠ 0) : (a + b * c) / b = a / b + c :=
@@ -198,7 +198,7 @@ theorem emod_lt_of_pos (a : Int) {b : Int} (H : 0 < b) : a % b < b :=
   | ofNat _, _, ⟨_, rfl⟩ => ofNat_lt.2 (Nat.mod_lt _ (Nat.succ_pos _))
   | -[_+1], _, ⟨_, rfl⟩ => Int.sub_lt_self _ (ofNat_lt.2 <| Nat.succ_pos _)
 
-@[simp] theorem add_mul_emod_self {a b c : Int} : (a + b * c) % c = a % c :=
+@[simp] theorem add_mul_emod_self_right (a b c : Int) : (a + b * c) % c = a % c :=
   if cz : c = 0 then by
     rw [cz, Int.mul_zero, Int.add_zero]
   else by
@@ -206,7 +206,17 @@ theorem emod_lt_of_pos (a : Int) {b : Int} (H : 0 < b) : a % b < b :=
       Int.mul_add, Int.mul_comm, ← Int.sub_sub, Int.add_sub_cancel]
 
 @[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]
+  rw [Int.mul_comm, add_mul_emod_self_right]
+
+@[simp] theorem mul_add_emod_self_right (a b c : Int) : (a * b + c) % b = c % b := by
+  rw [Int.add_comm, add_mul_emod_self_right]
+
+@[simp] theorem mul_add_emod_self_left (a b c : Int) : (a * b + c) % a = c % a := by
+  rw [Int.add_comm, add_mul_emod_self_left]
+
+@[deprecated add_mul_emod_self_right (since := "2025-04-11")]
+theorem add_mul_emod_self {a b c : Int} : (a + b * c) % c = a % c :=
+  add_mul_emod_self_right ..
 
 @[simp] theorem emod_add_emod (m n k : Int) : (m % n + k) % n = (m + k) % n := by
   have := (add_mul_emod_self_left (m % n + k) n (m / n)).symm
@@ -229,7 +239,7 @@ theorem emod_add_cancel_right {m n k : Int} (i) : (m + i) % n = (k + i) % n ↔
   add_emod_eq_add_emod_right _⟩
 
 @[simp] theorem mul_emod_left (a b : Int) : (a * b) % b = 0 := by
-  rw [← Int.zero_add (a * b), Int.add_mul_emod_self, Int.zero_emod]
+  rw [← Int.zero_add (a * b), add_mul_emod_self_right, Int.zero_emod]
 
 @[simp] theorem mul_emod_right (a b : Int) : (a * b) % a = 0 := by
   rw [Int.mul_comm, mul_emod_left]
@@ -238,7 +248,7 @@ theorem mul_emod (a b n : Int) : (a * b) % n = (a % n) * (b % n) % n := by
   conv => lhs; rw [
     ← emod_add_ediv a n, ← emod_add_ediv' b n, Int.add_mul, Int.mul_add, Int.mul_add,
     Int.mul_assoc, Int.mul_assoc, ← Int.mul_add n _ _, add_mul_emod_self_left,
-    ← Int.mul_assoc, add_mul_emod_self]
+    ← Int.mul_assoc, add_mul_emod_self_right]
 
 @[simp] theorem emod_self {a : Int} : a % a = 0 := by
   have := mul_emod_left 1 a; rwa [Int.one_mul] at this
@@ -324,10 +334,10 @@ theorem lt_mul_ediv_self_add {x k : Int} (h : 0 < k) : x < k * (x / k) + k :=
   split <;> simp [Int.sub_emod]
 
 theorem bmod_def (x : Int) (m : Nat) : bmod x m =
-  if (x % m) < (m + 1) / 2 then
-    x % m
-  else
-    (x % m) - m :=
+    if (x % m) < (m + 1) / 2 then
+      x % m
+    else
+      (x % m) - m :=
   rfl
 
 end Int

src/Init/Data/Int/Gcd.lean

@@ -1,20 +1,18 @@
 /-
 Copyright (c) 2022 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Mario Carneiro
+Authors: Mario Carneiro, Markus Himmel
 -/
 prelude
 import Init.Data.Int.Basic
 import Init.Data.Nat.Gcd
 import Init.Data.Nat.Lcm
 import Init.Data.Int.DivMod.Lemmas
+import Init.Data.Int.Pow
 
 /-!
 Definition and lemmas for gcd and lcm over Int
 
-## Future work
-Most of the material about `Nat.gcd` and `Nat.lcm` from `Init.Data.Nat.Gcd` and `Init.Data.Nat.Lcm`
-has analogues for `Int.gcd` and `Int.lcm` that should be added to this file.
 -/
 namespace Int
 
@@ -37,21 +35,382 @@ Examples:
 -/
 def gcd (m n : Int) : Nat := m.natAbs.gcd n.natAbs
 
-theorem gcd_dvd_left {a b : Int} : (gcd a b : Int) ∣ a := by
-  have := Nat.gcd_dvd_left a.natAbs b.natAbs
-  rw [← Int.ofNat_dvd] at this
-  exact Int.dvd_trans this natAbs_dvd_self
+theorem gcd_eq_natAbs_gcd_natAbs (m n : Int) : gcd m n = Nat.gcd m.natAbs n.natAbs := rfl
 
-theorem gcd_dvd_right {a b : Int} : (gcd a b : Int) ∣ b := by
-  have := Nat.gcd_dvd_right a.natAbs b.natAbs
-  rw [← Int.ofNat_dvd] at this
-  exact Int.dvd_trans this natAbs_dvd_self
+theorem gcd_dvd_natAbs_left (a b : Int) : gcd a b ∣ a.natAbs := Nat.gcd_dvd_left ..
+theorem gcd_dvd_natAbs_right (a b : Int) : gcd a b ∣ b.natAbs := Nat.gcd_dvd_right ..
 
-@[simp] theorem one_gcd {a : Int} : gcd 1 a = 1 := by simp [gcd]
-@[simp] theorem gcd_one {a : Int} : gcd a 1 = 1 := by simp [gcd]
+theorem gcd_dvd_left (a b : Int) : (gcd a b : Int) ∣ a := by
+  simp [ofNat_dvd_left, gcd_dvd_natAbs_left]
 
-@[simp] theorem neg_gcd {a b : Int} : gcd (-a) b = gcd a b := by simp [gcd]
-@[simp] theorem gcd_neg {a b : Int} : gcd a (-b) = gcd a b := by simp [gcd]
+theorem gcd_dvd_right (a b : Int) : (gcd a b : Int) ∣ b := by
+  simp [ofNat_dvd_left, gcd_dvd_natAbs_right]
+
+@[simp] theorem one_gcd {a : Int} : gcd 1 a = 1 := by simp [gcd_eq_natAbs_gcd_natAbs]
+@[simp] theorem gcd_one {a : Int} : gcd a 1 = 1 := by simp [gcd_eq_natAbs_gcd_natAbs]
+
+@[simp] theorem zero_gcd {a : Int} : gcd 0 a = a.natAbs := by simp [gcd_eq_natAbs_gcd_natAbs]
+@[simp] theorem gcd_zero {a : Int} : gcd a 0 = a.natAbs := by simp [gcd_eq_natAbs_gcd_natAbs]
+
+theorem gcd_one_left (a : Int) : gcd 1 a = 1 := by simp
+theorem gcd_one_right (a : Int) : gcd a 1 = 1 := by simp
+theorem gcd_zero_left (a : Int) : gcd 0 a = a.natAbs := by simp
+theorem gcd_zero_right (a : Int) : gcd a 0 = a.natAbs := by simp
+
+@[simp] theorem gcd_self {a : Int} : gcd a a = a.natAbs := by simp [gcd_eq_natAbs_gcd_natAbs]
+
+@[simp] theorem neg_gcd {a b : Int} : gcd (-a) b = gcd a b := by simp [gcd_eq_natAbs_gcd_natAbs]
+@[simp] theorem gcd_neg {a b : Int} : gcd a (-b) = gcd a b := by simp [gcd_eq_natAbs_gcd_natAbs]
+
+@[simp, norm_cast] protected theorem gcd_natCast_natCast (a b : Nat) :
+    gcd (a : Int) (b : Int) = Nat.gcd a b := by
+  simp [gcd_eq_natAbs_gcd_natAbs]
+
+theorem gcd_le_natAbs_left (b : Int) (ha : a ≠ 0) : gcd a b ≤ a.natAbs :=
+  Nat.gcd_le_left b.natAbs (natAbs_pos.2 ha)
+
+theorem gcd_le_natAbs_right (a : Int) (hb : b ≠ 0) : gcd a b ≤ b.natAbs :=
+  Nat.gcd_le_right a.natAbs (natAbs_pos.2 hb)
+
+theorem gcd_le_left (b : Int) (ha : 0 < a) : (gcd a b : Int) ≤ a := by
+  rw (occs := [2]) [(by omega : a = (a.natAbs : Int))]
+  simp [gcd_le_natAbs_left b (by omega : a ≠ 0)]
+
+theorem gcd_le_right (a : Int) (hb : 0 < b) : (gcd a b : Int) ≤ b := by
+  rw (occs := [2]) [(by omega : b = (b.natAbs : Int))]
+  simp [gcd_le_natAbs_right a (by omega : b ≠ 0)]
+
+theorem dvd_coe_gcd {a b c : Int} (ha : c ∣ a) (hb : c ∣ b) : c ∣ (gcd a b : Int) :=
+  ofNat_dvd_right.2 (Nat.dvd_gcd (natAbs_dvd_natAbs.2 ha) (natAbs_dvd_natAbs.2 hb))
+
+theorem dvd_gcd {a b : Int} {c : Nat} (ha : (c : Int) ∣ a) (hb : (c : Int) ∣ b) : c ∣ gcd a b :=
+  ofNat_dvd.1 (dvd_coe_gcd ha hb)
+
+theorem dvd_coe_gcd_iff {a b c : Int} : c ∣ (gcd a b : Int) ↔ c ∣ a ∧ c ∣ b :=
+  ⟨fun h => ⟨Int.dvd_trans h (gcd_dvd_left _ _), Int.dvd_trans h (gcd_dvd_right _ _)⟩,
+   fun ⟨ha, hb⟩ => dvd_coe_gcd ha hb⟩
+
+theorem dvd_gcd_iff {a b : Int} {c : Nat} : c ∣ gcd a b ↔ (c : Int) ∣ a ∧ (c : Int) ∣ b := by
+  rw [← ofNat_dvd, dvd_coe_gcd_iff]
+
+theorem gcd_comm (a b : Int) : gcd a b = gcd b a := Nat.gcd_comm ..
+
+theorem gcd_eq_natAbs_left_iff_dvd : gcd a b = a.natAbs ↔ a ∣ b := by
+  simp [gcd_eq_natAbs_gcd_natAbs, Nat.gcd_eq_left_iff_dvd]
+
+theorem gcd_eq_natAbs_right_iff_dvd : gcd a b = b.natAbs ↔ b ∣ a := by
+  simp [gcd_eq_natAbs_gcd_natAbs, Nat.gcd_eq_right_iff_dvd]
+
+theorem gcd_eq_left_iff_dvd (ha : 0 ≤ a) : gcd a b = a ↔ a ∣ b := by
+  rw (occs := [2]) [eq_natAbs_of_nonneg ha]
+  simp [ofNat_inj, gcd_eq_natAbs_left_iff_dvd]
+
+theorem gcd_eq_right_iff_dvd (hb : 0 ≤ b) : gcd a b = b ↔ b ∣ a := by
+  rw [gcd_comm, gcd_eq_left_iff_dvd hb]
+
+theorem gcd_assoc (a b c : Int) : gcd (gcd a b) c = gcd a (gcd b c) := Nat.gcd_assoc ..
+
+theorem gcd_mul_left (m n k : Int) : gcd (m * n) (m * k) = m.natAbs * gcd n k := by
+  simp [gcd_eq_natAbs_gcd_natAbs, Nat.gcd_mul_left, natAbs_mul]
+
+theorem gcd_mul_right (m n k : Int) : gcd (m * n) (k * n) = gcd m k * n.natAbs := by
+  simp [gcd_eq_natAbs_gcd_natAbs, Nat.gcd_mul_right, natAbs_mul]
+
+theorem gcd_pos_of_ne_zero_left {a : Int} (b : Int) (ha : a ≠ 0) : 0 < gcd a b :=
+  Nat.gcd_pos_of_pos_left _ (natAbs_pos.2 ha)
+
+theorem gcd_pos_of_ne_zero_right (a : Int) {b : Int} (hb : b ≠ 0) : 0 < gcd a b :=
+  Nat.gcd_pos_of_pos_right _ (natAbs_pos.2 hb)
+
+theorem gcd_ne_zero_left (ha : a ≠ 0) : gcd a b ≠ 0 := by
+  simp [← Nat.pos_iff_ne_zero, gcd_pos_of_ne_zero_left _ ha]
+
+theorem gcd_ne_zero_right (hb : b ≠ 0) : gcd a b ≠ 0 := by
+  simp [← Nat.pos_iff_ne_zero, gcd_pos_of_ne_zero_right _ hb]
+
+theorem natAbs_div_gcd_pos_of_ne_zero_left (b : Int) (h : a ≠ 0) : 0 < a.natAbs / gcd a b :=
+  Nat.div_gcd_pos_of_pos_left _ (natAbs_pos.2 h)
+
+theorem natAbs_div_gcd_pos_of_ne_zero_right (a : Int) (h : b ≠ 0) : 0 < b.natAbs / gcd a b :=
+  Nat.div_gcd_pos_of_pos_right _ (natAbs_pos.2 h)
+
+theorem ediv_gcd_ne_zero_of_ne_zero_left (b : Int) (h : a ≠ 0) : a / gcd a b ≠ 0 := by
+  rw [← natAbs_pos, natAbs_ediv_of_dvd (gcd_dvd_left _ _), natAbs_natCast]
+  exact natAbs_div_gcd_pos_of_ne_zero_left _ h
+
+theorem ediv_gcd_ne_zero_if_ne_zero_right (a : Int) (h : b ≠ 0) : b / gcd a b ≠ 0 := by
+  simpa [gcd_comm] using ediv_gcd_ne_zero_of_ne_zero_left a h
+
+theorem eq_zero_of_gcd_eq_zero_left (h : gcd a b = 0) : a = 0 :=
+  natAbs_eq_zero.1 (Nat.eq_zero_of_gcd_eq_zero_left h)
+
+theorem eq_zero_of_gcd_eq_zero_right (h : gcd a b = 0) : b = 0 :=
+  natAbs_eq_zero.1 (Nat.eq_zero_of_gcd_eq_zero_right h)
+
+theorem gcd_ediv {a b c : Int} (ha : c ∣ a) (hb : c ∣ b) :
+    gcd (a / c) (b / c) = gcd a b / c.natAbs := by
+  rw [gcd_eq_natAbs_gcd_natAbs, natAbs_ediv_of_dvd ha, natAbs_ediv_of_dvd hb,
+    Nat.gcd_div (by simpa) (by simpa), gcd_eq_natAbs_gcd_natAbs]
+
+theorem gcd_dvd_gcd_of_dvd_left {a b : Int} (c : Int) (h : a ∣ b) : gcd a c ∣ gcd b c :=
+  Nat.gcd_dvd_gcd_of_dvd_left _ (by simpa)
+
+theorem gcd_dvd_gcd_of_dvd_right {a b : Int} (c : Int) (h : a ∣ b) : gcd c a ∣ gcd c b :=
+  Nat.gcd_dvd_gcd_of_dvd_right _ (by simpa)
+
+theorem gcd_dvd_gcd_mul_left_left (a b c : Int) : gcd a b ∣ gcd (c * a) b := by
+  simpa [gcd_eq_natAbs_gcd_natAbs, natAbs_mul] using Nat.gcd_dvd_gcd_mul_left_left ..
+
+theorem gcd_dvd_gcd_mul_right_left (a b c : Int) : gcd a b ∣ gcd (a * c) b := by
+  simpa [gcd_eq_natAbs_gcd_natAbs, natAbs_mul] using Nat.gcd_dvd_gcd_mul_right_left ..
+
+theorem gcd_dvd_gcd_mul_left_right (a b c : Int) : gcd a b ∣ gcd a (c * b) := by
+  simpa [gcd_eq_natAbs_gcd_natAbs, natAbs_mul] using Nat.gcd_dvd_gcd_mul_left_right ..
+
+theorem gcd_dvd_gcd_mul_right_right (a b c : Int) : gcd a b ∣ gcd a (b * c) := by
+  simpa [gcd_eq_natAbs_gcd_natAbs, natAbs_mul] using Nat.gcd_dvd_gcd_mul_right_right ..
+
+theorem gcd_eq_natAbs_left (h : a ∣ b) : gcd a b = a.natAbs :=
+  gcd_eq_natAbs_left_iff_dvd.2 h
+
+theorem gcd_eq_natAbs_right (h : b ∣ a) : gcd a b = b.natAbs :=
+  gcd_eq_natAbs_right_iff_dvd.2 h
+
+theorem gcd_eq_left (ha : 0 ≤ a) (h : a ∣ b) : gcd a b = a :=
+  (gcd_eq_left_iff_dvd ha).2 h
+
+theorem gcd_eq_right (hb : 0 ≤ b) (h : b ∣ a) : gcd a b = b :=
+  (gcd_eq_right_iff_dvd hb).2 h
+
+theorem gcd_right_eq_iff {a b b' : Int} : gcd a b = gcd a b' ↔ ∀ c, c ∣ a → (c ∣ b ↔ c ∣ b') := by
+  simp only [gcd_eq_natAbs_gcd_natAbs, Nat.gcd_right_eq_iff]
+  refine ⟨fun hk c hc => ?_, fun hc k hk => ?_⟩
+  · simpa using hk c.natAbs (by simpa)
+  · simpa [ofNat_dvd_left] using hc k (by simpa [ofNat_dvd_left])
+
+theorem gcd_left_eq_iff {a a' b : Int} : gcd a b = gcd a' b ↔ ∀ c, c ∣ b → (c ∣ a ↔ c ∣ a') := by
+  rw [gcd_comm a b, gcd_comm a' b, gcd_right_eq_iff]
+
+@[simp] theorem gcd_mul_left_left (a b : Int) : gcd (a * b) b = b.natAbs := by
+  simp [gcd_eq_natAbs_gcd_natAbs, natAbs_mul]
+
+@[simp] theorem gcd_mul_left_right (a b : Int) : gcd a (b * a) = a.natAbs := by
+  simp [gcd_eq_natAbs_gcd_natAbs, natAbs_mul]
+
+@[simp] theorem gcd_mul_right_left (a b : Int) : gcd (b * a) b = b.natAbs := by
+  simp [gcd_eq_natAbs_gcd_natAbs, natAbs_mul]
+
+@[simp] theorem gcd_mul_right_right (a b : Int) : gcd a (a * b) = a.natAbs := by
+  simp [gcd_eq_natAbs_gcd_natAbs, natAbs_mul]
+
+@[simp] theorem gcd_gcd_self_right_left (m n : Int) : gcd m (gcd m n) = gcd m n :=
+  Nat.gcd_gcd_self_right_left ..
+
+@[simp] theorem gcd_gcd_self_right_right (m n : Int) : gcd m (gcd n m) = gcd n m :=
+  Nat.gcd_gcd_self_right_right ..
+
+@[simp] theorem gcd_gcd_self_left_right (m n : Int) : gcd (gcd n m) m = gcd n m :=
+  Nat.gcd_gcd_self_left_right ..
+
+@[simp] theorem gcd_gcd_self_left_left (m n : Int) : gcd (gcd m n) m = gcd m n :=
+  Nat.gcd_gcd_self_left_left ..
+
+@[simp] theorem gcd_add_mul_right_right (m n k : Int) : gcd m (n + k * m) = gcd m n :=
+  gcd_right_eq_iff.2 (by rintro c ⟨l, rfl⟩; rw [Int.mul_comm, Int.mul_assoc, Int.dvd_add_self_mul])
+
+@[simp] theorem gcd_add_mul_left_right (m n k : Int) : gcd m (n + m * k) = gcd m n := by
+  rw [Int.mul_comm, gcd_add_mul_right_right]
+
+@[simp] theorem gcd_mul_right_add_right (m n k : Int) : gcd m (k * m + n) = gcd m n := by
+  rw [Int.add_comm, gcd_add_mul_right_right]
+
+@[simp] theorem gcd_mul_left_add_right (m n k : Int) : gcd m (m * k + n) = gcd m n := by
+  rw [Int.add_comm, gcd_add_mul_left_right]
+
+@[simp] theorem gcd_add_mul_right_left (m n k : Int) : gcd (n + k * m) m = gcd n m := by
+  rw [gcd_comm, gcd_add_mul_right_right, gcd_comm]
+
+@[simp] theorem gcd_add_mul_left_left (m n k : Int) : gcd (n + m * k) m = gcd n m := by
+  rw [Int.mul_comm, gcd_add_mul_right_left]
+
+@[simp] theorem gcd_mul_right_add_left (m n k : Int) : gcd (k * m + n) m = gcd n m := by
+  rw [Int.add_comm, gcd_add_mul_right_left]
+
+@[simp] theorem gcd_mul_left_add_left (m n k : Int) : gcd (m * k + n) m = gcd n m := by
+  rw [Int.add_comm, gcd_add_mul_left_left]
+
+@[simp] theorem gcd_add_self_right (m n : Int) : gcd m (n + m) = gcd m n := by
+  simpa using gcd_add_mul_right_right _ _ 1
+
+@[simp] theorem gcd_self_add_right (m n : Int) : gcd m (m + n) = gcd m n := by
+  simpa using gcd_mul_right_add_right _ _ 1
+
+@[simp] theorem gcd_add_self_left (m n : Int) : gcd (n + m) m = gcd n m := by
+  simpa using gcd_add_mul_right_left _ _ 1
+
+@[simp] theorem gcd_self_add_left (m n : Int) : gcd (m + n) m = gcd n m := by
+  simpa using gcd_mul_right_add_left _ _ 1
+
+@[simp] theorem gcd_add_left_left_of_dvd {m k : Int} (n : Int) :
+    m ∣ k → gcd (k + n) m = gcd n m := by
+  rintro ⟨l, rfl⟩; exact gcd_mul_left_add_left m n l
+
+@[simp] theorem gcd_add_right_left_of_dvd {m k : Int} (n : Int) :
+    m ∣ k → gcd (n + k) m = gcd n m := by
+  rintro ⟨l, rfl⟩; exact gcd_add_mul_left_left m n l
+
+@[simp] theorem gcd_add_left_right_of_dvd {n k : Int} (m : Int) :
+    n ∣ k → gcd n (k + m) = gcd n m := by
+  rintro ⟨l, rfl⟩; exact gcd_mul_left_add_right n m l
+
+@[simp] theorem gcd_add_right_right_of_dvd {n k : Int} (m : Int) :
+    n ∣ k → gcd n (m + k) = gcd n m := by
+  rintro ⟨l, rfl⟩; exact gcd_add_mul_left_right n m l
+
+@[simp] theorem gcd_sub_mul_right_right (m n k : Int) : gcd m (n - k * m) = gcd m n := by
+  simp [Int.sub_eq_add_neg, ← Int.neg_mul]
+
+@[simp] theorem gcd_sub_mul_left_right (m n k : Int) : gcd m (n - m * k) = gcd m n := by
+  rw [Int.mul_comm, gcd_sub_mul_right_right]
+
+@[simp] theorem gcd_mul_right_sub_right (m n k : Int) : gcd m (k * m - n) = gcd m n := by
+  simp [Int.sub_eq_add_neg]
+
+@[simp] theorem gcd_mul_left_sub_right (m n k : Int) : gcd m (m * k - n) = gcd m n := by
+  simp [Int.sub_eq_add_neg]
+
+@[simp] theorem gcd_sub_mul_right_left (m n k : Int) : gcd (n - k * m) m = gcd n m := by
+  rw [gcd_comm, gcd_sub_mul_right_right, gcd_comm]
+
+@[simp] theorem gcd_sub_mul_left_left (m n k : Int) : gcd (n - m * k) m = gcd n m := by
+  rw [Int.mul_comm, gcd_sub_mul_right_left]
+
+@[simp] theorem gcd_mul_right_sub_left (m n k : Int) : gcd (k * m - n) m = gcd n m := by
+  simp [Int.sub_eq_add_neg]
+
+@[simp] theorem gcd_mul_left_sub_left (m n k : Int) : gcd (m * k - n) m = gcd n m := by
+  simp [Int.sub_eq_add_neg]
+
+@[simp] theorem gcd_sub_self_right (m n : Int) : gcd m (n - m) = gcd m n := by
+  simpa using gcd_sub_mul_right_right _ _ 1
+
+@[simp] theorem gcd_self_sub_right (m n : Int) : gcd m (m - n) = gcd m n := by
+  simpa using gcd_mul_right_sub_right _ _ 1
+
+@[simp] theorem gcd_sub_self_left (m n : Int) : gcd (n - m) m = gcd n m := by
+  simpa using gcd_sub_mul_right_left _ _ 1
+
+@[simp] theorem gcd_self_sub_left (m n : Int) : gcd (m - n) m = gcd n m := by
+  simpa using gcd_mul_right_sub_left _ _ 1
+
+@[simp] theorem gcd_sub_left_left_of_dvd {m k : Int} (n : Int) :
+    m ∣ k → gcd (k - n) m = gcd n m := by
+  rintro ⟨l, rfl⟩; exact gcd_mul_left_sub_left m n l
+
+@[simp] theorem gcd_sub_right_left_of_dvd {m k : Int} (n : Int) :
+    m ∣ k → gcd (n - k) m = gcd n m := by
+  rintro ⟨l, rfl⟩; exact gcd_sub_mul_left_left m n l
+
+@[simp] theorem gcd_sub_left_right_of_dvd {n k : Int} (m : Int) :
+    n ∣ k → gcd n (k - m) = gcd n m := by
+  rintro ⟨l, rfl⟩; exact gcd_mul_left_sub_right n m l
+
+@[simp] theorem gcd_sub_right_right_of_dvd {n k : Int} (m : Int) :
+    n ∣ k → gcd n (m - k) = gcd n m := by
+  rintro ⟨l, rfl⟩; exact gcd_sub_mul_left_right n m l
+
+@[simp] theorem gcd_eq_zero_iff {a b : Int} : gcd a b = 0 ↔ a = 0 ∧ b = 0 := by
+  simp [gcd_eq_natAbs_gcd_natAbs]
+
+@[simp] theorem gcd_pos_iff {a b : Int} : 0 < gcd a b ↔ a ≠ 0 ∨ b ≠ 0 := by
+  simp only [Nat.pos_iff_ne_zero, gcd_eq_zero_iff, ne_eq, Decidable.not_and_iff_not_or_not]
+
+theorem gcd_eq_iff {a b : Int} {g : Nat} :
+    gcd a b = g ↔ (g : Int) ∣ a ∧ (g : Int) ∣ b ∧ (∀ c, c ∣ a → c ∣ b → c ∣ g) := by
+  refine ⟨?_, fun ⟨ha, hb, hc⟩ => Nat.dvd_antisymm ?_ (dvd_gcd ha hb)⟩
+  · rintro rfl
+    exact ⟨gcd_dvd_left _ _, gcd_dvd_right _ _, fun _ => Int.dvd_coe_gcd⟩
+  · exact Int.ofNat_dvd.1 (hc _ (gcd_dvd_left _ _) (gcd_dvd_right _ _))
+
+/-- Represent a divisor of `m * n` as a product of a divisor of `m` and a divisor of `n`. -/
+def dvdProdDvdOfDvdProd {k m n : Int} (h : k ∣ m * n) :
+    { d : { m' // m' ∣ m } × { n' // n' ∣ n } // k = d.1.val * d.2.val } :=
+  let d₀ := Nat.dvdProdDvdOfDvdProd (natAbs_mul _ _ ▸ natAbs_dvd_natAbs.2 h)
+  if hk : 0 ≤ k then
+    ⟨⟨⟨d₀.val.1.val, ofNat_dvd_left.2 d₀.val.1.property⟩,
+      ⟨d₀.val.2.val, ofNat_dvd_left.2 d₀.val.2.property⟩⟩,
+     (eq_natAbs_of_nonneg hk).trans (by simp [d₀.property])⟩
+  else
+    ⟨⟨⟨-d₀.val.1.val, by simpa using ofNat_dvd_left.2 d₀.val.1.property⟩,
+      ⟨d₀.val.2.val, ofNat_dvd_left.2 d₀.val.2.property⟩⟩,
+     (eq_neg_natAbs_of_nonpos (Int.le_of_not_le hk)).trans (by simp [d₀.property, Int.neg_mul])⟩
+
+protected theorem dvd_mul {a b c : Int} : c ∣ a * b ↔ ∃ c₁ c₂, c₁ ∣ a ∧ c₂ ∣ b ∧ c₁ * c₂ = c := by
+  refine ⟨fun h => ?_, ?_⟩
+  · obtain ⟨⟨⟨k₁, hk₁⟩, ⟨k₂, hk₂⟩⟩, rfl⟩ := dvdProdDvdOfDvdProd h
+    exact ⟨k₁, k₂, hk₁, hk₂, rfl⟩
+  · rintro ⟨k₁, k₂, hk₁, hk₂, rfl⟩
+    exact Int.mul_dvd_mul hk₁ hk₂
+
+theorem gcd_mul_right_dvd_mul_gcd (k m n : Int) : gcd k (m * n) ∣ gcd k m * gcd k n := by
+  simp [gcd_eq_natAbs_gcd_natAbs, natAbs_mul, Nat.gcd_mul_right_dvd_mul_gcd]
+
+theorem gcd_mul_left_dvd_mul_gcd (k m n : Int) : gcd (m * n) k ∣ gcd m k * gcd n k := by
+  simp [gcd_eq_natAbs_gcd_natAbs, natAbs_mul, Nat.gcd_mul_left_dvd_mul_gcd]
+
+theorem dvd_gcd_mul_iff_dvd_mul {k n m : Int} : k ∣ gcd k n * m ↔ k ∣ n * m := by
+  simp [← natAbs_dvd_natAbs, natAbs_mul, Nat.dvd_gcd_mul_iff_dvd_mul, gcd_eq_natAbs_gcd_natAbs]
+
+theorem dvd_mul_gcd_iff_dvd_mul {k n m : Int} : k ∣ n * gcd k m ↔ k ∣ n * m := by
+  simp [← natAbs_dvd_natAbs, natAbs_mul, Nat.dvd_mul_gcd_iff_dvd_mul, gcd_eq_natAbs_gcd_natAbs]
+
+theorem dvd_gcd_mul_gcd_iff_dvd_mul {k n m : Int} : k ∣ gcd k n * gcd k m ↔ k ∣ n * m := by
+  simp [← natAbs_dvd_natAbs, natAbs_mul, Nat.dvd_gcd_mul_gcd_iff_dvd_mul, gcd_eq_natAbs_gcd_natAbs]
+
+theorem gcd_eq_one_iff {m n : Int} : gcd m n = 1 ↔ ∀ c, c ∣ m → c ∣ n → c ∣ 1 := by
+  simp [gcd_eq_iff]
+
+theorem gcd_mul_right_right_of_gcd_eq_one {n m k : Int} : gcd n m = 1 → gcd n (m * k) = gcd n k := by
+  simpa [gcd_eq_natAbs_gcd_natAbs, natAbs_mul] using Nat.gcd_mul_right_right_of_gcd_eq_one
+
+theorem gcd_mul_left_right_of_gcd_eq_one {n m k : Int} : gcd n m = 1 → gcd n (k * m) = gcd n k := by
+  simpa [gcd_eq_natAbs_gcd_natAbs, natAbs_mul] using Nat.gcd_mul_left_right_of_gcd_eq_one
+
+theorem gcd_mul_right_left_of_gcd_eq_one {n m k : Int} : gcd n m = 1 → gcd (n * k) m = gcd k m := by
+  simpa [gcd_eq_natAbs_gcd_natAbs, natAbs_mul] using Nat.gcd_mul_right_left_of_gcd_eq_one
+
+theorem gcd_mul_left_left_of_gcd_eq_one {n m k : Int} : gcd n m = 1 → gcd (k * n) m = gcd k m := by
+  simpa [gcd_eq_natAbs_gcd_natAbs, natAbs_mul] using Nat.gcd_mul_left_left_of_gcd_eq_one
+
+theorem gcd_pow_left_of_gcd_eq_one {n m : Int} {k : Nat} : gcd n m = 1 → gcd (n ^ k) m = 1 := by
+  simpa [gcd_eq_natAbs_gcd_natAbs, natAbs_pow] using Nat.gcd_pow_left_of_gcd_eq_one
+
+theorem gcd_pow_right_of_gcd_eq_one {n m : Int} {k : Nat} (h : gcd n m = 1) : gcd n (m ^ k) = 1 := by
+  rw [gcd_comm, gcd_pow_left_of_gcd_eq_one (gcd_comm _ _ ▸ h)]
+
+theorem pow_gcd_pow_of_gcd_eq_one {n m : Int} {k l : Nat} (h : gcd n m = 1) : gcd (n ^ k) (m ^ l) = 1 :=
+  gcd_pow_left_of_gcd_eq_one (gcd_pow_right_of_gcd_eq_one h)
+
+theorem gcd_ediv_gcd_ediv_gcd_of_ne_zero_left {n m : Int} (h : n ≠ 0) :
+    gcd (n / gcd n m) (m / gcd n m) = 1 := by
+  rw [gcd_ediv (gcd_dvd_left _ _) (gcd_dvd_right _ _), natAbs_natCast,
+    Nat.div_self (gcd_pos_of_ne_zero_left _ h)]
+
+theorem gcd_ediv_gcd_ediv_gcd_of_ne_zero_right {n m : Int} (h : m ≠ 0) :
+    gcd (n / gcd n m) (m / gcd n m) = 1 := by
+  rw [gcd_ediv (gcd_dvd_left _ _) (gcd_dvd_right _ _), natAbs_natCast,
+    Nat.div_self (gcd_pos_of_ne_zero_right _ h)]
+
+theorem gcd_ediv_gcd_ediv_gcd {i j : Int} (h : 0 < gcd i j) : gcd (i / gcd i j) (j / gcd i j) = 1 :=
+  match gcd_pos_iff.1 h with
+  | Or.inl h => gcd_ediv_gcd_ediv_gcd_of_ne_zero_left h
+  | Or.inr h => gcd_ediv_gcd_ediv_gcd_of_ne_zero_right h
+
+theorem pow_gcd_pow {n m : Int} {k : Nat} : gcd (n ^ k) (m ^ k) = (gcd n m) ^ k := by
+  simpa [gcd_eq_natAbs_gcd_natAbs, natAbs_pow] using Nat.pow_gcd_pow
+
+theorem pow_dvd_pow_iff {a b : Int} {n : Nat} (h : n ≠ 0) : a ^ n ∣ b ^ n ↔ a ∣ b := by
+  simp [← natAbs_dvd_natAbs, natAbs_pow, Nat.pow_dvd_pow_iff h]
 
 /-! ## lcm -/
 
@@ -69,16 +428,228 @@ Examples:
 -/
 def lcm (m n : Int) : Nat := m.natAbs.lcm n.natAbs
 
-theorem lcm_ne_zero (hm : m ≠ 0) (hn : n ≠ 0) : lcm m n ≠ 0 := by
-  simp only [lcm]
-  apply Nat.lcm_ne_zero <;> simpa
+theorem lcm_eq_natAbs_lcm_natAbs (m n : Int) : lcm m n = Nat.lcm m.natAbs n.natAbs := rfl
 
-theorem dvd_lcm_left {a b : Int} : a ∣ lcm a b :=
-  Int.dvd_trans dvd_natAbs_self (Int.ofNat_dvd.mpr (Nat.dvd_lcm_left a.natAbs b.natAbs))
+theorem lcm_eq_mul_div (m n : Int) : lcm m n = m.natAbs * n.natAbs / gcd m n := by
+  simp [lcm_eq_natAbs_lcm_natAbs, Nat.lcm_eq_mul_div, gcd_eq_natAbs_gcd_natAbs]
 
-theorem dvd_lcm_right {a b : Int} : b ∣ lcm a b :=
-  Int.dvd_trans dvd_natAbs_self (Int.ofNat_dvd.mpr (Nat.dvd_lcm_right a.natAbs b.natAbs))
+@[simp] theorem gcd_mul_lcm (m n : Int) : gcd m n * lcm m n = m.natAbs * n.natAbs := by
+  simp [gcd_eq_natAbs_gcd_natAbs, lcm_eq_natAbs_lcm_natAbs]
+
+@[simp] theorem lcm_mul_gcd (m n : Int) : lcm m n * gcd m n = m.natAbs * n.natAbs := by
+  simp [gcd_eq_natAbs_gcd_natAbs, lcm_eq_natAbs_lcm_natAbs]
+
+@[simp] theorem lcm_dvd_natAbs_mul (m n : Int) : lcm m n ∣ m.natAbs * n.natAbs := ⟨gcd m n, by simp⟩
+@[simp] theorem gcd_dvd_natAbs_mul (m n : Int) : gcd m n ∣ m.natAbs * n.natAbs := ⟨lcm m n, by simp⟩
+
+@[simp] theorem lcm_dvd_mul (m n : Int) : (lcm m n : Int) ∣ m * n := by
+  simp [ofNat_dvd_left, natAbs_mul]
+
+@[simp] theorem gcd_dvd_mul (m n : Int) : (gcd m n : Int) ∣ m * n := by
+  simp [ofNat_dvd_left, natAbs_mul]
+
+theorem natAbs_dvd_lcm_left (a b : Int) : a.natAbs ∣ lcm a b := Nat.dvd_lcm_left ..
+theorem natAbs_dvd_lcm_right (a b : Int) : b.natAbs ∣ lcm a b := Nat.dvd_lcm_right ..
+
+theorem dvd_lcm_left (a b : Int) : a ∣ lcm a b := by
+  simp [ofNat_dvd_right, natAbs_dvd_lcm_left]
+
+theorem dvd_lcm_right (a b : Int) : b ∣ lcm a b := by
+  simp [ofNat_dvd_right, natAbs_dvd_lcm_right]
+
+theorem lcm_le_natAbs_mul {a b : Int} (ha : a ≠ 0) (hb : b ≠ 0) : lcm a b ≤ a.natAbs * b.natAbs :=
+  Nat.lcm_le_mul (natAbs_pos.2 ha) (natAbs_pos.2 hb)
+
+theorem gcd_le_natAbs_mul {a b : Int} (ha : a ≠ 0) (hb : b ≠ 0) : gcd a b ≤ a.natAbs * b.natAbs :=
+  Nat.gcd_le_mul (natAbs_pos.2 ha) (natAbs_pos.2 hb)
+
+theorem lcm_comm (a b : Int) : lcm a b = lcm b a := Nat.lcm_comm ..
+
+@[simp] theorem one_lcm {a : Int} : lcm 1 a = a.natAbs := by simp [lcm_eq_natAbs_lcm_natAbs]
+@[simp] theorem lcm_one {a : Int} : lcm a 1 = a.natAbs := by simp [lcm_eq_natAbs_lcm_natAbs]
+
+@[simp] theorem zero_lcm {a : Int} : lcm 0 a = 0 := by simp [lcm_eq_natAbs_lcm_natAbs]
+@[simp] theorem lcm_zero {a : Int} : lcm a 0 = 0 := by simp [lcm_eq_natAbs_lcm_natAbs]
+
+theorem lcm_one_left (a : Int) : lcm 1 a = a.natAbs := by simp
+theorem lcm_one_right (a : Int) : lcm a 1 = a.natAbs := by simp
+
+theorem lcm_zero_left (a : Int) : lcm 0 a = 0 := by simp
+theorem lcm_zero_right (a : Int) : lcm a 0 = 0 := by simp
 
 @[simp] theorem lcm_self {a : Int} : lcm a a = a.natAbs := Nat.lcm_self _
 
+@[simp] theorem neg_lcm {a b : Int} : lcm (-a) b = lcm a b := by simp [lcm_eq_natAbs_lcm_natAbs]
+@[simp] theorem lcm_neg {a b : Int} : lcm a (-b) = lcm a b := by simp [lcm_eq_natAbs_lcm_natAbs]
+
+@[simp, norm_cast] protected theorem lcm_natCast_natCast (a b : Nat) :
+    lcm (a : Int) (b : Int) = Nat.lcm a b := by
+  simp [lcm_eq_natAbs_lcm_natAbs]
+
+theorem natAbs_le_lcm_left (a : Int) (hb : b ≠ 0) : a.natAbs ≤ lcm a b :=
+  Nat.le_lcm_left a.natAbs (natAbs_pos.2 hb)
+
+theorem natAbs_le_lcm_right (b : Int) (ha : a ≠ 0) : b.natAbs ≤ lcm a b :=
+  Nat.le_lcm_right b.natAbs (natAbs_pos.2 ha)
+
+theorem le_lcm_left (a : Int) (hb : b ≠ 0) : a ≤ (lcm a b : Int) :=
+  Int.le_trans le_natAbs (ofNat_le.2 (natAbs_le_lcm_left a hb))
+
+theorem le_lcm_right (b : Int) (ha : a ≠ 0) : b ≤ (lcm a b : Int) :=
+  Int.le_trans le_natAbs (ofNat_le.2 (natAbs_le_lcm_right b ha))
+
+theorem coe_lcm_dvd {a b c : Int} (ha : a ∣ c) (hb : b ∣ c) : (lcm a b : Int) ∣ c :=
+  ofNat_dvd_left.2 (Nat.lcm_dvd (natAbs_dvd_natAbs.2 ha) (natAbs_dvd_natAbs.2 hb))
+
+theorem lcm_dvd {a b : Int} {c : Nat} (ha : a ∣ (c : Int)) (hb : b ∣ (c : Int)) : lcm a b ∣ c :=
+  ofNat_dvd.1 (coe_lcm_dvd ha hb)
+
+theorem coe_lcm_dvd_iff {a b c : Int} : (lcm a b : Int) ∣ c ↔ a ∣ c ∧ b ∣ c :=
+  ⟨fun h => ⟨Int.dvd_trans (dvd_lcm_left _ _) h, Int.dvd_trans (dvd_lcm_right _ _ ) h⟩,
+   fun ⟨ha, hb⟩ => coe_lcm_dvd ha hb⟩
+
+theorem lcm_dvd_iff {a b : Int} {c : Nat} : lcm a b ∣ c ↔ a ∣ (c : Int) ∧ b ∣ (c : Int) := by
+  rw [← ofNat_dvd, coe_lcm_dvd_iff]
+
+theorem lcm_eq_natAbs_left_iff_dvd : lcm a b = a.natAbs ↔ b ∣ a := by
+  simp [lcm_eq_natAbs_lcm_natAbs, Nat.lcm_eq_left_iff_dvd]
+
+theorem lcm_eq_natAbs_right_iff_dvd : lcm a b = b.natAbs ↔ a ∣ b := by
+  simp [lcm_eq_natAbs_lcm_natAbs, Nat.lcm_eq_right_iff_dvd]
+
+theorem lcm_eq_left_iff_dvd (ha : 0 ≤ a) : lcm a b = a ↔ b ∣ a := by
+  rw (occs := [2]) [eq_natAbs_of_nonneg ha]
+  simp [ofNat_inj, lcm_eq_natAbs_left_iff_dvd]
+
+theorem lcm_eq_right_iff_dvd (hb : 0 ≤ b) : lcm a b = b ↔ a ∣ b := by
+  rw [lcm_comm, lcm_eq_left_iff_dvd hb]
+
+theorem lcm_assoc (a b c : Int) : lcm (lcm a b) c = lcm a (lcm b c) := Nat.lcm_assoc ..
+
+theorem lcm_mul_left (m n k : Int) : lcm (m * n) (m * k) = m.natAbs * lcm n k := by
+  simp [lcm_eq_natAbs_lcm_natAbs, Nat.lcm_mul_left, natAbs_mul]
+
+theorem lcm_mul_right (m n k : Int) : lcm (m * n) (k * n) = lcm m k * n.natAbs := by
+  simp [lcm_eq_natAbs_lcm_natAbs, Nat.lcm_mul_right, natAbs_mul]
+
+theorem lcm_ne_zero (hm : m ≠ 0) (hn : n ≠ 0) : lcm m n ≠ 0 := by
+  apply Nat.lcm_ne_zero <;> simpa
+
+theorem lcm_pos : m ≠ 0 → n ≠ 0 → 0 < lcm m n := by
+  simpa [← Nat.pos_iff_ne_zero] using lcm_ne_zero
+
+theorem eq_zero_of_lcm_eq_zero (h : lcm m n = 0) : m = 0 ∨ n = 0 := by
+  have := lcm_ne_zero (m := m) (n := n); omega
+
+@[simp] theorem lcm_eq_zero_iff : lcm m n = 0 ↔ m = 0 ∨ n = 0 :=
+  ⟨eq_zero_of_lcm_eq_zero, by rintro (rfl|rfl) <;> simp⟩
+
+@[simp] theorem lcm_pos_iff : 0 < lcm m n ↔ m ≠ 0 ∧ n ≠ 0 := by
+  simp only [Nat.pos_iff_ne_zero, ne_eq, lcm_eq_zero_iff, not_or]
+
+theorem lcm_eq_iff {n m : Int} {l : Nat} :
+    lcm n m = l ↔ n ∣ (l : Int) ∧ m ∣ (l : Int) ∧ (∀ c, n ∣ c → m ∣ c → (l : Int) ∣ c) := by
+  refine ⟨?_, fun ⟨hn, hm, hl⟩ => Nat.dvd_antisymm (lcm_dvd hn hm) ?_⟩
+  · rintro rfl
+    exact ⟨dvd_lcm_left _ _, dvd_lcm_right _ _, fun _ => coe_lcm_dvd⟩
+  · exact Int.ofNat_dvd.1 (hl _ (dvd_lcm_left _ _) (dvd_lcm_right _ _))
+
+theorem lcm_ediv {a b c : Int} (ha : c ∣ a) (hb : c ∣ b) :
+    lcm (a / c) (b / c) = lcm a b / c.natAbs := by
+  rw [lcm_eq_natAbs_lcm_natAbs, natAbs_ediv_of_dvd ha, natAbs_ediv_of_dvd hb,
+    Nat.lcm_div (by simpa) (by simpa), lcm_eq_natAbs_lcm_natAbs]
+
+theorem lcm_dvd_lcm_of_dvd_left {a b : Int} (c : Int) (h : a ∣ b) : lcm a c ∣ lcm b c :=
+  Nat.lcm_dvd_lcm_of_dvd_left _ (by simpa)
+
+theorem lcm_dvd_lcm_of_dvd_right {a b : Int} (c : Int) (h : a ∣ b) : lcm c a ∣ lcm c b :=
+  Nat.lcm_dvd_lcm_of_dvd_right _ (by simpa)
+
+theorem lcm_dvd_lcm_mul_left_left (a b c : Int) : lcm a b ∣ lcm (c * a) b := by
+  simpa [lcm_eq_natAbs_lcm_natAbs, natAbs_mul] using Nat.lcm_dvd_lcm_mul_left_left ..
+
+theorem lcm_dvd_lcm_mul_right_left (a b c : Int) : lcm a b ∣ lcm (a * c) b := by
+  simpa [lcm_eq_natAbs_lcm_natAbs, natAbs_mul] using Nat.lcm_dvd_lcm_mul_right_left ..
+
+theorem lcm_dvd_lcm_mul_left_right (a b c : Int) : lcm a b ∣ lcm a (c * b) := by
+  simpa [lcm_eq_natAbs_lcm_natAbs, natAbs_mul] using Nat.lcm_dvd_lcm_mul_left_right ..
+
+theorem lcm_dvd_lcm_mul_right_right (a b c : Int) : lcm a b ∣ lcm a (b * c) := by
+  simpa [lcm_eq_natAbs_lcm_natAbs, natAbs_mul] using Nat.lcm_dvd_lcm_mul_right_right ..
+
+theorem lcm_eq_natAbs_left (h : b ∣ a) : lcm a b = a.natAbs :=
+  lcm_eq_natAbs_left_iff_dvd.2 h
+
+theorem lcm_eq_natAbs_right (h : a ∣ b) : lcm a b = b.natAbs :=
+  lcm_eq_natAbs_right_iff_dvd.2 h
+
+theorem lcm_eq_left (ha : 0 ≤ a) (h : b ∣ a) : lcm a b = a :=
+  (lcm_eq_left_iff_dvd ha).2 h
+
+theorem lcm_eq_right (hb : 0 ≤ b) (h : a ∣ b) : lcm a b = b :=
+  (lcm_eq_right_iff_dvd hb).2 h
+
+@[simp] theorem lcm_mul_left_left (a b : Int) : lcm (a * b) b = a.natAbs * b.natAbs := by
+  simp [lcm_eq_natAbs_lcm_natAbs, natAbs_mul]
+
+@[simp] theorem lcm_mul_left_right (a b : Int) : lcm a (b * a) = b.natAbs * a.natAbs := by
+  simp [lcm_eq_natAbs_lcm_natAbs, natAbs_mul]
+
+@[simp] theorem lcm_mul_right_left (a b : Int) : lcm (b * a) b = b.natAbs * a.natAbs := by
+  simp [lcm_eq_natAbs_lcm_natAbs, natAbs_mul]
+
+@[simp] theorem lcm_mul_right_right (a b : Int) : lcm a (a * b) = a.natAbs * b.natAbs := by
+  simp [lcm_eq_natAbs_lcm_natAbs, natAbs_mul]
+
+@[simp] theorem lcm_lcm_self_right_left (m n : Int) : lcm m (lcm m n) = lcm m n :=
+  Nat.lcm_lcm_self_right_left ..
+
+@[simp] theorem lcm_lcm_self_right_right (m n : Int) : lcm m (lcm n m) = lcm m n :=
+  Nat.lcm_lcm_self_right_right ..
+
+@[simp] theorem lcm_lcm_self_left_right (m n : Int) : lcm (lcm n m) m = lcm n m :=
+  Nat.lcm_lcm_self_left_right ..
+
+@[simp] theorem lcm_lcm_self_left_left (m n : Int) : lcm (lcm m n) m = lcm n m :=
+  Nat.lcm_lcm_self_left_left ..
+
+theorem lcm_eq_mul_iff {m n : Int} : lcm m n = m.natAbs * n.natAbs ↔ m = 0 ∨ n = 0 ∨ gcd m n = 1 := by
+  simp [lcm_eq_natAbs_lcm_natAbs, Nat.lcm_eq_mul_iff, gcd_eq_natAbs_gcd_natAbs]
+
+@[simp] theorem lcm_eq_one_iff {m n : Int} : lcm m n = 1 ↔ m ∣ 1 ∧ n ∣ 1 := by
+  refine ⟨fun h => ⟨?_, ?_⟩, fun ⟨ha, hb⟩ => Nat.eq_one_of_dvd_one (lcm_dvd ha hb)⟩ <;>
+    simp [← natAbs_dvd_natAbs, ← h, natAbs_dvd_lcm_left, natAbs_dvd_lcm_right]
+
+theorem lcm_mul_right_dvd_mul_lcm (k m n : Nat) : lcm k (m * n) ∣ lcm k m * lcm k n := by
+  simp [lcm_eq_natAbs_lcm_natAbs, natAbs_mul, Nat.lcm_mul_right_dvd_mul_lcm]
+
+theorem lcm_mul_left_dvd_mul_lcm (k m n : Nat) : lcm (m * n) k ∣ lcm m k * lcm n k := by
+  simpa [lcm_comm, Nat.mul_comm] using lcm_mul_right_dvd_mul_lcm _ _ _
+
+theorem lcm_dvd_mul_self_left_iff_dvd_mul {k n m : Nat} : lcm k n ∣ k * m ↔ n ∣ k * m := by
+  simp [← natAbs_dvd_natAbs, natAbs_mul, Nat.lcm_dvd_mul_self_left_iff_dvd_mul,
+    lcm_eq_natAbs_lcm_natAbs]
+
+theorem lcm_dvd_mul_self_right_iff_dvd_mul {k m n : Nat} : lcm n k ∣ m * k ↔ n ∣ m * k := by
+  rw [lcm_comm, Nat.mul_comm m, lcm_dvd_mul_self_left_iff_dvd_mul]
+
+theorem lcm_mul_right_right_eq_mul_of_lcm_eq_mul {n m k : Int} (h : lcm n m = n.natAbs * m.natAbs) :
+    lcm n (m * k) = lcm n k * m.natAbs := by
+  simp [lcm_eq_natAbs_lcm_natAbs, natAbs_mul, Nat.lcm_mul_right_right_eq_mul_of_lcm_eq_mul h]
+
+theorem lcm_mul_left_right_eq_mul_of_lcm_eq_mul {n m k} (h : lcm n m = n.natAbs * m.natAbs) :
+    lcm n (k * m) = lcm n k * m.natAbs := by
+  simp [lcm_eq_natAbs_lcm_natAbs, natAbs_mul, Nat.lcm_mul_left_right_eq_mul_of_lcm_eq_mul h]
+
+theorem lcm_mul_right_left_eq_mul_of_lcm_eq_mul {n m k} (h : lcm n m = n.natAbs * m.natAbs) :
+    lcm (n * k) m = n.natAbs * lcm k m := by
+  simp [lcm_eq_natAbs_lcm_natAbs, natAbs_mul, Nat.lcm_mul_right_left_eq_mul_of_lcm_eq_mul h]
+
+theorem lcm_mul_left_left_eq_mul_of_lcm_eq_mul {n m k} (h : lcm n m = n.natAbs * m.natAbs) :
+    lcm (k * n) m = n.natAbs * lcm k m := by
+  simp [lcm_eq_natAbs_lcm_natAbs, natAbs_mul, Nat.lcm_mul_left_left_eq_mul_of_lcm_eq_mul h]
+
+theorem pow_lcm_pow {n m : Int} {k : Nat} : lcm (n ^ k) (m ^ k) = (lcm n m) ^ k := by
+  simpa [lcm_eq_natAbs_lcm_natAbs, natAbs_pow] using Nat.pow_lcm_pow
+
 end Int

src/Init/Data/Int/Lemmas.lean

@@ -377,6 +377,11 @@ theorem toNat_of_nonpos : ∀ {z : Int}, z ≤ 0 → z.toNat = 0
 @[simp] theorem negSucc_add_one_eq_neg_ofNat_iff {a b : Nat} : -[a+1] + 1 = - (b : Int) ↔ a = b := by
   rw [eq_comm, neg_ofNat_eq_negSucc_add_one_iff, eq_comm]
 
+protected theorem sub_eq_iff_eq_add {b a c : Int} : a - b = c ↔ a = c + b := by
+  refine ⟨fun h => ?_, fun h => ?_⟩ <;> subst h <;> simp
+protected theorem sub_eq_iff_eq_add' {b a c : Int} : a - b = c ↔ a = b + c := by
+  rw [Int.sub_eq_iff_eq_add, Int.add_comm]
+
 /- ## add/sub injectivity -/
 
 @[simp] protected theorem add_left_inj {i j : Int} (k : Int) : (i + k = j + k) ↔ i = j := by
@@ -561,7 +566,11 @@ theorem eq_one_of_mul_eq_self_left {a b : Int} (Hpos : a ≠ 0) (H : b * a = a)
 theorem eq_one_of_mul_eq_self_right {a b : Int} (Hpos : b ≠ 0) (H : b * a = b) : a = 1 :=
   Int.eq_of_mul_eq_mul_left Hpos <| by rw [Int.mul_one, H]
 
-/-! NatCast lemmas -/
+protected theorem two_mul (n : Int) : 2 * n = n + n := calc
+  2 * n = (1 + 1) * n := rfl
+  _     = n + n := by simp only [Int.add_mul, Int.one_mul]
+
+/-! ## NatCast lemmas -/
 
 /-!
 The following lemmas are later subsumed by e.g. `Nat.cast_add` and `Nat.cast_mul` in Mathlib
@@ -572,10 +581,8 @@ protected theorem natCast_zero : ((0 : Nat) : Int) = (0 : Int) := rfl
 
 protected theorem natCast_one : ((1 : Nat) : Int) = (1 : Int) := rfl
 
-@[simp] protected theorem natCast_add (a b : Nat) : ((a + b : Nat) : Int) = (a : Int) + (b : Int) := by
-  -- Note this only works because of local simp attributes in this file,
-  -- so it still makes sense to tag the lemmas with `@[simp]`.
-  simp
+@[simp, norm_cast] protected theorem natCast_add (a b : Nat) : ((a + b : Nat) : Int) = (a : Int) + (b : Int) := by
+  rfl
 
 protected theorem natCast_succ (n : Nat) : ((n + 1 : Nat) : Int) = (n : Int) + 1 := rfl
 

src/Init/Data/Int/LemmasAux.lean

@@ -5,6 +5,7 @@ Authors: Kim Morrison
 -/
 prelude
 import Init.Data.Int.Order
+import Init.Data.Int.Pow
 import Init.Data.Int.DivMod.Lemmas
 import Init.Omega
 
@@ -19,9 +20,6 @@ namespace Int
 
 @[simp] theorem natCast_le_zero : {n : Nat} → (n : Int) ≤ 0 ↔ n = 0 := by omega
 
-protected theorem sub_eq_iff_eq_add {b a c : Int} : a - b = c ↔ a = c + b := by omega
-protected theorem sub_eq_iff_eq_add' {b a c : Int} : a - b = c ↔ a = b + c := by omega
-
 @[simp] protected theorem neg_nonpos_iff (i : Int) : -i ≤ 0 ↔ 0 ≤ i := by omega
 
 @[simp] theorem zero_le_ofNat (n : Nat) : 0 ≤ ((no_index (OfNat.ofNat n)) : Int) :=
@@ -39,6 +37,42 @@ protected theorem sub_eq_iff_eq_add' {b a c : Int} : a - b = c ↔ a = b + c :=
 @[simp] theorem neg_ofNat_le_natCast (n m : Nat) : -(no_index (OfNat.ofNat n)) ≤ (m : Int) :=
   Int.le_trans (by simp) (ofNat_zero_le m)
 
+theorem neg_lt_self_iff {n : Int} : -n < n ↔ 0 < n := by
+  omega
+
+protected theorem ofNat_add_out (m n : Nat) : ↑m + ↑n = (↑(m + n) : Int) := rfl
+
+protected theorem ofNat_mul_out (m n : Nat) : ↑m * ↑n = (↑(m * n) : Int) := rfl
+
+protected theorem ofNat_add_one_out (n : Nat) : ↑n + (1 : Int) = ↑(Nat.succ n) := rfl
+
+@[simp] theorem ofNat_eq_natCast (n : Nat) : Int.ofNat n = n := rfl
+
+@[norm_cast] theorem natCast_inj {m n : Nat} : (m : Int) = (n : Int) ↔ m = n := ofNat_inj
+
+@[simp, norm_cast] theorem natAbs_cast (n : Nat) : natAbs ↑n = n := rfl
+
+@[norm_cast]
+protected theorem natCast_sub {n m : Nat} : n ≤ m → (↑(m - n) : Int) = ↑m - ↑n := ofNat_sub
+
+@[simp high] theorem natCast_eq_zero {n : Nat} : (n : Int) = 0 ↔ n = 0 := by omega
+
+theorem natCast_ne_zero {n : Nat} : (n : Int) ≠ 0 ↔ n ≠ 0 := by omega
+
+theorem natCast_ne_zero_iff_pos {n : Nat} : (n : Int) ≠ 0 ↔ 0 < n := by omega
+
+@[simp high] theorem natCast_pos {n : Nat} : (0 : Int) < n ↔ 0 < n := by omega
+
+theorem natCast_succ_pos (n : Nat) : 0 < (n.succ : Int) := natCast_pos.2 n.succ_pos
+
+@[simp high] theorem natCast_nonpos_iff {n : Nat} : (n : Int) ≤ 0 ↔ n = 0 := by omega
+
+theorem natCast_nonneg (n : Nat) : 0 ≤ (n : Int) := ofNat_le.2 (Nat.zero_le _)
+
+@[simp] theorem sign_natCast_add_one (n : Nat) : sign (n + 1) = 1 := rfl
+
+@[simp, norm_cast] theorem cast_id {n : Int} : Int.cast n = n := rfl
+
 /-! ### toNat -/
 
 @[simp] theorem toNat_sub' (a : Int) (b : Nat) : (a - b).toNat = a.toNat - b := by
@@ -69,15 +103,26 @@ protected theorem sub_eq_iff_eq_add' {b a c : Int} : a - b = c ↔ a = b + c :=
 
 @[simp] theorem toNat_le {m : Int} {n : Nat} : m.toNat ≤ n ↔ m ≤ n := by omega
 @[simp] theorem toNat_lt' {m : Int} {n : Nat} (hn : 0 < n) : m.toNat < n ↔ m < n := by omega
+@[simp] theorem lt_toNat {m : Nat} {n : Int} : m < toNat n ↔ m < n := by omega
+theorem lt_of_toNat_lt {a b : Int} (h : toNat a < toNat b) : a < b := by omega
 
-/-! ### natAbs -/
+theorem toNat_sub_of_le {a b : Int} (h : b ≤ a) : (toNat (a - b) : Int) = a - b := by omega
 
-theorem eq_zero_of_dvd_of_natAbs_lt_natAbs {d n : Int} (h : d ∣ n) (h₁ : n.natAbs < d.natAbs) :
-    n = 0 := by
-  obtain ⟨a, rfl⟩ := h
-  rw [natAbs_mul] at h₁
-  suffices ¬ 0 < a.natAbs by simp [Int.natAbs_eq_zero.1 (Nat.eq_zero_of_not_pos this)]
-  exact fun h => Nat.lt_irrefl _ (Nat.lt_of_le_of_lt (Nat.le_mul_of_pos_right d.natAbs h) h₁)
+theorem pos_iff_toNat_pos {n : Int} : 0 < n ↔ 0 < n.toNat := by
+  omega
+
+theorem natCast_toNat_eq_self {a : Int} : a.toNat = a ↔ 0 ≤ a := by omega
+
+@[deprecated natCast_toNat_eq_self (since := "2025-04-16")]
+theorem ofNat_toNat_eq_self {a : Int} : a.toNat = a ↔ 0 ≤ a := natCast_toNat_eq_self
+
+theorem eq_natCast_toNat {a : Int} : a = a.toNat ↔ 0 ≤ a := by omega
+
+@[deprecated eq_natCast_toNat (since := "2025-04-16")]
+theorem eq_ofNat_toNat {a : Int} : a = a.toNat ↔ 0 ≤ a := eq_natCast_toNat
+
+theorem toNat_le_toNat {n m : Int} (h : n ≤ m) : n.toNat ≤ m.toNat := by omega
+theorem toNat_lt_toNat {n m : Int} (hn : 0 < m) : n.toNat < m.toNat ↔ n < m := by omega
 
 /-! ### min and max -/
 
@@ -117,27 +162,62 @@ protected theorem sub_min_sub_left (a b c : Int) : min (a - b) (a - c) = a - max
 
 protected theorem sub_max_sub_left (a b c : Int) : max (a - b) (a - c) = a - min b c := by omega
 
-/-! ### bmod -/
+/-! ## mul -/
 
-theorem bmod_neg_iff {m : Nat} {x : Int} (h2 : -m ≤ x) (h1 : x < m) :
-    (x.bmod m) < 0 ↔ (-(m / 2) ≤ x ∧ x < 0) ∨ ((m + 1) / 2 ≤ x) := by
-  simp only [Int.bmod_def]
-  by_cases xpos : 0 ≤ x
-  · rw [Int.emod_eq_of_lt xpos (by omega)]; omega
-  · rw [Int.add_emod_self.symm, Int.emod_eq_of_lt (by omega) (by omega)]; omega
+theorem mul_le_mul_of_natAbs_le {x y : Int} {s t : Nat} (hx : x.natAbs ≤ s) (hy : y.natAbs ≤ t) :
+    x * y ≤ s * t := by
+  by_cases 0 < s ∧ 0 < t
+  · have := Nat.mul_pos (n := s) (m := t) (by omega) (by omega)
+    by_cases hx : 0 < x <;> by_cases hy : 0 < y
+    · apply Int.mul_le_mul <;> omega
+    · have : x * y ≤ 0 := Int.mul_nonpos_of_nonneg_of_nonpos (by omega) (by omega); omega
+    · have : x * y ≤ 0 := Int.mul_nonpos_of_nonpos_of_nonneg (by omega) (by omega); omega
+    · have : -x * -y ≤ s * t := Int.mul_le_mul (by omega) (by omega) (by omega) (by omega)
+      simp [Int.neg_mul_neg] at this
+      norm_cast
+  · have : (x = 0 ∨ y = 0) → x * y = 0 := by simp [Int.mul_eq_zero]
+    norm_cast
+    omega
 
-theorem bmod_eq_self_of_le {n : Int} {m : Nat} (hn' : -(m / 2) ≤ n) (hn : n < (m + 1) / 2) :
-    n.bmod m = n := by
-  rw [← Int.sub_eq_zero]
-  have := le_bmod (x := n) (m := m) (by omega)
-  have := bmod_lt (x := n) (m := m) (by omega)
-  apply eq_zero_of_dvd_of_natAbs_lt_natAbs Int.dvd_bmod_sub_self
-  omega
+/--
+This is a generalization of `a ≤ c` and `b ≤ d` implying `a * b ≤ c * d` for natural numbers,
+appropriately generalized to integers when `b` is nonnegative and `c` is nonpositive.
+-/
+theorem mul_le_mul_of_le_of_le_of_nonneg_of_nonpos {a b c d : Int}
+    (hac : a ≤ c) (hbd : d ≤ b) (hb : 0 ≤ b) (hc : c ≤ 0) : a * b ≤ c * d :=
+  Int.le_trans (Int.mul_le_mul_of_nonneg_right hac hb) (Int.mul_le_mul_of_nonpos_left hc hbd)
 
-theorem bmod_bmod_of_dvd {a : Int} {n m : Nat} (hnm : n ∣ m) :
-    (a.bmod m).bmod n = a.bmod n := by
-  rw [← Int.sub_eq_iff_eq_add.2 (bmod_add_bdiv a m).symm]
-  obtain ⟨k, rfl⟩ := hnm
-  simp [Int.mul_assoc]
+theorem mul_le_mul_of_le_of_le_of_nonneg_of_nonneg {a b c d : Int}
+    (hac : a ≤ c) (hbd : b ≤ d) (hb : 0 ≤ b) (hc : 0 ≤ c) : a * b ≤ c * d :=
+  Int.le_trans (Int.mul_le_mul_of_nonneg_right hac hb) (Int.mul_le_mul_of_nonneg_left hbd hc)
+
+theorem mul_le_mul_of_le_of_le_of_nonpos_of_nonpos {a b c d : Int}
+    (hac : c ≤ a) (hbd : d ≤ b) (hb : b ≤ 0) (hc : c ≤ 0) : a * b ≤ c * d :=
+  Int.le_trans (Int.mul_le_mul_of_nonpos_right hac hb) (Int.mul_le_mul_of_nonpos_left hc hbd)
+
+theorem mul_le_mul_of_le_of_le_of_nonpos_of_nonneg {a b c d : Int}
+    (hac : c ≤ a) (hbd : b ≤ d) (hb : b ≤ 0) (hc : 0 ≤ c) : a * b ≤ c * d :=
+  Int.le_trans (Int.mul_le_mul_of_nonpos_right hac hb) (Int.mul_le_mul_of_nonneg_left hbd hc)
+
+/--
+A corollary of |s| ≤ x, and |t| ≤ y, then |s * t| ≤ x * y,
+-/
+theorem neg_mul_le_mul {x y : Int} {s t : Nat} (lbx : -s ≤ x) (ubx : x < s) (lby : -t ≤ y) (uby : y < t) :
+      -(s * t) ≤ x * y := by
+  have := Nat.mul_pos (n := s) (m := t) (by omega) (by omega)
+  by_cases 0 ≤ x <;> by_cases 0 ≤ y
+  · have : 0 ≤ x * y := by apply Int.mul_nonneg <;> omega
+    norm_cast
+    omega
+  · rw [Int.mul_comm (a := x), Int.mul_comm (a := (s : Int)), ← Int.neg_mul]; apply Int.mul_le_mul_of_le_of_le_of_nonneg_of_nonpos <;> omega
+  · rw [← Int.neg_mul]; apply Int.mul_le_mul_of_le_of_le_of_nonneg_of_nonpos <;> omega
+  · have : 0 < x * y := by apply Int.mul_pos_of_neg_of_neg <;> omega
+    norm_cast
+    omega
+
+/-! ## pow -/
+
+theorem natAbs_pow_two (a : Int) : (natAbs a : Int) ^ 2 = a ^ 2 := by
+  simp [Int.pow_succ]
 
 end Int

src/Init/Data/Int/Linear.lean

@@ -191,9 +191,9 @@ theorem cmod_nonpos (a : Int) {b : Int} (h : b ≠ 0) : cmod a b ≤ 0 := by
 
 theorem cmod_eq_zero_iff_emod_eq_zero (a b : Int) : cmod a b = 0 ↔ a%b = 0 := by
   unfold cmod
-  have := @Int.emod_eq_emod_iff_emod_sub_eq_zero  b b a
-  simp at this
-  simp [Int.neg_emod_eq_sub_emod, ← this, Eq.comm]
+  have := @Int.emod_eq_emod_iff_emod_sub_eq_zero b b a
+  simp only [emod_self, sub_emod_left] at this
+  rw [Int.neg_eq_zero, ← this, Eq.comm]
 
 private abbrev div_mul_cancel_of_mod_zero :=
   @Int.ediv_mul_cancel_of_emod_eq_zero
@@ -435,7 +435,7 @@ def norm_eq_coeff_cert (lhs rhs : Expr) (p : Poly) (k : Int) : Bool :=
 theorem norm_eq_coeff (ctx : Context) (lhs rhs : Expr) (p : Poly) (k : Int)
     : norm_eq_coeff_cert lhs rhs p k → (lhs.denote ctx = rhs.denote ctx) = (p.denote' ctx = 0) := by
   simp [norm_eq_coeff_cert]
-  rw [norm_eq ctx lhs rhs (lhs.sub rhs).norm BEq.refl, Poly.denote'_eq_denote]
+  rw [norm_eq ctx lhs rhs (lhs.sub rhs).norm BEq.rfl, Poly.denote'_eq_denote]
   apply norm_eq_coeff'
 
 private theorem mul_le_zero_iff (a k : Int) (h₁ : k > 0) : k * a ≤ 0 ↔ a ≤ 0 := by
@@ -454,7 +454,7 @@ private theorem norm_le_coeff' (ctx : Context) (p p' : Poly) (k : Int) : p = p'.
 theorem norm_le_coeff (ctx : Context) (lhs rhs : Expr) (p : Poly) (k : Int)
     : norm_eq_coeff_cert lhs rhs p k → (lhs.denote ctx ≤ rhs.denote ctx) = (p.denote' ctx ≤ 0) := by
   simp [norm_eq_coeff_cert]
-  rw [norm_le ctx lhs rhs (lhs.sub rhs).norm BEq.refl, Poly.denote'_eq_denote]
+  rw [norm_le ctx lhs rhs (lhs.sub rhs).norm BEq.rfl, Poly.denote'_eq_denote]
   apply norm_le_coeff'
 
 private theorem mul_add_cmod_le_iff {a k b : Int} (h : k > 0) : a*k + cmod b k ≤ 0 ↔ a ≤ 0 := by
@@ -499,7 +499,7 @@ def norm_le_coeff_tight_cert (lhs rhs : Expr) (p : Poly) (k : Int) : Bool :=
 theorem norm_le_coeff_tight (ctx : Context) (lhs rhs : Expr) (p : Poly) (k : Int)
     : norm_le_coeff_tight_cert lhs rhs p k → (lhs.denote ctx ≤ rhs.denote ctx) = (p.denote' ctx ≤ 0) := by
   simp [norm_le_coeff_tight_cert]
-  rw [norm_le ctx lhs rhs (lhs.sub rhs).norm BEq.refl, Poly.denote'_eq_denote]
+  rw [norm_le ctx lhs rhs (lhs.sub rhs).norm BEq.rfl, Poly.denote'_eq_denote]
   apply eq_of_norm_eq_of_divCoeffs
 
 def Poly.isUnsatEq (p : Poly) : Bool :=
@@ -665,7 +665,7 @@ theorem norm_dvd (ctx : Context) (k : Int) (e : Expr) (p : Poly) : e.norm == p
   simp; intro h; simp [← h]
 
 theorem dvd_eq_false (ctx : Context) (k : Int) (e : Expr) (h : e.norm.isUnsatDvd k) : (k ∣ e.denote ctx) = False := by
-  rw [norm_dvd ctx k e e.norm BEq.refl]
+  rw [norm_dvd ctx k e e.norm BEq.rfl]
   apply dvd_eq_false' ctx k e.norm h
 
 def dvd_coeff_cert (k₁ : Int) (p₁ : Poly) (k₂ : Int) (p₂ : Poly) (k : Int) : Bool :=
@@ -1173,7 +1173,7 @@ private theorem cooper_dvd_left_core
   have ⟨k, h₁, h₂, h₃, h₄, h₅⟩ := Int.cooper_resolution_dvd_left a_pos' b_pos d_pos |>.mp ⟨x, h₁', h₂', h₃⟩
   rw [Int.neg_mul] at h₂
   simp only [Int.neg_mul, neg_gcd, lcm_neg_left, Int.mul_neg, Int.neg_neg, Int.neg_dvd] at *
-  rw [Int.neg_ediv_of_dvd Int.gcd_dvd_left] at h₂
+  rw [Int.neg_ediv_of_dvd (Int.gcd_dvd_left ..)] at h₂
   simp only [lcm_neg_right] at h₂
   have : c * k + c * p + -(a * s) = c * p + -(a * s) + c * k := by ac_rfl
   rw [this] at h₅; clear this
@@ -1796,6 +1796,45 @@ theorem of_not_dvd (a b : Int) : a != 0 → ¬ (a ∣ b) → b % a > 0 := by
   simp [h₁] at h₂
   assumption
 
+def le_of_le_cert (p q : Poly) (k : Nat) : Bool :=
+  q == p.addConst (- k)
+
+theorem le_of_le (ctx : Context) (p q : Poly) (k : Nat)
+    : le_of_le_cert p q k → p.denote' ctx ≤ 0 → q.denote' ctx ≤ 0 := by
+  simp [le_of_le_cert]; intro; subst q; simp
+  intro h
+  simp [Lean.Omega.Int.add_le_zero_iff_le_neg']
+  exact Int.le_trans h (Int.ofNat_zero_le _)
+
+def not_le_of_le_cert (p q : Poly) (k : Nat) : Bool :=
+  q == (p.mul (-1)).addConst (1 + k)
+
+theorem not_le_of_le (ctx : Context) (p q : Poly) (k : Nat)
+    : not_le_of_le_cert p q k → p.denote' ctx ≤ 0 → ¬ q.denote' ctx ≤ 0 := by
+  simp [not_le_of_le_cert]; intro; subst q
+  intro h
+  apply Int.pos_of_neg_neg
+  apply Int.lt_of_add_one_le
+  simp [Int.neg_add, Int.neg_sub]
+  rw [← Int.add_assoc, ← Int.add_assoc, Int.add_neg_cancel_right, Lean.Omega.Int.add_le_zero_iff_le_neg']
+  simp; exact Int.le_trans h (Int.ofNat_zero_le _)
+
+def eq_def_cert (x : Var) (xPoly : Poly) (p : Poly) : Bool :=
+  p == .add (-1) x xPoly
+
+theorem eq_def (ctx : Context) (x : Var) (xPoly : Poly) (p : Poly)
+    : eq_def_cert x xPoly p → x.denote ctx = xPoly.denote' ctx → p.denote' ctx = 0 := by
+  simp [eq_def_cert]; intro _ h; subst p; simp [h]
+  rw [← Int.sub_eq_add_neg, Int.sub_self]
+
+def eq_def'_cert (x : Var) (e : Expr) (p : Poly) : Bool :=
+  p == .add (-1) x e.norm
+
+theorem eq_def' (ctx : Context) (x : Var) (e : Expr) (p : Poly)
+    : eq_def'_cert x e p → x.denote ctx = e.denote ctx → p.denote' ctx = 0 := by
+  simp [eq_def'_cert]; intro _ h; subst p; simp [h]
+  rw [← Int.sub_eq_add_neg, Int.sub_self]
+
 end Int.Linear
 
 theorem Int.not_le_eq (a b : Int) : (¬a ≤ b) = (b + 1 ≤ a) := by

src/Init/Data/Int/OfNat.lean

@@ -6,6 +6,7 @@ Authors: Leonardo de Moura
 prelude
 import Init.Data.Int.Lemmas
 import Init.Data.Int.DivMod
+import Init.Data.Int.Linear
 import Init.Data.RArray
 
 namespace Int.OfNat
@@ -47,6 +48,9 @@ def Expr.denoteAsInt (ctx : Context) : Expr → Int
 theorem Expr.denoteAsInt_eq (ctx : Context) (e : Expr) : e.denoteAsInt ctx = e.denote ctx := by
   induction e <;> simp [denote, denoteAsInt, Int.ofNat_ediv, *] <;> rfl
 
+theorem Expr.eq_denoteAsInt (ctx : Context) (e : Expr) : e.denote ctx = e.denoteAsInt ctx := by
+  apply Eq.symm; apply denoteAsInt_eq
+
 theorem Expr.eq (ctx : Context) (lhs rhs : Expr)
     : (lhs.denote ctx = rhs.denote ctx) = (lhs.denoteAsInt ctx = rhs.denoteAsInt ctx) := by
   simp [denoteAsInt_eq, Int.ofNat_inj]
@@ -84,7 +88,7 @@ theorem ofNat_toNat (a : Int) : (NatCast.natCast a.toNat : Int) = if a ≤ 0 the
     have := Int.toNat_of_nonneg (Int.le_of_lt h)
     assumption
 
-theorem Expr.denoteAsInt_nonneg (ctx : Context) (e : Expr) : e.denoteAsInt ctx ≥ 0 := by
+theorem Expr.denoteAsInt_nonneg (ctx : Context) (e : Expr) : 0 ≤ e.denoteAsInt ctx := by
   simp [Expr.denoteAsInt_eq]
 
 end Int.OfNat

src/Init/Data/Int/Order.lean

@@ -84,6 +84,11 @@ theorem ofNat_succ_pos (n : Nat) : 0 < (succ n : Int) := ofNat_lt.2 <| Nat.succ_
 @[simp] protected theorem le_refl (a : Int) : a ≤ a :=
   le.intro _ (Int.add_zero a)
 
+protected theorem le_rfl {a : Int} : a ≤ a := a.le_refl
+
+protected theorem le_of_eq {a b : Int} (hab : a = b) : a ≤ b := by rw [hab]; exact Int.le_rfl
+protected theorem ge_of_eq {a b : Int} (hab : a = b) : b ≤ a := Int.le_of_eq hab.symm
+
 protected theorem le_trans {a b c : Int} (h₁ : a ≤ b) (h₂ : b ≤ c) : a ≤ c :=
   let ⟨n, hn⟩ := le.dest h₁; let ⟨m, hm⟩ := le.dest h₂
   le.intro (n + m) <| by rw [← hm, ← hn, Int.add_assoc, ofNat_add]
@@ -94,6 +99,9 @@ protected theorem le_antisymm {a b : Int} (h₁ : a ≤ b) (h₂ : b ≤ a) : a
   have := Int.ofNat.inj <| Int.add_left_cancel <| this.trans (Int.add_zero _).symm
   rw [← hn, Nat.eq_zero_of_add_eq_zero_left this, ofNat_zero, Int.add_zero a]
 
+protected theorem le_antisymm_iff {a b : Int} : a = b ↔ a ≤ b ∧ b ≤ a :=
+  ⟨fun h ↦ ⟨Int.le_of_eq h, Int.ge_of_eq h⟩, fun h ↦ Int.le_antisymm h.1 h.2⟩
+
 @[simp] protected theorem lt_irrefl (a : Int) : ¬a < a := fun H =>
   let ⟨n, hn⟩ := lt.dest H
   have : (a+Nat.succ n) = a+0 := by
@@ -119,6 +127,12 @@ protected theorem lt_succ (a : Int) : a < a + 1 := Int.le_refl _
 
 protected theorem zero_lt_one : (0 : Int) < 1 := ⟨_⟩
 
+protected theorem one_pos : 0 < (1 : Int) := Int.zero_lt_one
+
+protected theorem one_ne_zero : (1 : Int) ≠ 0 := by decide
+
+protected theorem one_nonneg : 0 ≤ (1 : Int) := Int.le_of_lt Int.zero_lt_one
+
 protected theorem lt_iff_le_not_le {a b : Int} : a < b ↔ a ≤ b ∧ ¬b ≤ a := by
   rw [Int.lt_iff_le_and_ne]
   constructor <;> refine fun ⟨h, h'⟩ => ⟨h, h'.imp fun h' => ?_⟩
@@ -137,6 +151,10 @@ protected theorem not_le_of_gt {a b : Int} (h : b < a) : ¬a ≤ b :=
 @[simp] protected theorem not_lt {a b : Int} : ¬a < b ↔ b ≤ a :=
   by rw [← Int.not_le, Decidable.not_not]
 
+protected theorem lt_asymm {a b : Int} : a < b → ¬ b < a := by rw [Int.not_lt]; exact Int.le_of_lt
+
+protected theorem lt_or_le (a b : Int) : a < b ∨ b ≤ a := by rw [← Int.not_lt]; exact Decidable.em _
+
 protected theorem le_of_not_gt {a b : Int} (h : ¬ a > b) : a ≤ b :=
   Int.not_lt.mp h
 
@@ -161,12 +179,23 @@ protected theorem ne_iff_lt_or_gt {a b : Int} : a ≠ b ↔ a < b ∨ b < a := b
 
 protected theorem lt_or_gt_of_ne {a b : Int} : a ≠ b →  a < b ∨ b < a:= Int.ne_iff_lt_or_gt.mp
 
+protected theorem lt_or_lt_of_ne {a b : Int} : a ≠ b → a < b ∨ b < a := Int.lt_or_gt_of_ne
+
 protected theorem eq_iff_le_and_ge {x y : Int} : x = y ↔ x ≤ y ∧ y ≤ x := by
   constructor
   · simp_all
   · intro ⟨h₁, h₂⟩
     exact Int.le_antisymm h₁ h₂
 
+protected theorem le_iff_eq_or_lt {a b : Int} : a ≤ b ↔ a = b ∨ a < b :=
+  match Int.lt_trichotomy a b with
+  | Or.inl h => by simp [h, Int.le_of_lt]
+  | Or.inr (Or.inl h) => by simp [h]
+  | Or.inr (Or.inr h) => by simp [h, Int.not_le_of_gt, Int.ne_of_gt, Int.le_of_lt]
+
+protected theorem le_iff_lt_or_eq {a b : Int} : a ≤ b ↔ a < b ∨ a = b := by
+  rw [Int.le_iff_eq_or_lt, or_comm]
+
 protected theorem lt_of_le_of_lt {a b c : Int} (h₁ : a ≤ b) (h₂ : b < c) : a < c :=
   Int.not_le.1 fun h => Int.not_le.2 h₂ (Int.le_trans h h₁)
 
@@ -283,9 +312,8 @@ protected theorem neg_lt_neg {a b : Int} (h : a < b) : -b < -a := by
 @[simp] protected theorem zero_lt_neg_iff {a : Int} : 0 < -a ↔ a < 0 := by
   rw [← Int.neg_zero, Int.neg_lt_neg_iff, Int.neg_zero]
 
-protected theorem neg_neg_of_pos {a : Int} (h : 0 < a) : -a < 0 := by
-  have : -a < -0 := Int.neg_lt_neg h
-  rwa [Int.neg_zero] at this
+protected theorem neg_neg_of_pos {a : Int} (h : 0 < a) : -a < 0 :=
+  Int.neg_lt_zero_iff.2 h
 
 protected theorem neg_pos_of_neg {a : Int} (h : a < 0) : 0 < -a := by
   have : -0 < -a := Int.neg_lt_neg h
@@ -329,9 +357,9 @@ protected theorem le_iff_lt_add_one {a b : Int} : a ≤ b ↔ a < b + 1 := by
 
 /- ### min and max -/
 
-protected theorem min_def (n m : Int) : min n m = if n ≤ m then n else m := rfl
+@[grind =] protected theorem min_def (n m : Int) : min n m = if n ≤ m then n else m := rfl
 
-protected theorem max_def (n m : Int) : max n m = if n ≤ m then m else n := rfl
+@[grind =] protected theorem max_def (n m : Int) : max n m = if n ≤ m then m else n := rfl
 
 @[simp] protected theorem neg_min_neg (a b : Int) : min (-a) (-b) = -max a b := by
   rw [Int.min_def, Int.max_def]
@@ -507,7 +535,17 @@ protected theorem mul_le_mul_of_nonpos_left {a b c : Int}
 
 /- ## natAbs -/
 
-@[simp, norm_cast] theorem natAbs_ofNat (n : Nat) : natAbs ↑n = n := rfl
+@[simp, norm_cast] theorem natAbs_natCast (n : Nat) : natAbs ↑n = n := rfl
+
+@[deprecated natAbs_natCast (since := "2025-04-16")]
+theorem natAbs_ofNat (n : Nat) : natAbs ↑n = n := natAbs_natCast n
+
+/-
+TODO: rename `natAbs_ofNat'` to `natAbs_ofNat` once the current deprecated alias
+`natAbs_ofNat := natAbs_natCast` is removed
+-/
+@[simp] theorem natAbs_ofNat' (n : Nat) : natAbs (ofNat n) = n := rfl
+
 @[simp] theorem natAbs_negSucc (n : Nat) : natAbs -[n+1] = n.succ := rfl
 @[simp] theorem natAbs_zero : natAbs (0 : Int) = (0 : Nat) := rfl
 @[simp] theorem natAbs_one : natAbs (1 : Int) = (1 : Nat) := rfl
@@ -518,7 +556,8 @@ protected theorem mul_le_mul_of_nonpos_left {a b c : Int}
     | -[_+1]  => absurd H (succ_ne_zero _),
   fun e => e ▸ rfl⟩
 
-theorem natAbs_pos : 0 < natAbs a ↔ a ≠ 0 := by rw [Nat.pos_iff_ne_zero, Ne, natAbs_eq_zero]
+@[simp] theorem natAbs_pos : 0 < natAbs a ↔ a ≠ 0 := by
+  rw [Nat.pos_iff_ne_zero, Ne, natAbs_eq_zero]
 
 @[simp] theorem natAbs_neg : ∀ (a : Int), natAbs (-a) = natAbs a
   | 0      => rfl
@@ -552,6 +591,9 @@ theorem natAbs_of_nonneg {a : Int} (H : 0 ≤ a) : (natAbs a : Int) = a :=
 theorem ofNat_natAbs_of_nonpos {a : Int} (H : a ≤ 0) : (natAbs a : Int) = -a := by
   rw [← natAbs_neg, natAbs_of_nonneg (Int.neg_nonneg_of_nonpos H)]
 
+theorem eq_neg_natAbs_of_nonpos {a : Int} (h : a ≤ 0) : a = -natAbs a := by
+  rw [ofNat_natAbs_of_nonpos h, Int.neg_neg]
+
 theorem natAbs_sub_of_nonneg_of_le {a b : Int} (h₁ : 0 ≤ b) (h₂ : b ≤ a) :
     (a - b).natAbs = a.natAbs - b.natAbs := by
   rw [← Int.ofNat_inj]
@@ -559,6 +601,16 @@ theorem natAbs_sub_of_nonneg_of_le {a b : Int} (h₁ : 0 ≤ b) (h₂ : b ≤ a)
   · rwa [← Int.ofNat_le, natAbs_of_nonneg h₁, natAbs_of_nonneg (Int.le_trans h₁ h₂)]
   · exact Int.sub_nonneg_of_le h₂
 
+theorem eq_zero_of_dvd_of_natAbs_lt_natAbs {d n : Int} (h : d ∣ n) (h₁ : n.natAbs < d.natAbs) :
+    n = 0 := by
+  let ⟨a, ha⟩ := h
+  subst ha
+  rw [natAbs_mul] at h₁
+  suffices ¬ 0 < a.natAbs by simp [Int.natAbs_eq_zero.1 (Nat.eq_zero_of_not_pos this)]
+  refine fun h => Nat.lt_irrefl _ (Nat.lt_of_le_of_lt ?_ h₁)
+  rw (occs := [1]) [← Nat.mul_one d.natAbs]
+  exact Nat.mul_le_mul (Nat.le_refl _) h
+
 /-! ### toNat -/
 
 theorem toNat_eq_max : ∀ a : Int, (toNat a : Int) = max a 0
@@ -572,12 +624,18 @@ theorem toNat_eq_max : ∀ a : Int, (toNat a : Int) = max a 0
 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_natCast (n : Nat) : toNat ↑n = n := rfl
+
+@[deprecated toNat_natCast (since := "2025-04-16")]
+theorem toNat_ofNat (n : Nat) : toNat ↑n = n := toNat_natCast n
 
 @[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 toNat_natCast_add_one {n : Nat} : ((n : Int) + 1).toNat = n + 1 := rfl
+
+@[deprecated toNat_natCast_add_one (since := "2025-04-16")]
+theorem toNat_ofNat_add_one {n : Nat} : ((n : Int) + 1).toNat = n + 1 := toNat_natCast_add_one
 
 @[simp] theorem ofNat_toNat (a : Int) : (a.toNat : Int) = max a 0 := by
   match a with
@@ -596,6 +654,18 @@ theorem toNat_add {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : (a + b).toNat = a.
   match a, b, eq_ofNat_of_zero_le ha, eq_ofNat_of_zero_le hb with
   | _, _, ⟨_, rfl⟩, ⟨_, rfl⟩ => rfl
 
+theorem toNat_mul {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : (a * b).toNat = a.toNat * b.toNat :=
+  match a, b, eq_ofNat_of_zero_le ha, eq_ofNat_of_zero_le hb with
+  | _, _, ⟨_, rfl⟩, ⟨_, rfl⟩ => rfl
+
+/--
+Variant of `Int.toNat_sub` taking non-negativity hypotheses,
+rather than expecting the arguments to be casts of natural numbers.
+-/
+theorem toNat_sub'' {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : (a - b).toNat = a.toNat - b.toNat :=
+  match a, b, eq_ofNat_of_zero_le ha, eq_ofNat_of_zero_le hb with
+  | _, _, ⟨_, rfl⟩, ⟨_, rfl⟩ => toNat_sub _ _
+
 theorem toNat_add_nat {a : Int} (ha : 0 ≤ a) (n : Nat) : (a + n).toNat = a.toNat + n :=
   match a, eq_ofNat_of_zero_le ha with | _, ⟨_, rfl⟩ => rfl
 
@@ -743,6 +813,16 @@ protected theorem neg_lt_of_neg_lt {a b : Int} (h : -a < b) : -b < a := by
   have h := Int.neg_lt_neg h
   rwa [Int.neg_neg] at h
 
+@[simp high]
+protected theorem neg_pos : 0 < -a ↔ a < 0 := ⟨Int.neg_of_neg_pos, Int.neg_pos_of_neg⟩
+
+@[simp high]
+protected theorem neg_nonneg : 0 ≤ -a ↔ a ≤ 0 :=
+  ⟨Int.nonpos_of_neg_nonneg, Int.neg_nonneg_of_nonpos⟩
+
+@[simp high]
+protected theorem neg_neg_iff_pos : -a < 0 ↔ 0 < a := ⟨Int.pos_of_neg_neg, Int.neg_neg_of_pos⟩
+
 protected theorem sub_nonpos_of_le {a b : Int} (h : a ≤ b) : a - b ≤ 0 := by
   have h := Int.add_le_add_right h (-b)
   rwa [Int.add_right_neg] at h
@@ -755,6 +835,14 @@ protected theorem sub_neg_of_lt {a b : Int} (h : a < b) : a - b < 0 := by
   have h := Int.add_lt_add_right h (-b)
   rwa [Int.add_right_neg] at h
 
+@[simp high]
+protected theorem sub_pos {a b : Int} : 0 < a - b ↔ b < a :=
+  ⟨Int.lt_of_sub_pos, Int.sub_pos_of_lt⟩
+
+@[simp high]
+protected theorem sub_nonneg {a b : Int} : 0 ≤ a - b ↔ b ≤ a :=
+  ⟨Int.le_of_sub_nonneg, Int.sub_nonneg_of_le⟩
+
 protected theorem lt_of_sub_neg {a b : Int} (h : a - b < 0) : a < b := by
   have h := Int.add_lt_add_right h b
   rwa [Int.sub_add_cancel, Int.zero_add] at h
@@ -995,6 +1083,33 @@ theorem le_sub_one_of_lt {a b : Int} (H : a < b) : a ≤ b - 1 := Int.le_sub_rig
 
 theorem lt_of_le_sub_one {a b : Int} (H : a ≤ b - 1) : a < b := Int.add_le_of_le_sub_right H
 
+theorem le_add_one_iff {m n : Int} : m ≤ n + 1 ↔ m ≤ n ∨ m = n + 1 := by
+  rw [Int.le_iff_lt_or_eq, ← Int.le_iff_lt_add_one]
+
+theorem sub_one_lt_iff {m n : Int} : m - 1 < n ↔ m ≤ n :=
+  ⟨le_of_sub_one_lt, sub_one_lt_of_le⟩
+
+theorem le_sub_one_iff {m n : Int} : m ≤ n - 1 ↔ m < n :=
+  ⟨lt_of_le_sub_one, le_sub_one_of_lt⟩
+
+protected theorem add_le_iff_le_sub {a b c : Int} : a + b ≤ c ↔ a ≤ c - b :=
+  ⟨Int.le_sub_right_of_add_le, Int.add_le_of_le_sub_right⟩
+
+protected theorem le_add_iff_sub_le {a b c : Int} : a ≤ b + c ↔ a - c ≤ b :=
+  ⟨Int.sub_right_le_of_le_add, Int.le_add_of_sub_right_le⟩
+
+protected theorem add_le_zero_iff_le_neg {a b : Int} : a + b ≤ 0 ↔ a ≤ -b := by
+  rw [Int.add_le_iff_le_sub, Int.zero_sub]
+
+protected theorem add_le_zero_iff_le_neg' {a b : Int} : a + b ≤ 0 ↔ b ≤ -a := by
+  rw [Int.add_comm, Int.add_le_zero_iff_le_neg]
+
+protected theorem add_nonnneg_iff_neg_le {a b : Int} : 0 ≤ a + b ↔ -b ≤ a := by
+  rw [Int.le_add_iff_sub_le, Int.zero_sub]
+
+protected theorem add_nonnneg_iff_neg_le' {a b : Int} : 0 ≤ a + b ↔ -a ≤ b := by
+  rw [Int.add_comm, Int.add_nonnneg_iff_neg_le]
+
 /- ### Order properties and multiplication -/
 
 protected theorem mul_lt_mul {a b c d : Int}
@@ -1070,13 +1185,21 @@ theorem sign_neg_one : sign (-1) = -1 := rfl
 theorem natAbs_sign (z : Int) : z.sign.natAbs = if z = 0 then 0 else 1 :=
   match z with | 0 | succ _ | -[_+1] => rfl
 
-theorem natAbs_sign_of_nonzero {z : Int} (hz : z ≠ 0) : z.sign.natAbs = 1 := by
+theorem natAbs_sign_of_ne_zero {z : Int} (hz : z ≠ 0) : z.sign.natAbs = 1 := by
   rw [Int.natAbs_sign, if_neg hz]
 
-theorem sign_ofNat_of_nonzero {n : Nat} (hn : n ≠ 0) : Int.sign n = 1 :=
+@[deprecated natAbs_sign_of_ne_zero (since := "2025-04-16")]
+theorem natAbs_sign_of_nonzero {z : Int} (hz : z ≠ 0) : z.sign.natAbs = 1 :=
+  natAbs_sign_of_ne_zero hz
+
+theorem sign_natCast_of_ne_zero {n : Nat} (hn : n ≠ 0) : Int.sign n = 1 :=
   match n, Nat.exists_eq_succ_of_ne_zero hn with
   | _, ⟨n, rfl⟩ => Int.sign_of_add_one n
 
+@[deprecated sign_natCast_of_ne_zero (since := "2025-04-16")]
+theorem sign_ofNat_of_nonzero {n : Nat} (hn : n ≠ 0) : Int.sign n = 1 :=
+  sign_natCast_of_ne_zero hn
+
 @[simp] theorem sign_neg (z : Int) : Int.sign (-z) = -Int.sign z := by
   match z with | 0 | succ _ | -[_+1] => rfl
 
@@ -1158,7 +1281,7 @@ theorem neg_of_sign_eq_neg_one : ∀ {a : Int}, sign a = -1 → a < 0
 
 @[deprecated mul_sign_self (since := "2025-02-24")] abbrev mul_sign := @mul_sign_self
 
-@[simp] theorem sign_mul_self : sign i * i = natAbs i := by
+@[simp] theorem sign_mul_self (i : Int) : sign i * i = natAbs i := by
   rw [Int.mul_comm, mul_sign_self]
 
 theorem sign_trichotomy (a : Int) : sign a = 1 ∨ sign a = 0 ∨ sign a = -1 := by
@@ -1184,15 +1307,15 @@ theorem natAbs_mul_natAbs_eq {a b : Int} {c : Nat}
   rw [← Int.ofNat_mul, natAbs_mul_self]
 
 theorem natAbs_eq_iff {a : Int} {n : Nat} : a.natAbs = n ↔ a = n ∨ a = -↑n := by
-  rw [← Int.natAbs_eq_natAbs_iff, Int.natAbs_ofNat]
+  rw [← Int.natAbs_eq_natAbs_iff, Int.natAbs_natCast]
 
 theorem natAbs_add_le (a b : Int) : natAbs (a + b) ≤ natAbs a + natAbs b := by
   suffices ∀ a b : Nat, natAbs (subNatNat a b.succ) ≤ (a + b).succ by
     match a, b with
-    | (a:Nat), (b:Nat) => rw [← ofNat_add, natAbs_ofNat]; apply Nat.le_refl
-    | (a:Nat), -[b+1]  => rw [natAbs_ofNat, natAbs_negSucc]; apply this
+    | (a:Nat), (b:Nat) => rw [← ofNat_add, natAbs_natCast]; apply Nat.le_refl
+    | (a:Nat), -[b+1]  => rw [natAbs_natCast, natAbs_negSucc]; apply this
     | -[a+1],  (b:Nat) =>
-      rw [natAbs_negSucc, natAbs_ofNat, Nat.succ_add, Nat.add_comm a b]; apply this
+      rw [natAbs_negSucc, natAbs_natCast, Nat.succ_add, Nat.add_comm a b]; apply this
     | -[a+1],  -[b+1]  => rw [natAbs_negSucc, succ_add]; apply Nat.le_refl
   refine fun a b => subNatNat_elim a b.succ
     (fun m n i => n = b.succ → natAbs i ≤ (m + b).succ) ?_
@@ -1208,6 +1331,15 @@ theorem natAbs_add_le (a b : Int) : natAbs (a + b) ≤ natAbs a + natAbs b := by
 theorem natAbs_sub_le (a b : Int) : natAbs (a - b) ≤ natAbs a + natAbs b := by
   rw [← Int.natAbs_neg b]; apply natAbs_add_le
 
+theorem natAbs_add_of_nonneg : ∀ {a b : Int}, 0 ≤ a → 0 ≤ b → natAbs (a + b) = natAbs a + natAbs b
+  | ofNat _, ofNat _, _, _ => rfl
+
+theorem natAbs_add_of_nonpos {a b : Int} (ha : a ≤ 0) (hb : b ≤ 0) :
+    natAbs (a + b) = natAbs a + natAbs b := by
+  rw [← Int.neg_neg a, ← Int.neg_neg b, ← Int.neg_add, natAbs_neg,
+    natAbs_add_of_nonneg (Int.neg_nonneg_of_nonpos ha) (Int.neg_nonneg_of_nonpos hb),
+    natAbs_neg (-a), natAbs_neg (-b)]
+
 @[deprecated negSucc_eq (since := "2025-03-11")]
 theorem negSucc_eq' (m : Nat) : -[m+1] = -m - 1 := by simp only [negSucc_eq, Int.neg_add]; rfl
 

src/Init/Data/Int/Pow.lean

@@ -17,6 +17,16 @@ protected theorem pow_succ (b : Int) (e : Nat) : b ^ (e+1) = (b ^ e) * b := rfl
 protected theorem pow_succ' (b : Int) (e : Nat) : b ^ (e+1) = b * (b ^ e) := by
   rw [Int.mul_comm, Int.pow_succ]
 
+protected theorem pow_pos {n : Int} {m : Nat} : 0 < n → 0 < n ^ m := by
+  induction m with
+  | zero => simp
+  | succ m ih => exact fun h => Int.mul_pos (ih h) h
+
+protected theorem pow_nonneg {n : Int} {m : Nat} : 0 ≤ n → 0 ≤ n ^ m := by
+  induction m with
+  | zero => simp
+  | succ m ih => exact fun h => Int.mul_nonneg (ih h) h
+
 @[deprecated Nat.pow_le_pow_left (since := "2025-02-17")]
 abbrev pow_le_pow_of_le_left := @Nat.pow_le_pow_left
 
@@ -26,7 +36,7 @@ abbrev pow_le_pow_of_le_right := @Nat.pow_le_pow_right
 @[deprecated Nat.pow_pos (since := "2025-02-17")]
 abbrev pos_pow_of_pos := @Nat.pow_pos
 
-@[norm_cast]
+@[simp, norm_cast]
 protected theorem natCast_pow (b n : Nat) : ((b^n : Nat) : Int) = (b : Int) ^ n := by
   match n with
   | 0 => rfl
@@ -44,6 +54,17 @@ protected theorem two_pow_pred_sub_two_pow' {w : Nat} (h : 0 < w) :
     (2 : Int) ^ (w - 1) - (2 : Int) ^ w = - (2 : Int) ^ (w - 1) := by
   norm_cast
   rw [← Nat.two_pow_pred_add_two_pow_pred h]
-  simp [h]
+  simp [h, -Int.natCast_pow]
+
+theorem pow_lt_pow_of_lt {a : Int} {b c : Nat} (ha : 1 < a) (hbc : b < c):
+    a ^ b < a ^ c := by
+  rw [← Int.toNat_of_nonneg (a := a) (by omega), ← Int.natCast_pow, ← Int.natCast_pow]
+  have := Nat.pow_lt_pow_of_lt (a := a.toNat) (m := c) (n := b)
+  simp only [Int.ofNat_lt]
+  omega
+
+@[simp] theorem natAbs_pow (n : Int) : (k : Nat) → (n ^ k).natAbs = n.natAbs ^ k
+  | 0 => rfl
+  | k + 1 => by rw [Int.pow_succ, natAbs_mul, natAbs_pow, Nat.pow_succ]
 
 end Int

src/Init/Data/List/Attach.lean

@@ -65,9 +65,9 @@ well-founded recursion mechanism to prove that the function terminates.
   | cons _ l', hL' => congrArg _ <| go l' fun _ hx => hL' (.tail _ hx)
   exact go l h'
 
-@[simp] theorem pmap_nil {P : α → Prop} (f : ∀ a, P a → β) : pmap f [] (by simp) = [] := rfl
+@[simp] theorem pmap_nil {P : α → Prop} {f : ∀ a, P a → β} : pmap f [] (by simp) = [] := rfl
 
-@[simp] theorem pmap_cons {P : α → Prop} (f : ∀ a, P a → β) (a : α) (l : List α) (h : ∀ b ∈ a :: l, P b) :
+@[simp] theorem pmap_cons {P : α → Prop} {f : ∀ a, P a → β} {a : α} {l : List α} (h : ∀ b ∈ a :: l, P b) :
     pmap f (a :: l) h = f a (forall_mem_cons.1 h).1 :: pmap f l (forall_mem_cons.1 h).2 := rfl
 
 @[simp] theorem attach_nil : ([] : List α).attach = [] := rfl
@@ -75,7 +75,7 @@ well-founded recursion mechanism to prove that the function terminates.
 @[simp] theorem attachWith_nil : ([] : List α).attachWith P H = [] := rfl
 
 @[simp]
-theorem pmap_eq_map (p : α → Prop) (f : α → β) (l : List α) (H) :
+theorem pmap_eq_map {p : α → Prop} {f : α → β} {l : List α} (H) :
     @pmap _ _ p (fun a _ => f a) l H = map f l := by
   induction l
   · rfl
@@ -86,18 +86,18 @@ theorem pmap_congr_left {p q : α → Prop} {f : ∀ a, p a → β} {g : ∀ a,
   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)]
+    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
 
-theorem map_pmap {p : α → Prop} (g : β → γ) (f : ∀ a, p a → β) (l H) :
+theorem map_pmap {p : α → Prop} {g : β → γ} {f : ∀ a, p a → β} {l : List α} (H) :
     map g (pmap f l H) = pmap (fun a h => g (f a h)) l H := by
   induction l
   · rfl
   · simp only [*, pmap, map]
 
-theorem pmap_map {p : β → Prop} (g : ∀ b, p b → γ) (f : α → β) (l H) :
-    pmap g (map f l) H = pmap (fun a h => g (f a) h) l fun _ h => H _ (mem_map_of_mem _ h) := by
+theorem pmap_map {p : β → Prop} {g : ∀ b, p b → γ} {f : α → β} {l : List α} (H) :
+    pmap g (map f l) H = pmap (fun a h => g (f a) h) l fun _ h => H _ (mem_map_of_mem h) := by
   induction l
   · rfl
   · simp only [*, pmap, map]
@@ -114,7 +114,7 @@ theorem attachWith_congr {l₁ l₂ : List α} (w : l₁ = l₂) {P : α → Pro
 
 @[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
+      ⟨x, mem_cons_self⟩ :: 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' _
@@ -122,42 +122,43 @@ theorem attachWith_congr {l₁ l₂ : List α} (w : l₁ = l₂) {P : α → Pro
 
 @[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)⟩ ::
+    (x :: xs).attachWith p h = ⟨x, h x (mem_cons_self)⟩ ::
       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) :
+theorem pmap_eq_map_attach {p : α → Prop} {f : ∀ a, p a → β} {l : List α} (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
 
 @[simp]
-theorem pmap_eq_attachWith {p q : α → Prop} (f : ∀ a, p a → q a) (l H) :
+theorem pmap_eq_attachWith {p q : α → Prop} {f : ∀ a, p a → q a} {l : List α} (H) :
     pmap (fun a h => ⟨a, f a h⟩) l H = l.attachWith q (fun x h => f x (H x h)) := by
   induction l with
   | nil => rfl
   | cons a l ih =>
     simp [pmap, attachWith, ih]
 
-theorem attach_map_val (l : List α) (f : α → β) :
+theorem attach_map_val {l : List α} {f : α → β} :
     (l.attach.map fun (i : {i // i ∈ l}) => f i) = l.map f := by
-  rw [attach, attachWith, map_pmap]; exact pmap_eq_map _ _ _ _
+  rw [attach, attachWith, map_pmap]; exact pmap_eq_map _
 
 @[deprecated attach_map_val (since := "2025-02-17")]
 abbrev attach_map_coe := @attach_map_val
 
+-- The argument `l : List α` is explicit to allow rewriting from right to left.
 theorem attach_map_subtype_val (l : List α) : l.attach.map Subtype.val = l :=
-  (attach_map_val _ _).trans (List.map_id _)
+  attach_map_val.trans (List.map_id _)
 
-theorem attachWith_map_val {p : α → Prop} (f : α → β) (l : List α) (H : ∀ a ∈ l, p a) :
+theorem attachWith_map_val {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 _ _ _ _
+  rw [attachWith, map_pmap]; exact pmap_eq_map _
 
 @[deprecated attachWith_map_val (since := "2025-02-17")]
 abbrev attachWith_map_coe := @attachWith_map_val
 
-theorem attachWith_map_subtype_val {p : α → Prop} (l : List α) (H : ∀ a ∈ l, p a) :
+theorem attachWith_map_subtype_val {p : α → Prop} {l : List α} (H : ∀ a ∈ l, p a) :
     (l.attachWith p H).map Subtype.val = l :=
-  (attachWith_map_val _ _ _).trans (List.map_id _)
+  (attachWith_map_val _).trans (List.map_id _)
 
 @[simp]
 theorem mem_attach (l : List α) : ∀ x, x ∈ l.attach
@@ -167,7 +168,7 @@ theorem mem_attach (l : List α) : ∀ x, x ∈ l.attach
     exact m
 
 @[simp]
-theorem mem_attachWith (l : List α) {q : α → Prop} (H) (x : {x // q x}) :
+theorem mem_attachWith {l : List α} {q : α → Prop} (H) (x : {x // q x}) :
     x ∈ l.attachWith q H ↔ x.1 ∈ l := by
   induction l with
   | nil => simp
@@ -240,7 +241,7 @@ theorem attachWith_ne_nil_iff {l : List α} {P : α → Prop} {H : ∀ a ∈ l,
 @[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) (i : Nat) :
+theorem getElem?_pmap {p : α → Prop} {f : ∀ a, p a → β} {l : List α} (h : ∀ a ∈ l, p a) (i : Nat) :
     (pmap f l h)[i]? = Option.pmap f l[i]? fun x H => h x (mem_of_getElem? H) := by
   induction l generalizing i with
   | nil => simp
@@ -257,6 +258,7 @@ theorem get?_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h :
   simp only [get?_eq_getElem?]
   simp [getElem?_pmap, h]
 
+-- The argument `f` is explicit to allow rewriting from right to left.
 @[simp]
 theorem getElem_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h : ∀ a ∈ l, p a) {i : Nat}
     (hn : i < (pmap f l h).length) :
@@ -302,19 +304,19 @@ 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 pmap_attach (l : List α) {p : {x // x ∈ l} → Prop} (f : ∀ a, p a → β) (H) :
+@[simp] theorem pmap_attach {l : List α} {p : {x // x ∈ l} → Prop} {f : ∀ a, p a → β} (H) :
     pmap f l.attach H =
       l.pmap (P := fun a => ∃ h : a ∈ l, p ⟨a, h⟩)
         (fun a h => f ⟨a, h.1⟩ h.2) (fun a h => ⟨h, H ⟨a, h⟩ (by simp)⟩) := by
   apply ext_getElem <;> simp
 
-@[simp] theorem pmap_attachWith (l : List α) {p : {x // q x} → Prop} (f : ∀ a, p a → β) (H₁ H₂) :
+@[simp] theorem pmap_attachWith {l : List α} {p : {x // q x} → Prop} {f : ∀ a, p a → β} (H₁ H₂) :
     pmap f (l.attachWith q H₁) H₂ =
       l.pmap (P := fun a => ∃ h : q a, p ⟨a, h⟩)
         (fun a h => f ⟨a, h.1⟩ h.2) (fun a h => ⟨H₁ _ h, H₂ ⟨a, H₁ _ h⟩ (by simpa)⟩) := by
   apply ext_getElem <;> simp
 
-@[simp] theorem head?_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
+@[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
@@ -323,7 +325,7 @@ theorem getElem_attach {xs : List α} {i : Nat} (h : i < xs.attach.length) :
     simp at ih
     simp [head?_pmap, ih]
 
-@[simp] theorem head_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
+@[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
@@ -332,7 +334,7 @@ theorem getElem_attach {xs : List α} {i : Nat} (h : i < xs.attach.length) :
 
 @[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
+    (xs.attachWith P H).head? = xs.head?.pbind (fun a h => some ⟨a, H _ (mem_of_head? h)⟩) := by
   cases xs <;> simp_all
 
 @[simp] theorem head_attachWith {P : α → Prop} {xs : List α}
@@ -342,8 +344,8 @@ theorem getElem_attach {xs : List α} {i : Nat} (h : i < xs.attach.length) :
   | 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
+@[simp] theorem head?_attach {xs : List α} :
+    xs.attach.head? = xs.head?.pbind (fun a h => some ⟨a, mem_of_head? h⟩) := by
   cases xs <;> simp_all
 
 @[simp] theorem head_attach {xs : List α} (h) :
@@ -352,7 +354,7 @@ theorem getElem_attach {xs : List α} {i : Nat} (h : i < xs.attach.length) :
   | nil => simp at h
   | cons x xs => simp [head_attach, h]
 
-@[simp] theorem tail_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
+@[simp] theorem tail_pmap {P : α → Prop} {f : (a : α) → P a → β} {xs : List α}
     (H : ∀ (a : α), a ∈ xs → P a) :
     (xs.pmap f H).tail = xs.tail.pmap f (fun a h => H a (mem_of_mem_tail h)) := by
   cases xs <;> simp
@@ -362,29 +364,29 @@ theorem getElem_attach {xs : List α} {i : Nat} (h : i < xs.attach.length) :
     (xs.attachWith P H).tail = xs.tail.attachWith P (fun a h => H a (mem_of_mem_tail h)) := by
   cases xs <;> simp
 
-@[simp] theorem tail_attach (xs : List α) :
+@[simp] theorem tail_attach {xs : List α} :
     xs.attach.tail = xs.tail.attach.map (fun ⟨x, h⟩ => ⟨x, mem_of_mem_tail h⟩) := by
   cases xs <;> simp
 
-theorem foldl_pmap (l : List α) {P : α → Prop} (f : (a : α) → P a → β)
-  (H : ∀ (a : α), a ∈ l → P a) (g : γ → β → γ) (x : γ) :
+theorem foldl_pmap {l : List α} {P : α → Prop} {f : (a : α) → P a → β}
+    (H : ∀ (a : α), a ∈ l → P a) (g : γ → β → γ) (x : γ) :
     (l.pmap f H).foldl g x = l.attach.foldl (fun acc a => g acc (f a.1 (H _ a.2))) x := by
   rw [pmap_eq_map_attach, foldl_map]
 
-theorem foldr_pmap (l : List α) {P : α → Prop} (f : (a : α) → P a → β)
-  (H : ∀ (a : α), a ∈ l → P a) (g : β → γ → γ) (x : γ) :
+theorem foldr_pmap {l : List α} {P : α → Prop} {f : (a : α) → P a → β}
+    (H : ∀ (a : α), a ∈ l → P a) (g : β → γ → γ) (x : γ) :
     (l.pmap f H).foldr g x = l.attach.foldr (fun a acc => g (f a.1 (H _ a.2)) acc) x := by
   rw [pmap_eq_map_attach, foldr_map]
 
 @[simp] theorem foldl_attachWith
-    (l : List α) {q : α → Prop} (H : ∀ a, a ∈ l → q a) {f : β → { x // q x} → β} {b} :
+    {l : List α} {q : α → Prop} (H : ∀ a, a ∈ l → q a) {f : β → { x // q x } → β} {b} :
     (l.attachWith q H).foldl f b = l.attach.foldl (fun b ⟨a, h⟩ => f b ⟨a, H _ h⟩) b := by
   induction l generalizing b with
   | nil => simp
   | cons a l ih => simp [ih, foldl_map]
 
 @[simp] theorem foldr_attachWith
-    (l : List α) {q : α → Prop} (H : ∀ a, a ∈ l → q a) {f : { x // q x} → β → β} {b} :
+    {l : List α} {q : α → Prop} (H : ∀ a, a ∈ l → q a) {f : { x // q x } → β → β} {b} :
     (l.attachWith q H).foldr f b = l.attach.foldr (fun a acc => f ⟨a.1, H _ a.2⟩ acc) b := by
   induction l generalizing b with
   | nil => simp
@@ -400,7 +402,7 @@ Unfortunately this can't be applied by `simp` because of the higher order unific
 and even when rewriting we need to specify the function explicitly.
 See however `foldl_subtype` below.
 -/
-theorem foldl_attach (l : List α) (f : β → α → β) (b : β) :
+theorem foldl_attach {l : List α} {f : β → α → β} {b : β} :
     l.attach.foldl (fun acc t => f acc t.1) b = l.foldl f b := by
   induction l generalizing b with
   | nil => simp
@@ -416,28 +418,28 @@ Unfortunately this can't be applied by `simp` because of the higher order unific
 and even when rewriting we need to specify the function explicitly.
 See however `foldr_subtype` below.
 -/
-theorem foldr_attach (l : List α) (f : α → β → β) (b : β) :
+theorem foldr_attach {l : List α} {f : α → β → β} {b : β} :
     l.attach.foldr (fun t acc => f t.1 acc) b = l.foldr f b := by
   induction l generalizing b with
   | nil => simp
   | cons a l ih => rw [foldr_cons, attach_cons, foldr_cons, foldr_map, ih]
 
-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
+theorem attach_map {l : List α} {f : α → β} :
+    (l.map f).attach = l.attach.map (fun ⟨x, h⟩ => ⟨f x, mem_map_of_mem 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 _ h => H _ (mem_map_of_mem f h))).map
+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 _ h => H _ (mem_map_of_mem h))).map
       fun ⟨x, h⟩ => ⟨f x, h⟩ := by
   induction l <;> simp [*]
 
 @[simp] theorem map_attachWith {l : List α} {P : α → Prop} {H : ∀ (a : α), a ∈ l → P a}
-    (f : { x // P x } → β) :
+    {f : { x // P x } → β} :
     (l.attachWith P H).map f = l.attach.map fun ⟨x, h⟩ => f ⟨x, H _ h⟩ := by
   induction l <;> simp_all
 
 theorem map_attachWith_eq_pmap {l : List α} {P : α → Prop} {H : ∀ (a : α), a ∈ l → P a}
-    (f : { x // P x } → β) :
+    {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
@@ -448,7 +450,7 @@ theorem map_attachWith_eq_pmap {l : List α} {P : α → Prop} {H : ∀ (a : α)
     simp
 
 /-- See also `pmap_eq_map_attach` for writing `pmap` in terms of `map` and `attach`. -/
-theorem map_attach_eq_pmap {l : List α} (f : { x // x ∈ l } → β) :
+theorem map_attach_eq_pmap {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
@@ -468,20 +470,19 @@ theorem attach_filterMap {l : List α} {f : α → Option β} :
   | 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,
+    · simp only [Option.pbind_eq_none_iff, reduceCtorEq, 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']
+      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]
@@ -494,7 +495,7 @@ theorem attach_filterMap {l : List α} {f : α → Option β} :
 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]
+  rw [attach_congr (congrFun filterMap_eq_filter.symm _), attach_filterMap, map_filterMap]
   simp only [Option.guard]
   congr
   ext1
@@ -521,13 +522,13 @@ theorem filter_attachWith {q : α → Prop} {l : List α} {p : {x // q x} → Bo
     simp only [attachWith_cons, filter_cons]
     split <;> simp_all [Function.comp_def, filter_map]
 
-theorem pmap_pmap {p : α → Prop} {q : β → Prop} (g : ∀ a, p a → β) (f : ∀ b, q b → γ) (l H₁ H₂) :
+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 ι)
+@[simp] 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)) ++
@@ -538,13 +539,13 @@ theorem pmap_pmap {p : α → Prop} {q : β → Prop} (g : ∀ a, p a → β) (f
     dsimp only [pmap, cons_append]
     rw [ih]
 
-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₁, p a) (h₂ : ∀ a ∈ l₂, p a) :
     ((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₂ _
+  pmap_append _
 
-@[simp] theorem attach_append (xs ys : List α) :
+@[simp] theorem attach_append {xs ys : List α} :
     (xs ++ ys).attach = xs.attach.map (fun ⟨x, h⟩ => ⟨x, mem_append_left ys h⟩) ++
       ys.attach.map fun ⟨x, h⟩ => ⟨x, mem_append_right xs h⟩ := by
   simp only [attach, attachWith, pmap, map_pmap, pmap_append]
@@ -557,12 +558,12 @@ theorem pmap_append' {p : α → Prop} (f : ∀ a : α, p a → β) (l₁ l₂ :
       ys.attachWith P (fun a h => H a (mem_append_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 α)
+@[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 α)
+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]
@@ -578,21 +579,21 @@ theorem reverse_attachWith {P : α → Prop} {xs : List α}
     (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 α) :
+@[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 α) :
+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 α)
+@[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]
@@ -600,7 +601,7 @@ theorem reverse_attach (xs : List α) :
   simp only [Option.map_map]
   congr
 
-@[simp] theorem getLast_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : List α)
+@[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]
@@ -629,26 +630,26 @@ theorem getLast_attach {xs : List α} (h : xs.attach ≠ []) :
   simp only [getLast_eq_head_reverse, reverse_attach, head_map, head_attach]
 
 @[simp]
-theorem countP_attach (l : List α) (p : α → Bool) :
+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]
 
 @[simp]
-theorem countP_attachWith {p : α → Prop} (l : List α) (H : ∀ a ∈ l, p a) (q : α → Bool) :
+theorem countP_attachWith {p : α → Prop} {q : α → Bool} {l : List α} (H : ∀ a ∈ l, p a) :
     (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}) :
+theorem count_attach [BEq α] {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 _ _
+  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}) :
+theorem count_attachWith [BEq α] {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 _ _ _
+  Eq.trans (countP_congr fun _ _ => by simp [Subtype.ext_iff]) <| countP_attachWith _
 
-@[simp] theorem countP_pmap {p : α → Prop} (g : ∀ a, p a → β) (f : β → Bool) (l : List α) (H₁) :
+@[simp] theorem countP_pmap {p : α → Prop} {g : ∀ a, p a → β} {f : β → Bool} {l : List α} (H₁) :
     (l.pmap g H₁).countP f =
       l.attach.countP (fun ⟨a, m⟩ => f (g a (H₁ a m))) := by
   simp [pmap_eq_map_attach, countP_map, Function.comp_def]
@@ -835,62 +836,62 @@ and simplifies these to the function directly taking the value.
 
 /-! ### Well-founded recursion preprocessing setup -/
 
-@[wf_preprocess] theorem map_wfParam (xs : List α) (f : α → β) :
+@[wf_preprocess] theorem map_wfParam {xs : List α} {f : α → β} :
     (wfParam xs).map f = xs.attach.unattach.map f := by
   simp [wfParam]
 
-@[wf_preprocess] theorem map_unattach (P : α → Prop) (xs : List (Subtype P)) (f : α → β) :
+@[wf_preprocess] theorem map_unattach {P : α → Prop} {xs : List (Subtype P)} {f : α → β} :
     xs.unattach.map f = xs.map fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x) := by
   simp [wfParam]
 
-@[wf_preprocess] theorem foldl_wfParam (xs : List α) (f : β → α → β) (x : β) :
+@[wf_preprocess] theorem foldl_wfParam {xs : List α} {f : β → α → β} {x : β} :
     (wfParam xs).foldl f x = xs.attach.unattach.foldl f x := by
   simp [wfParam]
 
-@[wf_preprocess] theorem foldl_unattach (P : α → Prop) (xs : List (Subtype P)) (f : β → α → β) (x : β):
+@[wf_preprocess] theorem foldl_unattach {P : α → Prop} {xs : List (Subtype P)} {f : β → α → β} {x : β} :
     xs.unattach.foldl f x = xs.foldl (fun s ⟨x, h⟩ =>
       binderNameHint s f <| binderNameHint x (f s) <| binderNameHint h () <| f s (wfParam x)) x := by
   simp [wfParam]
 
-@[wf_preprocess] theorem foldr_wfParam (xs : List α) (f : α → β → β) (x : β) :
+@[wf_preprocess] theorem foldr_wfParam {xs : List α} {f : α → β → β} {x : β} :
     (wfParam xs).foldr f x = xs.attach.unattach.foldr f x := by
   simp [wfParam]
 
-@[wf_preprocess] theorem foldr_unattach (P : α → Prop) (xs : List (Subtype P)) (f : α → β → β) (x : β):
+@[wf_preprocess] theorem foldr_unattach {P : α → Prop} {xs : List (Subtype P)} {f : α → β → β} {x : β} :
     xs.unattach.foldr f x = xs.foldr (fun ⟨x, h⟩ s =>
       binderNameHint x f <| binderNameHint s (f x) <| binderNameHint h () <| f (wfParam x) s) x := by
   simp [wfParam]
 
-@[wf_preprocess] theorem filter_wfParam (xs : List α) (f : α → Bool) :
+@[wf_preprocess] theorem filter_wfParam {xs : List α} {f : α → Bool} :
     (wfParam xs).filter f = xs.attach.unattach.filter f:= by
   simp [wfParam]
 
-@[wf_preprocess] theorem filter_unattach (P : α → Prop) (xs : List (Subtype P)) (f : α → Bool) :
+@[wf_preprocess] theorem filter_unattach {P : α → Prop} {xs : List (Subtype P)} {f : α → Bool} :
     xs.unattach.filter f = (xs.filter (fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x))).unattach := by
   simp [wfParam]
 
-@[wf_preprocess] theorem reverse_wfParam (xs : List α) :
+@[wf_preprocess] theorem reverse_wfParam {xs : List α} :
     (wfParam xs).reverse = xs.attach.unattach.reverse := by simp [wfParam]
 
-@[wf_preprocess] theorem reverse_unattach (P : α → Prop) (xs : List (Subtype P)) :
+@[wf_preprocess] theorem reverse_unattach {P : α → Prop} {xs : List (Subtype P)} :
     xs.unattach.reverse = xs.reverse.unattach := by simp
 
-@[wf_preprocess] theorem filterMap_wfParam (xs : List α) (f : α → Option β) :
+@[wf_preprocess] theorem filterMap_wfParam {xs : List α} {f : α → Option β} :
     (wfParam xs).filterMap f = xs.attach.unattach.filterMap f := by
   simp [wfParam]
 
-@[wf_preprocess] theorem filterMap_unattach (P : α → Prop) (xs : List (Subtype P)) (f : α → Option β) :
+@[wf_preprocess] theorem filterMap_unattach {P : α → Prop} {xs : List (Subtype P)} {f : α → Option β} :
     xs.unattach.filterMap f = xs.filterMap fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x) := by
   simp [wfParam]
 
-@[wf_preprocess] theorem flatMap_wfParam (xs : List α) (f : α → List β) :
+@[wf_preprocess] theorem flatMap_wfParam {xs : List α} {f : α → List β} :
     (wfParam xs).flatMap f = xs.attach.unattach.flatMap f := by
   simp [wfParam]
 
-@[wf_preprocess] theorem flatMap_unattach (P : α → Prop) (xs : List (Subtype P)) (f : α → List β) :
+@[wf_preprocess] theorem flatMap_unattach {P : α → Prop} {xs : List (Subtype P)} {f : α → List β} :
     xs.unattach.flatMap f = xs.flatMap fun ⟨x, h⟩ =>
       binderNameHint x f <| binderNameHint h () <| f (wfParam x) := by
   simp [wfParam]

src/Init/Data/List/Basic.lean

@@ -76,14 +76,14 @@ namespace List
 @[simp] theorem length_nil : length ([] : List α) = 0 :=
   rfl
 
-@[simp] theorem length_singleton (a : α) : length [a] = 1 := rfl
+@[simp] theorem length_singleton {a : α} : length [a] = 1 := rfl
 
-@[simp] theorem length_cons {α} (a : α) (as : List α) : (cons a as).length = as.length + 1 :=
+@[simp] theorem length_cons {a : α} {as : List α} : (cons a as).length = as.length + 1 :=
   rfl
 
 /-! ### set -/
 
-@[simp] theorem length_set (as : List α) (i : Nat) (a : α) : (as.set i a).length = as.length := by
+@[simp] theorem length_set {as : List α} {i : Nat} {a : α} : (as.set i a).length = as.length := by
   induction as generalizing i with
   | nil => rfl
   | cons x xs ih =>
@@ -95,11 +95,11 @@ namespace List
 
 -- As `List.foldl` is defined in `Init.Prelude`, we write the basic simplification lemmas here.
 @[simp] theorem foldl_nil : [].foldl f b = b := rfl
-@[simp] theorem foldl_cons (l : List α) (b : β) : (a :: l).foldl f b = l.foldl f (f b a) := rfl
+@[simp] theorem foldl_cons {l : List α} {f : β → α → β} {b : β} : (a :: l).foldl f b = l.foldl f (f b a) := rfl
 
 /-! ### concat -/
 
-theorem length_concat (as : List α) (a : α) : (concat as a).length = as.length + 1 := by
+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]
@@ -125,12 +125,18 @@ protected def beq [BEq α] : List α → List α → Bool
   | _,     _     => false
 
 @[simp] theorem beq_nil_nil [BEq α] : List.beq ([] : List α) ([] : List α) = true := rfl
-@[simp] theorem beq_cons_nil [BEq α] (a : α) (as : List α) : List.beq (a::as) [] = false := rfl
-@[simp] theorem beq_nil_cons [BEq α] (a : α) (as : List α) : List.beq [] (a::as) = false := rfl
-theorem beq_cons₂ [BEq α] (a b : α) (as bs : List α) : List.beq (a::as) (b::bs) = (a == b && List.beq as bs) := rfl
+@[simp] theorem beq_cons_nil [BEq α] {a : α} {as : List α} : List.beq (a::as) [] = false := rfl
+@[simp] theorem beq_nil_cons [BEq α] {a : α} {as : List α} : List.beq [] (a::as) = false := rfl
+theorem beq_cons₂ [BEq α] {a b : α} {as bs : List α} : List.beq (a::as) (b::bs) = (a == b && List.beq as bs) := rfl
 
 instance [BEq α] : BEq (List α) := ⟨List.beq⟩
 
+instance [BEq α] [ReflBEq α] : ReflBEq (List α) where
+  rfl {as} := by
+    induction as with
+    | nil => rfl
+    | cons a as ih => simp [BEq.beq, List.beq]; exact ih
+
 instance [BEq α] [LawfulBEq α] : LawfulBEq (List α) where
   eq_of_beq {as bs} := by
     induction as generalizing bs with
@@ -142,10 +148,6 @@ instance [BEq α] [LawfulBEq α] : LawfulBEq (List α) where
         simp [show (a::as == b::bs) = (a == b && as == bs) from rfl, -and_imp]
         intro ⟨h₁, h₂⟩
         exact ⟨h₁, ih h₂⟩
-  rfl {as} := by
-    induction as with
-    | nil => rfl
-    | cons a as ih => simp [BEq.beq, List.beq, LawfulBEq.rfl]; exact ih
 
 /--
 Returns `true` if `as` and `bs` have the same length and they are pairwise related by `eqv`.
@@ -344,8 +346,8 @@ def getLastD : (as : List α) → (fallback : α) → α
   | 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
+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
 
 /-! ## Head and tail -/
 
@@ -357,7 +359,7 @@ Returns the first element of a non-empty list.
 def head : (as : List α) → as ≠ [] → α
   | a::_, _ => a
 
-@[simp] theorem head_cons : @head α (a::l) h = a := rfl
+@[simp] theorem head_cons {a : α} {l : List α} {h} : head (a::l) h = a := rfl
 
 /-! ### head? -/
 
@@ -375,8 +377,8 @@ def head? : List α → Option α
   | []   => none
   | a::_ => some a
 
-@[simp] theorem head?_nil : @head? α [] = none := rfl
-@[simp] theorem head?_cons : @head? α (a::l) = some a := rfl
+@[simp] theorem head?_nil : head? ([] : List α) = none := rfl
+@[simp] theorem head?_cons {a : α} {l : List α} : head? (a::l) = some a := rfl
 
 /-! ### headD -/
 
@@ -394,8 +396,8 @@ def headD : (as : List α) → (fallback : α) → α
   | [],   fallback => fallback
   | a::_, _  => a
 
-@[simp] theorem headD_nil : @headD α [] d = d := rfl
-@[simp] theorem headD_cons : @headD α (a::l) d = a := rfl
+@[simp] theorem headD_nil {d : α} : headD [] d = d := rfl
+@[simp] theorem headD_cons {a : α} {l : List α} {d : α} : headD (a::l) d = a := rfl
 
 /-! ### tail -/
 
@@ -412,8 +414,8 @@ def tail : List α → List α
   | []    => []
   | _::as => as
 
-@[simp] theorem tail_nil : @tail α [] = [] := rfl
-@[simp] theorem tail_cons : @tail α (a::as) = as := rfl
+@[simp] theorem tail_nil : tail ([] : List α) = [] := rfl
+@[simp] theorem tail_cons {a : α} {as : List α} : tail (a::as) = as := rfl
 
 /-! ### tail? -/
 
@@ -433,8 +435,8 @@ def tail? : List α → Option (List α)
   | []    => none
   | _::as => some as
 
-@[simp] theorem tail?_nil : @tail? α [] = none := rfl
-@[simp] theorem tail?_cons : @tail? α (a::l) = some l := rfl
+@[simp] theorem tail?_nil : tail? ([] : List α) = none := rfl
+@[simp] theorem tail?_cons {a : α} {l : List α} : tail? (a::l) = some l := rfl
 
 /-! ### tailD -/
 
@@ -456,8 +458,8 @@ def tailD (l fallback : List α) : List α :=
   | [] => fallback
   | _ :: tl => tl
 
-@[simp] theorem tailD_nil : @tailD α [] l' = l' := rfl
-@[simp] theorem tailD_cons : @tailD α (a::l) l' = l := rfl
+@[simp] theorem tailD_nil {l' : List α} : tailD [] l' = l' := rfl
+@[simp] theorem tailD_cons {a : α} {l : List α} {l' : List α} : tailD (a::l) l' = l := rfl
 
 /-! ## Basic `List` operations.
 
@@ -483,7 +485,7 @@ Examples:
   | a::as => f a :: map f as
 
 @[simp] theorem map_nil {f : α → β} : map f [] = [] := rfl
-@[simp] theorem map_cons (f : α → β) a l : map f (a :: l) = f a :: map f l := rfl
+@[simp] theorem map_cons {f : α → β} {a : α} {l : List α} : map f (a :: l) = f a :: map f l := rfl
 
 /-! ### filter -/
 
@@ -503,7 +505,7 @@ def filter (p : α → Bool) : (l : List α) → List α
     | true => a :: filter p as
     | false => filter p as
 
-@[simp] theorem filter_nil (p : α → Bool) : filter p [] = [] := rfl
+@[simp] theorem filter_nil {p : α → Bool} : filter p [] = [] := rfl
 
 /-! ### filterMap -/
 
@@ -529,8 +531,8 @@ Example:
     | none   => filterMap f as
     | some b => b :: filterMap f as
 
-@[simp] theorem filterMap_nil (f : α → Option β) : filterMap f [] = [] := rfl
-theorem filterMap_cons (f : α → Option β) (a : α) (l : List α) :
+@[simp] theorem filterMap_nil {f : α → Option β} : filterMap f [] = [] := rfl
+theorem filterMap_cons {f : α → Option β} {a : α} {l : List α} :
     filterMap f (a :: l) =
       match f a with
       | none => filterMap f l
@@ -554,7 +556,8 @@ Examples:
   | a :: l => f a (foldr f init l)
 
 @[simp] theorem foldr_nil : [].foldr f b = b := rfl
-@[simp] theorem foldr_cons (l : List α) : (a :: l).foldr f b = f a (l.foldr f b) := rfl
+@[simp] theorem foldr_cons {a} {l : List α} {f : α → β → β} {b} :
+    (a :: l).foldr f b = f a (l.foldr f b) := rfl
 
 /-! ### reverse -/
 
@@ -584,10 +587,11 @@ def reverse (as : List α) : List α :=
 
 @[simp] theorem reverse_nil : reverse ([] : List α) = [] := rfl
 
-theorem reverseAux_reverseAux (as bs cs : List α) : reverseAux (reverseAux as bs) cs = reverseAux bs (reverseAux (reverseAux as []) cs) := by
+theorem reverseAux_reverseAux {as bs cs : List α} :
+    reverseAux (reverseAux as bs) cs = reverseAux bs (reverseAux (reverseAux as []) cs) := by
   induction as generalizing bs cs with
   | nil => rfl
-  | cons a as ih => simp [reverseAux, ih (a::bs), ih [a]]
+  | cons a as ih => simp [reverseAux, ih (bs := a::bs), ih (bs := [a])]
 
 /-! ### append -/
 
@@ -633,10 +637,10 @@ def appendTR (as bs : List α) : List α :=
 
 instance : Append (List α) := ⟨List.append⟩
 
-@[simp] theorem append_eq (as bs : List α) : List.append as bs = as ++ bs := rfl
+@[simp] theorem append_eq {as bs : List α} : List.append as bs = as ++ bs := rfl
 
 @[simp] theorem nil_append (as : List α) : [] ++ as = as := rfl
-@[simp] theorem cons_append (a : α) (as bs : List α) : (a::as) ++ bs = a::(as ++ bs) := rfl
+@[simp] theorem cons_append {a : α} {as bs : List α} : (a::as) ++ bs = a::(as ++ bs) := rfl
 
 @[simp] theorem append_nil (as : List α) : as ++ [] = as := by
   induction as with
@@ -648,7 +652,7 @@ instance : Std.LawfulIdentity (α := List α) (· ++ ·) [] where
   left_id := nil_append
   right_id := append_nil
 
-@[simp] theorem length_append (as bs : List α) : (as ++ bs).length = as.length + bs.length := by
+@[simp] theorem length_append {as bs : List α} : (as ++ bs).length = as.length + bs.length := by
   induction as with
   | nil => simp
   | cons _ as ih => simp [ih, Nat.succ_add]
@@ -660,21 +664,22 @@ instance : Std.LawfulIdentity (α := List α) (· ++ ·) [] where
 
 instance : Std.Associative (α := List α) (· ++ ·) := ⟨append_assoc⟩
 
+-- Arguments are explicit as there is often ambiguity inferring the arguments.
 theorem append_cons (as : List α) (b : α) (bs : List α) : as ++ b :: bs = as ++ [b] ++ bs := by
   simp
 
-@[simp] theorem concat_eq_append (as : List α) (a : α) : as.concat a = as ++ [a] := by
+@[simp] theorem concat_eq_append {as : List α} {a : α} : as.concat a = as ++ [a] := by
   induction as <;> simp [concat, *]
 
-theorem reverseAux_eq_append (as bs : List α) : reverseAux as bs = reverseAux as [] ++ bs := by
+theorem reverseAux_eq_append {as bs : List α} : reverseAux as bs = reverseAux as [] ++ bs := by
   induction as generalizing bs with
   | nil => simp [reverseAux]
   | cons a as ih =>
     simp [reverseAux]
-    rw [ih (a :: bs), ih [a], append_assoc]
+    rw [ih (bs := a :: bs), ih (bs := [a]), append_assoc]
     rfl
 
-@[simp] theorem reverse_cons (a : α) (as : List α) : reverse (a :: as) = reverse as ++ [a] := by
+@[simp] theorem reverse_cons {a : α} {as : List α} : reverse (a :: as) = reverse as ++ [a] := by
   simp [reverse, reverseAux]
   rw [← reverseAux_eq_append]
 
@@ -725,8 +730,8 @@ Examples:
 -/
 @[inline] def flatMap {α : Type u} {β : Type v} (b : α → List β) (as : List α) : List β := flatten (map b as)
 
-@[simp] theorem flatMap_nil (f : α → List β) : List.flatMap f [] = [] := by simp [flatten, List.flatMap]
-@[simp] theorem flatMap_cons x xs (f : α → List β) :
+@[simp] theorem flatMap_nil {f : α → List β} : List.flatMap f [] = [] := by simp [flatten, List.flatMap]
+@[simp] theorem flatMap_cons {x : α} {xs : List α} {f : α → List β} :
   List.flatMap f (x :: xs) = f x ++ List.flatMap f xs := by simp [flatten, List.flatMap]
 
 set_option linter.missingDocs false in
@@ -749,10 +754,10 @@ def replicate : (n : Nat) → (a : α) → List α
   | 0,   _ => []
   | n+1, a => a :: replicate n a
 
-@[simp] theorem replicate_zero : replicate 0 a = [] := rfl
-theorem replicate_succ (a : α) (n) : replicate (n+1) a = a :: replicate n a := rfl
+@[simp] theorem replicate_zero {a : α} : replicate 0 a = [] := rfl
+theorem replicate_succ {a : α} {n : Nat} : replicate (n+1) a = a :: replicate n a := rfl
 
-@[simp] theorem length_replicate (n : Nat) (a : α) : (replicate n a).length = n := by
+@[simp] theorem length_replicate {n : Nat} {a : α} : (replicate n a).length = n := by
   induction n with
   | zero => simp
   | succ n ih => simp only [ih, replicate_succ, length_cons, Nat.succ_eq_add_one]
@@ -897,7 +902,7 @@ theorem mem_of_elem_eq_true [BEq α] [LawfulBEq α] {a : α} {as : List α} : el
     next h => intros; simp [BEq.beq] at h; subst h; apply Mem.head
     next _ => intro h; exact Mem.tail _ (mem_of_elem_eq_true h)
 
-theorem elem_eq_true_of_mem [BEq α] [LawfulBEq α] {a : α} {as : List α} (h : a ∈ as) : elem a as = true := by
+theorem elem_eq_true_of_mem [BEq α] [ReflBEq α] {a : α} {as : List α} (h : a ∈ as) : elem a as = true := by
   induction h with
   | head _ => simp [elem]
   | tail _ _ ih => simp [elem]; split; rfl; assumption
@@ -911,7 +916,7 @@ theorem mem_append_left {a : α} {as : List α} (bs : List α) : a ∈ as → a
   | head => apply Mem.head
   | tail => apply Mem.tail; assumption
 
-theorem mem_append_right {b : α} {bs : List α} (as : List α) : b ∈ bs → b ∈ as ++ bs := by
+theorem mem_append_right {b : α} (as : List α) {bs : List α} : b ∈ bs → b ∈ as ++ bs := by
   intro h
   induction as with
   | nil  => simp [h]
@@ -959,9 +964,9 @@ def take : (n : Nat) → (xs : List α) → List α
   | _+1, []    => []
   | n+1, a::as => a :: take n as
 
-@[simp] theorem take_nil : ([] : List α).take i = [] := by cases i <;> rfl
-@[simp] theorem take_zero (l : List α) : l.take 0 = [] := rfl
-@[simp] theorem take_succ_cons : (a::as).take (i+1) = a :: as.take i := rfl
+@[simp] theorem take_nil {i : Nat} : ([] : List α).take i = [] := by cases i <;> rfl
+@[simp] theorem take_zero {l : List α} : l.take 0 = [] := rfl
+@[simp] theorem take_succ_cons {a : α} {as : List α} {i : Nat} : (a::as).take (i+1) = a :: as.take i := rfl
 
 /-! ### drop -/
 
@@ -983,8 +988,8 @@ def drop : (n : Nat) → (xs : List α) → List α
 
 @[simp] theorem drop_nil : ([] : List α).drop i = [] := by
   cases i <;> rfl
-@[simp] theorem drop_zero (l : List α) : l.drop 0 = l := rfl
-@[simp] theorem drop_succ_cons : (a :: l).drop (i + 1) = l.drop i := rfl
+@[simp] theorem drop_zero {l : List α} : l.drop 0 = l := rfl
+@[simp] theorem drop_succ_cons {a : α} {l : List α} {i : Nat} : (a :: l).drop (i + 1) = l.drop i := rfl
 
 theorem drop_eq_nil_of_le {as : List α} {i : Nat} (h : as.length ≤ i) : as.drop i = [] := by
   match as, i with
@@ -1009,7 +1014,7 @@ Examples:
 abbrev extract (l : List α) (start : Nat := 0) (stop : Nat := l.length) : List α :=
   (l.drop start).take (stop - start)
 
-@[simp] theorem extract_eq_drop_take (l : List α) (start stop : Nat) :
+@[simp] theorem extract_eq_drop_take {l : List α} {start stop : Nat} :
     l.extract start stop = (l.drop start).take (stop - start) := rfl
 
 /-! ### takeWhile -/
@@ -1102,12 +1107,10 @@ def dropLast {α} : List α → List α
 
 -- Later this can be proved by `simp` via `[List.length_dropLast, List.length_cons, Nat.add_sub_cancel]`,
 -- but we need this while bootstrapping `Array`.
-@[simp] theorem length_dropLast_cons (a : α) (as : List α) : (a :: as).dropLast.length = as.length := by
+@[simp] theorem length_dropLast_cons {a : α} {as : List α} : (a :: as).dropLast.length = as.length := by
   match as with
   | []       => rfl
-  | b::bs =>
-    have ih := length_dropLast_cons b bs
-    simp [dropLast, ih]
+  | b::bs => simp [dropLast, length_dropLast_cons]
 
 /-! ### Subset -/
 
@@ -1500,8 +1503,8 @@ Examples:
   | [] => []
   | a :: l => f a :: l
 
-@[simp] theorem modifyHead_nil (f : α → α) : [].modifyHead f = [] := by rw [modifyHead]
-@[simp] theorem modifyHead_cons (a : α) (l : List α) (f : α → α) :
+@[simp] theorem modifyHead_nil {f : α → α} : [].modifyHead f = [] := by rw [modifyHead]
+@[simp] theorem modifyHead_cons {a : α} {l : List α} {f : α → α} :
     (a :: l).modifyHead f = f a :: l := by rw [modifyHead]
 
 /--
@@ -1566,7 +1569,7 @@ protected def erase {α} [BEq α] : List α → α → List α
     | false => a :: List.erase as b
 
 @[simp] theorem erase_nil [BEq α] (a : α) : [].erase a = [] := rfl
-theorem erase_cons [BEq α] (a b : α) (l : List α) :
+theorem erase_cons [BEq α] {a b : α} {l : List α} :
     (b :: l).erase a = if b == a then l else b :: l.erase a := by
   simp only [List.erase]; split <;> simp_all
 
@@ -1668,7 +1671,7 @@ Examples:
   | [], n => n
   | a :: l, n => bif p a then n else go l (n + 1)
 
-@[simp] theorem findIdx_nil {α : Type _} (p : α → Bool) : [].findIdx p = 0 := rfl
+@[simp] theorem findIdx_nil {p : α → Bool} : [].findIdx p = 0 := rfl
 
 /-! ### idxOf -/
 
@@ -1805,14 +1808,14 @@ Examples:
 * `[(1, "one"), (3, "three"), (3, "other")].lookup 2 = none`
 -/
 def lookup [BEq α] : α → List (α × β) → Option β
-  | _, []        => none
-  | a, (k,b)::as => match a == k with
+  | _, []           => none
+  | a, (k, b) :: as => match a == k with
     | true  => some b
     | false => lookup a as
 
 @[simp] theorem lookup_nil [BEq α] : ([] : List (α × β)).lookup a = none := rfl
 theorem lookup_cons [BEq α] {k : α} :
-    ((k,b)::as).lookup a = match a == k with | true => some b | false => as.lookup a :=
+    ((k, b)::as).lookup a = match a == k with | true => some b | false => as.lookup a :=
   rfl
 
 /-! ## Permutations -/
@@ -2047,10 +2050,10 @@ def sum {α} [Add α] [Zero α] : List α → α :=
 protected def _root_.Nat.sum (l : List Nat) : Nat := l.foldr (·+·) 0
 
 set_option linter.deprecated false in
-@[simp, deprecated sum_nil (since := "2024-10-17")]
+@[deprecated sum_nil (since := "2024-10-17")]
 theorem _root_.Nat.sum_nil : Nat.sum ([] : List Nat) = 0 := rfl
 set_option linter.deprecated false in
-@[simp, deprecated sum_cons (since := "2024-10-17")]
+@[deprecated sum_cons (since := "2024-10-17")]
 theorem _root_.Nat.sum_cons (a : Nat) (l : List Nat) :
     Nat.sum (a::l) = a + Nat.sum l := rfl
 
@@ -2220,9 +2223,9 @@ def intersperse (sep : α) : (l : List α) → List α
   | [x]   => [x]
   | x::xs => x :: sep :: intersperse sep xs
 
-@[simp] theorem intersperse_nil (sep : α) : ([] : List α).intersperse sep = [] := rfl
-@[simp] theorem intersperse_single (sep : α) : [x].intersperse sep = [x] := rfl
-@[simp] theorem intersperse_cons₂ (sep : α) :
+@[simp] theorem intersperse_nil {sep : α} : ([] : List α).intersperse sep = [] := rfl
+@[simp] theorem intersperse_single {x : α} {sep : α} : [x].intersperse sep = [x] := rfl
+@[simp] theorem intersperse_cons₂ {x : α} {y : α} {zs : List α} {sep : α} :
     (x::y::zs).intersperse sep = x::sep::((y::zs).intersperse sep) := rfl
 
 /-! ### intercalate -/
@@ -2368,7 +2371,7 @@ 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
+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 =>
@@ -2399,13 +2402,13 @@ where
   | [],    bs => bs.reverse
   | a::as, bs => loop as (f a :: bs)
 
-theorem mapTR_loop_eq (f : α → β) (as : List α) (bs : List β) :
+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]
+    rw [ih (bs := f a :: bs), reverse_cons, append_assoc]
     rfl
 
 @[csimp] theorem map_eq_mapTR : @map = @mapTR :=
@@ -2433,7 +2436,7 @@ where
      | true  => loop as (a::acc)
      | false => loop as acc
 
-theorem filterTR_loop_eq (p : α → Bool) (as bs : List α) :
+theorem filterTR_loop_eq {p : α → Bool} {as : List α} {bs : List α} :
     filterTR.loop p as bs = bs.reverse ++ filter p as := by
   induction as generalizing bs with
   | nil => simp [filterTR.loop, filter]
@@ -2462,19 +2465,19 @@ def replicateTR {α : Type u} (n : Nat) (a : α) : List α :=
     | n+1, as => loop n (a::as)
   loop n []
 
-theorem replicateTR_loop_replicate_eq (a : α) (m n : Nat) :
+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)
+  | succ n ih => simp [Nat.succ_add]; exact ih (m := 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,
+  | n+1 => by rw [← replicateTR_loop_replicate_eq, 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
+  exact (replicateTR_loop_replicate_eq (m := 0)).symm
 
 /-! ## Additional functions -/
 

src/Init/Data/List/Control.lean

@@ -236,8 +236,8 @@ def foldlM {m : Type u → Type v} [Monad m] {s : Type u} {α : Type w} : (f : s
     let s' ← f s a
     List.foldlM f s' as
 
-@[simp] theorem foldlM_nil [Monad m] (f : β → α → m β) (b) : [].foldlM f b = pure b := rfl
-@[simp] theorem foldlM_cons [Monad m] (f : β → α → m β) (b) (a) (l : List α) :
+@[simp] theorem foldlM_nil [Monad m] {f : β → α → m β} {b : β} : [].foldlM f b = pure b := rfl
+@[simp] theorem foldlM_cons [Monad m] {f : β → α → m β} {b : β} {a : α} {l : List α} :
     (a :: l).foldlM f b = f b a >>= l.foldlM f := by
   simp [List.foldlM]
 
@@ -260,7 +260,7 @@ example [Monad m] (f : α → β → m β) :
 def foldrM {m : Type u → Type v} [Monad m] {s : Type u} {α : Type w} (f : α → s → m s) (init : s) (l : List α) : m s :=
   l.reverse.foldlM (fun s a => f a s) init
 
-@[simp] theorem foldrM_nil [Monad m] (f : α → β → m β) (b) : [].foldrM f b = pure b := rfl
+@[simp] theorem foldrM_nil [Monad m] {f : α → β → m β} {b : β} : [].foldrM f b = pure b := rfl
 
 /--
 Maps `f` over the list and collects the results with `<|>`. The result for the end of the list is
@@ -382,7 +382,7 @@ def findSomeM? {m : Type u → Type v} [Monad m] {α : Type w} {β : Type u} (f
     | none   => findSomeM? f as
 
 @[simp]
-theorem findSomeM?_pure [Monad m] [LawfulMonad m] (f : α → Option β) (as : List α) :
+theorem findSomeM?_pure [Monad m] [LawfulMonad m] {f : α → Option β} {as : List α} :
     findSomeM? (m := m) (pure <| f ·) as = pure (as.findSome? f) := by
   induction as with
   | nil => rfl
@@ -393,10 +393,10 @@ theorem findSomeM?_pure [Monad m] [LawfulMonad m] (f : α → Option β) (as : L
     | none   => simp [ih]
 
 @[simp]
-theorem findSomeM?_id (f : α → Option β) (as : List α) : findSomeM? (m := Id) f as = as.findSome? f :=
-  findSomeM?_pure _ _
+theorem findSomeM?_id {f : α → Option β} {as : List α} : findSomeM? (m := Id) f as = as.findSome? f :=
+  findSomeM?_pure
 
-theorem findM?_eq_findSomeM? [Monad m] [LawfulMonad m] (p : α → m Bool) (as : List α) :
+theorem findM?_eq_findSomeM? [Monad m] [LawfulMonad m] {p : α → m Bool} {as : List α} :
     as.findM? p = as.findSomeM? fun a => return if (← p a) then some a else none := by
   induction as with
   | nil => rfl
@@ -420,7 +420,7 @@ theorem findM?_eq_findSomeM? [Monad m] [LawfulMonad m] (p : α → m Bool) (as :
       match (← f a this b) with
       | ForInStep.done b  => pure b
       | ForInStep.yield b =>
-        have : Exists (fun bs => bs ++ as' = as) := have ⟨bs, h⟩ := h; ⟨bs ++ [a], by rw [← h, append_cons bs a as']⟩
+        have : Exists (fun bs => bs ++ as' = as) := have ⟨bs, h⟩ := h; ⟨bs ++ [a], by rw [← h, append_cons (bs := as')]⟩
         loop as' b this
   loop as init ⟨[], rfl⟩
 
@@ -432,10 +432,10 @@ instance : ForIn' m (List α) α inferInstance where
 -- We simplify `List.forIn'` to `forIn'`.
 @[simp] theorem forIn'_eq_forIn' [Monad m] : @List.forIn' α β m _ = forIn' := rfl
 
-@[simp] theorem forIn'_nil [Monad m] (f : (a : α) → a ∈ [] → β → m (ForInStep β)) (b : β) : forIn' [] b f = pure b :=
+@[simp] theorem forIn'_nil [Monad m] {f : (a : α) → a ∈ [] → β → m (ForInStep β)} {b : β} : forIn' [] b f = pure b :=
   rfl
 
-@[simp] theorem forIn_nil [Monad m] (f : α → β → m (ForInStep β)) (b : β) : forIn [] b f = pure b :=
+@[simp] theorem forIn_nil [Monad m] {f : α → β → m (ForInStep β)} {b : β} : forIn [] b f = pure b :=
   rfl
 
 instance : ForM m (List α) α where
@@ -444,9 +444,9 @@ instance : ForM m (List α) α where
 -- We simplify `List.forM` to `forM`.
 @[simp] theorem forM_eq_forM [Monad m] : @List.forM m _ α = forM := rfl
 
-@[simp] theorem forM_nil  [Monad m] (f : α → m PUnit) : forM [] f = pure ⟨⟩ :=
+@[simp] theorem forM_nil [Monad m] {f : α → m PUnit} : forM [] f = pure ⟨⟩ :=
   rfl
-@[simp] theorem forM_cons [Monad m] (f : α → m PUnit) (a : α) (as : List α) : forM (a::as) f = f a >>= fun _ => forM as f :=
+@[simp] theorem forM_cons [Monad m] {f : α → m PUnit} {a : α} {as : List α} : forM (a::as) f = f a >>= fun _ => forM as f :=
   rfl
 
 instance : Functor List where

src/Init/Data/List/Count.lean

@@ -20,11 +20,11 @@ open Nat
 /-! ### countP -/
 section countP
 
-variable (p q : α → Bool)
+variable {p q : α → Bool}
 
 @[simp] theorem countP_nil : countP p [] = 0 := rfl
 
-protected theorem countP_go_eq_add (l) : countP.go p l n = n + countP.go p l 0 := by
+protected theorem countP_go_eq_add {l} : countP.go p l n = n + countP.go p l 0 := by
   induction l generalizing n with
   | nil => rfl
   | cons hd _ ih =>
@@ -32,40 +32,40 @@ protected theorem countP_go_eq_add (l) : countP.go p l n = n + countP.go p l 0 :
     rw [ih (n := n + 1), ih (n := n), ih (n := 1)]
     if h : p hd then simp [h, Nat.add_assoc] else simp [h]
 
-@[simp] theorem countP_cons_of_pos (l) (pa : p a) : countP p (a :: l) = countP p l + 1 := by
+@[simp] theorem countP_cons_of_pos {l} (pa : p a) : countP p (a :: l) = countP p l + 1 := by
   have : countP.go p (a :: l) 0 = countP.go p l 1 := show cond .. = _ by rw [pa]; rfl
   unfold countP
   rw [this, Nat.add_comm, List.countP_go_eq_add]
 
-@[simp] theorem countP_cons_of_neg (l) (pa : ¬p a) : countP p (a :: l) = countP p l := by
+@[simp] theorem countP_cons_of_neg {l} (pa : ¬p a) : countP p (a :: l) = countP p l := by
   simp [countP, countP.go, pa]
 
-theorem countP_cons (a : α) (l) : countP p (a :: l) = countP p l + if p a then 1 else 0 := by
+theorem countP_cons {a : α} {l : List α} : countP p (a :: l) = countP p l + if p a then 1 else 0 := by
   by_cases h : p a <;> simp [h]
 
-@[simp] theorem countP_singleton (a : α) : countP p [a] = if p a then 1 else 0 := by
+@[simp] 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
+theorem length_eq_countP_add_countP (p : α → Bool) {l : List α} : length l = countP p l + countP (fun a => ¬p a) l := by
   induction l with
   | nil => rfl
   | cons hd _ ih =>
     if h : p hd then
-      rw [countP_cons_of_pos _ _ h, countP_cons_of_neg _ _ _, length, ih]
+      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]
     else
-      rw [countP_cons_of_pos (fun a => ¬p a) _ _, countP_cons_of_neg _ _ h, length, ih]
+      rw [countP_cons_of_pos (p := fun a => ¬p a), countP_cons_of_neg h, length, ih]
       · rfl
       · simp [h]
 
-theorem countP_eq_length_filter (l) : countP p l = length (filter p l) := by
+theorem countP_eq_length_filter {l : List α} : countP p l = length (filter p l) := by
   induction l with
   | nil => rfl
   | cons x l ih =>
     if h : p x
-    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]
+    then rw [countP_cons_of_pos h, ih, filter_cons_of_pos h, length]
+    else rw [countP_cons_of_neg h, ih, filter_cons_of_neg h]
 
 theorem countP_eq_length_filter' : countP p = length ∘ filter p := by
   funext l
@@ -75,7 +75,7 @@ theorem countP_le_length : countP p l ≤ l.length := by
   simp only [countP_eq_length_filter]
   apply length_filter_le
 
-@[simp] theorem countP_append (l₁ l₂) : countP p (l₁ ++ l₂) = countP p l₁ + countP p l₂ := by
+@[simp] theorem countP_append {l₁ l₂ : List α} : 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
@@ -92,12 +92,12 @@ theorem countP_le_length : countP p l ≤ l.length := by
 @[simp] theorem countP_eq_length {p} : countP p l = l.length ↔ ∀ a ∈ l, p a := by
   rw [countP_eq_length_filter, length_filter_eq_length_iff]
 
-theorem countP_replicate (p : α → Bool) (a : α) (n : Nat) :
+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) :
+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
@@ -107,25 +107,25 @@ theorem boole_getElem_le_countP (p : α → Bool) (l : List α) (i : Nat) (h : i
     | succ i =>
       simp only [length_cons, add_one_lt_add_one_iff] at h
       simp only [getElem_cons_succ, countP_cons]
-      specialize ih _ h
+      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 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
 
 -- See `Init.Data.List.Nat.Count` for `Sublist.le_countP : countP p l₂ - (l₂.length - l₁.length) ≤ countP p l₁`.
 
 theorem countP_tail_le (l) : countP p l.tail ≤ countP p l :=
-  (tail_sublist l).countP_le _
+  (tail_sublist l).countP_le
 
 -- See `Init.Data.List.Nat.Count` for `le_countP_tail : countP p l - 1 ≤ countP p l.tail`.
 
-theorem countP_filter (l : List α) :
+theorem countP_filter {l : List α} :
     countP p (filter q l) = countP (fun a => p a && q a) l := by
   simp only [countP_eq_length_filter, filter_filter]
 
@@ -137,12 +137,12 @@ theorem countP_filter (l : List α) :
   funext l
   simp
 
-@[simp] theorem countP_map (p : β → Bool) (f : α → β) :
-    ∀ l, countP p (map f l) = countP (p ∘ f) l
+@[simp] theorem countP_map {p : β → Bool} {f : α → β} :
+    ∀ {l}, countP p (map f l) = countP (p ∘ f) l
   | [] => rfl
-  | a :: l => by rw [map_cons, countP_cons, countP_cons, countP_map p f l]; rfl
+  | a :: l => by rw [map_cons, countP_cons, countP_cons, countP_map]; rfl
 
-theorem length_filterMap_eq_countP (f : α → Option β) (l : List α) :
+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
@@ -150,7 +150,7 @@ theorem length_filterMap_eq_countP (f : α → Option β) (l : List α) :
     simp only [filterMap_cons, countP_cons]
     split <;> simp [ih, *]
 
-theorem countP_filterMap (p : β → Bool) (f : α → Option β) (l : List α) :
+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]
@@ -158,22 +158,20 @@ theorem countP_filterMap (p : β → Bool) (f : α → Option β) (l : List α)
   ext a
   simp +contextual [Option.getD_eq_iff, Option.isSome_eq_isSome]
 
-@[simp] theorem countP_flatten (l : List (List α)) :
+@[simp] theorem countP_flatten {l : List (List α)} :
     countP p l.flatten = (l.map (countP p)).sum := by
   simp only [countP_eq_length_filter, filter_flatten]
   simp [countP_eq_length_filter']
 
 @[deprecated countP_flatten (since := "2024-10-14")] abbrev countP_join := @countP_flatten
 
-theorem countP_flatMap (p : β → Bool) (l : List α) (f : α → List β) :
+theorem countP_flatMap {p : β → Bool} {l : List α} {f : α → List β} :
     countP p (l.flatMap f) = sum (map (countP p ∘ f) l) := by
   rw [List.flatMap, countP_flatten, map_map]
 
-@[simp] theorem countP_reverse (l : List α) : countP p l.reverse = countP p l := by
+@[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
   induction l with
   | nil => apply Nat.le_refl
@@ -200,71 +198,69 @@ section count
 
 variable [BEq α]
 
-@[simp] theorem count_nil (a : α) : count a [] = 0 := rfl
+@[simp] theorem count_nil {a : α} : count a [] = 0 := rfl
 
-theorem count_cons (a b : α) (l : List α) :
+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 : α} {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 ≠ []),
+theorem count_tail : ∀ {l : List α} (h : l ≠ []) (a : α),
       l.tail.count a = l.count a - if l.head h == a then 1 else 0
   | _ :: _, a, _ => by simp [count_cons]
 
-theorem count_le_length (a : α) (l : List α) : count a l ≤ l.length := countP_le_length _
+theorem count_le_length {a : α} {l : List α} : count a l ≤ l.length := countP_le_length
 
-theorem Sublist.count_le (h : l₁ <+ l₂) (a : α) : count a l₁ ≤ count a l₂ := h.countP_le _
+theorem Sublist.count_le (a : α) (h : l₁ <+ l₂) : 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 IsPrefix.count_le (a : α) (h : l₁ <+: l₂) : count a l₁ ≤ count a l₂ := h.sublist.count_le a
+theorem IsSuffix.count_le (a : α) (h : l₁ <:+ l₂) : count a l₁ ≤ count a l₂ := h.sublist.count_le a
+theorem IsInfix.count_le (a : α) (h : l₁ <:+: l₂) : count a l₁ ≤ count a l₂ := h.sublist.count_le a
 
 -- See `Init.Data.List.Nat.Count` for `Sublist.le_count : count a l₂ - (l₂.length - l₁.length) ≤ countP a l₁`.
 
-theorem count_tail_le (a : α) (l) : count a l.tail ≤ count a l :=
-  (tail_sublist l).count_le _
+theorem count_tail_le {a : α} {l : List α} : count a l.tail ≤ count a l :=
+  (tail_sublist l).count_le a
 
 -- See `Init.Data.List.Nat.Count` for `le_count_tail : count a l - 1 ≤ count a l.tail`.
 
-theorem count_le_count_cons (a b : α) (l : List α) : count a l ≤ count a (b :: l) :=
-  (sublist_cons_self _ _).count_le _
+theorem count_le_count_cons {a b : α} {l : List α} : count a l ≤ count a (b :: l) :=
+  (sublist_cons_self _ _).count_le a
 
-theorem count_singleton (a b : α) : count a [b] = if b == a then 1 else 0 := by
+theorem count_singleton {a b : α} : count a [b] = if b == a then 1 else 0 := by
   simp [count_cons]
 
-@[simp] theorem count_append (a : α) : ∀ l₁ l₂, count a (l₁ ++ l₂) = count a l₁ + count a l₂ :=
-  countP_append _
+@[simp] theorem count_append {a : α} {l₁ l₂ : List α} : count a (l₁ ++ l₂) = count a l₁ + count a l₂ :=
+  countP_append
 
-theorem count_flatten (a : α) (l : List (List α)) : count a l.flatten = (l.map (count a)).sum := by
+theorem count_flatten {a : α} {l : List (List α)} : count a l.flatten = (l.map (count a)).sum := by
   simp only [count_eq_countP, countP_flatten, count_eq_countP']
 
 @[deprecated count_flatten (since := "2024-10-14")] abbrev count_join := @count_flatten
 
-@[simp] theorem count_reverse (a : α) (l : List α) : count a l.reverse = count a l := by
+@[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) :
+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)
+  apply boole_getElem_le_countP (p := (· == a))
 
 variable [LawfulBEq α]
 
-@[simp] theorem count_cons_self (a : α) (l : List α) : count a (a :: l) = count a l + 1 := by
+@[simp] theorem count_cons_self {a : α} {l : List α} : count a (a :: l) = count a l + 1 := by
   simp [count_cons]
 
-@[simp] theorem count_cons_of_ne (h : a ≠ b) (l : List α) : count a (b :: l) = count a l := by
-  simp only [count_cons, cond_eq_if, beq_iff_eq]
-  split <;> simp_all
+@[simp] theorem count_cons_of_ne (h : b ≠ a) {l : List α} : count a (b :: l) = count a l := by
+  simp [count_cons, h]
 
-theorem count_singleton_self (a : α) : count a [a] = 1 := by simp
+theorem count_singleton_self {a : α} : count a [a] = 1 := by simp
 
-theorem count_concat_self (a : α) (l : List α) :
-    count a (concat l a) = (count a l) + 1 := by simp
+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
@@ -290,41 +286,40 @@ theorem count_eq_length {l : List α} : count a l = l.length ↔ ∀ b ∈ l, a
   · simpa using h b hb
   · rw [h b hb, beq_self_eq_true]
 
-@[simp] theorem count_replicate_self (a : α) (n : Nat) : count a (replicate n a) = n :=
+@[simp] theorem count_replicate_self {a : α} {n : Nat} : count a (replicate n a) = n :=
   (count_eq_length.2 <| fun _ h => (eq_of_mem_replicate h).symm).trans (length_replicate ..)
 
-theorem count_replicate (a b : α) (n : Nat) : count a (replicate n b) = if b == a then n else 0 := by
+theorem count_replicate {a b : α} {n : Nat} : count a (replicate n b) = if b == a then n else 0 := by
   split <;> (rename_i h; simp only [beq_iff_eq] at h)
   · exact ‹b = a› ▸ count_replicate_self ..
   · 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
+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]
   exact ⟨trivial, fun _ h => h.2⟩
 
-theorem filter_eq {α} [DecidableEq α] (l : List α) (a : α) : l.filter (· = a) = replicate (count a l) a :=
-  filter_beq l a
+theorem filter_eq [DecidableEq α] {l : List α} (a : α) : l.filter (· = a) = replicate (count a l) a :=
+  funext (Bool.beq_eq_decide_eq · a) ▸ filter_beq a
 
 theorem le_count_iff_replicate_sublist {l : List α} : n ≤ count a l ↔ replicate n a <+ l := by
   refine ⟨fun h => ?_, fun h => ?_⟩
-  · exact ((replicate_sublist_replicate a).2 h).trans <| filter_beq l a ▸ filter_sublist _
+  · exact ((replicate_sublist_replicate a).2 h).trans <| filter_beq a ▸ filter_sublist
   · simpa only [count_replicate_self] using h.count_le a
 
 theorem replicate_count_eq_of_count_eq_length {l : List α} (h : count a l = length l) :
     replicate (count a l) a = l :=
-  (le_count_iff_replicate_sublist.mp (Nat.le_refl _)).eq_of_length <|
-    (length_replicate (count a l) a).trans h
+  (le_count_iff_replicate_sublist.mp (Nat.le_refl _)).eq_of_length <| length_replicate.trans h
 
 @[simp] theorem count_filter {l : List α} (h : p a) : count a (filter p l) = count a l := by
   rw [count, countP_filter]; congr; funext b
   simp; rintro rfl; exact h
 
-theorem count_le_count_map [DecidableEq β] (l : List α) (f : α → β) (x : α) :
+theorem count_le_count_map {β} [BEq β] [LawfulBEq β] {l : List α} {f : α → β} {x : α} :
     count x l ≤ count (f x) (map f l) := by
   rw [count, count, countP_map]
   apply countP_mono_left; simp +contextual
 
-theorem count_filterMap {α} [BEq β] (b : β) (f : α → Option β) (l : List α) :
+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
@@ -333,11 +328,11 @@ theorem count_filterMap {α} [BEq β] (b : β) (f : α → Option β) (l : List
   · simp
   · simp
 
-theorem count_flatMap {α} [BEq β] (l : List α) (f : α → List β) (x : β) :
-    count x (l.flatMap f) = sum (map (count x ∘ f) l) := countP_flatMap _ _ _
+theorem count_flatMap {α} [BEq β] {l : List α} {f : α → List β} {x : β} :
+    count x (l.flatMap f) = sum (map (count x ∘ f) l) := countP_flatMap
 
-theorem count_erase (a b : α) :
-    ∀ l : List α, count a (l.erase b) = count a l - if b == a then 1 else 0
+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]
@@ -346,17 +341,17 @@ theorem count_erase (a b : α) :
       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, reduceCtorEq]
       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]
       else
         rw [if_neg (by simpa using ha), Nat.sub_zero, Nat.sub_zero]
 
-@[simp] theorem count_erase_self (a : α) (l : List α) :
+@[simp] theorem count_erase_self {a : α} {l : List α} :
     count a (List.erase l a) = count a l - 1 := by rw [count_erase, if_pos (by simp)]
 
-@[simp] theorem count_erase_of_ne (ab : a ≠ b) (l : List α) : count a (l.erase b) = count a l := by
+@[simp] theorem count_erase_of_ne (ab : a ≠ b) {l : List α} : count a (l.erase b) = count a l := by
   rw [count_erase, if_neg (by simpa using ab.symm), Nat.sub_zero]
 
 end count