update release_checklist.md

.github/workflows/ci.yml

@@ -238,7 +238,7 @@ jobs:
                 "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",
+                "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/",
                 "cmultilib": true,
                 "release": true,
                 "check-level": 2,
@@ -327,7 +327,7 @@ jobs:
         run: |
           sudo dpkg --add-architecture i386
           sudo apt-get update
-          sudo apt-get install -y gcc-multilib g++-multilib ccache libuv1-dev:i386 pkgconf:i386
+          sudo apt-get install -y gcc-multilib g++-multilib ccache libuv1-dev:i386
         if: matrix.cmultilib
       - name: Cache
         uses: actions/cache@v4

CMakeLists.txt

@@ -18,9 +18,6 @@ foreach(var ${vars})
     if("${var}" MATCHES "LLVM*")
       list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
     endif()
-    if("${var}" MATCHES "PKG_CONFIG*")
-      list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
-    endif()
   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()

doc/dev/commit_convention.md

@@ -33,9 +33,6 @@ Format of the commit message
  - chore (maintain, ex: travis-ci)
  - perf (performance improvement, optimization, ...)
 
-Every `feat` or `fix` commit must have a `changelog-*` label, and a commit message
-beginning with "This PR " that will be included in the changelog.
-
 ``<subject>`` has the following constraints:
 
  - use imperative, present tense: "change" not "changed" nor "changes"
@@ -47,7 +44,6 @@ beginning with "This PR " that will be included in the changelog.
  - just as in ``<subject>``, use imperative, present tense
  - includes motivation for the change and contrasts with previous
    behavior
- - If a `changelog-*` label is present, the body must begin with "This PR ".
 
 ``<footer>`` is optional and may contain two items:
 
@@ -64,21 +60,17 @@ Examples
 
 fix: add declarations for operator<<(std::ostream&, expr const&) and operator<<(std::ostream&, context const&) in the kernel
 
-This PR adds declarations `operator<<` for raw printing.
 The actual implementation of these two operators is outside of the
-kernel. They are implemented in the file 'library/printer.cpp'.
-
-We declare them in the kernel to prevent the following problem.
-Suppose there is a file 'foo.cpp' that does not include 'library/printer.h',
+kernel. They are implemented in the file 'library/printer.cpp'. We
+declare them in the kernel to prevent the following problem. Suppose
+there is a file 'foo.cpp' that does not include 'library/printer.h',
 but contains
-```cpp
-expr a;
-...
-std::cout << a << "\n";
-...
-```
+
+    expr a;
+    ...
+    std::cout << a << "\n";
+    ...
 
 The compiler does not generate an error message. It silently uses the
 operator bool() to coerce the expression into a Boolean. This produces
 counter-intuitive behavior, and may confuse developers.
-

doc/dev/ffi.md

@@ -49,9 +49,8 @@ In the case of `@[extern]` all *irrelevant* types are removed first; see next se
   is represented by the representation of that parameter's type.
 
   For example, `{ x : α // p }`, the `Subtype` structure of a value of type `α` and an irrelevant proof, is represented by the representation of `α`.
-  Similarly, the signed integer types `Int8`, ..., `Int64`, `ISize` are also represented by the unsigned C types `uint8_t`, ..., `uint64_t`, `size_t`, respectively, because they have a trivial structure.
-* `Nat` and `Int` are represented by `lean_object *`.
-  Their runtime values is either a pointer to an opaque bignum object or, if the lowest bit of the "pointer" is 1 (`lean_is_scalar`), an encoded unboxed natural number or integer (`lean_box`/`lean_unbox`).
+* `Nat` is represented by `lean_object *`.
+  Its runtime value is either a pointer to an opaque bignum object or, if the lowest bit of the "pointer" is 1 (`lean_is_scalar`), an encoded unboxed natural number (`lean_box`/`lean_unbox`).
 * A universe `Sort u`, type constructor `... → Sort u`, or proposition `p : Prop` is *irrelevant* and is either statically erased (see above) or represented as a `lean_object *` with the runtime value `lean_box(0)`
 * Any other type is represented by `lean_object *`.
   Its runtime value is a pointer to an object of a subtype of `lean_object` (see the "Inductive types" section below) or the unboxed value `lean_box(cidx)` for the `cidx`th constructor of an inductive type if this constructor does not have any relevant parameters.

doc/dev/index.md

@@ -80,10 +80,3 @@ Unlike most Lean projects, all submodules of the `Lean` module begin with the
 `prelude` keyword. This disables the automated import of `Init`, meaning that
 developers need to figure out their own subset of `Init` to import. This is done
 such that changing files in `Init` doesn't force a full rebuild of `Lean`.
-
-### Testing against Mathlib/Batteries
-You can test a Lean PR against Mathlib and Batteries by rebasing your PR
-on to `nightly-with-mathlib` branch. (It is fine to force push after rebasing.)
-CI will generate a branch of Mathlib and Batteries called `lean-pr-testing-NNNN`
-that uses the toolchain for your PR, and will report back to the Lean PR with results from Mathlib CI.
-See https://leanprover-community.github.io/contribute/tags_and_branches.html for more details.

doc/dev/release_checklist.md

@@ -37,32 +37,16 @@ We'll use `v4.6.0` as the intended release version as a running example.
     - 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`
-    - [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
-      - 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)
+    - [Batteries](https://github.com/leanprover-community/batteries)
       - No dependencies
       - Toolchain bump PR
       - Create and push the tag
-      - There is no `stable` branch; skip this step
+      - Merge the tag into `stable`
     - [ProofWidgets4](https://github.com/leanprover-community/ProofWidgets4)
       - Dependencies: `Batteries`
       - Note on versions and branches:
@@ -77,11 +61,18 @@ We'll use `v4.6.0` as the intended release version as a running example.
       - 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)
+    - [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
-    - [plausible](https://github.com/leanprover-community/plausible)
+    - [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
+      - Toolchain bump PR including updated Lake manifest
+      - Create and push the tag
+      - There is no `stable` branch; skip this step
+    - [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
@@ -102,7 +93,6 @@ We'll use `v4.6.0` as the intended release version as a running example.
       - Toolchain bump PR including updated Lake manifest
       - Create and push the tag
       - Merge the tag into `stable`
-- Run `scripts/release_checklist.py v4.6.0` to check that everything is in order.
 - The `v4.6.0` section of `RELEASES.md` is out of sync between
   `releases/v4.6.0` and `master`. This should be reconciled:
   - Replace the `v4.6.0` section on `master` with the `v4.6.0` section on `releases/v4.6.0`

doc/make/osx-10.9.md

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

doc/make/ubuntu.md

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

flake.nix

@@ -28,7 +28,7 @@
           stdenv = pkgs.overrideCC pkgs.stdenv lean-packages.llvmPackages.clang;
         } ({
           buildInputs = with pkgs; [
-            cmake gmp libuv ccache cadical pkg-config
+            cmake gmp libuv ccache cadical
             lean-packages.llvmPackages.llvm  # llvm-symbolizer for asan/lsan
             gdb
             tree  # for CI

nix/bootstrap.nix

@@ -1,12 +1,12 @@
 { src, debug ? false, stage0debug ? false, extraCMakeFlags ? [],
-  stdenv, lib, cmake, pkg-config, gmp, libuv, cadical, git, gnumake, bash, buildLeanPackage, writeShellScriptBin, runCommand, symlinkJoin, lndir, perl, gnused, darwin, llvmPackages, linkFarmFromDrvs,
+  stdenv, lib, cmake, gmp, libuv, cadical, git, gnumake, bash, buildLeanPackage, writeShellScriptBin, runCommand, symlinkJoin, lndir, perl, gnused, darwin, llvmPackages, linkFarmFromDrvs,
   ... } @ args:
 with builtins;
 lib.warn "The Nix-based build is deprecated" rec {
   inherit stdenv;
   sourceByRegex = p: rs: lib.sourceByRegex p (map (r: "(/src/)?${r}") rs);
   buildCMake = args: stdenv.mkDerivation ({
-    nativeBuildInputs = [ cmake pkg-config ];
+    nativeBuildInputs = [ cmake ];
     buildInputs = [ gmp libuv llvmPackages.llvm ];
     # https://github.com/NixOS/nixpkgs/issues/60919
     hardeningDisable = [ "all" ];

releases_drafts/list_lex.md

@@ -0,0 +1,16 @@
+We replace 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 subtely 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.

script/prepare-llvm-linux.sh

@@ -63,8 +63,8 @@ else
 fi
 # use `-nostdinc` to make sure headers are not visible by default (in particular, not to `#include_next` in the clang headers),
 # but do not change sysroot so users can still link against system libs
-echo -n " -DLEANC_INTERNAL_FLAGS='--sysroot ROOT -nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang"
-echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='--sysroot ROOT -L ROOT/lib -L ROOT/lib/glibc ROOT/lib/glibc/libc_nonshared.a ROOT/lib/glibc/libpthread_nonshared.a -Wl,--as-needed -Wl,-Bstatic -lgmp -lunwind -luv -Wl,-Bdynamic -Wl,--no-as-needed -fuse-ld=lld'"
+echo -n " -DLEANC_INTERNAL_FLAGS='-nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang"
+echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -L ROOT/lib/glibc ROOT/lib/glibc/libc_nonshared.a ROOT/lib/glibc/libpthread_nonshared.a -Wl,--as-needed -Wl,-Bstatic -lgmp -lunwind -luv -Wl,-Bdynamic -Wl,--no-as-needed -fuse-ld=lld'"
 # when not using the above flags, link GMP dynamically/as usual
 echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-Wl,--as-needed -lgmp -luv -lpthread -ldl -lrt -Wl,--no-as-needed'"
 # do not set `LEAN_CC` for tests

script/prepare-llvm-macos.sh

@@ -48,11 +48,12 @@ if [[ -L llvm-host ]]; then
   echo -n " -DCMAKE_C_COMPILER=$PWD/stage1/bin/clang"
   gcp $GMP/lib/libgmp.a stage1/lib/
   gcp $LIBUV/lib/libuv.a stage1/lib/
+  echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -L ROOT/lib/libc -fuse-ld=lld'"
   echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-lgmp -luv'"
 else
   echo -n " -DCMAKE_C_COMPILER=$PWD/llvm-host/bin/clang -DLEANC_OPTS='--sysroot $PWD/stage1 -resource-dir $PWD/stage1/lib/clang/15.0.1 ${EXTRA_FLAGS:-}'"
+  echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -L ROOT/lib/libc -fuse-ld=lld'"
 fi
-echo -n " -DLEANC_INTERNAL_FLAGS='--sysroot ROOT -nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang"
-echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='--sysroot ROOT -L ROOT/lib -L ROOT/lib/libc -fuse-ld=lld'"
+echo -n " -DLEANC_INTERNAL_FLAGS='-nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang"
 # do not set `LEAN_CC` for tests
 echo -n " -DLEAN_TEST_VARS=''"

script/prepare-llvm-mingw.sh

@@ -43,7 +43,7 @@ echo -n " -DCMAKE_C_COMPILER=$PWD/stage1/bin/clang.exe -DCMAKE_C_COMPILER_WORKS=
 echo -n " -DSTAGE0_CMAKE_C_COMPILER=clang -DSTAGE0_CMAKE_CXX_COMPILER=clang++"
 echo -n " -DLEAN_EXTRA_CXX_FLAGS='--sysroot $PWD/llvm -idirafter /clang64/include/'"
 echo -n " -DLEANC_INTERNAL_FLAGS='--sysroot ROOT -nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang.exe"
-echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='--sysroot ROOT -L ROOT/lib -Wl,-Bstatic -lgmp $(pkg-config --static --libs libuv) -lunwind -Wl,-Bdynamic -fuse-ld=lld'"
+echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -static-libgcc -Wl,-Bstatic -lgmp $(pkg-config --static --libs libuv) -lunwind -Wl,-Bdynamic -fuse-ld=lld'"
 # when not using the above flags, link GMP dynamically/as usual. Always link ICU dynamically.
 echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-lgmp $(pkg-config --libs libuv) -lucrtbase'"
 # do not set `LEAN_CC` for tests

script/push_repo_release_tag.py

@@ -1,69 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import subprocess
-import requests
-
-def main():
-    if len(sys.argv) != 4:
-        print("Usage: ./push_repo_release_tag.py <repo> <branch> <version_tag>")
-        sys.exit(1)
-
-    repo, branch, version_tag = sys.argv[1], sys.argv[2], sys.argv[3]
-
-    if branch not in {"master", "main"}:
-        print(f"Error: Branch '{branch}' is not 'master' or 'main'.")
-        sys.exit(1)
-
-    # Get the `lean-toolchain` file content
-    lean_toolchain_url = f"https://raw.githubusercontent.com/{repo}/{branch}/lean-toolchain"
-    try:
-        response = requests.get(lean_toolchain_url)
-        response.raise_for_status()
-    except requests.exceptions.RequestException as e:
-        print(f"Error fetching 'lean-toolchain' file: {e}")
-        sys.exit(1)
-
-    lean_toolchain_content = response.text.strip()
-    expected_prefix = "leanprover/lean4:"
-    if not lean_toolchain_content.startswith(expected_prefix) or lean_toolchain_content != f"{expected_prefix}{version_tag}":
-        print(f"Error: 'lean-toolchain' content does not match '{expected_prefix}{version_tag}'.")
-        sys.exit(1)
-
-    # Create and push the tag using `gh`
-    try:
-        # Check if the tag already exists
-        list_tags_cmd = ["gh", "api", f"repos/{repo}/git/matching-refs/tags/v4", "--jq", ".[].ref"]
-        list_tags_output = subprocess.run(list_tags_cmd, capture_output=True, text=True)
-
-        if list_tags_output.returncode == 0:
-            existing_tags = list_tags_output.stdout.strip().splitlines()
-            if f"refs/tags/{version_tag}" in existing_tags:
-                print(f"Error: Tag '{version_tag}' already exists.")
-                print("Existing tags starting with 'v4':")
-                for tag in existing_tags:
-                    print(tag.replace("refs/tags/", ""))
-                sys.exit(1)
-
-        # Get the SHA of the branch
-        get_sha_cmd = [
-            "gh", "api", f"repos/{repo}/git/ref/heads/{branch}", "--jq", ".object.sha"
-        ]
-        sha_result = subprocess.run(get_sha_cmd, capture_output=True, text=True, check=True)
-        sha = sha_result.stdout.strip()
-
-        # Create the tag
-        create_tag_cmd = [
-            "gh", "api", f"repos/{repo}/git/refs",
-            "-X", "POST",
-            "-F", f"ref=refs/tags/{version_tag}",
-            "-F", f"sha={sha}"
-        ]
-        subprocess.run(create_tag_cmd, capture_output=True, text=True, check=True)
-
-        print(f"Successfully created and pushed tag '{version_tag}' to {repo}.")
-    except subprocess.CalledProcessError as e:
-        print(f"Error while creating/pushing tag: {e.stderr.strip() if e.stderr else e}")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main()

script/release_checklist.py

@@ -1,227 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import yaml
-import requests
-import base64
-import subprocess
-import sys
-import os
-
-def parse_repos_config(file_path):
-    with open(file_path, "r") as f:
-        return yaml.safe_load(f)["repositories"]
-
-def get_github_token():
-    try:
-        import subprocess
-        result = subprocess.run(['gh', 'auth', 'token'], capture_output=True, text=True)
-        if result.returncode == 0:
-            return result.stdout.strip()
-    except FileNotFoundError:
-        print("Warning: 'gh' CLI not found. Some API calls may be rate-limited.")
-    return None
-
-def strip_rc_suffix(toolchain):
-    """Remove -rcX suffix from the toolchain."""
-    return toolchain.split("-")[0]
-
-def branch_exists(repo_url, branch, github_token):
-    api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + f"/branches/{branch}"
-    headers = {'Authorization': f'token {github_token}'} if github_token else {}
-    response = requests.get(api_url, headers=headers)
-    return response.status_code == 200
-
-def tag_exists(repo_url, tag_name, github_token):
-    api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + f"/git/refs/tags/{tag_name}"
-    headers = {'Authorization': f'token {github_token}'} if github_token else {}
-    response = requests.get(api_url, headers=headers)
-    return response.status_code == 200
-
-def release_page_exists(repo_url, tag_name, github_token):
-    api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + f"/releases/tags/{tag_name}"
-    headers = {'Authorization': f'token {github_token}'} if github_token else {}
-    response = requests.get(api_url, headers=headers)
-    return response.status_code == 200
-
-def get_release_notes(repo_url, tag_name, github_token):
-    api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + f"/releases/tags/{tag_name}"
-    headers = {'Authorization': f'token {github_token}'} if github_token else {}
-    response = requests.get(api_url, headers=headers)
-    if response.status_code == 200:
-        return response.json().get("body", "").strip()
-    return None
-
-def get_branch_content(repo_url, branch, file_path, github_token):
-    api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + f"/contents/{file_path}?ref={branch}"
-    headers = {'Authorization': f'token {github_token}'} if github_token else {}
-    response = requests.get(api_url, headers=headers)
-    if response.status_code == 200:
-        content = response.json().get("content", "")
-        content = content.replace("\n", "")
-        try:
-            return base64.b64decode(content).decode('utf-8').strip()
-        except Exception:
-            return None
-    return None
-
-def parse_version(version_str):
-    # Remove 'v' prefix and extract version and release candidate suffix
-    if ':' in version_str:
-        version_str = version_str.split(':')[1]
-    version = version_str.lstrip('v')
-    parts = version.split('-')
-    base_version = tuple(map(int, parts[0].split('.')))
-    rc_part = parts[1] if len(parts) > 1 and parts[1].startswith('rc') else None
-    rc_number = int(rc_part[2:]) if rc_part else float('inf')  # Treat non-rc as higher than rc
-    return base_version + (rc_number,)
-
-def is_version_gte(version1, version2):
-    """Check if version1 >= version2, including proper handling of release candidates."""
-    return parse_version(version1) >= parse_version(version2)
-
-def is_merged_into_stable(repo_url, tag_name, stable_branch, github_token):
-    # 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 {}
-
-    # 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:
-        return False
-    tag_sha = tag_response.json()['object']['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:
-        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
-
-def is_release_candidate(version):
-    return "-rc" in version
-
-def check_cmake_version(repo_url, branch, version_major, version_minor, github_token):
-    """Verify the CMake version settings in src/CMakeLists.txt."""
-    cmake_file_path = "src/CMakeLists.txt"
-    content = get_branch_content(repo_url, branch, cmake_file_path, github_token)
-    if content is None:
-        print(f"  ❌ Could not retrieve {cmake_file_path} from {branch}")
-        return False
-
-    expected_lines = [
-        f"set(LEAN_VERSION_MAJOR {version_major})",
-        f"set(LEAN_VERSION_MINOR {version_minor})",
-        f"set(LEAN_VERSION_PATCH 0)",
-        f"set(LEAN_VERSION_IS_RELEASE 1)"
-    ]
-
-    for line in expected_lines:
-        if not any(l.strip().startswith(line) for l in content.splitlines()):
-            print(f"  ❌ Missing or incorrect line in {cmake_file_path}: {line}")
-            return False
-
-    print(f"  ✅ CMake version settings are correct in {cmake_file_path}")
-    return True
-
-def extract_org_repo_from_url(repo_url):
-    """Extract the 'org/repo' part from a GitHub URL."""
-    if repo_url.startswith("https://github.com/"):
-        return repo_url.replace("https://github.com/", "").rstrip("/")
-    return repo_url
-
-def main():
-    github_token = get_github_token()
-
-    if len(sys.argv) != 2:
-        print("Usage: python3 release_checklist.py <toolchain>")
-        sys.exit(1)
-
-    toolchain = sys.argv[1]
-    stripped_toolchain = strip_rc_suffix(toolchain)
-    lean_repo_url = "https://github.com/leanprover/lean4"
-
-    # Preliminary checks
-    print("\nPerforming preliminary checks...")
-
-    # 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:
-        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")
-    else:
-        print(f"  ❌ Tag {toolchain} does not exist.")
-
-    # Check for release page
-    if release_page_exists(lean_repo_url, toolchain, github_token):
-        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 release_notes.splitlines()[0].strip() == toolchain:
-            print(f"  ✅ Release notes look good.")
-        else:
-            previous_minor_version = version_minor - 1
-            previous_stable_branch = f"releases/v{version_major}.{previous_minor_version}.0"
-            previous_release = f"v{version_major}.{previous_minor_version}.0"
-            print(f"  ❌ Release notes not published. Please run `script/release_notes.py {previous_release}` on branch `{previous_stable_branch}`.")
-    else:
-        print(f"  ❌ Release page for {toolchain} does not exist")
-
-    # Load repositories and perform further checks
-    print("\nChecking repositories...")
-
-    with open(os.path.join(os.path.dirname(__file__), "release_repos.yml")) as f:
-        repos = yaml.safe_load(f)["repositories"]
-
-    for repo in repos:
-        name = repo["name"]
-        url = repo["url"]
-        branch = repo["branch"]
-        check_stable = repo["stable-branch"]
-        check_tag = repo.get("toolchain-tag", True)
-
-        print(f"\nRepository: {name}")
-
-        # 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")
-            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()})")
-            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}`.")
-                continue
-            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):
-                print(f"  ❌ Tag {toolchain} is not merged into stable")
-                continue
-            print(f"  ✅ Tag {toolchain} is merged into stable")
-
-if __name__ == "__main__":
-    main()

script/release_repos.yml

@@ -1,86 +0,0 @@
-repositories:
-  - name: Batteries
-    url: https://github.com/leanprover-community/batteries
-    toolchain-tag: true
-    stable-branch: true
-    branch: main
-    dependencies: []
-
-  - name: lean4checker
-    url: https://github.com/leanprover/lean4checker
-    toolchain-tag: true
-    stable-branch: true
-    branch: master
-    dependencies: []
-
-  - name: doc-gen4
-    url: https://github.com/leanprover/doc-gen4
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies: []
-
-  - name: Verso
-    url: https://github.com/leanprover/verso
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies: []
-
-  - name: Cli
-    url: https://github.com/leanprover/lean4-cli
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies: []
-
-  - name: ProofWidgets4
-    url: https://github.com/leanprover-community/ProofWidgets4
-    toolchain-tag: false
-    stable-branch: false
-    branch: main
-    dependencies:
-      - Batteries
-
-  - name: Aesop
-    url: https://github.com/leanprover-community/aesop
-    toolchain-tag: true
-    stable-branch: true
-    branch: master
-    dependencies:
-      - Batteries
-
-  - name: import-graph
-    url: https://github.com/leanprover-community/import-graph
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies: []
-
-  - name: plausible
-    url: https://github.com/leanprover-community/plausible
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies: []
-
-  - name: Mathlib
-    url: https://github.com/leanprover-community/mathlib4
-    toolchain-tag: true
-    stable-branch: true
-    branch: master
-    dependencies:
-      - Aesop
-      - ProofWidgets4
-      - lean4checker
-      - Batteries
-      - doc-gen4
-      - import-graph
-
-  - name: REPL
-    url: https://github.com/leanprover-community/repl
-    toolchain-tag: true
-    stable-branch: true
-    branch: master
-    dependencies:
-      - Mathlib

src/CMakeLists.txt

@@ -295,15 +295,14 @@ index 5e8e0166..f3b29134 100644
 	  PATCH_COMMAND git reset --hard HEAD && printf "${LIBUV_PATCH}" > patch.diff && git apply patch.diff
     BUILD_IN_SOURCE ON
     INSTALL_COMMAND "")
-  set(LIBUV_INCLUDE_DIRS "${CMAKE_BINARY_DIR}/libuv/src/libuv/include")
-  set(LIBUV_LDFLAGS "${CMAKE_BINARY_DIR}/libuv/src/libuv/libuv.a")
+  set(LIBUV_INCLUDE_DIR "${CMAKE_BINARY_DIR}/libuv/src/libuv/include")
+  set(LIBUV_LIBRARIES "${CMAKE_BINARY_DIR}/libuv/src/libuv/libuv.a")
 else()
   find_package(LibUV 1.0.0 REQUIRED)
 endif()
-include_directories(${LIBUV_INCLUDE_DIRS})
+include_directories(${LIBUV_INCLUDE_DIR})
 if(NOT LEAN_STANDALONE)
-  string(JOIN " " LIBUV_LDFLAGS ${LIBUV_LDFLAGS})
-  string(APPEND LEAN_EXTRA_LINKER_FLAGS " ${LIBUV_LDFLAGS}")
+  string(APPEND LEAN_EXTRA_LINKER_FLAGS " ${LIBUV_LIBRARIES}")
 endif()
 
 # Windows SDK (for ICU)
@@ -699,12 +698,12 @@ else()
 endif()
 
 if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-  add_custom_target(lake_lib
+  add_custom_target(lake_lib ALL
     WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
     DEPENDS leanshared
     COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make Lake
     VERBATIM)
-  add_custom_target(lake_shared
+  add_custom_target(lake_shared ALL
     WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
     DEPENDS lake_lib
     COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make libLake_shared

src/Init.lean

@@ -37,4 +37,3 @@ import Init.MacroTrace
 import Init.Grind
 import Init.While
 import Init.Syntax
-import Init.Internal

src/Init/Conv.lean

@@ -150,10 +150,6 @@ See the `simp` tactic for more information. -/
 syntax (name := simp) "simp" optConfig (discharger)? (&" only")?
   (" [" withoutPosition((simpStar <|> simpErase <|> simpLemma),*) "]")? : conv
 
-/-- `simp?` takes the same arguments as `simp`, but reports an equivalent call to `simp only`
-that would be sufficient to close the goal. See the `simp?` tactic for more information. -/
-syntax (name := simpTrace) "simp?" optConfig (discharger)? (&" only")? (simpArgs)? : conv
-
 /--
 `dsimp` is the definitional simplifier in `conv`-mode. It differs from `simp` in that it only
 applies theorems that hold by reflexivity.
@@ -171,9 +167,6 @@ example (a : Nat): (0 + 0) = a - a := by
 syntax (name := dsimp) "dsimp" optConfig (discharger)? (&" only")?
   (" [" withoutPosition((simpErase <|> simpLemma),*) "]")? : conv
 
-@[inherit_doc simpTrace]
-syntax (name := dsimpTrace) "dsimp?" optConfig (&" only")? (dsimpArgs)? : conv
-
 /-- `simp_match` simplifies match expressions. For example,
 ```
 match [a, b] with

src/Init/Data/Array/Attach.lean

@@ -6,7 +6,6 @@ Authors: Joachim Breitner, Mario Carneiro
 prelude
 import Init.Data.Array.Mem
 import Init.Data.Array.Lemmas
-import Init.Data.Array.Count
 import Init.Data.List.Attach
 
 namespace Array
@@ -143,16 +142,10 @@ theorem pmap_eq_map_attach {p : α → Prop} (f : ∀ a, p a → β) (l H) :
   cases l
   simp [List.pmap_eq_map_attach]
 
-@[simp]
-theorem pmap_eq_attachWith {p q : α → Prop} (f : ∀ a, p a → q a) (l H) :
-    pmap (fun a h => ⟨a, f a h⟩) l H = l.attachWith q (fun x h => f x (H x h)) := by
-  cases l
-  simp [List.pmap_eq_attachWith]
-
 theorem attach_map_coe (l : Array α) (f : α → β) :
     (l.attach.map fun (i : {i // i ∈ l}) => f i) = l.map f := by
   cases l
-  simp
+  simp [List.attach_map_coe]
 
 theorem attach_map_val (l : Array α) (f : α → β) : (l.attach.map fun i => f i.val) = l.map f :=
   attach_map_coe _ _
@@ -179,12 +172,6 @@ theorem mem_attach (l : Array α) : ∀ x, x ∈ l.attach
     rcases this with ⟨⟨_, _⟩, m, rfl⟩
     exact m
 
-@[simp]
-theorem mem_attachWith (l : Array α) {q : α → Prop} (H) (x : {x // q x}) :
-    x ∈ l.attachWith q H ↔ x.1 ∈ l := by
-  cases l
-  simp
-
 @[simp]
 theorem mem_pmap {p : α → Prop} {f : ∀ a, p a → β} {l H b} :
     b ∈ pmap f l H ↔ ∃ (a : _) (h : a ∈ l), f a (H a h) = b := by
@@ -236,16 +223,16 @@ theorem attachWith_ne_empty_iff {l : Array α} {P : α → Prop} {H : ∀ a ∈
   cases l; simp
 
 @[simp]
-theorem getElem?_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : Array α} (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
+theorem getElem?_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : Array α} (h : ∀ a ∈ l, p a) (n : Nat) :
+    (pmap f l h)[n]? = Option.pmap f l[n]? fun x H => h x (mem_of_getElem? H) := by
   cases l; simp
 
 @[simp]
-theorem getElem_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : Array α} (h : ∀ a ∈ l, p a) {i : Nat}
-    (hi : i < (pmap f l h).size) :
-    (pmap f l h)[i] =
-      f (l[i]'(@size_pmap _ _ p f l h ▸ hi))
-        (h _ (getElem_mem (@size_pmap _ _ p f l h ▸ hi))) := by
+theorem getElem_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : Array α} (h : ∀ a ∈ l, p a) {n : Nat}
+    (hn : n < (pmap f l h).size) :
+    (pmap f l h)[n] =
+      f (l[n]'(@size_pmap _ _ p f l h ▸ hn))
+        (h _ (getElem_mem (@size_pmap _ _ p f l h ▸ hn))) := by
   cases l; simp
 
 @[simp]
@@ -269,18 +256,6 @@ 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 (l : Array α) {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
-  ext <;> simp
-
-@[simp] theorem pmap_attachWith (l : Array α) {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
-  ext <;> simp
-
 theorem foldl_pmap (l : Array α) {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
@@ -338,7 +313,11 @@ theorem attachWith_map {l : Array α} (f : α → β) {P : β → Prop} {H : ∀
     (l.map f).attachWith P H = (l.attachWith (P ∘ f) (fun _ h => H _ (mem_map_of_mem f h))).map
       fun ⟨x, h⟩ => ⟨f x, h⟩ := by
   cases l
-  simp [List.attachWith_map]
+  ext
+  · simp
+  · simp only [List.map_toArray, List.attachWith_toArray, List.getElem_toArray,
+      List.getElem_attachWith, List.getElem_map, Function.comp_apply]
+    erw [List.getElem_attachWith] -- Why is `erw` needed here?
 
 theorem map_attachWith {l : Array α} {P : α → Prop} {H : ∀ (a : α), a ∈ l → P a}
     (f : { x // P x } → β) :
@@ -368,23 +347,7 @@ theorem attach_filter {l : Array α} (p : α → Bool) :
   simp [List.attach_filter, List.map_filterMap, Function.comp_def]
 
 -- We are still missing here `attachWith_filterMap` and `attachWith_filter`.
-
-@[simp]
-theorem filterMap_attachWith {q : α → Prop} {l : Array α} {f : {x // q x} → Option β} (H)
-    (w : stop = (l.attachWith q H).size) :
-    (l.attachWith q H).filterMap f 0 stop = l.attach.filterMap (fun ⟨x, h⟩ => f ⟨x, H _ h⟩) := by
-  subst w
-  cases l
-  simp [Function.comp_def]
-
-@[simp]
-theorem filter_attachWith {q : α → Prop} {l : Array α} {p : {x // q x} → Bool} (H)
-    (w : stop = (l.attachWith q H).size) :
-    (l.attachWith q H).filter p 0 stop =
-      (l.attach.filter (fun ⟨x, h⟩ => p ⟨x, H _ h⟩)).map (fun ⟨x, h⟩ => ⟨x, H _ h⟩) := by
-  subst w
-  cases l
-  simp [Function.comp_def, List.filter_map]
+-- Also missing are `filterMap_attach`, `filter_attach`, `filterMap_attachWith` and `filter_attachWith`.
 
 theorem pmap_pmap {p : α → Prop} {q : β → Prop} (g : ∀ a, p a → β) (f : ∀ b, q b → γ) (l H₁ H₂) :
     pmap f (pmap g l H₁) H₂ =
@@ -464,48 +427,16 @@ theorem reverse_attach (xs : Array α) :
 
 @[simp] theorem back?_attachWith {P : α → Prop} {xs : Array α}
     {H : ∀ (a : α), a ∈ xs → P a} :
-    (xs.attachWith P H).back? = xs.back?.pbind (fun a h => some ⟨a, H _ (mem_of_back? h)⟩) := by
+    (xs.attachWith P H).back? = xs.back?.pbind (fun a h => some ⟨a, H _ (mem_of_back?_eq_some h)⟩) := by
   cases xs
   simp
 
 @[simp]
 theorem back?_attach {xs : Array α} :
-    xs.attach.back? = xs.back?.pbind fun a h => some ⟨a, mem_of_back? h⟩ := by
+    xs.attach.back? = xs.back?.pbind fun a h => some ⟨a, mem_of_back?_eq_some h⟩ := by
   cases xs
   simp
 
-@[simp]
-theorem countP_attach (l : Array α) (p : α → Bool) :
-    l.attach.countP (fun a : {x // x ∈ l} => p a) = l.countP p := by
-  cases l
-  simp [Function.comp_def]
-
-@[simp]
-theorem countP_attachWith {p : α → Prop} (l : Array α) (H : ∀ a ∈ l, p a) (q : α → Bool) :
-    (l.attachWith p H).countP (fun a : {x // p x} => q a) = l.countP q := by
-  cases l
-  simp
-
-@[simp]
-theorem count_attach [DecidableEq α] (l : Array α) (a : {x // x ∈ l}) :
-    l.attach.count a = l.count ↑a := by
-  rcases l with ⟨l⟩
-  simp only [List.attach_toArray, List.attachWith_mem_toArray, List.count_toArray]
-  rw [List.map_attach, List.count_eq_countP]
-  simp only [Subtype.beq_iff]
-  rw [List.countP_pmap, List.countP_attach (p := (fun x => x == a.1)), List.count]
-
-@[simp]
-theorem count_attachWith [DecidableEq α] {p : α → Prop} (l : Array α) (H : ∀ a ∈ l, p a) (a : {x // p x}) :
-    (l.attachWith p H).count a = l.count ↑a := by
-  cases l
-  simp
-
-@[simp] theorem countP_pmap {p : α → Prop} (g : ∀ a, p a → β) (f : β → Bool) (l : Array α) (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]
-
 /-! ## unattach
 
 `Array.unattach` is the (one-sided) inverse of `Array.attach`. It is a synonym for `Array.map Subtype.val`.
@@ -524,7 +455,7 @@ and is ideally subsequently simplified away by `unattach_attach`.
 
 If not, usually the right approach is `simp [Array.unattach, -Array.map_subtype]` to unfold.
 -/
-def unattach {α : Type _} {p : α → Prop} (l : Array { x // p x }) : Array α := l.map (·.val)
+def unattach {α : Type _} {p : α → Prop} (l : Array { x // p x }) := l.map (·.val)
 
 @[simp] theorem unattach_nil {p : α → Prop} : (#[] : Array { x // p x }).unattach = #[] := rfl
 @[simp] theorem unattach_push {p : α → Prop} {a : { x // p x }} {l : Array { x // p x }} :
@@ -647,16 +578,4 @@ and simplifies these to the function directly taking the value.
   cases l₂
   simp
 
-@[simp] theorem unattach_flatten {p : α → Prop} {l : Array (Array { x // p x })} :
-    l.flatten.unattach = (l.map unattach).flatten := by
-  unfold unattach
-  cases l using array₂_induction
-  simp only [flatten_toArray, List.map_map, Function.comp_def, List.map_id_fun', id_eq,
-    List.map_toArray, List.map_flatten, map_subtype, map_id_fun', List.unattach_toArray, mk.injEq]
-  simp only [List.unattach]
-
-@[simp] theorem unattach_mkArray {p : α → Prop} {n : Nat} {x : { x // p x }} :
-    (Array.mkArray n x).unattach = Array.mkArray n x.1 := by
-  simp [unattach]
-
 end Array

src/Init/Data/Array/Basic.lean

@@ -244,7 +244,8 @@ def ofFn {n} (f : Fin n → α) : Array α := go 0 (mkEmpty n) where
 def range (n : Nat) : Array Nat :=
   ofFn fun (i : Fin n) => i
 
-@[inline] protected def singleton (v : α) : Array α := #[v]
+def singleton (v : α) : Array α :=
+  mkArray 1 v
 
 def back! [Inhabited α] (a : Array α) : α :=
   a[a.size - 1]!
@@ -455,7 +456,7 @@ def mapM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α
 /-- Variant of `mapIdxM` which receives the index as a `Fin as.size`. -/
 @[inline]
 def mapFinIdxM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m]
-    (as : Array α) (f : (i : Nat) → α → (h : i < as.size) → m β) : m (Array β) :=
+    (as : Array α) (f : Fin as.size → α → m β) : m (Array β) :=
   let rec @[specialize] map (i : Nat) (j : Nat) (inv : i + j = as.size) (bs : Array β) : m (Array β) := do
     match i, inv with
     | 0,    _  => pure bs
@@ -464,12 +465,12 @@ def mapFinIdxM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m]
         rw [← inv, Nat.add_assoc, Nat.add_comm 1 j, Nat.add_comm]
         apply Nat.le_add_right
       have : i + (j + 1) = as.size := by rw [← inv, Nat.add_comm j 1, Nat.add_assoc]
-      map i (j+1) this (bs.push (← f j (as.get j j_lt) j_lt))
+      map i (j+1) this (bs.push (← f ⟨j, j_lt⟩ (as.get j j_lt)))
   map as.size 0 rfl (mkEmpty as.size)
 
 @[inline]
 def mapIdxM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : Nat → α → m β) (as : Array α) : m (Array β) :=
-  as.mapFinIdxM fun i a _ => f i a
+  as.mapFinIdxM fun i a => f i a
 
 @[inline]
 def findSomeM? {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → m (Option β)) (as : Array α) : m (Option β) := do
@@ -576,28 +577,13 @@ def foldl {α : Type u} {β : Type v} (f : β → α → β) (init : β) (as : A
 def foldr {α : Type u} {β : Type v} (f : α → β → β) (init : β) (as : Array α) (start := as.size) (stop := 0) : β :=
   Id.run <| as.foldrM f init start stop
 
-/-- Sum of an array.
-
-`Array.sum #[a, b, c] = a + (b + (c + 0))` -/
-@[inline]
-def sum {α} [Add α] [Zero α] : Array α → α :=
-  foldr (· + ·) 0
-
-@[inline]
-def countP {α : Type u} (p : α → Bool) (as : Array α) : Nat :=
-  as.foldr (init := 0) fun a acc => bif p a then acc + 1 else acc
-
-@[inline]
-def count {α : Type u} [BEq α] (a : α) (as : Array α) : Nat :=
-  countP (· == a) as
-
 @[inline]
 def map {α : Type u} {β : Type v} (f : α → β) (as : Array α) : Array β :=
   Id.run <| as.mapM f
 
 /-- Variant of `mapIdx` which receives the index as a `Fin as.size`. -/
 @[inline]
-def mapFinIdx {α : Type u} {β : Type v} (as : Array α) (f : (i : Nat) → α → (h : i < as.size) → β) : Array β :=
+def mapFinIdx {α : Type u} {β : Type v} (as : Array α) (f : Fin as.size → α → β) : Array β :=
   Id.run <| as.mapFinIdxM f
 
 @[inline]

src/Init/Data/Array/Bootstrap.lean

@@ -81,18 +81,12 @@ theorem foldrM_eq_reverse_foldlM_toList [Monad m] (f : α → β → m β) (init
 
 @[simp] theorem toList_empty : (#[] : Array α).toList = [] := rfl
 
-@[simp] theorem append_empty (as : Array α) : as ++ #[] = as := by
+@[simp] theorem append_nil (as : Array α) : as ++ #[] = as := 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 (as : Array α) : #[] ++ as = as := by
+@[simp] theorem nil_append (as : Array α) : #[] ++ as = as := 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 (as bs cs : Array α) : as ++ bs ++ cs = as ++ (bs ++ cs) := by
   apply ext'; simp only [toList_append, List.append_assoc]
 

src/Init/Data/Array/Count.lean

@@ -1,270 +0,0 @@
-/-
-Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.Array.Lemmas
-import Init.Data.List.Nat.Count
-
-/-!
-# Lemmas about `Array.countP` and `Array.count`.
--/
-
-namespace Array
-
-open Nat
-
-/-! ### countP -/
-section countP
-
-variable (p q : α → Bool)
-
-@[simp] theorem countP_empty : countP p #[] = 0 := rfl
-
-@[simp] theorem countP_push_of_pos (l) (pa : p a) : countP p (l.push a) = countP p l + 1 := by
-  rcases l with ⟨l⟩
-  simp_all
-
-@[simp] theorem countP_push_of_neg (l) (pa : ¬p a) : countP p (l.push a) = countP p l := by
-  rcases l with ⟨l⟩
-  simp_all
-
-theorem countP_push (a : α) (l) : countP p (l.push a) = countP p l + if p a then 1 else 0 := by
-  rcases l with ⟨l⟩
-  simp_all
-
-@[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 (l) : l.size = countP p l + countP (fun a => ¬p a) l := by
-  cases l
-  simp [List.length_eq_countP_add_countP (p := p)]
-
-theorem countP_eq_size_filter (l) : countP p l = (filter p l).size := by
-  cases l
-  simp [List.countP_eq_length_filter]
-
-theorem countP_eq_size_filter' : countP p = size ∘ filter p := by
-  funext l
-  apply countP_eq_size_filter
-
-theorem countP_le_size : countP p l ≤ l.size := by
-  simp only [countP_eq_size_filter]
-  apply size_filter_le
-
-@[simp] theorem countP_append (l₁ l₂) : countP p (l₁ ++ l₂) = countP p l₁ + countP p l₂ := by
-  cases l₁
-  cases l₂
-  simp
-
-@[simp] theorem countP_pos_iff {p} : 0 < countP p l ↔ ∃ a ∈ l, p a := by
-  cases l
-  simp
-
-@[simp] theorem one_le_countP_iff {p} : 1 ≤ countP p l ↔ ∃ a ∈ l, p a :=
-  countP_pos_iff
-
-@[simp] theorem countP_eq_zero {p} : countP p l = 0 ↔ ∀ a ∈ l, ¬p a := by
-  cases l
-  simp
-
-@[simp] theorem countP_eq_size {p} : countP p l = l.size ↔ ∀ a ∈ l, p a := by
-  cases l
-  simp
-
-theorem countP_mkArray (p : α → Bool) (a : α) (n : Nat) :
-    countP p (mkArray n a) = if p a then n else 0 := by
-  simp [← List.toArray_replicate, List.countP_replicate]
-
-theorem boole_getElem_le_countP (p : α → Bool) (l : Array α) (i : Nat) (h : i < l.size) :
-    (if p l[i] then 1 else 0) ≤ l.countP p := by
-  cases l
-  simp [List.boole_getElem_le_countP]
-
-theorem countP_set (p : α → Bool) (l : Array α) (i : Nat) (a : α) (h : i < l.size) :
-    (l.set i a).countP p = l.countP p - (if p l[i] then 1 else 0) + (if p a then 1 else 0) := by
-  cases l
-  simp [List.countP_set, h]
-
-theorem countP_filter (l : Array α) :
-    countP p (filter q l) = countP (fun a => p a && q a) l := by
-  cases l
-  simp [List.countP_filter]
-
-@[simp] theorem countP_true : (countP fun (_ : α) => true) = size := by
-  funext l
-  simp
-
-@[simp] theorem countP_false : (countP fun (_ : α) => false) = Function.const _ 0 := by
-  funext l
-  simp
-
-@[simp] theorem countP_map (p : β → Bool) (f : α → β) (l : Array α) :
-    countP p (map f l) = countP (p ∘ f) l := by
-  cases l
-  simp
-
-theorem size_filterMap_eq_countP (f : α → Option β) (l : Array α) :
-    (filterMap f l).size = countP (fun a => (f a).isSome) l := by
-  cases l
-  simp [List.length_filterMap_eq_countP]
-
-theorem countP_filterMap (p : β → Bool) (f : α → Option β) (l : Array α) :
-    countP p (filterMap f l) = countP (fun a => ((f a).map p).getD false) l := by
-  cases l
-  simp [List.countP_filterMap]
-
-@[simp] theorem countP_flatten (l : Array (Array α)) :
-    countP p l.flatten = (l.map (countP p)).sum := by
-  cases l using array₂_induction
-  simp [List.countP_flatten, Function.comp_def]
-
-theorem countP_flatMap (p : β → Bool) (l : Array α) (f : α → Array β) :
-    countP p (l.flatMap f) = sum (map (countP p ∘ f) l) := by
-  cases l
-  simp [List.countP_flatMap, Function.comp_def]
-
-@[simp] theorem countP_reverse (l : Array α) : countP p l.reverse = countP p l := by
-  cases l
-  simp [List.countP_reverse]
-
-variable {p q}
-
-theorem countP_mono_left (h : ∀ x ∈ l, p x → q x) : countP p l ≤ countP q l := by
-  cases l
-  simpa using List.countP_mono_left (by simpa using h)
-
-theorem countP_congr (h : ∀ x ∈ l, p x ↔ q x) : countP p l = countP q l :=
-  Nat.le_antisymm
-    (countP_mono_left fun x hx => (h x hx).1)
-    (countP_mono_left fun x hx => (h x hx).2)
-
-end countP
-
-/-! ### count -/
-section count
-
-variable [BEq α]
-
-@[simp] theorem count_empty (a : α) : count a #[] = 0 := rfl
-
-theorem count_push (a b : α) (l : Array α) :
-    count a (l.push b) = count a l + if b == a then 1 else 0 := by
-  simp [count, countP_push]
-
-theorem count_eq_countP (a : α) (l : Array α) : 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_le_size (a : α) (l : Array α) : count a l ≤ l.size := countP_le_size _
-
-theorem count_le_count_push (a b : α) (l : Array α) : count a l ≤ count a (l.push b) := by
-  simp [count_push]
-
-@[simp] 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 : α) : ∀ l₁ l₂, count a (l₁ ++ l₂) = count a l₁ + count a l₂ :=
-  countP_append _
-
-@[simp] theorem count_flatten (a : α) (l : Array (Array α)) :
-    count a l.flatten = (l.map (count a)).sum := by
-  cases l using array₂_induction
-  simp [List.count_flatten, Function.comp_def]
-
-@[simp] theorem count_reverse (a : α) (l : Array α) : count a l.reverse = count a l := by
-  cases l
-  simp
-
-theorem boole_getElem_le_count (a : α) (l : Array α) (i : Nat) (h : i < l.size) :
-    (if l[i] == a then 1 else 0) ≤ l.count a := by
-  rw [count_eq_countP]
-  apply boole_getElem_le_countP (· == a)
-
-theorem count_set (a b : α) (l : Array α) (i : Nat) (h : i < l.size) :
-    (l.set i a).count b = l.count b - (if l[i] == b then 1 else 0) + (if a == b then 1 else 0) := by
-  simp [count_eq_countP, countP_set, h]
-
-variable [LawfulBEq α]
-
-@[simp] theorem count_push_self (a : α) (l : Array α) : count a (l.push a) = count a l + 1 := by
-  simp [count_push]
-
-@[simp] theorem count_push_of_ne (h : b ≠ a) (l : Array α) : count a (l.push b) = count a l := by
-  simp_all [count_push, h]
-
-theorem count_singleton_self (a : α) : count a #[a] = 1 := by simp
-
-@[simp]
-theorem count_pos_iff {a : α} {l : Array α} : 0 < count a l ↔ a ∈ l := by
-  simp only [count, countP_pos_iff, beq_iff_eq, exists_eq_right]
-
-@[simp] theorem one_le_count_iff {a : α} {l : Array α} : 1 ≤ count a l ↔ a ∈ l :=
-  count_pos_iff
-
-theorem count_eq_zero_of_not_mem {a : α} {l : Array α} (h : a ∉ l) : count a l = 0 :=
-  Decidable.byContradiction fun h' => h <| count_pos_iff.1 (Nat.pos_of_ne_zero h')
-
-theorem not_mem_of_count_eq_zero {a : α} {l : Array α} (h : count a l = 0) : a ∉ l :=
-  fun h' => Nat.ne_of_lt (count_pos_iff.2 h') h.symm
-
-theorem count_eq_zero {l : Array α} : count a l = 0 ↔ a ∉ l :=
-  ⟨not_mem_of_count_eq_zero, count_eq_zero_of_not_mem⟩
-
-theorem count_eq_size {l : Array α} : count a l = l.size ↔ ∀ b ∈ l, a = b := by
-  rw [count, countP_eq_size]
-  refine ⟨fun h b hb => Eq.symm ?_, fun h b hb => ?_⟩
-  · simpa using h b hb
-  · rw [h b hb, beq_self_eq_true]
-
-@[simp] theorem count_mkArray_self (a : α) (n : Nat) : count a (mkArray n a) = n := by
-  simp [← List.toArray_replicate]
-
-theorem count_mkArray (a b : α) (n : Nat) : count a (mkArray n b) = if b == a then n else 0 := by
-  simp [← List.toArray_replicate, List.count_replicate]
-
-theorem filter_beq (l : Array α) (a : α) : l.filter (· == a) = mkArray (count a l) a := by
-  cases l
-  simp [List.filter_beq]
-
-theorem filter_eq {α} [DecidableEq α] (l : Array α) (a : α) : l.filter (· = a) = mkArray (count a l) a :=
-  filter_beq l a
-
-theorem mkArray_count_eq_of_count_eq_size {l : Array α} (h : count a l = l.size) :
-    mkArray (count a l) a = l := by
-  cases l
-  rw [← toList_inj]
-  simp [List.replicate_count_eq_of_count_eq_length (by simpa using h)]
-
-@[simp] theorem count_filter {l : Array α} (h : p a) : count a (filter p l) = count a l := by
-  cases l
-  simp [List.count_filter, h]
-
-theorem count_le_count_map [DecidableEq β] (l : Array α) (f : α → β) (x : α) :
-    count x l ≤ count (f x) (map f l) := by
-  cases l
-  simp [List.count_le_count_map, countP_map]
-
-theorem count_filterMap {α} [BEq β] (b : β) (f : α → Option β) (l : Array α) :
-    count b (filterMap f l) = countP (fun a => f a == some b) l := by
-  cases l
-  simp [List.count_filterMap, countP_filterMap]
-
-theorem count_flatMap {α} [BEq β] (l : Array α) (f : α → Array β) (x : β) :
-    count x (l.flatMap f) = sum (map (count x ∘ f) l) := by
-  simp [count_eq_countP, countP_flatMap, Function.comp_def]
-
--- FIXME these theorems can be restored once `List.erase` and `Array.erase` have been related.
-
--- theorem count_erase (a b : α) (l : Array α) : count a (l.erase b) = count a l - if b == a then 1 else 0 := by
---   sorry
-
--- @[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)]
-
--- @[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]
-
-end count

src/Init/Data/Array/Find.lean

@@ -74,12 +74,12 @@ theorem findSome?_append {l₁ l₂ : Array α} : (l₁ ++ l₂).findSome? f = (
 
 theorem getElem?_zero_flatten (L : Array (Array α)) :
     (flatten L)[0]? = L.findSome? fun l => l[0]? := by
-  cases L using array₂_induction
+  cases L using array_array_induction
   simp [← List.head?_eq_getElem?, List.head?_flatten, List.findSome?_map, Function.comp_def]
 
 theorem getElem_zero_flatten.proof {L : Array (Array α)} (h : 0 < L.flatten.size) :
     (L.findSome? fun l => l[0]?).isSome := by
-  cases L using array₂_induction
+  cases L using array_array_induction
   simp only [List.findSome?_toArray, List.findSome?_map, Function.comp_def, List.getElem?_toArray,
     List.findSome?_isSome_iff, isSome_getElem?]
   simp only [flatten_toArray_map_toArray, size_toArray, List.length_flatten,
@@ -95,7 +95,7 @@ theorem getElem_zero_flatten {L : Array (Array α)} (h) :
 
 theorem back?_flatten {L : Array (Array α)} :
     (flatten L).back? = (L.findSomeRev? fun l => l.back?) := by
-  cases L using array₂_induction
+  cases L using array_array_induction
   simp [List.getLast?_flatten, ← List.map_reverse, List.findSome?_map, Function.comp_def]
 
 theorem findSome?_mkArray : findSome? f (mkArray n a) = if n = 0 then none else f a := by
@@ -203,7 +203,7 @@ theorem get_find?_mem {xs : Array α} (h) : (xs.find? p).get h ∈ xs := by
 
 @[simp] theorem find?_flatten (xs : Array (Array α)) (p : α → Bool) :
     xs.flatten.find? p = xs.findSome? (·.find? p) := by
-  cases xs using array₂_induction
+  cases xs using array_array_induction
   simp [List.findSome?_map, Function.comp_def]
 
 theorem find?_flatten_eq_none {xs : Array (Array α)} {p : α → Bool} :
@@ -220,7 +220,7 @@ theorem find?_flatten_eq_some {xs : Array (Array α)} {p : α → Bool} {a : α}
       p a ∧ ∃ (as : Array (Array α)) (ys zs : Array α) (bs : Array (Array α)),
         xs = as.push (ys.push a ++ zs) ++ bs ∧
         (∀ a ∈ as, ∀ x ∈ a, !p x) ∧ (∀ x ∈ ys, !p x) := by
-  cases xs using array₂_induction
+  cases xs using array_array_induction
   simp only [flatten_toArray_map_toArray, List.find?_toArray, List.find?_flatten_eq_some]
   simp only [Bool.not_eq_eq_eq_not, Bool.not_true, exists_and_right, and_congr_right_iff]
   intro w

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

@@ -17,8 +17,8 @@ namespace Array
 @[simp] theorem lt_toList [LT α] (l₁ l₂ : Array α) : l₁.toList < l₂.toList ↔ l₁ < l₂ := Iff.rfl
 @[simp] theorem le_toList [LT α] (l₁ l₂ : Array α) : l₁.toList ≤ l₂.toList ↔ l₁ ≤ l₂ := 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 α) :
+theorem not_lt_iff_ge [LT α] (l₁ l₂ : List α) : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
+theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] (l₁ l₂ : List α) :
     ¬ l₁ ≤ l₂ ↔ l₂ < l₁ :=
   Decidable.not_not
 
@@ -135,7 +135,7 @@ protected theorem le_of_lt [DecidableEq α] [LT α] [DecidableLT α]
     {l₁ l₂ : Array α} (h : l₁ < l₂) : l₁ ≤ l₂ :=
   List.le_of_lt h
 
-protected theorem le_iff_lt_or_eq [DecidableEq α] [LT α] [DecidableLT α]
+theorem le_iff_lt_or_eq [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)]
     [Std.Total (¬ · < · : α → α → Prop)]
@@ -211,7 +211,7 @@ theorem lex_eq_false_iff_exists [BEq α] [PartialEquivBEq α] (lt : α → α
   cases l₂
   simp_all [List.lex_eq_false_iff_exists]
 
-protected theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Array α} :
+theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Array α} :
     l₁ < l₂ ↔
       (l₁ = l₂.take l₁.size ∧ l₁.size < l₂.size) ∨
         (∃ (i : Nat) (h₁ : i < l₁.size) (h₂ : i < l₂.size),
@@ -221,7 +221,7 @@ protected theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁
   cases l₂
   simp [List.lt_iff_exists]
 
-protected theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
+theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Asymm (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)] {l₁ l₂ : Array α} :
@@ -258,14 +258,14 @@ theorem le_append_left [LT α] [Std.Irrefl (· < · : α → α → Prop)]
   cases l₂
   simpa using List.le_append_left
 
-protected theorem map_lt [LT α] [LT β]
+theorem map_lt [LT α] [LT β]
     {l₁ l₂ : Array α} {f : α → β} (w : ∀ x y, x < y → f x < f y) (h : l₁ < l₂) :
     map f l₁ < map f l₂ := by
   cases l₁
   cases l₂
   simpa using List.map_lt w h
 
-protected theorem map_le [DecidableEq α] [LT α] [DecidableLT α] [DecidableEq β] [LT β] [DecidableLT β]
+theorem map_le [DecidableEq α] [LT α] [DecidableLT α] [DecidableEq β] [LT β] [DecidableLT β]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Asymm (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)]

src/Init/Data/Array/MapIdx.lean

@@ -5,7 +5,6 @@ Authors: Mario Carneiro, Kim Morrison
 -/
 prelude
 import Init.Data.Array.Lemmas
-import Init.Data.Array.Attach
 import Init.Data.List.MapIdx
 
 namespace Array
@@ -13,82 +12,81 @@ namespace Array
 /-! ### mapFinIdx -/
 
 -- This could also be proved from `SatisfiesM_mapIdxM` in Batteries.
-theorem mapFinIdx_induction (as : Array α) (f : (i : Nat) → α → (h : i < as.size) → β)
+theorem mapFinIdx_induction (as : Array α) (f : Fin as.size → α → β)
     (motive : Nat → Prop) (h0 : motive 0)
-    (p : (i : Nat) → β → (h : i < as.size) → Prop)
-    (hs : ∀ i h, motive i → p i (f i as[i] h) h ∧ motive (i + 1)) :
+    (p : Fin as.size → β → Prop)
+    (hs : ∀ i, motive i.1 → p i (f i as[i]) ∧ motive (i + 1)) :
     motive as.size ∧ ∃ eq : (Array.mapFinIdx as f).size = as.size,
-      ∀ i h, p i ((Array.mapFinIdx as f)[i]) h := by
-  let rec go {bs i j h} (h₁ : j = bs.size) (h₂ : ∀ i h h', p i bs[i] h) (hm : motive j) :
+      ∀ i h, p ⟨i, h⟩ ((Array.mapFinIdx as f)[i]) := by
+  let rec go {bs i j h} (h₁ : j = bs.size) (h₂ : ∀ i h h', p ⟨i, h⟩ bs[i]) (hm : motive j) :
     let arr : Array β := Array.mapFinIdxM.map (m := Id) as f i j h bs
-    motive as.size ∧ ∃ eq : arr.size = as.size, ∀ i h, p i arr[i] h := by
+    motive as.size ∧ ∃ eq : arr.size = as.size, ∀ i h, p ⟨i, h⟩ arr[i] := by
     induction i generalizing j bs with simp [mapFinIdxM.map]
     | zero =>
       have := (Nat.zero_add _).symm.trans h
       exact ⟨this ▸ hm, h₁ ▸ this, fun _ _ => h₂ ..⟩
     | succ i ih =>
-      apply @ih (bs.push (f j as[j] (by omega))) (j + 1) (by omega) (by simp; omega)
+      apply @ih (bs.push (f ⟨j, by omega⟩ as[j])) (j + 1) (by omega) (by simp; omega)
       · intro i i_lt h'
         rw [getElem_push]
         split
         · apply h₂
         · simp only [size_push] at h'
           obtain rfl : i = j := by omega
-          apply (hs i (by omega) hm).1
-      · exact (hs j (by omega) hm).2
+          apply (hs ⟨i, by omega⟩ hm).1
+      · exact (hs ⟨j, by omega⟩ hm).2
   simp [mapFinIdx, mapFinIdxM]; exact go rfl nofun h0
 
-theorem mapFinIdx_spec (as : Array α) (f : (i : Nat) → α → (h : i < as.size) → β)
-    (p : (i : Nat) → β → (h : i < as.size) → Prop) (hs : ∀ i h, p i (f i as[i] h) h) :
+theorem mapFinIdx_spec (as : Array α) (f : Fin as.size → α → β)
+    (p : Fin as.size → β → Prop) (hs : ∀ i, p i (f i as[i])) :
     ∃ eq : (Array.mapFinIdx as f).size = as.size,
-      ∀ i h, p i ((Array.mapFinIdx as f)[i]) h :=
-  (mapFinIdx_induction _ _ (fun _ => True) trivial p fun _ _ _ => ⟨hs .., trivial⟩).2
+      ∀ i h, p ⟨i, h⟩ ((Array.mapFinIdx as f)[i]) :=
+  (mapFinIdx_induction _ _ (fun _ => True) trivial p fun _ _ => ⟨hs .., trivial⟩).2
 
-@[simp] theorem size_mapFinIdx (a : Array α) (f : (i : Nat) → α → (h : i < a.size) → β) :
-    (a.mapFinIdx f).size = a.size :=
-  (mapFinIdx_spec (p := fun _ _ _ => True) (hs := fun _ _ => trivial)).1
+@[simp] theorem size_mapFinIdx (a : Array α) (f : Fin a.size → α → β) : (a.mapFinIdx f).size = a.size :=
+  (mapFinIdx_spec (p := fun _ _ => True) (hs := fun _ => trivial)).1
 
 @[simp] theorem size_zipWithIndex (as : Array α) : as.zipWithIndex.size = as.size :=
   Array.size_mapFinIdx _ _
 
-@[simp] theorem getElem_mapFinIdx (a : Array α) (f : (i : Nat) → α → (h : i < a.size) → β) (i : Nat)
+@[simp] theorem getElem_mapFinIdx (a : Array α) (f : Fin a.size → α → β) (i : Nat)
     (h : i < (mapFinIdx a f).size) :
-    (a.mapFinIdx f)[i] = f i (a[i]'(by simp_all))  (by simp_all) :=
-  (mapFinIdx_spec _ _ (fun i b h => b = f i a[i] h) fun _ _ => rfl).2 i _
+    (a.mapFinIdx f)[i] = f ⟨i, by simp_all⟩ (a[i]'(by simp_all)) :=
+  (mapFinIdx_spec _ _ (fun i b => b = f i a[i]) fun _ => rfl).2 i _
 
-@[simp] theorem getElem?_mapFinIdx (a : Array α) (f : (i : Nat) → α → (h : i < a.size) → β) (i : Nat) :
+@[simp] theorem getElem?_mapFinIdx (a : Array α) (f : Fin a.size → α → β) (i : Nat) :
     (a.mapFinIdx f)[i]? =
-      a[i]?.pbind fun b h => f i b (getElem?_eq_some_iff.1 h).1 := by
+      a[i]?.pbind fun b h => f ⟨i, (getElem?_eq_some_iff.1 h).1⟩ b := by
   simp only [getElem?_def, size_mapFinIdx, getElem_mapFinIdx]
   split <;> simp_all
 
-@[simp] theorem toList_mapFinIdx (a : Array α) (f : (i : Nat) → α → (h : i < a.size) → β) :
-    (a.mapFinIdx f).toList = a.toList.mapFinIdx (fun i a h => f i a (by simpa)) := by
+@[simp] theorem toList_mapFinIdx (a : Array α) (f : Fin a.size → α → β) :
+    (a.mapFinIdx f).toList = a.toList.mapFinIdx (fun i a => f ⟨i, by simp⟩ a) := by
   apply List.ext_getElem <;> simp
 
 /-! ### mapIdx -/
 
 theorem mapIdx_induction (f : Nat → α → β) (as : Array α)
     (motive : Nat → Prop) (h0 : motive 0)
-    (p : (i : Nat) → β → (h : i < as.size) → Prop)
-    (hs : ∀ i h, motive i → p i (f i as[i]) h ∧ motive (i + 1)) :
+    (p : Fin as.size → β → Prop)
+    (hs : ∀ i, motive i.1 → p i (f i as[i]) ∧ motive (i + 1)) :
     motive as.size ∧ ∃ eq : (as.mapIdx f).size = as.size,
-      ∀ i h, p i ((as.mapIdx f)[i]) h :=
-  mapFinIdx_induction as (fun i a _ => f i a) motive h0 p hs
+      ∀ i h, p ⟨i, h⟩ ((as.mapIdx f)[i]) :=
+  mapFinIdx_induction as (fun i a => f i a) motive h0 p hs
 
 theorem mapIdx_spec (f : Nat → α → β) (as : Array α)
-    (p : (i : Nat) → β → (h : i < as.size) → Prop) (hs : ∀ i h, p i (f i as[i]) h) :
+    (p : Fin as.size → β → Prop) (hs : ∀ i, p i (f i as[i])) :
     ∃ eq : (as.mapIdx f).size = as.size,
-      ∀ i h, p i ((as.mapIdx f)[i]) h :=
-  (mapIdx_induction _ _ (fun _ => True) trivial p fun _ _ _ => ⟨hs .., trivial⟩).2
+      ∀ i h, p ⟨i, h⟩ ((as.mapIdx f)[i]) :=
+  (mapIdx_induction _ _ (fun _ => True) trivial p fun _ _ => ⟨hs .., trivial⟩).2
 
 @[simp] theorem size_mapIdx (f : Nat → α → β) (as : Array α) : (as.mapIdx f).size = as.size :=
-  (mapIdx_spec (p := fun _ _ _ => True) (hs := fun _ _ => trivial)).1
+  (mapIdx_spec (p := fun _ _ => True) (hs := fun _ => trivial)).1
 
 @[simp] theorem getElem_mapIdx (f : Nat → α → β) (as : Array α) (i : Nat)
     (h : i < (as.mapIdx f).size) :
     (as.mapIdx f)[i] = f i (as[i]'(by simp_all)) :=
-  (mapIdx_spec _ _ (fun i b h => b = f i as[i]) fun _ _ => rfl).2 i (by simp_all)
+  (mapIdx_spec _ _ (fun i b => b = f i as[i]) fun _ => rfl).2 i (by simp_all)
 
 @[simp] theorem getElem?_mapIdx (f : Nat → α → β) (as : Array α) (i : Nat) :
     (as.mapIdx f)[i]? =
@@ -103,7 +101,7 @@ end Array
 
 namespace List
 
-@[simp] theorem mapFinIdx_toArray (l : List α) (f : (i : Nat) → α → (h : i < l.length) → β) :
+@[simp] theorem mapFinIdx_toArray (l : List α) (f : Fin l.length → α → β) :
     l.toArray.mapFinIdx f = (l.mapFinIdx f).toArray := by
   ext <;> simp
 
@@ -112,293 +110,3 @@ namespace List
   ext <;> simp
 
 end List
-
-namespace Array
-
-/-! ### zipWithIndex -/
-
-@[simp] theorem getElem_zipWithIndex (a : Array α) (i : Nat) (h : i < a.zipWithIndex.size) :
-    (a.zipWithIndex)[i] = (a[i]'(by simp_all), i) := by
-  simp [zipWithIndex]
-
-@[simp] theorem zipWithIndex_toArray {l : List α} :
-    l.toArray.zipWithIndex = (l.enum.map fun (i, x) => (x, i)).toArray := by
-  ext i hi₁ hi₂ <;> simp
-
-@[simp] theorem toList_zipWithIndex (a : Array α) :
-    a.zipWithIndex.toList = a.toList.enum.map (fun (i, a) => (a, i)) := by
-  rcases a with ⟨a⟩
-  simp
-
-theorem mk_mem_zipWithIndex_iff_getElem? {x : α} {i : Nat} {l : Array α} :
-    (x, i) ∈ l.zipWithIndex ↔ l[i]? = x := by
-  rcases l with ⟨l⟩
-  simp only [zipWithIndex_toArray, mem_toArray, List.mem_map, Prod.mk.injEq, Prod.exists,
-    List.mk_mem_enum_iff_getElem?, List.getElem?_toArray]
-  constructor
-  · rintro ⟨a, b, h, rfl, rfl⟩
-    exact h
-  · intro h
-    exact ⟨i, x, by simp [h]⟩
-
-theorem mem_enum_iff_getElem? {x : α × Nat} {l : Array α} : x ∈ l.zipWithIndex ↔ l[x.2]? = some x.1 :=
-  mk_mem_zipWithIndex_iff_getElem?
-
-/-! ### mapFinIdx -/
-
-@[congr] theorem mapFinIdx_congr {xs ys : Array α} (w : xs = ys)
-    (f : (i : Nat) → α → (h : i < xs.size) → β) :
-    mapFinIdx xs f = mapFinIdx ys (fun i a h => f i a (by simp [w]; omega)) := by
-  subst w
-  rfl
-
-@[simp]
-theorem mapFinIdx_empty {f : (i : Nat) → α → (h : i < 0) → β} : mapFinIdx #[] f = #[] :=
-  rfl
-
-theorem mapFinIdx_eq_ofFn {as : Array α} {f : (i : Nat) → α → (h : i < as.size) → β} :
-    as.mapFinIdx f = Array.ofFn fun i : Fin as.size => f i as[i] i.2 := by
-  cases as
-  simp [List.mapFinIdx_eq_ofFn]
-
-theorem mapFinIdx_append {K L : Array α} {f : (i : Nat) → α → (h : i < (K ++ L).size) → β} :
-    (K ++ L).mapFinIdx f =
-      K.mapFinIdx (fun i a h => f i a (by simp; omega)) ++
-        L.mapFinIdx (fun i a h => f (i + K.size) a (by simp; omega)) := by
-  cases K
-  cases L
-  simp [List.mapFinIdx_append]
-
-@[simp]
-theorem mapFinIdx_push {l : Array α} {a : α} {f : (i : Nat) → α → (h : i < (l.push a).size) → β} :
-    mapFinIdx (l.push a) f =
-      (mapFinIdx l (fun i a h => f i a (by simp; omega))).push (f l.size a (by simp)) := by
-  simp [← append_singleton, mapFinIdx_append]
-
-theorem mapFinIdx_singleton {a : α} {f : (i : Nat) → α → (h : i < 1) → β} :
-    #[a].mapFinIdx f = #[f 0 a (by simp)] := by
-  simp
-
-theorem mapFinIdx_eq_zipWithIndex_map {l : Array α} {f : (i : Nat) → α → (h : i < l.size) → β} :
-    l.mapFinIdx f = l.zipWithIndex.attach.map
-      fun ⟨⟨x, i⟩, m⟩ =>
-        f i x (by simp [mk_mem_zipWithIndex_iff_getElem?, getElem?_eq_some_iff] at m; exact m.1) := by
-  ext <;> simp
-
-@[simp]
-theorem mapFinIdx_eq_empty_iff {l : Array α} {f : (i : Nat) → α → (h : i < l.size) → β} :
-    l.mapFinIdx f = #[] ↔ l = #[] := by
-  cases l
-  simp
-
-theorem mapFinIdx_ne_empty_iff {l : Array α} {f : (i : Nat) → α → (h : i < l.size) → β} :
-    l.mapFinIdx f ≠ #[] ↔ l ≠ #[] := by
-  simp
-
-theorem exists_of_mem_mapFinIdx {b : β} {l : Array α} {f : (i : Nat) → α → (h : i < l.size) → β}
-    (h : b ∈ l.mapFinIdx f) : ∃ (i : Nat) (h : i < l.size), f i l[i] h = b := by
-  rcases l with ⟨l⟩
-  exact List.exists_of_mem_mapFinIdx (by simpa using h)
-
-@[simp] theorem mem_mapFinIdx {b : β} {l : Array α} {f : (i : Nat) → α → (h : i < l.size) → β} :
-    b ∈ l.mapFinIdx f ↔ ∃ (i : Nat) (h : i < l.size), f i l[i] h = b := by
-  rcases l with ⟨l⟩
-  simp
-
-theorem mapFinIdx_eq_iff {l : Array α} {f : (i : Nat) → α → (h : i < l.size) → β} :
-    l.mapFinIdx f = l' ↔ ∃ h : l'.size = l.size, ∀ (i : Nat) (h : i < l.size), l'[i] = f i l[i] h := by
-  rcases l with ⟨l⟩
-  rcases l' with ⟨l'⟩
-  simpa using List.mapFinIdx_eq_iff
-
-@[simp] theorem mapFinIdx_eq_singleton_iff {l : Array α} {f : (i : Nat) → α → (h : i < l.size) → β} {b : β} :
-    l.mapFinIdx f = #[b] ↔ ∃ (a : α) (w : l = #[a]), f 0 a (by simp [w]) = b := by
-  rcases l with ⟨l⟩
-  simp
-
-theorem mapFinIdx_eq_append_iff {l : Array α} {f : (i : Nat) → α → (h : i < l.size) → β} {l₁ l₂ : Array β} :
-    l.mapFinIdx f = l₁ ++ l₂ ↔
-      ∃ (l₁' : Array α) (l₂' : Array α) (w : l = l₁' ++ l₂'),
-        l₁'.mapFinIdx (fun i a h => f i a (by simp [w]; omega)) = l₁ ∧
-        l₂'.mapFinIdx (fun i a h => f (i + l₁'.size) a (by simp [w]; omega)) = l₂ := by
-  rcases l with ⟨l⟩
-  rcases l₁ with ⟨l₁⟩
-  rcases l₂ with ⟨l₂⟩
-  simp only [List.mapFinIdx_toArray, List.append_toArray, mk.injEq, List.mapFinIdx_eq_append_iff,
-    toArray_eq_append_iff]
-  constructor
-  · rintro ⟨l₁, l₂, rfl, rfl, rfl⟩
-    refine ⟨l₁.toArray, l₂.toArray, by simp_all⟩
-  · rintro ⟨⟨l₁⟩, ⟨l₂⟩, rfl, h₁, h₂⟩
-    simp [← toList_inj] at h₁ h₂
-    obtain rfl := h₁
-    obtain rfl := h₂
-    refine ⟨l₁, l₂, by simp_all⟩
-
-theorem mapFinIdx_eq_push_iff {l : Array α} {b : β} {f : (i : Nat) → α → (h : i < l.size) → β} :
-    l.mapFinIdx f = l₂.push b ↔
-      ∃ (l₁ : Array α) (a : α) (w : l = l₁.push a),
-        l₁.mapFinIdx (fun i a h => f i a (by simp [w]; omega)) = l₂ ∧ b = f (l.size - 1) a (by simp [w]) := by
-  rw [push_eq_append, mapFinIdx_eq_append_iff]
-  constructor
-  · rintro ⟨l₁, l₂, rfl, rfl, h₂⟩
-    simp only [mapFinIdx_eq_singleton_iff, Nat.zero_add] at h₂
-    obtain ⟨a, rfl, rfl⟩ := h₂
-    exact ⟨l₁, a, by simp⟩
-  · rintro ⟨l₁, a, rfl, rfl, rfl⟩
-    exact ⟨l₁, #[a], by simp⟩
-
-theorem mapFinIdx_eq_mapFinIdx_iff {l : Array α} {f g : (i : Nat) → α → (h : i < l.size) → β} :
-    l.mapFinIdx f = l.mapFinIdx g ↔ ∀ (i : Nat) (h : i < l.size), f i l[i] h = g i l[i] h := by
-  rw [eq_comm, mapFinIdx_eq_iff]
-  simp
-
-@[simp] theorem mapFinIdx_mapFinIdx {l : Array α}
-    {f : (i : Nat) → α → (h : i < l.size) → β}
-    {g : (i : Nat) → β → (h : i < (l.mapFinIdx f).size) → γ} :
-    (l.mapFinIdx f).mapFinIdx g = l.mapFinIdx (fun i a h => g i (f i a h) (by simpa using h)) := by
-  simp [mapFinIdx_eq_iff]
-
-theorem mapFinIdx_eq_mkArray_iff {l : Array α} {f : (i : Nat) → α → (h : i < l.size) → β} {b : β} :
-    l.mapFinIdx f = mkArray l.size b ↔ ∀ (i : Nat) (h : i < l.size), f i l[i] h = b := by
-  rcases l with ⟨l⟩
-  rw [← toList_inj]
-  simp [List.mapFinIdx_eq_replicate_iff]
-
-@[simp] theorem mapFinIdx_reverse {l : Array α} {f : (i : Nat) → α → (h : i < l.reverse.size) → β} :
-    l.reverse.mapFinIdx f = (l.mapFinIdx (fun i a h => f (l.size - 1 - i) a (by simp; omega))).reverse := by
-  rcases l with ⟨l⟩
-  simp [List.mapFinIdx_reverse]
-
-/-! ### mapIdx -/
-
-@[simp]
-theorem mapIdx_empty {f : Nat → α → β} : mapIdx f #[] = #[] :=
-  rfl
-
-@[simp] theorem mapFinIdx_eq_mapIdx {l : Array α} {f : (i : Nat) → α → (h : i < l.size) → β} {g : Nat → α → β}
-    (h : ∀ (i : Nat) (h : i < l.size), f i l[i] h = g i l[i]) :
-    l.mapFinIdx f = l.mapIdx g := by
-  simp_all [mapFinIdx_eq_iff]
-
-theorem mapIdx_eq_mapFinIdx {l : Array α} {f : Nat → α → β} :
-    l.mapIdx f = l.mapFinIdx (fun i a _ => f i a) := by
-  simp [mapFinIdx_eq_mapIdx]
-
-theorem mapIdx_eq_zipWithIndex_map {l : Array α} {f : Nat → α → β} :
-    l.mapIdx f = l.zipWithIndex.map fun ⟨a, i⟩ => f i a := by
-  ext <;> simp
-
-theorem mapIdx_append {K L : Array α} :
-    (K ++ L).mapIdx f = K.mapIdx f ++ L.mapIdx fun i => f (i + K.size) := by
-  rcases K with ⟨K⟩
-  rcases L with ⟨L⟩
-  simp [List.mapIdx_append]
-
-@[simp]
-theorem mapIdx_push {l : Array α} {a : α} :
-    mapIdx f (l.push a) = (mapIdx f l).push (f l.size a) := by
-  simp [← append_singleton, mapIdx_append]
-
-theorem mapIdx_singleton {a : α} : mapIdx f #[a] = #[f 0 a] := by
-  simp
-
-@[simp]
-theorem mapIdx_eq_empty_iff {l : Array α} : mapIdx f l = #[] ↔ l = #[] := by
-  rcases l with ⟨l⟩
-  simp
-
-theorem mapIdx_ne_empty_iff {l : Array α} :
-    mapIdx f l ≠ #[] ↔ l ≠ #[] := by
-  simp
-
-theorem exists_of_mem_mapIdx {b : β} {l : Array α}
-    (h : b ∈ mapIdx f l) : ∃ (i : Nat) (h : i < l.size), f i l[i] = b := by
-  rw [mapIdx_eq_mapFinIdx] at h
-  simpa [Fin.exists_iff] using exists_of_mem_mapFinIdx h
-
-@[simp] theorem mem_mapIdx {b : β} {l : Array α} :
-    b ∈ mapIdx f l ↔ ∃ (i : Nat) (h : i < l.size), f i l[i] = b := by
-  constructor
-  · intro h
-    exact exists_of_mem_mapIdx h
-  · rintro ⟨i, h, rfl⟩
-    rw [mem_iff_getElem]
-    exact ⟨i, by simpa using h, by simp⟩
-
-theorem mapIdx_eq_push_iff {l : Array α} {b : β} :
-    mapIdx f l = l₂.push b ↔
-      ∃ (a : α) (l₁ : Array α), l = l₁.push a ∧ mapIdx f l₁ = l₂ ∧ f l₁.size a = b := by
-  rw [mapIdx_eq_mapFinIdx, mapFinIdx_eq_push_iff]
-  simp only [mapFinIdx_eq_mapIdx, exists_and_left, exists_prop]
-  constructor
-  · rintro ⟨l₁, rfl, a, rfl, rfl⟩
-    exact ⟨a, l₁, by simp⟩
-  · rintro ⟨a, l₁, rfl, rfl, rfl⟩
-    exact ⟨l₁, rfl, a, by simp⟩
-
-@[simp] theorem mapIdx_eq_singleton_iff {l : Array α} {f : Nat → α → β} {b : β} :
-    mapIdx f l = #[b] ↔ ∃ (a : α), l = #[a] ∧ f 0 a = b := by
-  rcases l with ⟨l⟩
-  simp [List.mapIdx_eq_singleton_iff]
-
-theorem mapIdx_eq_append_iff {l : Array α} {f : Nat → α → β} {l₁ l₂ : Array β} :
-    mapIdx f l = l₁ ++ l₂ ↔
-      ∃ (l₁' : Array α) (l₂' : Array α), l = l₁' ++ l₂' ∧
-        l₁'.mapIdx f = l₁ ∧
-        l₂'.mapIdx (fun i => f (i + l₁'.size)) = l₂ := by
-  rcases l with ⟨l⟩
-  rcases l₁ with ⟨l₁⟩
-  rcases l₂ with ⟨l₂⟩
-  simp only [List.mapIdx_toArray, List.append_toArray, mk.injEq, List.mapIdx_eq_append_iff,
-    toArray_eq_append_iff]
-  constructor
-  · rintro ⟨l₁, l₂, rfl, rfl, rfl⟩
-    exact ⟨l₁.toArray, l₂.toArray, by simp⟩
-  · rintro ⟨⟨l₁⟩, ⟨l₂⟩, rfl, h₁, h₂⟩
-    simp only [List.mapIdx_toArray, mk.injEq, size_toArray] at h₁ h₂
-    obtain rfl := h₁
-    obtain rfl := h₂
-    exact ⟨l₁, l₂, by simp⟩
-
-theorem mapIdx_eq_iff {l : Array α} : mapIdx f l = l' ↔ ∀ i : Nat, l'[i]? = l[i]?.map (f i) := by
-  rcases l with ⟨l⟩
-  rcases l' with ⟨l'⟩
-  simp [List.mapIdx_eq_iff]
-
-theorem mapIdx_eq_mapIdx_iff {l : Array α} :
-    mapIdx f l = mapIdx g l ↔ ∀ i : Nat, (h : i < l.size) → f i l[i] = g i l[i] := by
-  rcases l with ⟨l⟩
-  simp [List.mapIdx_eq_mapIdx_iff]
-
-@[simp] theorem mapIdx_set {l : Array α} {i : Nat} {h : i < l.size} {a : α} :
-    (l.set i a).mapIdx f = (l.mapIdx f).set i (f i a) (by simpa) := by
-  rcases l with ⟨l⟩
-  simp [List.mapIdx_set]
-
-@[simp] theorem mapIdx_setIfInBounds {l : Array α} {i : Nat} {a : α} :
-    (l.setIfInBounds i a).mapIdx f = (l.mapIdx f).setIfInBounds i (f i a) := by
-  rcases l with ⟨l⟩
-  simp [List.mapIdx_set]
-
-@[simp] theorem back?_mapIdx {l : Array α} {f : Nat → α → β} :
-    (mapIdx f l).back? = (l.back?).map (f (l.size - 1)) := by
-  rcases l with ⟨l⟩
-  simp [List.getLast?_mapIdx]
-
-@[simp] theorem mapIdx_mapIdx {l : Array α} {f : Nat → α → β} {g : Nat → β → γ} :
-    (l.mapIdx f).mapIdx g = l.mapIdx (fun i => g i ∘ f i) := by
-  simp [mapIdx_eq_iff]
-
-theorem mapIdx_eq_mkArray_iff {l : Array α} {f : Nat → α → β} {b : β} :
-    mapIdx f l = mkArray l.size b ↔ ∀ (i : Nat) (h : i < l.size), f i l[i] = b := by
-  rcases l with ⟨l⟩
-  rw [← toList_inj]
-  simp [List.mapIdx_eq_replicate_iff]
-
-@[simp] theorem mapIdx_reverse {l : Array α} {f : Nat → α → β} :
-    l.reverse.mapIdx f = (mapIdx (fun i => f (l.size - 1 - i)) l).reverse := by
-  rcases l with ⟨l⟩
-  simp [List.mapIdx_reverse]
-
-end Array

src/Init/Data/BitVec/Lemmas.lean

@@ -9,9 +9,7 @@ import Init.Data.Bool
 import Init.Data.BitVec.Basic
 import Init.Data.Fin.Lemmas
 import Init.Data.Nat.Lemmas
-import Init.Data.Nat.Div.Lemmas
 import Init.Data.Nat.Mod
-import Init.Data.Nat.Div.Lemmas
 import Init.Data.Int.Bitwise.Lemmas
 import Init.Data.Int.Pow
 
@@ -100,12 +98,6 @@ theorem ofFin_eq_ofNat : @BitVec.ofFin w (Fin.mk x lt) = BitVec.ofNat w x := by
 theorem eq_of_toNat_eq {n} : ∀ {x y : BitVec n}, x.toNat = y.toNat → x = y
   | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl
 
-/-- Prove nonequality of bitvectors in terms of nat operations. -/
-theorem toNat_ne_iff_ne {n} {x y : BitVec n} : x.toNat ≠ y.toNat ↔ x ≠ y := by
-  constructor
-  · rintro h rfl; apply h rfl
-  · intro h h_eq; apply h <| eq_of_toNat_eq h_eq
-
 @[simp] theorem val_toFin (x : BitVec w) : x.toFin.val = x.toNat := rfl
 
 @[bv_toNat] theorem toNat_eq {x y : BitVec n} : x = y ↔ x.toNat = y.toNat :=
@@ -450,10 +442,6 @@ theorem toInt_eq_toNat_cond (x : BitVec n) :
         (x.toNat : Int) - (2^n : Nat) :=
   rfl
 
-theorem toInt_eq_toNat_of_lt {x : BitVec n} (h : 2 * x.toNat < 2^n) :
-    x.toInt = x.toNat := by
-  simp [toInt_eq_toNat_cond, h]
-
 theorem msb_eq_false_iff_two_mul_lt {x : BitVec w} : x.msb = false ↔ 2 * x.toNat < 2^w := by
   cases w <;> simp [Nat.pow_succ, Nat.mul_comm _ 2, msb_eq_decide, toNat_of_zero_length]
 
@@ -466,9 +454,6 @@ theorem toInt_eq_msb_cond (x : BitVec w) :
   simp only [BitVec.toInt, ← msb_eq_false_iff_two_mul_lt]
   cases x.msb <;> rfl
 
-theorem toInt_eq_toNat_of_msb {x : BitVec w} (h : x.msb = false) :
-    x.toInt = x.toNat := by
-  simp [toInt_eq_msb_cond, h]
 
 theorem toInt_eq_toNat_bmod (x : BitVec n) : x.toInt = Int.bmod x.toNat (2^n) := by
   simp only [toInt_eq_toNat_cond]
@@ -800,19 +785,6 @@ theorem extractLsb'_eq_extractLsb {w : Nat} (x : BitVec w) (start len : Nat) (h
   unfold allOnes
   simp
 
-@[simp] theorem toInt_allOnes : (allOnes w).toInt = if 0 < w then -1 else 0 := by
-  norm_cast
-  by_cases h : w = 0
-  · subst h
-    simp
-  · have : 1 < 2 ^ w := by simp [h]
-    simp [BitVec.toInt]
-    omega
-
-@[simp] theorem toFin_allOnes : (allOnes w).toFin = Fin.ofNat' (2^w) (2^w - 1) := by
-  ext
-  simp
-
 @[simp] theorem getLsbD_allOnes : (allOnes v).getLsbD i = decide (i < v) := by
   simp [allOnes]
 
@@ -1170,16 +1142,11 @@ theorem getMsb_not {x : BitVec w} :
 /-! ### shiftLeft -/
 
 @[simp, bv_toNat] theorem toNat_shiftLeft {x : BitVec v} :
-    (x <<< n).toNat = x.toNat <<< n % 2^v :=
+    BitVec.toNat (x <<< n) = BitVec.toNat x <<< n % 2^v :=
   BitVec.toNat_ofNat _ _
 
-@[simp] theorem toInt_shiftLeft {x : BitVec w} :
-    (x <<< n).toInt = (x.toNat <<< n : Int).bmod (2^w) := by
-  rw [toInt_eq_toNat_bmod, toNat_shiftLeft, Nat.shiftLeft_eq]
-  simp
-
 @[simp] theorem toFin_shiftLeft {n : Nat} (x : BitVec w) :
-    (x <<< n).toFin = Fin.ofNat' (2^w) (x.toNat <<< n) := rfl
+    BitVec.toFin (x <<< n) = Fin.ofNat' (2^w) (x.toNat <<< n) := rfl
 
 @[simp]
 theorem shiftLeft_zero (x : BitVec w) : x <<< 0 = x := by
@@ -1294,6 +1261,11 @@ theorem allOnes_shiftLeft_or_shiftLeft {x : BitVec w} {n : Nat} :
     BitVec.allOnes w <<< n ||| x <<< n = BitVec.allOnes w <<< n := by
   simp [← shiftLeft_or_distrib]
 
+@[deprecated shiftLeft_add (since := "2024-06-02")]
+theorem shiftLeft_shiftLeft {w : Nat} (x : BitVec w) (n m : Nat) :
+    (x <<< n) <<< m = x <<< (n + m) := by
+  rw [shiftLeft_add]
+
 /-! ### shiftLeft reductions from BitVec to Nat -/
 
 @[simp]
@@ -1941,6 +1913,11 @@ theorem msb_shiftLeft {x : BitVec w} {n : Nat} :
     (x <<< n).msb = x.getMsbD n := by
   simp [BitVec.msb]
 
+@[deprecated shiftRight_add (since := "2024-06-02")]
+theorem shiftRight_shiftRight {w : Nat} (x : BitVec w) (n m : Nat) :
+    (x >>> n) >>> m = x >>> (n + m) := by
+  rw [shiftRight_add]
+
 /-! ### rev -/
 
 theorem getLsbD_rev (x : BitVec w) (i : Fin w) :
@@ -2305,12 +2282,6 @@ theorem ofNat_sub_ofNat {n} (x y : Nat) : BitVec.ofNat n x - BitVec.ofNat n y =
 @[simp, bv_toNat] theorem toNat_neg (x : BitVec n) : (- x).toNat = (2^n - x.toNat) % 2^n := by
   simp [Neg.neg, BitVec.neg]
 
-theorem toNat_neg_of_pos {x : BitVec n} (h : 0#n < x) :
-    (- x).toNat = 2^n - x.toNat := by
-  change 0 < x.toNat at h
-  rw [toNat_neg, Nat.mod_eq_of_lt]
-  omega
-
 theorem toInt_neg {x : BitVec w} :
     (-x).toInt = (-x.toInt).bmod (2 ^ w) := by
   rw [← BitVec.zero_sub, toInt_sub]
@@ -2406,54 +2377,6 @@ theorem not_neg (x : BitVec w) : ~~~(-x) = x + -1#w := by
         show (_ - x.toNat) % _ = _ by rw [Nat.mod_eq_of_lt (by omega)]]
       omega
 
-/-! ### fill -/
-
-@[simp]
-theorem getLsbD_fill {w i : Nat} {v : Bool} :
-    (fill w v).getLsbD i = (v && decide (i < w)) := by
-  by_cases h : v
-  <;> simp [h, BitVec.fill, BitVec.negOne_eq_allOnes]
-
-@[simp]
-theorem getMsbD_fill {w i : Nat} {v : Bool} :
-    (fill w v).getMsbD i = (v && decide (i < w)) := by
-  by_cases h : v
-  <;> simp [h, BitVec.fill, BitVec.negOne_eq_allOnes]
-
-@[simp]
-theorem getElem_fill {w i : Nat} {v : Bool} (h : i < w) :
-    (fill w v)[i] = v := by
-  by_cases h : v
-  <;> simp [h, BitVec.fill, BitVec.negOne_eq_allOnes]
-
-@[simp]
-theorem msb_fill {w : Nat} {v : Bool} :
-    (fill w v).msb = (v && decide (0 < w)) := by
-  simp [BitVec.msb]
-
-theorem fill_eq {w : Nat} {v : Bool} : fill w v = if v = true then allOnes w else 0#w := by
-  by_cases h : v <;> (simp only [h] ; ext ; simp)
-
-@[simp]
-theorem fill_true {w : Nat} : fill w true = allOnes w := by
-  simp [fill_eq]
-
-@[simp]
-theorem fill_false {w : Nat} : fill w false = 0#w := by
-  simp [fill_eq]
-
-@[simp] theorem fill_toNat {w : Nat} {v : Bool} :
-    (fill w v).toNat = if v = true then 2^w - 1 else 0 := by
-  by_cases h : v <;> simp [h]
-
-@[simp] theorem fill_toInt {w : Nat} {v : Bool} :
-    (fill w v).toInt = if v = true && 0 < w then -1 else 0 := by
-  by_cases h : v <;> simp [h]
-
-@[simp] theorem fill_toFin {w : Nat} {v : Bool} :
-    (fill w v).toFin = if v = true then (allOnes w).toFin else Fin.ofNat' (2 ^ w) 0 := by
-  by_cases h : v <;> simp [h]
-
 /-! ### mul -/
 
 theorem mul_def {n} {x y : BitVec n} : x * y = (ofFin <| x.toFin * y.toFin) := by rfl
@@ -2597,13 +2520,13 @@ theorem udiv_def {x y : BitVec n} : x / y = BitVec.ofNat n (x.toNat / y.toNat) :
   rw [← udiv_eq]
   simp [udiv, bv_toNat, h, Nat.mod_eq_of_lt]
 
-@[simp]
-theorem toFin_udiv {x y : BitVec n} : (x / y).toFin = x.toFin / y.toFin := by
-  rfl
-
 @[simp, bv_toNat]
 theorem toNat_udiv {x y : BitVec n} : (x / y).toNat = x.toNat / y.toNat := by
-  rfl
+  rw [udiv_def]
+  by_cases h : y = 0
+  · simp [h]
+  · rw [toNat_ofNat, Nat.mod_eq_of_lt]
+    exact Nat.lt_of_le_of_lt (Nat.div_le_self ..) (by omega)
 
 @[simp]
 theorem zero_udiv {x : BitVec w} : (0#w) / x = 0#w := by
@@ -2639,45 +2562,6 @@ theorem udiv_self {x : BitVec w} :
       ↓reduceIte, toNat_udiv]
     rw [Nat.div_self (by omega), Nat.mod_eq_of_lt (by omega)]
 
-theorem msb_udiv (x y : BitVec w) :
-    (x / y).msb = (x.msb && y == 1#w) := by
-  cases msb_x : x.msb
-  · suffices x.toNat / y.toNat < 2 ^ (w - 1) by simpa [msb_eq_decide]
-    calc
-      x.toNat / y.toNat ≤ x.toNat     := by apply Nat.div_le_self
-                      _ < 2 ^ (w - 1) := by simpa [msb_eq_decide] using msb_x
-  . rcases w with _|w
-    · contradiction
-    · have : (y == 1#_) = decide (y.toNat = 1) := by
-        simp [(· == ·), toNat_eq]
-      simp only [this, Bool.true_and]
-      match hy : y.toNat with
-      | 0 =>
-        obtain rfl : y = 0#_ := eq_of_toNat_eq hy
-        simp
-      | 1 =>
-        obtain rfl : y = 1#_ := eq_of_toNat_eq (by simp [hy])
-        simpa using msb_x
-      | y + 2 =>
-        suffices x.toNat / (y + 2) < 2 ^ w by
-          simp_all [msb_eq_decide, hy]
-        calc
-          x.toNat / (y + 2)
-            ≤ x.toNat / 2 := by apply Nat.div_add_le_right (by omega)
-          _ < 2 ^ w       := by omega
-
-theorem msb_udiv_eq_false_of {x : BitVec w} (h : x.msb = false) (y : BitVec w) :
-    (x / y).msb = false := by
-  simp [msb_udiv, h]
-
-/--
-If `x` is nonnegative (i.e., does not have its msb set),
-then `x / y` is nonnegative, thus `toInt` and `toNat` coincide.
--/
-theorem toInt_udiv_of_msb {x : BitVec w} (h : x.msb = false) (y : BitVec w) :
-    (x / y).toInt = x.toNat / y.toNat := by
-  simp [toInt_eq_msb_cond, msb_udiv_eq_false_of h]
-
 /-! ### umod -/
 
 theorem umod_def {x y : BitVec n} :
@@ -2690,10 +2574,6 @@ theorem umod_def {x y : BitVec n} :
 theorem toNat_umod {x y : BitVec n} :
     (x % y).toNat = x.toNat % y.toNat := rfl
 
-@[simp]
-theorem toFin_umod {x y : BitVec w} :
-    (x % y).toFin = x.toFin % y.toFin := rfl
-
 @[simp]
 theorem umod_zero {x : BitVec n} : x % 0#n = x := by
   simp [umod_def]
@@ -2721,55 +2601,6 @@ theorem umod_eq_and {x y : BitVec 1} : x % y = x &&& (~~~y) := by
     rcases hy with rfl | rfl <;>
       rfl
 
-theorem umod_eq_of_lt {x y : BitVec w} (h : x < y) :
-    x % y = x := by
-  apply eq_of_toNat_eq
-  simp [Nat.mod_eq_of_lt h]
-
-@[simp]
-theorem msb_umod {x y : BitVec w} :
-    (x % y).msb = (x.msb && (x < y || y == 0#w)) := by
-  rw [msb_eq_decide, toNat_umod]
-  cases msb_x : x.msb
-  · suffices x.toNat % y.toNat < 2 ^ (w - 1) by simpa
-    calc
-      x.toNat % y.toNat ≤ x.toNat     := by apply Nat.mod_le
-                      _ < 2 ^ (w - 1) := by simpa [msb_eq_decide] using msb_x
-  . by_cases hy : y = 0
-    · simp_all [msb_eq_decide]
-    · suffices 2 ^ (w - 1) ≤ x.toNat % y.toNat ↔ x < y by simp_all
-      by_cases x_lt_y : x < y
-      . simp_all [Nat.mod_eq_of_lt x_lt_y, msb_eq_decide]
-      · suffices x.toNat % y.toNat < 2 ^ (w - 1) by
-          simpa [x_lt_y]
-        have y_le_x : y.toNat ≤ x.toNat := by
-          simpa using x_lt_y
-        replace hy : y.toNat ≠ 0 :=
-          toNat_ne_iff_ne.mpr hy
-        by_cases msb_y : y.toNat < 2 ^ (w - 1)
-        · have : x.toNat % y.toNat < y.toNat := Nat.mod_lt _ (by omega)
-          omega
-        · rcases w with _|w
-          · contradiction
-          simp only [Nat.add_one_sub_one]
-          replace msb_y : 2 ^ w ≤ y.toNat := by
-            simpa using msb_y
-          have : y.toNat ≤ y.toNat * (x.toNat / y.toNat) := by
-              apply Nat.le_mul_of_pos_right
-              apply Nat.div_pos y_le_x
-              omega
-          have : x.toNat % y.toNat ≤ x.toNat - y.toNat := by
-            rw [Nat.mod_eq_sub]; omega
-          omega
-
-theorem toInt_umod {x y : BitVec w} :
-    (x % y).toInt = (x.toNat % y.toNat : Int).bmod (2 ^ w) := by
-  simp [toInt_eq_toNat_bmod]
-
-theorem toInt_umod_of_msb {x y : BitVec w} (h : x.msb = false) :
-    (x % y).toInt = x.toInt % y.toNat := by
-  simp [toInt_eq_msb_cond, h]
-
 /-! ### smtUDiv -/
 
 theorem smtUDiv_eq (x y : BitVec w) : smtUDiv x y = if y = 0#w then allOnes w else x / y := by
@@ -2926,12 +2757,7 @@ theorem smod_zero {x : BitVec n} : x.smod 0#n = x := by
 
 /-! # Rotate Left -/
 
-/--`rotateLeft` is defined in terms of left and right shifts. -/
-theorem rotateLeft_def {x : BitVec w} {r : Nat} :
-    x.rotateLeft r = (x <<< (r % w)) ||| (x >>> (w - r % w)) := by
-  simp only [rotateLeft, rotateLeftAux]
-
-/-- `rotateLeft` is invariant under `mod` by the bitwidth. -/
+/-- rotateLeft is invariant under `mod` by the bitwidth. -/
 @[simp]
 theorem rotateLeft_mod_eq_rotateLeft {x : BitVec w} {r : Nat} :
     x.rotateLeft (r % w) = x.rotateLeft r := by
@@ -3075,18 +2901,8 @@ theorem msb_rotateLeft {m w : Nat} {x : BitVec w} :
   · simp
     omega
 
-@[simp]
-theorem toNat_rotateLeft {x : BitVec w} {r : Nat} :
-    (x.rotateLeft r).toNat = (x.toNat <<< (r % w)) % (2^w) ||| x.toNat >>> (w - r % w) := by
-  simp only [rotateLeft_def, toNat_shiftLeft, toNat_ushiftRight, toNat_or]
-
 /-! ## Rotate Right -/
 
-/-- `rotateRight` is defined in terms of left and right shifts. -/
-theorem rotateRight_def {x : BitVec w} {r : Nat} :
-    x.rotateRight r = (x >>> (r % w)) ||| (x <<< (w - r % w)) := by
-  simp only [rotateRight, rotateRightAux]
-
 /--
 Accessing bits in `x.rotateRight r` the range `[0, w-r)` is equal to
 accessing bits `x` in the range `[r, w)`.
@@ -3222,11 +3038,6 @@ theorem msb_rotateRight {r w : Nat} {x : BitVec w} :
     simp [h₁]
   · simp [show w = 0 by omega]
 
-@[simp]
-theorem toNat_rotateRight {x : BitVec w} {r : Nat} :
-    (x.rotateRight r).toNat = (x.toNat >>> (r % w)) ||| x.toNat <<< (w - r % w) % (2^w) := by
-  simp only [rotateRight_def, toNat_shiftLeft, toNat_ushiftRight, toNat_or]
-
 /- ## twoPow -/
 
 theorem twoPow_eq (w : Nat) (i : Nat) : twoPow w i = 1#w <<< i := by
@@ -3529,7 +3340,7 @@ theorem getLsbD_intMax (w : Nat) : (intMax w).getLsbD i = decide (i + 1 < w) :=
 
 /-! ### Non-overflow theorems -/
 
-/-- If `x.toNat + y.toNat < 2^w`, then the addition `(x + y)` does not overflow. -/
+/-- If `x.toNat * y.toNat < 2^w`, then the multiplication `(x * y)` does not overflow. -/
 theorem toNat_add_of_lt {w} {x y : BitVec w} (h : x.toNat + y.toNat < 2^w) :
     (x + y).toNat = x.toNat + y.toNat := by
   rw [BitVec.toNat_add, Nat.mod_eq_of_lt h]

src/Init/Data/Bool.lean

@@ -620,12 +620,3 @@ but may be used locally.
 -/
 def boolRelToRel : Coe (α → α → Bool) (α → α → Prop) where
   coe r := fun a b => Eq (r a b) true
-
-/-! ### 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]

src/Init/Data/Char/Lemmas.lean

@@ -70,3 +70,5 @@ theorem utf8Size_eq (c : Char) : c.utf8Size = 1 ∨ c.utf8Size = 2 ∨ c.utf8Siz
   rfl
 
 end Char
+
+@[deprecated Char.utf8Size (since := "2024-06-04")] abbrev String.csize := Char.utf8Size

src/Init/Data/Int/DivMod.lean

@@ -257,7 +257,7 @@ theorem ofNat_fdiv : ∀ m n : Nat, ↑(m / n) = fdiv ↑m ↑n
 # `bmod` ("balanced" mod)
 
 Balanced mod (and balanced div) are a division and modulus pair such
-that `b * (Int.bdiv a b) + Int.bmod a b = a` and `-b/2 ≤ Int.bmod a b <
+that `b * (Int.bdiv a b) + Int.bmod a b = a` and `b/2 ≤ Int.bmod a b <
 b/2` for all `a : Int` and `b > 0`.
 
 This is used in Omega as well as signed bitvectors.
@@ -266,26 +266,10 @@ This is used in Omega as well as signed bitvectors.
 /--
 Balanced modulus.  This version of Integer modulus uses the
 balanced rounding convention, which guarantees that
-`-m/2 ≤ bmod x m < m/2` for `m ≠ 0` and `bmod x m` is congruent
+`m/2 ≤ bmod x m < m/2` for `m ≠ 0` and `bmod x m` is congruent
 to `x` modulo `m`.
 
 If `m = 0`, then `bmod x m = x`.
-
-Examples:
-```
-#eval (7 : Int).bdiv 0 -- 0
-#eval (0 : Int).bdiv 7 -- 0
-
-#eval (12 : Int).bdiv 6 -- 2
-#eval (12 : Int).bdiv 7 -- 2
-#eval (12 : Int).bdiv 8 -- 2
-#eval (12 : Int).bdiv 9 -- 1
-
-#eval (-12 : Int).bdiv 6 -- -2
-#eval (-12 : Int).bdiv 7 -- -2
-#eval (-12 : Int).bdiv 8 -- -1
-#eval (-12 : Int).bdiv 9 -- -1
-```
 -/
 def bmod (x : Int) (m : Nat) : Int :=
   let r := x % m
@@ -297,22 +281,6 @@ def bmod (x : Int) (m : Nat) : Int :=
 /--
 Balanced division.  This returns the unique integer so that
 `b * (Int.bdiv a b) + Int.bmod a b = a`.
-
-Examples:
-```
-#eval (7 : Int).bmod 0 -- 7
-#eval (0 : Int).bmod 7 -- 0
-
-#eval (12 : Int).bmod 6 -- 0
-#eval (12 : Int).bmod 7 -- -2
-#eval (12 : Int).bmod 8 -- -4
-#eval (12 : Int).bmod 9 -- 3
-
-#eval (-12 : Int).bmod 6 -- 0
-#eval (-12 : Int).bmod 7 -- 2
-#eval (-12 : Int).bmod 8 -- -4
-#eval (-12 : Int).bmod 9 -- -3
-```
 -/
 def bdiv (x : Int) (m : Nat) : Int :=
   if m = 0 then

src/Init/Data/Int/DivModLemmas.lean

@@ -534,13 +534,6 @@ theorem mul_emod (a b n : Int) : (a * b) % n = (a % n) * (b % n) % n := by
 @[simp] theorem emod_emod (a b : Int) : (a % b) % b = a % b := by
   conv => rhs; rw [← emod_add_ediv a b, add_mul_emod_self_left]
 
-@[simp] theorem emod_sub_emod (m n k : Int) : (m % n - k) % n = (m - k) % n :=
-  Int.emod_add_emod m n (-k)
-
-@[simp] theorem sub_emod_emod (m n k : Int) : (m - n % k) % k = (m - n) % k := by
-  apply (emod_add_cancel_right (n % k)).mp
-  rw [Int.sub_add_cancel, Int.add_emod_emod, Int.sub_add_cancel]
-
 theorem sub_emod (a b n : Int) : (a - b) % n = (a % n - b % n) % n := by
   apply (emod_add_cancel_right b).mp
   rw [Int.sub_add_cancel, ← Int.add_emod_emod, Int.sub_add_cancel, emod_emod]
@@ -1105,32 +1098,6 @@ theorem bmod_def (x : Int) (m : Nat) : bmod x m =
     (x % m) - m :=
   rfl
 
-theorem bdiv_add_bmod (x : Int) (m : Nat) : m * bdiv x m + bmod x m = x := by
-  unfold bdiv bmod
-  split
-  · simp_all only [Nat.cast_ofNat_Int, Int.mul_zero, emod_zero, Int.zero_add, Int.sub_zero,
-      ite_self]
-  · dsimp only
-    split
-    · exact ediv_add_emod x m
-    · rw [Int.mul_add, Int.mul_one, Int.add_assoc, Int.add_comm m, Int.sub_add_cancel]
-      exact ediv_add_emod x m
-
-theorem bmod_add_bdiv (x : Int) (m : Nat) : bmod x m + m * bdiv x m = x := by
-  rw [Int.add_comm]; exact bdiv_add_bmod x m
-
-theorem bdiv_add_bmod' (x : Int) (m : Nat) : bdiv x m * m + bmod x m = x := by
-  rw [Int.mul_comm]; exact bdiv_add_bmod x m
-
-theorem bmod_add_bdiv' (x : Int) (m : Nat) : bmod x m + bdiv x m * m = x := by
-  rw [Int.add_comm]; exact bdiv_add_bmod' x m
-
-theorem bmod_eq_self_sub_mul_bdiv (x : Int) (m : Nat) : bmod x m = x - m * bdiv x m := by
-  rw [← Int.add_sub_cancel (bmod x m), bmod_add_bdiv]
-
-theorem bmod_eq_self_sub_bdiv_mul (x : Int) (m : Nat) : bmod x m = x - bdiv x m * m := by
-  rw [← Int.add_sub_cancel (bmod x m), bmod_add_bdiv']
-
 theorem bmod_pos (x : Int) (m : Nat) (p : x % m < (m + 1) / 2) : bmod x m = x % m := by
   simp [bmod_def, p]
 

src/Init/Data/List/Attach.lean

@@ -111,14 +111,6 @@ theorem pmap_eq_map_attach {p : α → Prop} (f : ∀ a, p a → β) (l H) :
     pmap f l H = l.attach.map fun x => f x.1 (H _ x.2) := by
   rw [attach, attachWith, map_pmap]; exact pmap_congr_left l fun _ _ _ _ => rfl
 
-@[simp]
-theorem pmap_eq_attachWith {p q : α → Prop} (f : ∀ a, p a → q a) (l 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_coe (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 _ _ _ _
@@ -144,23 +136,10 @@ theorem attachWith_map_subtype_val {p : α → Prop} (l : List α) (H : ∀ a
 @[simp]
 theorem mem_attach (l : List α) : ∀ x, x ∈ l.attach
   | ⟨a, h⟩ => by
-    have := mem_map.1 (by rw [attach_map_subtype_val]; exact h)
+    have := mem_map.1 (by rw [attach_map_subtype_val] <;> exact h)
     rcases this with ⟨⟨_, _⟩, m, rfl⟩
     exact m
 
-@[simp]
-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
-  | cons a l ih =>
-    simp [ih]
-    constructor
-    · rintro (_ | _) <;> simp_all
-    · rintro (h | h)
-      · simp [← h]
-      · simp_all
-
 @[simp]
 theorem mem_pmap {p : α → Prop} {f : ∀ a, p a → β} {l H b} :
     b ∈ pmap f l H ↔ ∃ (a : _) (h : a ∈ l), f a (H a h) = b := by
@@ -287,18 +266,6 @@ 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) :
-    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₂) :
-    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 α)
     (H : ∀ (a : α), a ∈ xs → P a) :
     (xs.pmap f H).head? = xs.attach.head?.map fun ⟨a, m⟩ => f a (H a m) := by
@@ -464,25 +431,7 @@ theorem attach_filter {l : List α} (p : α → Bool) :
   split <;> simp
 
 -- We are still missing here `attachWith_filterMap` and `attachWith_filter`.
-
-@[simp]
-theorem filterMap_attachWith {q : α → Prop} {l : List α} {f : {x // q x} → Option β} (H) :
-    (l.attachWith q H).filterMap f = l.attach.filterMap (fun ⟨x, h⟩ => f ⟨x, H _ h⟩) := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [attachWith_cons, filterMap_cons]
-    split <;> simp_all [Function.comp_def]
-
-@[simp]
-theorem filter_attachWith {q : α → Prop} {l : List α} {p : {x // q x} → Bool} (H) :
-    (l.attachWith q H).filter p =
-      (l.attach.filter (fun ⟨x, h⟩ => p ⟨x, H _ h⟩)).map (fun ⟨x, h⟩ => ⟨x, H _ h⟩) := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [attachWith_cons, filter_cons]
-    split <;> simp_all [Function.comp_def, filter_map]
+-- Also missing are `filterMap_attach`, `filter_attach`, `filterMap_attachWith` and `filter_attachWith`.
 
 theorem pmap_pmap {p : α → Prop} {q : β → Prop} (g : ∀ a, p a → β) (f : ∀ b, q b → γ) (l H₁ H₂) :
     pmap f (pmap g l H₁) H₂ =
@@ -571,7 +520,7 @@ theorem reverse_attach (xs : List α) :
 
 @[simp] theorem getLast?_attachWith {P : α → Prop} {xs : List α}
     {H : ∀ (a : α), a ∈ xs → P a} :
-    (xs.attachWith P H).getLast? = xs.getLast?.pbind (fun a h => some ⟨a, H _ (mem_of_getLast? h)⟩) := by
+    (xs.attachWith P H).getLast? = xs.getLast?.pbind (fun a h => some ⟨a, H _ (mem_of_getLast?_eq_some h)⟩) := by
   rw [getLast?_eq_head?_reverse, reverse_attachWith, head?_attachWith]
   simp
 
@@ -582,7 +531,7 @@ theorem reverse_attach (xs : List α) :
 
 @[simp]
 theorem getLast?_attach {xs : List α} :
-    xs.attach.getLast? = xs.getLast?.pbind fun a h => some ⟨a, mem_of_getLast? h⟩ := by
+    xs.attach.getLast? = xs.getLast?.pbind fun a h => some ⟨a, mem_of_getLast?_eq_some h⟩ := by
   rw [getLast?_eq_head?_reverse, reverse_attach, head?_map, head?_attach]
   simp
 
@@ -611,11 +560,6 @@ theorem count_attachWith [DecidableEq α] {p : α → Prop} (l : List α) (H :
     (l.attachWith p H).count a = l.count ↑a :=
   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₁) :
-    (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]
-
 /-! ## unattach
 
 `List.unattach` is the (one-sided) inverse of `List.attach`. It is a synonym for `List.map Subtype.val`.
@@ -634,7 +578,7 @@ and is ideally subsequently simplified away by `unattach_attach`.
 
 If not, usually the right approach is `simp [List.unattach, -List.map_subtype]` to unfold.
 -/
-def unattach {α : Type _} {p : α → Prop} (l : List { x // p x }) : List α := l.map (·.val)
+def unattach {α : Type _} {p : α → Prop} (l : List { x // p x }) := l.map (·.val)
 
 @[simp] theorem unattach_nil {p : α → Prop} : ([] : List { x // p x }).unattach = [] := rfl
 @[simp] theorem unattach_cons {p : α → Prop} {a : { x // p x }} {l : List { x // p x }} :

src/Init/Data/List/Basic.lean

@@ -258,6 +258,9 @@ theorem ext_get? : ∀ {l₁ l₂ : List α}, (∀ n, l₁.get? n = l₂.get? n)
     have h0 : some a = some a' := h 0
     injection h0 with aa; simp only [aa, ext_get? fun n => h (n+1)]
 
+/-- Deprecated alias for `ext_get?`. The preferred extensionality theorem is now `ext_getElem?`. -/
+@[deprecated ext_get? (since := "2024-06-07")] abbrev ext := @ext_get?
+
 /-! ### getD -/
 
 /--
@@ -603,11 +606,11 @@ set_option linter.missingDocs false in
 to get a list of lists, and then concatenates them all together.
 * `[2, 3, 2].bind range = [0, 1, 0, 1, 2, 0, 1]`
 -/
-@[inline] def flatMap {α : Type u} {β : Type v} (b : α → List β) (a : List α) : List β := flatten (map b a)
+@[inline] def flatMap {α : Type u} {β : Type v} (a : List α) (b : α → List β) : List β := flatten (map b a)
 
-@[simp] theorem flatMap_nil (f : α → List β) : List.flatMap f [] = [] := by simp [flatten, List.flatMap]
+@[simp] theorem flatMap_nil (f : α → List β) : List.flatMap [] f = [] := by simp [flatten, List.flatMap]
 @[simp] theorem flatMap_cons x xs (f : α → List β) :
-  List.flatMap f (x :: xs) = f x ++ List.flatMap f xs := by simp [flatten, List.flatMap]
+  List.flatMap (x :: xs) f = f x ++ List.flatMap xs f := by simp [flatten, List.flatMap]
 
 set_option linter.missingDocs false in
 @[deprecated flatMap (since := "2024-10-16")] abbrev bind := @flatMap
@@ -616,6 +619,11 @@ set_option linter.missingDocs false in
 set_option linter.missingDocs false in
 @[deprecated flatMap_cons (since := "2024-10-16")] abbrev cons_flatMap := @flatMap_cons
 
+set_option linter.missingDocs false in
+@[deprecated flatMap_nil (since := "2024-06-15")] abbrev nil_bind := @flatMap_nil
+set_option linter.missingDocs false in
+@[deprecated flatMap_cons (since := "2024-06-15")] abbrev cons_bind := @flatMap_cons
+
 /-! ### replicate -/
 
 /--
@@ -705,6 +713,11 @@ def elem [BEq α] (a : α) : List α → Bool
 theorem elem_cons [BEq α] {a : α} :
     (b::bs).elem a = match a == b with | true => true | false => bs.elem a := rfl
 
+/-- `notElem a l` is `!(elem a l)`. -/
+@[deprecated "Use `!(elem a l)` instead."(since := "2024-06-15")]
+def notElem [BEq α] (a : α) (as : List α) : Bool :=
+  !(as.elem a)
+
 /-! ### contains -/
 
 @[inherit_doc elem] abbrev contains [BEq α] (as : List α) (a : α) : Bool :=

src/Init/Data/List/Count.lean

@@ -40,7 +40,7 @@ protected theorem countP_go_eq_add (l) : countP.go p l n = n + countP.go p l 0 :
 theorem countP_cons (a : α) (l) : countP p (a :: l) = countP p l + if p a then 1 else 0 := by
   by_cases h : p a <;> simp [h]
 
-@[simp] theorem countP_singleton (a : α) : countP p [a] = if p a then 1 else 0 := by
+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

src/Init/Data/List/Erase.lean

@@ -6,7 +6,6 @@ Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, M
 -/
 prelude
 import Init.Data.List.Pairwise
-import Init.Data.List.Find
 
 /-!
 # Lemmas about `List.eraseP` and `List.erase`.
@@ -573,19 +572,4 @@ protected theorem IsPrefix.eraseIdx {l l' : List α} (h : l <+: l') (k : Nat) :
 -- See also `mem_eraseIdx_iff_getElem` and `mem_eraseIdx_iff_getElem?` in
 -- `Init/Data/List/Nat/Basic.lean`.
 
-theorem erase_eq_eraseIdx [BEq α] [LawfulBEq α] (l : List α) (a : α) (i : Nat) (w : l.indexOf a = i) :
-    l.erase a = l.eraseIdx i := by
-  subst w
-  rw [erase_eq_iff]
-  by_cases h : a ∈ l
-  · right
-    obtain ⟨as, bs, rfl, h'⟩ := eq_append_cons_of_mem h
-    refine ⟨as, bs, h', by simp, ?_⟩
-    rw [indexOf_append, if_neg h', indexOf_cons_self, eraseIdx_append_of_length_le] <;>
-      simp
-  · left
-    refine ⟨h, ?_⟩
-    rw [eq_comm, eraseIdx_eq_self]
-    exact Nat.le_of_eq (indexOf_eq_length h).symm
-
 end List

src/Init/Data/List/Find.lean

@@ -884,68 +884,14 @@ theorem IsInfix.findIdx?_eq_none {l₁ l₂ : List α} {p : α → Bool} (h : l
     List.findIdx? p l₂ = none → List.findIdx? p l₁ = none :=
   h.sublist.findIdx?_eq_none
 
-/-! ### indexOf
-
-The verification API for `indexOf` is still incomplete.
-The lemmas below should be made consistent with those for `findIdx` (and proved using them).
--/
+/-! ### indexOf -/
 
 theorem indexOf_cons [BEq α] :
     (x :: xs : List α).indexOf y = bif x == y then 0 else xs.indexOf y + 1 := by
   dsimp [indexOf]
   simp [findIdx_cons]
 
-@[simp] theorem indexOf_cons_self [BEq α] [ReflBEq α] {l : List α} : (a :: l).indexOf a = 0 := by
-  simp [indexOf_cons]
-
-theorem indexOf_append [BEq α] [LawfulBEq α] {l₁ l₂ : List α} {a : α} :
-    (l₁ ++ l₂).indexOf a = if a ∈ l₁ then l₁.indexOf a else l₂.indexOf a + l₁.length := by
-  rw [indexOf, findIdx_append]
-  split <;> rename_i h
-  · rw [if_pos]
-    simpa using h
-  · rw [if_neg]
-    simpa using h
-
-theorem indexOf_eq_length [BEq α] [LawfulBEq α] {l : List α} (h : a ∉ l) : l.indexOf a = l.length := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [mem_cons, not_or] at h
-    simp only [indexOf_cons, cond_eq_if, beq_iff_eq]
-    split <;> simp_all
-
-theorem indexOf_lt_length [BEq α] [LawfulBEq α] {l : List α} (h : a ∈ l) : l.indexOf a < l.length := by
-  induction l with
-  | nil => simp at h
-  | cons x xs ih =>
-    simp only [mem_cons] at h
-    obtain rfl | h := h
-    · simp
-    · simp only [indexOf_cons, cond_eq_if, beq_iff_eq, length_cons]
-      specialize ih h
-      split
-      · exact zero_lt_succ xs.length
-      · exact Nat.add_lt_add_right ih 1
-
-/-! ### indexOf?
-
-The verification API for `indexOf?` is still incomplete.
-The lemmas below should be made consistent with those for `findIdx?` (and proved using them).
--/
-
-@[simp] theorem indexOf?_eq_none_iff [BEq α] [LawfulBEq α] {l : List α} {a : α} :
-    l.indexOf? a = none ↔ a ∉ l := by
-  simp only [indexOf?, findIdx?_eq_none_iff, beq_eq_false_iff_ne, ne_eq]
-  constructor
-  · intro w h
-    specialize w _ h
-    simp at w
-  · rintro w x h rfl
-    contradiction
-
 /-! ### lookup -/
-
 section lookup
 variable [BEq α] [LawfulBEq α]
 

src/Init/Data/List/Impl.lean

@@ -96,14 +96,14 @@ The following operations are given `@[csimp]` replacements below:
 /-! ### flatMap  -/
 
 /-- Tail recursive version of `List.flatMap`. -/
-@[inline] def flatMapTR (f : α → List β) (as : List α) : List β := go as #[] where
+@[inline] def flatMapTR (as : List α) (f : α → List β) : List β := go as #[] where
   /-- Auxiliary for `flatMap`: `flatMap.go f as = acc.toList ++ bind f as` -/
   @[specialize] go : List α → Array β → List β
   | [], acc => acc.toList
   | x::xs, acc => go xs (acc ++ f x)
 
 @[csimp] theorem flatMap_eq_flatMapTR : @List.flatMap = @flatMapTR := by
-  funext α β f as
+  funext α β as f
   let rec go : ∀ as acc, flatMapTR.go f as acc = acc.toList ++ as.flatMap f
     | [], acc => by simp [flatMapTR.go, flatMap]
     | x::xs, acc => by simp [flatMapTR.go, flatMap, go xs]
@@ -112,7 +112,7 @@ The following operations are given `@[csimp]` replacements below:
 /-! ### flatten -/
 
 /-- Tail recursive version of `List.flatten`. -/
-@[inline] def flattenTR (l : List (List α)) : List α := l.flatMapTR id
+@[inline] def flattenTR (l : List (List α)) : List α := flatMapTR l id
 
 @[csimp] theorem flatten_eq_flattenTR : @flatten = @flattenTR := by
   funext α l; rw [← List.flatMap_id, List.flatMap_eq_flatMapTR]; rfl

src/Init/Data/List/Lex.lean

@@ -14,8 +14,8 @@ namespace List
 @[simp] theorem lex_lt [LT α] (l₁ l₂ : List α) : Lex (· < ·) l₁ l₂ ↔ l₁ < l₂ := Iff.rfl
 @[simp] theorem not_lex_lt [LT α] (l₁ l₂ : List α) : ¬ Lex (· < ·) l₁ l₂ ↔ l₂ ≤ l₁ := 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 α) :
+theorem not_lt_iff_ge [LT α] (l₁ l₂ : List α) : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
+theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] (l₁ l₂ : List α) :
     ¬ l₁ ≤ l₂ ↔ l₂ < l₁ :=
   Decidable.not_not
 
@@ -260,7 +260,7 @@ protected theorem le_of_lt [DecidableEq α] [LT α] [DecidableLT α]
   · exfalso
     exact h' h
 
-protected theorem le_iff_lt_or_eq [DecidableEq α] [LT α] [DecidableLT α]
+theorem le_iff_lt_or_eq [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)]
     [Std.Total (¬ · < · : α → α → Prop)]
@@ -333,7 +333,7 @@ theorem lex_eq_true_iff_exists [BEq α] (lt : α → α → Bool) :
     cases l₂ with
     | nil => simp [lex]
     | cons b l₂ =>
-      simp [lex_cons_cons, Bool.or_eq_true, Bool.and_eq_true, ih, isEqv, length_cons]
+      simp only [lex_cons_cons, Bool.or_eq_true, Bool.and_eq_true, ih, isEqv, length_cons]
       constructor
       · rintro (hab | ⟨hab, ⟨h₁, h₂⟩ | ⟨i, h₁, h₂, w₁, w₂⟩⟩)
         · exact .inr ⟨0, by simp [hab]⟩
@@ -397,7 +397,7 @@ theorem lex_eq_false_iff_exists [BEq α] [PartialEquivBEq α] (lt : α → α
     cases l₂ with
     | nil => simp [lex]
     | cons b l₂ =>
-      simp [lex_cons_cons, Bool.or_eq_false_iff, Bool.and_eq_false_imp, ih, isEqv,
+      simp only [lex_cons_cons, Bool.or_eq_false_iff, Bool.and_eq_false_imp, ih, isEqv,
         Bool.and_eq_true, length_cons]
       constructor
       · rintro ⟨hab, h⟩
@@ -435,7 +435,7 @@ theorem lex_eq_false_iff_exists [BEq α] [PartialEquivBEq α] (lt : α → α
               simpa using w₁ (j + 1) (by simpa)
             · simpa using w₂
 
-protected theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : List α} :
+theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : List α} :
     l₁ < l₂ ↔
       (l₁ = l₂.take l₁.length ∧ l₁.length < l₂.length) ∨
         (∃ (i : Nat) (h₁ : i < l₁.length) (h₂ : i < l₂.length),
@@ -444,7 +444,7 @@ protected theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁
   rw [← lex_eq_true_iff_lt, lex_eq_true_iff_exists]
   simp
 
-protected theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
+theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Asymm (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)] {l₁ l₂ : List α} :
@@ -489,7 +489,7 @@ theorem IsPrefix.le [LT α] [Std.Irrefl (· < · : α → α → Prop)]
   rcases h with ⟨_, rfl⟩
   apply le_append_left
 
-protected theorem map_lt [LT α] [LT β]
+theorem map_lt [LT α] [LT β]
     {l₁ l₂ : List α} {f : α → β} (w : ∀ x y, x < y → f x < f y) (h : l₁ < l₂) :
     map f l₁ < map f l₂ := by
   match l₁, l₂, h with
@@ -497,11 +497,11 @@ protected theorem map_lt [LT α] [LT β]
   | nil, cons b l₂, h => simp
   | cons a l₁, nil, h => simp at h
   | cons a l₁, cons _ l₂, .cons h =>
-    simp [cons_lt_cons_iff, List.map_lt w (by simpa using h)]
+    simp [cons_lt_cons_iff, map_lt w (by simpa using h)]
   | cons a l₁, cons b l₂, .rel h =>
     simp [cons_lt_cons_iff, w, h]
 
-protected theorem map_le [DecidableEq α] [LT α] [DecidableLT α] [DecidableEq β] [LT β] [DecidableLT β]
+theorem map_le [DecidableEq α] [LT α] [DecidableLT α] [DecidableEq β] [LT β] [DecidableLT β]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Asymm (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)]
@@ -510,7 +510,7 @@ protected theorem map_le [DecidableEq α] [LT α] [DecidableLT α] [DecidableEq
     [Std.Antisymm (¬ · < · : β → β → Prop)]
     {l₁ l₂ : List α} {f : α → β} (w : ∀ x y, x < y → f x < f y) (h : l₁ ≤ l₂) :
     map f l₁ ≤ map f l₂ := by
-  rw [List.le_iff_exists] at h ⊢
+  rw [le_iff_exists] at h ⊢
   obtain (h | ⟨i, h₁, h₂, w₁, w₂⟩) := h
   · left
     rw [h]

src/Init/Data/List/MapIdx.lean

@@ -17,19 +17,18 @@ namespace List
 
 /-! ### mapIdx -/
 
+
 /--
 Given a list `as = [a₀, a₁, ...]` function `f : Fin as.length → α → β`, returns the list
 `[f 0 a₀, f 1 a₁, ...]`.
 -/
-@[inline] def mapFinIdx (as : List α) (f : (i : Nat) → α → (h : i < as.length) → β) : List β :=
-  go as #[] (by simp)
-where
+@[inline] def mapFinIdx (as : List α) (f : Fin as.length → α → β) : List β := go as #[] (by simp) where
   /-- Auxiliary for `mapFinIdx`:
   `mapFinIdx.go [a₀, a₁, ...] acc = acc.toList ++ [f 0 a₀, f 1 a₁, ...]` -/
   @[specialize] go : (bs : List α) → (acc : Array β) → bs.length + acc.size = as.length → List β
   | [], acc, h => acc.toList
   | a :: as, acc, h =>
-    go as (acc.push (f acc.size a (by simp at h; omega))) (by simp at h ⊢; omega)
+    go as (acc.push (f ⟨acc.size, by simp at h; omega⟩ a)) (by simp at h ⊢; omega)
 
 /--
 Given a function `f : Nat → α → β` and `as : List α`, `as = [a₀, a₁, ...]`, returns the list
@@ -44,14 +43,8 @@ Given a function `f : Nat → α → β` and `as : List α`, `as = [a₀, a₁,
 
 /-! ### mapFinIdx -/
 
-@[congr] theorem mapFinIdx_congr {xs ys : List α} (w : xs = ys)
-    (f : (i : Nat) → α → (h : i < xs.length) → β) :
-    mapFinIdx xs f = mapFinIdx ys (fun i a h => f i a (by simp [w]; omega)) := by
-  subst w
-  rfl
-
 @[simp]
-theorem mapFinIdx_nil {f : (i : Nat) → α → (h : i < 0) → β} : mapFinIdx [] f = [] :=
+theorem mapFinIdx_nil {f : Fin 0 → α → β} : mapFinIdx [] f = [] :=
   rfl
 
 @[simp] theorem length_mapFinIdx_go :
@@ -60,16 +53,13 @@ theorem mapFinIdx_nil {f : (i : Nat) → α → (h : i < 0) → β} : mapFinIdx
   | nil => simpa using h
   | cons _ _ ih => simp [mapFinIdx.go, ih]
 
-@[simp] theorem length_mapFinIdx {as : List α} {f : (i : Nat) → α → (h : i < as.length) → β} :
+@[simp] theorem length_mapFinIdx {as : List α} {f : Fin as.length → α → β} :
     (as.mapFinIdx f).length = as.length := by
   simp [mapFinIdx, length_mapFinIdx_go]
 
-theorem getElem_mapFinIdx_go {as : List α} {f : (i : Nat) → α → (h : i < as.length) → β} {i : Nat} {h} {w} :
+theorem getElem_mapFinIdx_go {as : List α} {f : Fin as.length → α → β} {i : Nat} {h} {w} :
     (mapFinIdx.go as f bs acc h)[i] =
-      if w' : i < acc.size then
-        acc[i]
-      else
-        f i (bs[i - acc.size]'(by simp at w; omega)) (by simp at w; omega) := by
+      if w' : i < acc.size then acc[i] else f ⟨i, by simp at w; omega⟩ (bs[i - acc.size]'(by simp at w; omega)) := by
   induction bs generalizing acc with
   | nil =>
     simp only [length_mapFinIdx_go, length_nil, Nat.zero_add] at w h
@@ -88,30 +78,29 @@ theorem getElem_mapFinIdx_go {as : List α} {f : (i : Nat) → α → (h : i < a
     · have h₃ : i - acc.size = (i - (acc.size + 1)) + 1 := by omega
       simp [h₃]
 
-@[simp] theorem getElem_mapFinIdx {as : List α} {f : (i : Nat) → α → (h : i < as.length) → β} {i : Nat} {h} :
-    (as.mapFinIdx f)[i] = f i (as[i]'(by simp at h; omega)) (by simp at h; omega) := by
+@[simp] theorem getElem_mapFinIdx {as : List α} {f : Fin as.length → α → β} {i : Nat} {h} :
+    (as.mapFinIdx f)[i] = f ⟨i, by simp at h; omega⟩ (as[i]'(by simp at h; omega)) := by
   simp [mapFinIdx, getElem_mapFinIdx_go]
 
-theorem mapFinIdx_eq_ofFn {as : List α} {f : (i : Nat) → α → (h : i < as.length) → β} :
-    as.mapFinIdx f = List.ofFn fun i : Fin as.length => f i as[i] i.2 := by
+theorem mapFinIdx_eq_ofFn {as : List α} {f : Fin as.length → α → β} :
+    as.mapFinIdx f = List.ofFn fun i : Fin as.length => f i as[i] := by
   apply ext_getElem <;> simp
 
-@[simp] theorem getElem?_mapFinIdx {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} {i : Nat} :
-    (l.mapFinIdx f)[i]? = l[i]?.pbind fun x m => f i x (by simp [getElem?_eq_some_iff] at m; exact m.1) := by
+@[simp] theorem getElem?_mapFinIdx {l : List α} {f : Fin l.length → α → β} {i : Nat} :
+    (l.mapFinIdx f)[i]? = l[i]?.pbind fun x m => f ⟨i, by simp [getElem?_eq_some_iff] at m; exact m.1⟩ x := by
   simp only [getElem?_def, length_mapFinIdx, getElem_mapFinIdx]
   split <;> simp
 
 @[simp]
-theorem mapFinIdx_cons {l : List α} {a : α} {f : (i : Nat) → α → (h : i < l.length + 1) → β} :
-    mapFinIdx (a :: l) f = f 0 a (by omega) :: mapFinIdx l (fun i a h => f (i + 1) a (by omega)) := by
+theorem mapFinIdx_cons {l : List α} {a : α} {f : Fin (l.length + 1) → α → β} :
+    mapFinIdx (a :: l) f = f 0 a :: mapFinIdx l (fun i => f i.succ) := by
   apply ext_getElem
   · simp
   · rintro (_|i) h₁ h₂ <;> simp
 
-theorem mapFinIdx_append {K L : List α} {f : (i : Nat) → α → (h : i < (K ++ L).length) → β} :
+theorem mapFinIdx_append {K L : List α} {f : Fin (K ++ L).length → α → β} :
     (K ++ L).mapFinIdx f =
-      K.mapFinIdx (fun i a h => f i a (by simp; omega)) ++
-        L.mapFinIdx (fun i a h => f (i + K.length) a (by simp; omega)) := by
+      K.mapFinIdx (fun i => f (i.castLE (by simp))) ++ L.mapFinIdx (fun i => f ((i.natAdd K.length).cast (by simp))) := by
   apply ext_getElem
   · simp
   · intro i h₁ h₂
@@ -119,57 +108,60 @@ theorem mapFinIdx_append {K L : List α} {f : (i : Nat) → α → (h : i < (K +
     simp only [getElem_mapFinIdx, length_mapFinIdx]
     split <;> rename_i h
     · rw [getElem_append_left]
+      congr
     · simp only [Nat.not_lt] at h
       rw [getElem_append_right h]
       congr
+      simp
       omega
 
-@[simp] theorem mapFinIdx_concat {l : List α} {e : α} {f : (i : Nat) → α → (h : i < (l ++ [e]).length) → β}:
-    (l ++ [e]).mapFinIdx f = l.mapFinIdx (fun i a h => f i a (by simp; omega)) ++ [f l.length e (by simp)] := by
+@[simp] theorem mapFinIdx_concat {l : List α} {e : α} {f : Fin (l ++ [e]).length → α → β}:
+    (l ++ [e]).mapFinIdx f = l.mapFinIdx (fun i => f (i.castLE (by simp))) ++ [f ⟨l.length, by simp⟩ e] := by
   simp [mapFinIdx_append]
+  congr
 
-theorem mapFinIdx_singleton {a : α} {f : (i : Nat) → α → (h : i < 1) → β} :
-    [a].mapFinIdx f = [f 0 a (by simp)] := by
+theorem mapFinIdx_singleton {a : α} {f : Fin 1 → α → β} :
+    [a].mapFinIdx f = [f ⟨0, by simp⟩ a] := by
   simp
 
-theorem mapFinIdx_eq_enum_map {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} :
+theorem mapFinIdx_eq_enum_map {l : List α} {f : Fin l.length → α → β} :
     l.mapFinIdx f = l.enum.attach.map
       fun ⟨⟨i, x⟩, m⟩ =>
-        f i x (by rw [mk_mem_enum_iff_getElem?, getElem?_eq_some_iff] at m; exact m.1) := by
+        f ⟨i, by rw [mk_mem_enum_iff_getElem?, getElem?_eq_some_iff] at m; exact m.1⟩ x := by
   apply ext_getElem <;> simp
 
 @[simp]
-theorem mapFinIdx_eq_nil_iff {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} :
+theorem mapFinIdx_eq_nil_iff {l : List α} {f : Fin l.length → α → β} :
     l.mapFinIdx f = [] ↔ l = [] := by
   rw [mapFinIdx_eq_enum_map, map_eq_nil_iff, attach_eq_nil_iff, enum_eq_nil_iff]
 
-theorem mapFinIdx_ne_nil_iff {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} :
+theorem mapFinIdx_ne_nil_iff {l : List α} {f : Fin l.length → α → β} :
     l.mapFinIdx f ≠ [] ↔ l ≠ [] := by
   simp
 
-theorem exists_of_mem_mapFinIdx {b : β} {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β}
-    (h : b ∈ l.mapFinIdx f) : ∃ (i : Nat) (h : i < l.length), f i l[i] h = b := by
+theorem exists_of_mem_mapFinIdx {b : β} {l : List α} {f : Fin l.length → α → β}
+    (h : b ∈ l.mapFinIdx f) : ∃ (i : Fin l.length), f i l[i] = b := by
   rw [mapFinIdx_eq_enum_map] at h
   replace h := exists_of_mem_map h
   simp only [mem_attach, true_and, Subtype.exists, Prod.exists, mk_mem_enum_iff_getElem?] at h
   obtain ⟨i, b, h, rfl⟩ := h
   rw [getElem?_eq_some_iff] at h
   obtain ⟨h', rfl⟩ := h
-  exact ⟨i, h', rfl⟩
+  exact ⟨⟨i, h'⟩, rfl⟩
 
-@[simp] theorem mem_mapFinIdx {b : β} {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} :
-    b ∈ l.mapFinIdx f ↔ ∃ (i : Nat) (h : i < l.length), f i l[i] h = b := by
+@[simp] theorem mem_mapFinIdx {b : β} {l : List α} {f : Fin l.length → α → β} :
+    b ∈ l.mapFinIdx f ↔ ∃ (i : Fin l.length), f i l[i] = b := by
   constructor
   · intro h
     exact exists_of_mem_mapFinIdx h
   · rintro ⟨i, h, rfl⟩
     rw [mem_iff_getElem]
-    exact ⟨i, by simpa using h, by simp⟩
+    exact ⟨i, by simp⟩
 
-theorem mapFinIdx_eq_cons_iff {l : List α} {b : β} {f : (i : Nat) → α → (h : i < l.length) → β} :
+theorem mapFinIdx_eq_cons_iff {l : List α} {b : β} {f : Fin l.length → α → β} :
     l.mapFinIdx f = b :: l₂ ↔
-      ∃ (a : α) (l₁ : List α) (w : l = a :: l₁),
-        f 0 a (by simp [w]) = b ∧ l₁.mapFinIdx (fun i a h => f (i + 1) a (by simp [w]; omega)) = l₂ := by
+      ∃ (a : α) (l₁ : List α) (h : l = a :: l₁),
+        f ⟨0, by simp [h]⟩ a = b ∧ l₁.mapFinIdx (fun i => f (i.succ.cast (by simp [h]))) = l₂ := by
   cases l with
   | nil => simp
   | cons x l' =>
@@ -177,91 +169,39 @@ theorem mapFinIdx_eq_cons_iff {l : List α} {b : β} {f : (i : Nat) → α → (
       exists_and_left]
     constructor
     · rintro ⟨rfl, rfl⟩
-      refine ⟨x, l', ⟨rfl, rfl⟩, by simp⟩
-    · rintro ⟨a, l', ⟨rfl, rfl⟩, ⟨rfl, rfl⟩⟩
-      exact ⟨rfl, by simp⟩
+      refine ⟨x, rfl, l', by simp⟩
+    · rintro ⟨a, ⟨rfl, h⟩, ⟨_, ⟨rfl, rfl⟩, h⟩⟩
+      exact ⟨rfl, h⟩
 
-theorem mapFinIdx_eq_cons_iff' {l : List α} {b : β} {f : (i : Nat) → α → (h : i < l.length) → β} :
+theorem mapFinIdx_eq_cons_iff' {l : List α} {b : β} {f : Fin l.length → α → β} :
     l.mapFinIdx f = b :: l₂ ↔
-      l.head?.pbind (fun x m => (f 0 x (by cases l <;> simp_all))) = some b ∧
-        l.tail?.attach.map (fun ⟨t, m⟩ => t.mapFinIdx fun i a h => f (i + 1) a (by cases l <;> simp_all)) = some l₂ := by
+      l.head?.pbind (fun x m => (f ⟨0, by cases l <;> simp_all⟩ x)) = some b ∧
+        l.tail?.attach.map (fun ⟨t, m⟩ => t.mapFinIdx fun i => f (i.succ.cast (by cases l <;> simp_all))) = some l₂ := by
   cases l <;> simp
 
-theorem mapFinIdx_eq_iff {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} :
-    l.mapFinIdx f = l' ↔ ∃ h : l'.length = l.length, ∀ (i : Nat) (h : i < l.length), l'[i] = f i l[i] h := by
+theorem mapFinIdx_eq_iff {l : List α} {f : Fin l.length → α → β} :
+    l.mapFinIdx f = l' ↔ ∃ h : l'.length = l.length, ∀ (i : Nat) (h : i < l.length), l'[i] = f ⟨i, h⟩ l[i] := by
   constructor
   · rintro rfl
     simp
   · rintro ⟨h, w⟩
     apply ext_getElem <;> simp_all
 
-@[simp] theorem mapFinIdx_eq_singleton_iff {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} {b : β} :
-    l.mapFinIdx f = [b] ↔ ∃ (a : α) (w : l = [a]), f 0 a (by simp [w]) = b := by
-  simp [mapFinIdx_eq_cons_iff]
-
-theorem mapFinIdx_eq_append_iff {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} :
-    l.mapFinIdx f = l₁ ++ l₂ ↔
-      ∃ (l₁' : List α) (l₂' : List α) (w : l = l₁' ++ l₂'),
-        l₁'.mapFinIdx (fun i a h => f i a (by simp [w]; omega)) = l₁ ∧
-        l₂'.mapFinIdx (fun i a h => f (i + l₁'.length) a (by simp [w]; omega)) = l₂ := by
-  rw [mapFinIdx_eq_iff]
-  constructor
-  · intro ⟨h, w⟩
-    simp only [length_append] at h
-    refine ⟨l.take l₁.length, l.drop l₁.length, by simp, ?_⟩
-    constructor
-    · apply ext_getElem
-      · simp
-        omega
-      · intro i hi₁ hi₂
-        simp only [getElem_mapFinIdx, getElem_take]
-        specialize w i (by omega)
-        rw [getElem_append_left hi₂] at w
-        exact w.symm
-    · apply ext_getElem
-      · simp
-        omega
-      · intro i hi₁ hi₂
-        simp only [getElem_mapFinIdx, getElem_take]
-        simp only [length_take, getElem_drop]
-        have : l₁.length ≤ l.length := by omega
-        simp only [Nat.min_eq_left this, Nat.add_comm]
-        specialize w (i + l₁.length) (by omega)
-        rw [getElem_append_right (by omega)] at w
-        simpa using w.symm
-  · rintro ⟨l₁', l₂', rfl, rfl, rfl⟩
-    refine ⟨by simp, fun i h => ?_⟩
-    rw [getElem_append]
-    split <;> rename_i h'
-    · simp [getElem_append_left (by simpa using h')]
-    · simp only [length_mapFinIdx, Nat.not_lt] at h'
-      have : i - l₁'.length + l₁'.length = i := by omega
-      simp [getElem_append_right h', this]
-
-theorem mapFinIdx_eq_mapFinIdx_iff {l : List α} {f g : (i : Nat) → α → (h : i < l.length) → β} :
-    l.mapFinIdx f = l.mapFinIdx g ↔ ∀ (i : Nat) (h : i < l.length), f i l[i] h = g i l[i] h := by
+theorem mapFinIdx_eq_mapFinIdx_iff {l : List α} {f g : Fin l.length → α → β} :
+    l.mapFinIdx f = l.mapFinIdx g ↔ ∀ (i : Fin l.length), f i l[i] = g i l[i] := by
   rw [eq_comm, mapFinIdx_eq_iff]
   simp [Fin.forall_iff]
 
-@[simp] theorem mapFinIdx_mapFinIdx {l : List α}
-    {f : (i : Nat) → α → (h : i < l.length) → β}
-    {g : (i : Nat) → β → (h : i < (l.mapFinIdx f).length) → γ} :
-    (l.mapFinIdx f).mapFinIdx g = l.mapFinIdx (fun i a h => g i (f i a h) (by simpa)) := by
+@[simp] theorem mapFinIdx_mapFinIdx {l : List α} {f : Fin l.length → α → β} {g : Fin _ → β → γ} :
+    (l.mapFinIdx f).mapFinIdx g = l.mapFinIdx (fun i => g (i.cast (by simp)) ∘ f i) := by
   simp [mapFinIdx_eq_iff]
 
-theorem mapFinIdx_eq_replicate_iff {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} {b : β} :
-    l.mapFinIdx f = replicate l.length b ↔ ∀ (i : Nat) (h : i < l.length), f i l[i] h = b := by
-  rw [eq_replicate_iff, length_mapFinIdx]
-  simp only [mem_mapFinIdx, forall_exists_index, true_and]
-  constructor
-  · intro w i h
-    exact w (f i l[i] h) i h rfl
-  · rintro w b i h rfl
-    exact w i h
+theorem mapFinIdx_eq_replicate_iff {l : List α} {f : Fin l.length → α → β} {b : β} :
+    l.mapFinIdx f = replicate l.length b ↔ ∀ (i : Fin l.length), f i l[i] = b := by
+  simp [eq_replicate_iff, length_mapFinIdx, mem_mapFinIdx, forall_exists_index, true_and]
 
-@[simp] theorem mapFinIdx_reverse {l : List α} {f : (i : Nat) → α → (h : i < l.reverse.length) → β} :
-    l.reverse.mapFinIdx f =
-      (l.mapFinIdx (fun i a h => f (l.length - 1 - i) a (by simp; omega))).reverse := by
+@[simp] theorem mapFinIdx_reverse {l : List α} {f : Fin l.reverse.length → α → β} :
+    l.reverse.mapFinIdx f = (l.mapFinIdx (fun i => f ⟨l.length - 1 - i, by simp; omega⟩)).reverse := by
   simp [mapFinIdx_eq_iff]
   intro i h
   congr
@@ -322,13 +262,13 @@ theorem getElem?_mapIdx_go : ∀ {l : List α} {arr : Array β} {i : Nat},
   rw [← getElem?_eq_getElem, getElem?_mapIdx, getElem?_eq_getElem (by simpa using h)]
   simp
 
-@[simp] theorem mapFinIdx_eq_mapIdx {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} {g : Nat → α → β}
-    (h : ∀ (i : Nat) (h : i < l.length), f i l[i] h = g i l[i]) :
+@[simp] theorem mapFinIdx_eq_mapIdx {l : List α} {f : Fin l.length → α → β} {g : Nat → α → β}
+    (h : ∀ (i : Fin l.length), f i l[i] = g i l[i]) :
     l.mapFinIdx f = l.mapIdx g := by
   simp_all [mapFinIdx_eq_iff]
 
 theorem mapIdx_eq_mapFinIdx {l : List α} {f : Nat → α → β} :
-    l.mapIdx f = l.mapFinIdx (fun i a _ => f i a) := by
+    l.mapIdx f = l.mapFinIdx (fun i => f i) := by
   simp [mapFinIdx_eq_mapIdx]
 
 theorem mapIdx_eq_enum_map {l : List α} :
@@ -388,10 +328,6 @@ theorem mapIdx_eq_cons_iff' {l : List α} {b : β} :
       l.head?.map (f 0) = some b ∧ l.tail?.map (mapIdx fun i => f (i + 1)) = some l₂ := by
   cases l <;> simp
 
-@[simp] theorem mapIdx_eq_singleton_iff {l : List α} {f : Nat → α → β} {b : β} :
-    mapIdx f l = [b] ↔ ∃ (a : α), l = [a] ∧ f 0 a = b := by
-  simp [mapIdx_eq_cons_iff]
-
 theorem mapIdx_eq_iff {l : List α} : mapIdx f l = l' ↔ ∀ i : Nat, l'[i]? = l[i]?.map (f i) := by
   constructor
   · intro w i
@@ -400,19 +336,6 @@ theorem mapIdx_eq_iff {l : List α} : mapIdx f l = l' ↔ ∀ i : Nat, l'[i]? =
     ext1 i
     simp [w]
 
-theorem mapIdx_eq_append_iff {l : List α} :
-    mapIdx f l = l₁ ++ l₂ ↔
-      ∃ (l₁' : List α) (l₂' : List α), l = l₁' ++ l₂' ∧
-        mapIdx f l₁' = l₁ ∧
-        mapIdx (fun i => f (i + l₁'.length)) l₂' = l₂ := by
-  rw [mapIdx_eq_mapFinIdx, mapFinIdx_eq_append_iff]
-  simp only [mapFinIdx_eq_mapIdx, exists_and_left, exists_prop]
-  constructor
-  · rintro ⟨l₁, rfl, l₂, rfl, h⟩
-    refine ⟨l₁, l₂, by simp_all⟩
-  · rintro ⟨l₁, l₂, rfl, rfl, rfl⟩
-    refine ⟨l₁, rfl, l₂, by simp_all⟩
-
 theorem mapIdx_eq_mapIdx_iff {l : List α} :
     mapIdx f l = mapIdx g l ↔ ∀ i : Nat, (h : i < l.length) → f i l[i] = g i l[i] := by
   constructor

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

@@ -47,16 +47,41 @@ length `> i`. Version designed to rewrite from the small list to the big list. -
     L[i]'(Nat.lt_of_lt_of_le h (length_take_le' _ _)) := by
   rw [length_take, Nat.lt_min] at h; rw [getElem_take' L _ h.1]
 
+/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
+length `> i`. Version designed to rewrite from the big list to the small list. -/
+@[deprecated getElem_take' (since := "2024-06-12")]
+theorem get_take (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
+    get L ⟨i, hi⟩ = get (L.take j) ⟨i, length_take .. ▸ Nat.lt_min.mpr ⟨hj, hi⟩⟩ := by
+  simp
+
+/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
+length `> i`. Version designed to rewrite from the small list to the big list. -/
+@[deprecated getElem_take (since := "2024-06-12")]
+theorem get_take' (L : List α) {j i} :
+    get (L.take j) i =
+    get L ⟨i.1, Nat.lt_of_lt_of_le i.2 (length_take_le' _ _)⟩ := by
+  simp [getElem_take]
+
 theorem getElem?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
     (l.take n)[m]? = none :=
   getElem?_eq_none <| Nat.le_trans (length_take_le _ _) h
 
+@[deprecated getElem?_take_eq_none (since := "2024-06-12")]
+theorem get?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
+    (l.take n).get? m = none := by
+  simp [getElem?_take_eq_none h]
+
 theorem getElem?_take {l : List α} {n m : Nat} :
     (l.take n)[m]? = if m < n then l[m]? else none := by
   split
   · next h => exact getElem?_take_of_lt h
   · next h => exact getElem?_take_eq_none (Nat.le_of_not_lt h)
 
+@[deprecated getElem?_take (since := "2024-06-12")]
+theorem get?_take_eq_if {l : List α} {n m : Nat} :
+    (l.take n).get? m = if m < n then l.get? m else none := by
+  simp [getElem?_take]
+
 theorem head?_take {l : List α} {n : Nat} :
     (l.take n).head? = if n = 0 then none else l.head? := by
   simp [head?_eq_getElem?, getElem?_take]
@@ -201,6 +226,13 @@ theorem getElem_drop' (L : List α) {i j : Nat} (h : i + j < L.length) :
   · simp [Nat.min_eq_left this, Nat.add_sub_cancel_left]
   · simp [Nat.min_eq_left this, Nat.le_add_right]
 
+/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
+dropping the first `i` elements. Version designed to rewrite from the big list to the small list. -/
+@[deprecated getElem_drop' (since := "2024-06-12")]
+theorem get_drop (L : List α) {i j : Nat} (h : i + j < L.length) :
+    get L ⟨i + j, h⟩ = get (L.drop i) ⟨j, lt_length_drop L h⟩ := by
+  simp [getElem_drop']
+
 /-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
 dropping the first `i` elements. Version designed to rewrite from the small list to the big list. -/
 @[simp] theorem getElem_drop (L : List α) {i : Nat} {j : Nat} {h : j < (L.drop i).length} :
@@ -209,6 +241,15 @@ dropping the first `i` elements. Version designed to rewrite from the small list
       exact Nat.add_lt_of_lt_sub (length_drop i L ▸ h)) := by
   rw [getElem_drop']
 
+/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
+dropping the first `i` elements. Version designed to rewrite from the small list to the big list. -/
+@[deprecated getElem_drop' (since := "2024-06-12")]
+theorem get_drop' (L : List α) {i j} :
+    get (L.drop i) j = get L ⟨i + j, by
+      rw [Nat.add_comm]
+      exact Nat.add_lt_of_lt_sub (length_drop i L ▸ j.2)⟩ := by
+  simp
+
 @[simp]
 theorem getElem?_drop (L : List α) (i j : Nat) : (L.drop i)[j]? = L[i + j]? := by
   ext
@@ -220,6 +261,10 @@ theorem getElem?_drop (L : List α) (i j : Nat) : (L.drop i)[j]? = L[i + j]? :=
     rw [Nat.add_comm] at h
     apply Nat.lt_sub_of_add_lt h
 
+@[deprecated getElem?_drop (since := "2024-06-12")]
+theorem get?_drop (L : List α) (i j : Nat) : get? (L.drop i) j = get? L (i + j) := by
+  simp
+
 theorem mem_take_iff_getElem {l : List α} {a : α} :
     a ∈ l.take n ↔ ∃ (i : Nat) (hm : i < min n l.length), l[i] = a := by
   rw [mem_iff_getElem]

src/Init/Data/List/Perm.lean

@@ -510,18 +510,4 @@ theorem Perm.eraseP (f : α → Bool) {l₁ l₂ : List α}
     refine (IH₁ H).trans (IH₂ ((p₁.pairwise_iff ?_).1 H))
     exact fun h h₁ h₂ => h h₂ h₁
 
-theorem perm_insertIdx {α} (x : α) (l : List α) {n} (h : n ≤ l.length) :
-    insertIdx n x l ~ x :: l := by
-  induction l generalizing n with
-  | nil =>
-    cases n with
-    | zero => rfl
-    | succ => cases h
-  | cons _ _ ih =>
-    cases n with
-    | zero => simp [insertIdx]
-    | succ =>
-      simp only [insertIdx, modifyTailIdx]
-      refine .trans (.cons _ (ih (Nat.le_of_succ_le_succ h))) (.swap ..)
-
 end List

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

@@ -253,10 +253,6 @@ theorem merge_perm_append : ∀ {xs ys : List α}, merge xs ys le ~ xs ++ ys
     · exact (merge_perm_append.cons y).trans
         ((Perm.swap x y _).trans (perm_middle.symm.cons x))
 
-theorem Perm.merge (s₁ s₂ : α → α → Bool) (hl : l₁ ~ l₂) (hr : r₁ ~ r₂) :
-    merge l₁ r₁ s₁ ~ merge l₂ r₂ s₂ :=
-  Perm.trans (merge_perm_append ..) <| Perm.trans (Perm.append hl hr) <| Perm.symm (merge_perm_append ..)
-
 /-! ### mergeSort -/
 
 @[simp] theorem mergeSort_nil : [].mergeSort r = [] := by rw [List.mergeSort]

src/Init/Data/List/TakeDrop.lean

@@ -67,9 +67,17 @@ theorem getElem_cons_drop : ∀ (l : List α) (i : Nat) (h : i < l.length),
   | _::_, 0, _ => rfl
   | _::_, i+1, h => getElem_cons_drop _ i (Nat.add_one_lt_add_one_iff.mp h)
 
+@[deprecated getElem_cons_drop (since := "2024-06-12")]
+theorem get_cons_drop (l : List α) (i) : get l i :: drop (i + 1) l = drop i l := by
+  simp
+
 theorem drop_eq_getElem_cons {n} {l : List α} (h : n < l.length) : drop n l = l[n] :: drop (n + 1) l :=
   (getElem_cons_drop _ n h).symm
 
+@[deprecated drop_eq_getElem_cons (since := "2024-06-12")]
+theorem drop_eq_get_cons {n} {l : List α} (h) : drop n l = get l ⟨n, h⟩ :: drop (n + 1) l := by
+  simp [drop_eq_getElem_cons]
+
 @[simp]
 theorem getElem?_take_of_lt {l : List α} {n m : Nat} (h : m < n) : (l.take n)[m]? = l[m]? := by
   induction n generalizing l m with
@@ -83,6 +91,10 @@ theorem getElem?_take_of_lt {l : List α} {n m : Nat} (h : m < n) : (l.take n)[m
       · simp
       · simpa using hn (Nat.lt_of_succ_lt_succ h)
 
+@[deprecated getElem?_take_of_lt (since := "2024-06-12")]
+theorem get?_take {l : List α} {n m : Nat} (h : m < n) : (l.take n).get? m = l.get? m := by
+  simp [getElem?_take_of_lt, h]
+
 theorem getElem?_take_of_succ {l : List α} {n : Nat} : (l.take (n + 1))[n]? = l[n]? := by simp
 
 @[simp] theorem drop_drop (n : Nat) : ∀ (m) (l : List α), drop n (drop m l) = drop (m + n) l
@@ -99,6 +111,10 @@ theorem take_drop : ∀ (m n : Nat) (l : List α), take n (drop m l) = drop m (t
   | _, _, [] => by simp
   | _+1, _, _ :: _ => by simpa [Nat.succ_add, take_succ_cons, drop_succ_cons] using take_drop ..
 
+@[deprecated drop_drop (since := "2024-06-15")]
+theorem drop_add (m n) (l : List α) : drop (m + n) l = drop n (drop m l) := by
+  simp [drop_drop]
+
 @[simp]
 theorem tail_drop (l : List α) (n : Nat) : (l.drop n).tail = l.drop (n + 1) := by
   induction l generalizing n with

src/Init/Data/List/ToArray.lean

@@ -46,7 +46,7 @@ theorem toArray_cons (a : α) (l : List α) : (a :: l).toArray = #[a] ++ l.toArr
 @[simp] theorem isEmpty_toArray (l : List α) : l.toArray.isEmpty = l.isEmpty := by
   cases l <;> simp [Array.isEmpty]
 
-@[simp] theorem toArray_singleton (a : α) : (List.singleton a).toArray = Array.singleton a := rfl
+@[simp] theorem toArray_singleton (a : α) : (List.singleton a).toArray = singleton a := rfl
 
 @[simp] theorem back!_toArray [Inhabited α] (l : List α) : l.toArray.back! = l.getLast! := by
   simp only [back!, size_toArray, Array.get!_eq_getElem!, getElem!_toArray, getLast!_eq_getElem!]
@@ -143,9 +143,6 @@ theorem forM_toArray [Monad m] (l : List α) (f : α → m PUnit) :
   subst h
   rw [foldl_toList]
 
-@[simp] theorem sum_toArray [Add α] [Zero α] (l : List α) : l.toArray.sum = l.sum := by
-  simp [Array.sum, List.sum]
-
 @[simp] theorem append_toArray (l₁ l₂ : List α) :
     l₁.toArray ++ l₂.toArray = (l₁ ++ l₂).toArray := by
   apply ext'
@@ -397,24 +394,4 @@ theorem takeWhile_go_toArray (p : α → Bool) (l : List α) (i : Nat) :
 @[deprecated toArray_replicate (since := "2024-12-13")]
 abbrev _root_.Array.mkArray_eq_toArray_replicate := @toArray_replicate
 
-@[simp] theorem flatMap_empty {β} (f : α → Array β) : (#[] : Array α).flatMap f = #[] := rfl
-
-theorem flatMap_toArray_cons {β} (f : α → Array β) (a : α) (as : List α) :
-    (a :: as).toArray.flatMap f = f a ++ as.toArray.flatMap f := by
-  simp [Array.flatMap]
-  suffices ∀ cs, List.foldl (fun bs a => bs ++ f a) (f a ++ cs) as =
-      f a ++ List.foldl (fun bs a => bs ++ f a) cs as by
-    erw [empty_append] -- Why doesn't this work via `simp`?
-    simpa using this #[]
-  intro cs
-  induction as generalizing cs <;> simp_all
-
-@[simp] theorem flatMap_toArray {β} (f : α → Array β) (as : List α) :
-    as.toArray.flatMap f = (as.flatMap (fun a => (f a).toList)).toArray := by
-  induction as with
-  | nil => simp
-  | cons a as ih =>
-    apply ext'
-    simp [ih, flatMap_toArray_cons]
-
 end List

src/Init/Data/List/Zip.lean

@@ -76,6 +76,15 @@ theorem getElem?_zip_eq_some {l₁ : List α} {l₂ : List β} {z : α × β} {i
   · rintro ⟨h₀, h₁⟩
     exact ⟨_, _, h₀, h₁, rfl⟩
 
+@[deprecated getElem?_zipWith (since := "2024-06-12")]
+theorem get?_zipWith {f : α → β → γ} :
+    (List.zipWith f as bs).get? i = match as.get? i, bs.get? i with
+      | some a, some b => some (f a b) | _, _ => none := by
+  simp [getElem?_zipWith]
+
+set_option linter.deprecated false in
+@[deprecated getElem?_zipWith (since := "2024-06-07")] abbrev zipWith_get? := @get?_zipWith
+
 theorem head?_zipWith {f : α → β → γ} :
     (List.zipWith f as bs).head? = match as.head?, bs.head? with
       | some a, some b => some (f a b) | _, _ => none := by
@@ -194,11 +203,11 @@ theorem zipWith_eq_append_iff {f : α → β → γ} {l₁ : List α} {l₂ : Li
     cases l₂ with
     | nil =>
       constructor
-      · simp only [zipWith_nil_right, nil_eq, append_eq_nil_iff, exists_and_left, and_imp]
+      · simp only [zipWith_nil_right, nil_eq, append_eq_nil, exists_and_left, and_imp]
         rintro rfl  rfl
         exact ⟨[], x₁ :: l₁, [], by simp⟩
       · rintro ⟨w, x, y, z, h₁, _, h₃, rfl, rfl⟩
-        simp only [nil_eq, append_eq_nil_iff] at h₃
+        simp only [nil_eq, append_eq_nil] at h₃
         obtain ⟨rfl, rfl⟩ := h₃
         simp
     | cons x₂ l₂ =>
@@ -250,7 +259,7 @@ theorem zip_map (f : α → γ) (g : β → δ) :
   | [], _ => rfl
   | _, [] => by simp only [map, zip_nil_right]
   | _ :: _, _ :: _ => by
-    simp only [map, zip_cons_cons, zip_map, Prod.map]; try constructor -- TODO: remove try constructor after update stage0
+    simp only [map, zip_cons_cons, zip_map, Prod.map]; constructor
 
 theorem zip_map_left (f : α → γ) (l₁ : List α) (l₂ : List β) :
     zip (l₁.map f) l₂ = (zip l₁ l₂).map (Prod.map f id) := by rw [← zip_map, map_id]
@@ -360,6 +369,15 @@ theorem getElem?_zipWithAll {f : Option α → Option β → γ} {i : Nat} :
       cases i <;> simp_all
     | cons b bs => cases i <;> simp_all
 
+@[deprecated getElem?_zipWithAll (since := "2024-06-12")]
+theorem get?_zipWithAll {f : Option α → Option β → γ} :
+    (zipWithAll f as bs).get? i = match as.get? i, bs.get? i with
+      | none, none => .none | a?, b? => some (f a? b?) := by
+  simp [getElem?_zipWithAll]
+
+set_option linter.deprecated false in
+@[deprecated getElem?_zipWithAll (since := "2024-06-07")] abbrev zipWithAll_get? := @get?_zipWithAll
+
 theorem head?_zipWithAll {f : Option α → Option β → γ} :
     (zipWithAll f as bs).head? = match as.head?, bs.head? with
       | none, none => .none | a?, b? => some (f a? b?) := by

src/Init/Data/Nat/Basic.lean

@@ -788,6 +788,9 @@ theorem not_eq_zero_of_lt (h : b < a) : a ≠ 0 := by
 theorem pred_lt_of_lt {n m : Nat} (h : m < n) : pred n < n :=
   pred_lt (not_eq_zero_of_lt h)
 
+set_option linter.missingDocs false in
+@[deprecated pred_lt_of_lt (since := "2024-06-01")] abbrev pred_lt' := @pred_lt_of_lt
+
 theorem sub_one_lt_of_lt {n m : Nat} (h : m < n) : n - 1 < n :=
   sub_one_lt (not_eq_zero_of_lt h)
 
@@ -1071,6 +1074,9 @@ theorem pred_mul (n m : Nat) : pred n * m = n * m - m := by
   | zero   => simp
   | succ n => rw [Nat.pred_succ, succ_mul, Nat.add_sub_cancel]
 
+set_option linter.missingDocs false in
+@[deprecated pred_mul (since := "2024-06-01")] abbrev mul_pred_left := @pred_mul
+
 protected theorem sub_one_mul  (n m : Nat) : (n - 1) * m = n * m - m := by
   cases n with
   | zero   => simp
@@ -1080,6 +1086,9 @@ protected theorem sub_one_mul  (n m : Nat) : (n - 1) * m = n * m - m := by
 theorem mul_pred (n m : Nat) : n * pred m = n * m - n := by
   rw [Nat.mul_comm, pred_mul, Nat.mul_comm]
 
+set_option linter.missingDocs false in
+@[deprecated mul_pred (since := "2024-06-01")] abbrev mul_pred_right := @mul_pred
+
 theorem mul_sub_one (n m : Nat) : n * (m - 1) = n * m - n := by
   rw [Nat.mul_comm, Nat.sub_one_mul , Nat.mul_comm]
 

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

@@ -711,32 +711,6 @@ theorem mul_add_lt_is_or {b : Nat} (b_lt : b < 2^i) (a : Nat) : 2^i * a + b = 2^
   rw [mod_two_eq_one_iff_testBit_zero, testBit_shiftLeft]
   simp
 
-theorem testBit_mul_two_pow (x i n : Nat) :
-    (x * 2 ^ n).testBit i = (decide (n ≤ i) && x.testBit (i - n)) := by
-  rw [← testBit_shiftLeft, shiftLeft_eq]
-
-theorem bitwise_mul_two_pow (of_false_false : f false false = false := by rfl) :
-    (bitwise f x y) * 2 ^ n = bitwise f (x * 2 ^ n) (y * 2 ^ n) := by
-  apply Nat.eq_of_testBit_eq
-  simp only [testBit_mul_two_pow, testBit_bitwise of_false_false, Bool.if_false_right]
-  intro i
-  by_cases hn : n ≤ i
-  · simp [hn]
-  · simp [hn, of_false_false]
-
-theorem shiftLeft_bitwise_distrib {a b : Nat} (of_false_false : f false false = false := by rfl) :
-    (bitwise f a b) <<< i = bitwise f (a <<< i) (b <<< i) := by
-  simp [shiftLeft_eq, bitwise_mul_two_pow of_false_false]
-
-theorem shiftLeft_and_distrib {a b : Nat} : (a &&& b) <<< i = a <<< i &&& b <<< i :=
-  shiftLeft_bitwise_distrib
-
-theorem shiftLeft_or_distrib {a b : Nat} : (a ||| b) <<< i = a <<< i ||| b <<< i :=
-  shiftLeft_bitwise_distrib
-
-theorem shiftLeft_xor_distrib {a b : Nat} : (a ^^^ b) <<< i = a <<< i ^^^ b <<< i :=
-  shiftLeft_bitwise_distrib
-
 @[simp] theorem decide_shiftRight_mod_two_eq_one :
     decide (x >>> i % 2 = 1) = x.testBit i := by
   simp only [testBit, one_and_eq_mod_two, mod_two_bne_zero]

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

@@ -49,17 +49,4 @@ theorem lt_div_mul_self (h : 0 < k) (w : k ≤ x) : x - k < x / k * k := by
   have : x % k < k := mod_lt x h
   omega
 
-theorem div_pos (hba : b ≤ a) (hb : 0 < b) : 0 < a / b := by
-  cases b
-  · contradiction
-  · simp [Nat.pos_iff_ne_zero, div_eq_zero_iff_lt, hba]
-
-theorem div_le_div_left (hcb : c ≤ b) (hc : 0 < c) : a / b ≤ a / c :=
-  (Nat.le_div_iff_mul_le hc).2 <|
-    Nat.le_trans (Nat.mul_le_mul_left _ hcb) (Nat.div_mul_le_self a b)
-
-theorem div_add_le_right {z : Nat} (h : 0 < z) (x y : Nat) :
-    x / (y + z) ≤ x / z :=
-  div_le_div_left (Nat.le_add_left z y) h
-
 end Nat

src/Init/Data/Nat/Lemmas.lean

@@ -622,14 +622,6 @@ protected theorem pos_of_mul_pos_right {a b : Nat} (h : 0 < a * b) : 0 < a := by
     0 < a * b ↔ 0 < a :=
   ⟨Nat.pos_of_mul_pos_right, fun w => Nat.mul_pos w h⟩
 
-protected theorem pos_of_lt_mul_left {a b c : Nat} (h : a < b * c) : 0 < c := by
-  replace h : 0 < b * c := by omega
-  exact Nat.pos_of_mul_pos_left h
-
-protected theorem pos_of_lt_mul_right {a b c : Nat} (h : a < b * c) : 0 < b := by
-  replace h : 0 < b * c := by omega
-  exact Nat.pos_of_mul_pos_right h
-
 /-! ### div/mod -/
 
 theorem mod_two_eq_zero_or_one (n : Nat) : n % 2 = 0 ∨ n % 2 = 1 :=
@@ -1003,6 +995,11 @@ theorem shiftLeft_add (m n : Nat) : ∀ k, m <<< (n + k) = (m <<< n) <<< k
   | 0 => rfl
   | k + 1 => by simp [← Nat.add_assoc, shiftLeft_add _ _ k, shiftLeft_succ]
 
+@[deprecated shiftLeft_add (since := "2024-06-02")]
+theorem shiftLeft_shiftLeft (m n : Nat) : ∀ k, (m <<< n) <<< k = m <<< (n + k)
+  | 0 => rfl
+  | k + 1 => by simp [← Nat.add_assoc, shiftLeft_shiftLeft _ _ k, shiftLeft_succ]
+
 @[simp] theorem shiftLeft_shiftRight (x n : Nat) : x <<< n >>> n = x := by
   rw [Nat.shiftLeft_eq, Nat.shiftRight_eq_div_pow, Nat.mul_div_cancel _ (Nat.two_pow_pos _)]
 

src/Init/Data/Option/Lemmas.lean

@@ -208,15 +208,6 @@ theorem comp_map (h : β → γ) (g : α → β) (x : Option α) : x.map (h ∘
 
 theorem mem_map_of_mem (g : α → β) (h : a ∈ x) : g a ∈ Option.map g x := h.symm ▸ map_some' ..
 
-theorem map_inj_right {f : α → β} {o o' : Option α} (w : ∀ x y, f x = f y → x = y) :
-    o.map f = o'.map f ↔ o = o' := by
-  cases o with
-  | none => cases o' <;> simp
-  | some a =>
-    cases o' with
-    | none => simp
-    | some a' => simpa using ⟨fun h => w _ _ h, fun h => congrArg f h⟩
-
 @[simp] theorem map_if {f : α → β} [Decidable c] :
      (if c then some a else none).map f = if c then some (f a) else none := by
   split <;> rfl
@@ -638,15 +629,6 @@ theorem pbind_eq_some_iff {o : Option α} {f : (a : α) → a ∈ o → Option
     · rintro ⟨h, rfl⟩
       rfl
 
-@[simp]
-theorem pmap_eq_map (p : α → Prop) (f : α → β) (o : Option α) (H) :
-    @pmap _ _ p (fun a _ => f a) o H = Option.map f o := by
-  cases o <;> simp
-
-theorem map_pmap {p : α → Prop} (g : β → γ) (f : ∀ a, p a → β) (o H) :
-    Option.map g (pmap f o H) = pmap (fun a h => g (f a h)) o H := by
-  cases o <;> simp
-
 /-! ### pelim -/
 
 @[simp] theorem pelim_none : pelim none b f = b := rfl

src/Init/Data/Subtype.lean

@@ -5,7 +5,6 @@ Authors: Johannes Hölzl
 -/
 prelude
 import Init.Ext
-import Init.Core
 
 namespace Subtype
 

src/Init/Data/UInt/Basic.lean

@@ -159,8 +159,6 @@ def UInt32.xor (a b : UInt32) : UInt32 := ⟨a.toBitVec ^^^ b.toBitVec⟩
 def UInt32.shiftLeft (a b : UInt32) : UInt32 := ⟨a.toBitVec <<< (mod b 32).toBitVec⟩
 @[extern "lean_uint32_shift_right"]
 def UInt32.shiftRight (a b : UInt32) : UInt32 := ⟨a.toBitVec >>> (mod b 32).toBitVec⟩
-def UInt32.lt (a b : UInt32) : Prop := a.toBitVec < b.toBitVec
-def UInt32.le (a b : UInt32) : Prop := a.toBitVec ≤ b.toBitVec
 
 instance : Add UInt32       := ⟨UInt32.add⟩
 instance : Sub UInt32       := ⟨UInt32.sub⟩
@@ -171,8 +169,6 @@ set_option linter.deprecated false in
 instance : HMod UInt32 Nat UInt32 := ⟨UInt32.modn⟩
 
 instance : Div UInt32       := ⟨UInt32.div⟩
-instance : LT UInt32        := ⟨UInt32.lt⟩
-instance : LE UInt32        := ⟨UInt32.le⟩
 
 @[extern "lean_uint32_complement"]
 def UInt32.complement (a : UInt32) : UInt32 := ⟨~~~a.toBitVec⟩

src/Init/Data/UInt/Bitwise.lean

@@ -13,17 +13,11 @@ macro "declare_bitwise_uint_theorems" typeName:ident bits:term:arg : command =>
 `(
 namespace $typeName
 
-@[simp, int_toBitVec] protected theorem toBitVec_add {a b : $typeName} : (a + b).toBitVec = a.toBitVec + b.toBitVec := rfl
-@[simp, int_toBitVec] protected theorem toBitVec_sub {a b : $typeName} : (a - b).toBitVec = a.toBitVec - b.toBitVec := rfl
-@[simp, int_toBitVec] protected theorem toBitVec_mul {a b : $typeName} : (a * b).toBitVec = a.toBitVec * b.toBitVec := rfl
-@[simp, int_toBitVec] protected theorem toBitVec_div {a b : $typeName} : (a / b).toBitVec = a.toBitVec / b.toBitVec := rfl
-@[simp, int_toBitVec] protected theorem toBitVec_mod {a b : $typeName} : (a % b).toBitVec = a.toBitVec % b.toBitVec := rfl
-@[simp, int_toBitVec] protected theorem toBitVec_not {a : $typeName} : (~~~a).toBitVec = ~~~a.toBitVec := rfl
-@[simp, int_toBitVec] protected theorem toBitVec_and (a b : $typeName) : (a &&& b).toBitVec = a.toBitVec &&& b.toBitVec := rfl
-@[simp, int_toBitVec] protected theorem toBitVec_or (a b : $typeName) : (a ||| b).toBitVec = a.toBitVec ||| b.toBitVec := rfl
-@[simp, int_toBitVec] protected theorem toBitVec_xor (a b : $typeName) : (a ^^^ b).toBitVec = a.toBitVec ^^^ b.toBitVec := rfl
-@[simp, int_toBitVec] protected theorem toBitVec_shiftLeft (a b : $typeName) : (a <<< b).toBitVec = a.toBitVec <<< (b.toBitVec % $bits) := rfl
-@[simp, int_toBitVec] protected theorem toBitVec_shiftRight (a b : $typeName) : (a >>> b).toBitVec = a.toBitVec >>> (b.toBitVec % $bits) := rfl
+@[simp] protected theorem toBitVec_and (a b : $typeName) : (a &&& b).toBitVec = a.toBitVec &&& b.toBitVec := rfl
+@[simp] protected theorem toBitVec_or (a b : $typeName) : (a ||| b).toBitVec = a.toBitVec ||| b.toBitVec := rfl
+@[simp] protected theorem toBitVec_xor (a b : $typeName) : (a ^^^ b).toBitVec = a.toBitVec ^^^ b.toBitVec := rfl
+@[simp] protected theorem toBitVec_shiftLeft (a b : $typeName) : (a <<< b).toBitVec = a.toBitVec <<< (b.toBitVec % $bits) := rfl
+@[simp] protected theorem toBitVec_shiftRight (a b : $typeName) : (a >>> b).toBitVec = a.toBitVec >>> (b.toBitVec % $bits) := rfl
 
 @[simp] protected theorem toNat_and (a b : $typeName) : (a &&& b).toNat = a.toNat &&& b.toNat := by simp [toNat]
 @[simp] protected theorem toNat_or (a b : $typeName) : (a ||| b).toNat = a.toNat ||| b.toNat := by simp [toNat]
@@ -43,31 +37,3 @@ declare_bitwise_uint_theorems UInt16 16
 declare_bitwise_uint_theorems UInt32 32
 declare_bitwise_uint_theorems UInt64 64
 declare_bitwise_uint_theorems USize System.Platform.numBits
-
-@[simp, int_toBitVec]
-theorem Bool.toBitVec_toUInt8 {b : Bool} :
-    b.toUInt8.toBitVec = (BitVec.ofBool b).setWidth 8 := by
-  cases b <;> simp [toUInt8]
-
-@[simp, int_toBitVec]
-theorem Bool.toBitVec_toUInt16 {b : Bool} :
-    b.toUInt16.toBitVec = (BitVec.ofBool b).setWidth 16 := by
-  cases b <;> simp [toUInt16]
-
-@[simp, int_toBitVec]
-theorem Bool.toBitVec_toUInt32 {b : Bool} :
-    b.toUInt32.toBitVec = (BitVec.ofBool b).setWidth 32 := by
-  cases b <;> simp [toUInt32]
-
-@[simp, int_toBitVec]
-theorem Bool.toBitVec_toUInt64 {b : Bool} :
-    b.toUInt64.toBitVec = (BitVec.ofBool b).setWidth 64 := by
-  cases b <;> simp [toUInt64]
-
-@[simp, int_toBitVec]
-theorem Bool.toBitVec_toUSize {b : Bool} :
-    b.toUSize.toBitVec = (BitVec.ofBool b).setWidth System.Platform.numBits := by
-  cases b
-  · simp [toUSize]
-  · apply BitVec.eq_of_toNat_eq
-    simp [toUSize]

src/Init/Data/UInt/Lemmas.lean

@@ -41,9 +41,9 @@ macro "declare_uint_theorems" typeName:ident bits:term:arg : command => do
   theorem toNat_ofNat_of_lt {n : Nat} (h : n < size) : (ofNat n).toNat = n := by
     rw [toNat, toBitVec_eq_of_lt h]
 
-  @[int_toBitVec] theorem le_def {a b : $typeName} : a ≤ b ↔ a.toBitVec ≤ b.toBitVec := .rfl
+  theorem le_def {a b : $typeName} : a ≤ b ↔ a.toBitVec ≤ b.toBitVec := .rfl
 
-  @[int_toBitVec] theorem lt_def {a b : $typeName} : a < b ↔ a.toBitVec < b.toBitVec := .rfl
+  theorem lt_def {a b : $typeName} : a < b ↔ a.toBitVec < b.toBitVec := .rfl
 
   theorem le_iff_toNat_le {a b : $typeName} : a ≤ b ↔ a.toNat ≤ b.toNat := .rfl
 
@@ -74,11 +74,6 @@ macro "declare_uint_theorems" typeName:ident bits:term:arg : command => do
   protected theorem toBitVec_inj {a b : $typeName} : a.toBitVec = b.toBitVec ↔ a = b :=
     Iff.intro eq_of_toBitVec_eq toBitVec_eq_of_eq
 
-  open $typeName (eq_of_toBitVec_eq toBitVec_eq_of_eq) in
-  @[int_toBitVec]
-  protected theorem eq_iff_toBitVec_eq {a b : $typeName} : a = b ↔ a.toBitVec = b.toBitVec :=
-    Iff.intro toBitVec_eq_of_eq eq_of_toBitVec_eq
-
   open $typeName (eq_of_toBitVec_eq) in
   protected theorem eq_of_val_eq {a b : $typeName} (h : a.val = b.val) : a = b := by
     rcases a with ⟨⟨_⟩⟩; rcases b with ⟨⟨_⟩⟩; simp_all [val]
@@ -87,19 +82,10 @@ macro "declare_uint_theorems" typeName:ident bits:term:arg : command => do
   protected theorem val_inj {a b : $typeName} : a.val = b.val ↔ a = b :=
     Iff.intro eq_of_val_eq (congrArg val)
 
-  open $typeName (eq_of_toBitVec_eq) in
-  protected theorem toBitVec_ne_of_ne {a b : $typeName} (h : a ≠ b) : a.toBitVec ≠ b.toBitVec :=
-    fun h' => h (eq_of_toBitVec_eq h')
-
   open $typeName (toBitVec_eq_of_eq) in
   protected theorem ne_of_toBitVec_ne {a b : $typeName} (h : a.toBitVec ≠ b.toBitVec) : a ≠ b :=
     fun h' => absurd (toBitVec_eq_of_eq h') h
 
-  open $typeName (ne_of_toBitVec_ne toBitVec_ne_of_ne) in
-  @[int_toBitVec]
-  protected theorem ne_iff_toBitVec_ne {a b : $typeName} : a ≠ b ↔ a.toBitVec ≠ b.toBitVec :=
-    Iff.intro toBitVec_ne_of_ne ne_of_toBitVec_ne
-
   open $typeName (ne_of_toBitVec_ne) in
   protected theorem ne_of_lt {a b : $typeName} (h : a < b) : a ≠ b := by
     apply ne_of_toBitVec_ne
@@ -173,7 +159,7 @@ macro "declare_uint_theorems" typeName:ident bits:term:arg : command => do
   @[simp]
   theorem val_ofNat (n : Nat) : val (no_index (OfNat.ofNat n)) = OfNat.ofNat n := rfl
 
-  @[simp, int_toBitVec]
+  @[simp]
   theorem toBitVec_ofNat (n : Nat) : toBitVec (no_index (OfNat.ofNat n)) = BitVec.ofNat _ n := rfl
 
   @[simp]
@@ -234,3 +220,23 @@ theorem UInt32.toNat_le_of_le {n : UInt32} {m : Nat} (h : m < size) : n ≤ ofNa
 
 theorem UInt32.le_toNat_of_le {n : UInt32} {m : Nat} (h : m < size) : ofNat m ≤ n → m ≤ n.toNat := by
   simp [le_def, BitVec.le_def, UInt32.toNat, toBitVec_eq_of_lt h]
+
+@[deprecated UInt8.toNat_zero (since := "2024-06-23")] protected abbrev UInt8.zero_toNat := @UInt8.toNat_zero
+@[deprecated UInt8.toNat_div (since := "2024-06-23")] protected abbrev UInt8.div_toNat := @UInt8.toNat_div
+@[deprecated UInt8.toNat_mod (since := "2024-06-23")] protected abbrev UInt8.mod_toNat := @UInt8.toNat_mod
+
+@[deprecated UInt16.toNat_zero (since := "2024-06-23")] protected abbrev UInt16.zero_toNat := @UInt16.toNat_zero
+@[deprecated UInt16.toNat_div (since := "2024-06-23")] protected abbrev UInt16.div_toNat := @UInt16.toNat_div
+@[deprecated UInt16.toNat_mod (since := "2024-06-23")] protected abbrev UInt16.mod_toNat := @UInt16.toNat_mod
+
+@[deprecated UInt32.toNat_zero (since := "2024-06-23")] protected abbrev UInt32.zero_toNat := @UInt32.toNat_zero
+@[deprecated UInt32.toNat_div (since := "2024-06-23")] protected abbrev UInt32.div_toNat := @UInt32.toNat_div
+@[deprecated UInt32.toNat_mod (since := "2024-06-23")] protected abbrev UInt32.mod_toNat := @UInt32.toNat_mod
+
+@[deprecated UInt64.toNat_zero (since := "2024-06-23")] protected abbrev UInt64.zero_toNat := @UInt64.toNat_zero
+@[deprecated UInt64.toNat_div (since := "2024-06-23")] protected abbrev UInt64.div_toNat := @UInt64.toNat_div
+@[deprecated UInt64.toNat_mod (since := "2024-06-23")] protected abbrev UInt64.mod_toNat := @UInt64.toNat_mod
+
+@[deprecated USize.toNat_zero (since := "2024-06-23")] protected abbrev USize.zero_toNat := @USize.toNat_zero
+@[deprecated USize.toNat_div (since := "2024-06-23")] protected abbrev USize.div_toNat := @USize.toNat_div
+@[deprecated USize.toNat_mod (since := "2024-06-23")] protected abbrev USize.mod_toNat := @USize.toNat_mod

src/Init/Data/Vector.lean

@@ -5,7 +5,3 @@ Authors: Kim Morrison
 -/
 prelude
 import Init.Data.Vector.Basic
-import Init.Data.Vector.Lemmas
-import Init.Data.Vector.Lex
-import Init.Data.Vector.MapIdx
-import Init.Data.Vector.Count

src/Init/Data/Vector/Attach.lean

@@ -1,551 +0,0 @@
-/-
-Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.Vector.Lemmas
-import Init.Data.Array.Attach
-
-namespace Vector
-
-/--
-`O(n)`. Partial map. If `f : Π a, P a → β` is a partial function defined on
-`a : α` satisfying `P`, then `pmap f l h` is essentially the same as `map f l`
-but is defined only when all members of `l` satisfy `P`, using the proof
-to apply `f`.
-
-We replace this at runtime with a more efficient version via the `csimp` lemma `pmap_eq_pmapImpl`.
--/
-def pmap {P : α → Prop} (f : ∀ a, P a → β) (l : Vector α n) (H : ∀ a ∈ l, P a) : Vector β n :=
-  Vector.mk (l.toArray.pmap f (fun a m => H a (by simpa using m))) (by simp)
-
-/--
-Unsafe implementation of `attachWith`, taking advantage of the fact that the representation of
-`Vector {x // P x} n` is the same as the input `Vector α n`.
--/
-@[inline] private unsafe def attachWithImpl
-    (xs : Vector α n) (P : α → Prop) (_ : ∀ x ∈ xs, P x) : Vector {x // P x} n := unsafeCast xs
-
-/-- `O(1)`. "Attach" a proof `P x` that holds for all the elements of `xs` to produce a new array
-  with the same elements but in the type `{x // P x}`. -/
-@[implemented_by attachWithImpl] def attachWith
-    (xs : Vector α n) (P : α → Prop) (H : ∀ x ∈ xs, P x) : Vector {x // P x} n :=
-  Vector.mk (xs.toArray.attachWith P fun x h => H x (by simpa using h)) (by simp)
-
-/-- `O(1)`. "Attach" the proof that the elements of `xs` are in `xs` to produce a new vector
-  with the same elements but in the type `{x // x ∈ xs}`. -/
-@[inline] def attach (xs : Vector α n) : Vector {x // x ∈ xs} n := xs.attachWith _ fun _ => id
-
-@[simp] theorem attachWith_mk {xs : Array α} {h : xs.size = n} {P : α → Prop} {H : ∀ x ∈ mk xs h, P x} :
-    (mk xs h).attachWith P H = mk (xs.attachWith P (by simpa using H)) (by simpa using h) := by
-  simp [attachWith]
-
-@[simp] theorem attach_mk {xs : Array α} {h : xs.size = n} :
-    (mk xs h).attach = mk (xs.attachWith (· ∈ mk xs h) (by simp)) (by simpa using h):= by
-  simp [attach]
-
-@[simp] theorem pmap_mk {xs : Array α} {h : xs.size = n} {P : α → Prop} {f : ∀ a, P a → β}
-    {H : ∀ a ∈ mk xs h, P a} :
-    (mk xs h).pmap f H = mk (xs.pmap f (by simpa using H)) (by simpa using h) := by
-  simp [pmap]
-
-@[simp] theorem toArray_attachWith {l : Vector α n} {P : α → Prop} {H : ∀ x ∈ l, P x} :
-   (l.attachWith P H).toArray = l.toArray.attachWith P (by simpa using H) := by
-  simp [attachWith]
-
-@[simp] theorem toArray_attach {α : Type _} {l : Vector α n} :
-    l.attach.toArray = l.toArray.attachWith (· ∈ l) (by simp) := by
-  simp [attach]
-
-@[simp] theorem toArray_pmap {l : Vector α n} {P : α → Prop} {f : ∀ a, P a → β} {H : ∀ a ∈ l, P a} :
-    (l.pmap f H).toArray = l.toArray.pmap f (fun a m => H a (by simpa using m)) := by
-  simp [pmap]
-
-@[simp] theorem toList_attachWith {l : Vector α n} {P : α → Prop} {H : ∀ x ∈ l, P x} :
-   (l.attachWith P H).toList = l.toList.attachWith P (by simpa using H) := by
-  simp [attachWith]
-
-@[simp] theorem toList_attach {α : Type _} {l : Vector α n} :
-    l.attach.toList = l.toList.attachWith (· ∈ l) (by simp) := by
-  simp [attach]
-
-@[simp] theorem toList_pmap {l : Vector α n} {P : α → Prop} {f : ∀ a, P a → β} {H : ∀ a ∈ l, P a} :
-    (l.pmap f H).toList = l.toList.pmap f (fun a m => H a (by simpa using m)) := by
-  simp [pmap]
-
-/-- Implementation of `pmap` using the zero-copy version of `attach`. -/
-@[inline] private def pmapImpl {P : α → Prop} (f : ∀ a, P a → β) (l : Vector α n) (H : ∀ a ∈ l, P a) :
-    Vector β n := (l.attachWith _ H).map fun ⟨x, h'⟩ => f x h'
-
-@[csimp] private theorem pmap_eq_pmapImpl : @pmap = @pmapImpl := by
-  funext α β n p f L h'
-  rcases L with ⟨L, rfl⟩
-  simp only [pmap, pmapImpl, attachWith_mk, map_mk, Array.map_attachWith, eq_mk]
-  apply Array.pmap_congr_left
-  intro a m h₁ h₂
-  congr
-
-@[simp] theorem pmap_empty {P : α → Prop} (f : ∀ a, P a → β) : pmap f #v[] (by simp) = #v[] := rfl
-
-@[simp] theorem pmap_push {P : α → Prop} (f : ∀ a, P a → β) (a : α) (l : Vector α n) (h : ∀ b ∈ l.push a, P b) :
-    pmap f (l.push a) h =
-      (pmap f l (fun a m => by simp at h; exact h a (.inl m))).push (f a (h a (by simp))) := by
-  simp [pmap]
-
-@[simp] theorem attach_empty : (#v[] : Vector α 0).attach = #v[] := rfl
-
-@[simp] theorem attachWith_empty {P : α → Prop} (H : ∀ x ∈ #v[], P x) : (#v[] : Vector α 0).attachWith P H = #v[] := rfl
-
-@[simp]
-theorem pmap_eq_map (p : α → Prop) (f : α → β) (l : Vector α n) (H) :
-    @pmap _ _ _ p (fun a _ => f a) l H = map f l := by
-  cases l; simp
-
-theorem pmap_congr_left {p q : α → Prop} {f : ∀ a, p a → β} {g : ∀ a, q a → β} (l : Vector α n) {H₁ H₂}
-    (h : ∀ a ∈ l, ∀ (h₁ h₂), f a h₁ = g a h₂) : pmap f l H₁ = pmap g l H₂ := by
-  rcases l with ⟨l, rfl⟩
-  simp only [pmap_mk, eq_mk]
-  apply Array.pmap_congr_left
-  simpa using h
-
-theorem map_pmap {p : α → Prop} (g : β → γ) (f : ∀ a, p a → β) (l : Vector α n) (H) :
-    map g (pmap f l H) = pmap (fun a h => g (f a h)) l H := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.map_pmap]
-
-theorem pmap_map {p : β → Prop} (g : ∀ b, p b → γ) (f : α → β) (l : Vector α n) (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
-  rcases l with ⟨l, rfl⟩
-  simp [Array.pmap_map]
-
-theorem attach_congr {l₁ l₂ : Vector α n} (h : l₁ = l₂) :
-    l₁.attach = l₂.attach.map (fun x => ⟨x.1, h ▸ x.2⟩) := by
-  subst h
-  simp
-
-theorem attachWith_congr {l₁ l₂ : Vector α n} (w : l₁ = l₂) {P : α → Prop} {H : ∀ x ∈ l₁, P x} :
-    l₁.attachWith P H = l₂.attachWith P fun _ h => H _ (w ▸ h) := by
-  subst w
-  simp
-
-@[simp] theorem attach_push {a : α} {l : Vector α n} :
-    (l.push a).attach =
-      (l.attach.map (fun ⟨x, h⟩ => ⟨x, mem_push_of_mem a h⟩)).push ⟨a, by simp⟩ := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.map_attachWith]
-
-@[simp] theorem attachWith_push {a : α} {l : Vector α n} {P : α → Prop} {H : ∀ x ∈ l.push a, P x} :
-    (l.push a).attachWith P H =
-      (l.attachWith P (fun x h => by simp at H; exact H x (.inl h))).push ⟨a, H a (by simp)⟩ := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-theorem pmap_eq_map_attach {p : α → Prop} (f : ∀ a, p a → β) (l : Vector α n) (H) :
-    pmap f l H = l.attach.map fun x => f x.1 (H _ x.2) := by
-  rcases l with ⟨l, rfl⟩
-  simp only [pmap_mk, Array.pmap_eq_map_attach, attach_mk, map_mk, eq_mk]
-  rw [Array.map_attach, Array.map_attachWith]
-  ext i hi₁ hi₂ <;> simp
-
-@[simp]
-theorem pmap_eq_attachWith {p q : α → Prop} (f : ∀ a, p a → q a) (l : Vector α n) (H) :
-    pmap (fun a h => ⟨a, f a h⟩) l H = l.attachWith q (fun x h => f x (H x h)) := by
-  cases l
-  simp
-
-theorem attach_map_coe (l : Vector α n) (f : α → β) :
-    (l.attach.map fun (i : {i // i ∈ l}) => f i) = l.map f := by
-  cases l
-  simp
-
-theorem attach_map_val (l : Vector α n) (f : α → β) : (l.attach.map fun i => f i.val) = l.map f :=
-  attach_map_coe _ _
-
-theorem attach_map_subtype_val (l : Vector α n) : l.attach.map Subtype.val = l := by
-  cases l; simp
-
-theorem attachWith_map_coe {p : α → Prop} (f : α → β) (l : Vector α n) (H : ∀ a ∈ l, p a) :
-    ((l.attachWith p H).map fun (i : { i // p i}) => f i) = l.map f := by
-  cases l; simp
-
-theorem attachWith_map_val {p : α → Prop} (f : α → β) (l : Vector α n) (H : ∀ a ∈ l, p a) :
-    ((l.attachWith p H).map fun i => f i.val) = l.map f :=
-  attachWith_map_coe _ _ _
-
-theorem attachWith_map_subtype_val {p : α → Prop} (l : Vector α n) (H : ∀ a ∈ l, p a) :
-    (l.attachWith p H).map Subtype.val = l := by
-  cases l; simp
-
-@[simp]
-theorem mem_attach (l : Vector α n) : ∀ x, x ∈ l.attach
-  | ⟨a, h⟩ => by
-    have := mem_map.1 (by rw [attach_map_subtype_val] <;> exact h)
-    rcases this with ⟨⟨_, _⟩, m, rfl⟩
-    exact m
-
-@[simp]
-theorem mem_attachWith (l : Vector α n) {q : α → Prop} (H) (x : {x // q x}) :
-    x ∈ l.attachWith q H ↔ x.1 ∈ l := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-@[simp]
-theorem mem_pmap {p : α → Prop} {f : ∀ a, p a → β} {l : Vector α n} {H b} :
-    b ∈ pmap f l H ↔ ∃ (a : _) (h : a ∈ l), f a (H a h) = b := by
-  simp only [pmap_eq_map_attach, mem_map, mem_attach, true_and, Subtype.exists, eq_comm]
-
-theorem mem_pmap_of_mem {p : α → Prop} {f : ∀ a, p a → β} {l : Vector α n} {H} {a} (h : a ∈ l) :
-    f a (H a h) ∈ pmap f l H := by
-  rw [mem_pmap]
-  exact ⟨a, h, rfl⟩
-
-theorem pmap_eq_self {l : Vector α n} {p : α → Prop} {hp : ∀ (a : α), a ∈ l → p a}
-    {f : (a : α) → p a → α} : l.pmap f hp = l ↔ ∀ a (h : a ∈ l), f a (hp a h) = a := by
-  cases l; simp [Array.pmap_eq_self]
-
-@[simp]
-theorem getElem?_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : Vector α n} (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
-  cases l; simp
-
-@[simp]
-theorem getElem_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : Vector α n} (h : ∀ a ∈ l, p a) {i : Nat}
-    (hn : i < n) :
-    (pmap f l h)[i] = f (l[i]) (h _ (by simp)) := by
-  cases l; simp
-
-@[simp]
-theorem getElem?_attachWith {xs : Vector α n} {i : Nat} {P : α → Prop} {H : ∀ a ∈ xs, P a} :
-    (xs.attachWith P H)[i]? = xs[i]?.pmap Subtype.mk (fun _ a => H _ (mem_of_getElem? a)) :=
-  getElem?_pmap ..
-
-@[simp]
-theorem getElem?_attach {xs : Vector α n} {i : Nat} :
-    xs.attach[i]? = xs[i]?.pmap Subtype.mk (fun _ a => mem_of_getElem? a) :=
-  getElem?_attachWith
-
-@[simp]
-theorem getElem_attachWith {xs : Vector α n} {P : α → Prop} {H : ∀ a ∈ xs, P a}
-    {i : Nat} (h : i < n) :
-    (xs.attachWith P H)[i] = ⟨xs[i]'(by simpa using h), H _ (getElem_mem (by simpa using h))⟩ :=
-  getElem_pmap _ _ h
-
-@[simp]
-theorem getElem_attach {xs : Vector α n} {i : Nat} (h : i < n) :
-    xs.attach[i] = ⟨xs[i]'(by simpa using h), getElem_mem (by simpa using h)⟩ :=
-  getElem_attachWith h
-
-@[simp] theorem pmap_attach (l : Vector α n) {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
-  ext <;> simp
-
-@[simp] theorem pmap_attachWith (l : Vector α n) {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
-  ext <;> simp
-
-theorem foldl_pmap (l : Vector α n) {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 : Vector α n) {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]
-
-/--
-If we fold over `l.attach` with a function that ignores the membership predicate,
-we get the same results as folding over `l` directly.
-
-This is useful when we need to use `attach` to show termination.
-
-Unfortunately this can't be applied by `simp` because of the higher order unification problem,
-and even when rewriting we need to specify the function explicitly.
-See however `foldl_subtype` below.
--/
-theorem foldl_attach (l : Vector α n) (f : β → α → β) (b : β) :
-    l.attach.foldl (fun acc t => f acc t.1) b = l.foldl f b := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.foldl_attach]
-
-/--
-If we fold over `l.attach` with a function that ignores the membership predicate,
-we get the same results as folding over `l` directly.
-
-This is useful when we need to use `attach` to show termination.
-
-Unfortunately this can't be applied by `simp` because of the higher order unification problem,
-and even when rewriting we need to specify the function explicitly.
-See however `foldr_subtype` below.
--/
-theorem foldr_attach (l : Vector α n) (f : α → β → β) (b : β) :
-    l.attach.foldr (fun t acc => f t.1 acc) b = l.foldr f b := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.foldr_attach]
-
-theorem attach_map {l : Vector α n} (f : α → β) :
-    (l.map f).attach = l.attach.map (fun ⟨x, h⟩ => ⟨f x, mem_map_of_mem f h⟩) := by
-  cases l
-  ext <;> simp
-
-theorem attachWith_map {l : Vector α n} (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
-      fun ⟨x, h⟩ => ⟨f x, h⟩ := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.attachWith_map]
-
-theorem map_attachWith {l : Vector α n} {P : α → Prop} {H : ∀ (a : α), a ∈ l → P a}
-    (f : { x // P x } → β) :
-    (l.attachWith P H).map f =
-      l.pmap (fun a (h : a ∈ l ∧ P a) => f ⟨a, H _ h.1⟩) (fun a h => ⟨h, H a h⟩) := by
-  cases l
-  ext <;> simp
-
-/-- See also `pmap_eq_map_attach` for writing `pmap` in terms of `map` and `attach`. -/
-theorem map_attach {l : Vector α n} (f : { x // x ∈ l } → β) :
-    l.attach.map f = l.pmap (fun a h => f ⟨a, h⟩) (fun _ => id) := by
-  cases l
-  ext <;> simp
-
-theorem pmap_pmap {p : α → Prop} {q : β → Prop} (g : ∀ a, p a → β) (f : ∀ b, q b → γ) (l : Vector α n) (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
-  rcases l with ⟨l, rfl⟩
-  ext <;> simp
-
-@[simp] theorem pmap_append {p : ι → Prop} (f : ∀ a : ι, p a → α) (l₁ : Vector ι n) (l₂ : Vector ι m)
-    (h : ∀ a ∈ l₁ ++ l₂, p a) :
-    (l₁ ++ l₂).pmap f h =
-      (l₁.pmap f fun a ha => h a (mem_append_left l₂ ha)) ++
-        l₂.pmap f fun a ha => h a (mem_append_right l₁ ha) := by
-  cases l₁
-  cases l₂
-  simp
-
-theorem pmap_append' {p : α → Prop} (f : ∀ a : α, p a → β) (l₁ : Vector α n) (l₂ : Vector α m)
-    (h₁ : ∀ a ∈ l₁, p a) (h₂ : ∀ a ∈ l₂, p a) :
-    ((l₁ ++ l₂).pmap f fun a ha => (mem_append.1 ha).elim (h₁ a) (h₂ a)) =
-      l₁.pmap f h₁ ++ l₂.pmap f h₂ :=
-  pmap_append f l₁ l₂ _
-
-@[simp] theorem attach_append (xs : Vector α n) (ys : Vector α m) :
-    (xs ++ ys).attach = xs.attach.map (fun ⟨x, h⟩ => (⟨x, mem_append_left ys h⟩ : { x // x ∈ xs ++ ys })) ++
-      ys.attach.map (fun ⟨y, h⟩ => (⟨y, mem_append_right xs h⟩ : { y // y ∈ xs ++ ys })) := by
-  rcases xs with ⟨xs, rfl⟩
-  rcases ys with ⟨ys, rfl⟩
-  simp [Array.map_attachWith]
-
-@[simp] theorem attachWith_append {P : α → Prop} {xs : Vector α n} {ys : Vector α m}
-    {H : ∀ (a : α), a ∈ xs ++ ys → P a} :
-    (xs ++ ys).attachWith P H = xs.attachWith P (fun a h => H a (mem_append_left ys h)) ++
-      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 : Vector α n)
-    (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 : Vector α n)
-    (H : ∀ (a : α), a ∈ xs → P a) :
-    (xs.pmap f H).reverse = xs.reverse.pmap f (fun a h => H a (by simpa using h)) := by
-  rw [pmap_reverse]
-
-@[simp] theorem attachWith_reverse {P : α → Prop} {xs : Vector α n}
-    {H : ∀ (a : α), a ∈ xs.reverse → P a} :
-    xs.reverse.attachWith P H =
-      (xs.attachWith P (fun a h => H a (by simpa using h))).reverse := by
-  cases xs
-  simp
-
-theorem reverse_attachWith {P : α → Prop} {xs : Vector α n}
-    {H : ∀ (a : α), a ∈ xs → P a} :
-    (xs.attachWith P H).reverse = (xs.reverse.attachWith P (fun a h => H a (by simpa using h))) := by
-  cases xs
-  simp
-
-@[simp] theorem attach_reverse (xs : Vector α n) :
-    xs.reverse.attach = xs.attach.reverse.map fun ⟨x, h⟩ => ⟨x, by simpa using h⟩ := by
-  cases xs
-  rw [attach_congr (reverse_mk ..)]
-  simp [Array.map_attachWith]
-
-theorem reverse_attach (xs : Vector α n) :
-    xs.attach.reverse = xs.reverse.attach.map fun ⟨x, h⟩ => ⟨x, by simpa using h⟩ := by
-  cases xs
-  simp [Array.map_attachWith]
-
-@[simp] theorem back?_pmap {P : α → Prop} (f : (a : α) → P a → β) (xs : Vector α n)
-    (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
-  simp
-
-@[simp] theorem back?_attachWith {P : α → Prop} {xs : Vector α n}
-    {H : ∀ (a : α), a ∈ xs → P a} :
-    (xs.attachWith P H).back? = xs.back?.pbind (fun a h => some ⟨a, H _ (mem_of_back? h)⟩) := by
-  cases xs
-  simp
-
-@[simp]
-theorem back?_attach {xs : Vector α n} :
-    xs.attach.back? = xs.back?.pbind fun a h => some ⟨a, mem_of_back? h⟩ := by
-  cases xs
-  simp
-
-@[simp]
-theorem countP_attach (l : Vector α n) (p : α → Bool) :
-    l.attach.countP (fun a : {x // x ∈ l} => p a) = l.countP p := by
-  cases l
-  simp [Function.comp_def]
-
-@[simp]
-theorem countP_attachWith {p : α → Prop} (l : Vector α n) (H : ∀ a ∈ l, p a) (q : α → Bool) :
-    (l.attachWith p H).countP (fun a : {x // p x} => q a) = l.countP q := by
-  cases l
-  simp
-
-@[simp]
-theorem count_attach [DecidableEq α] (l : Vector α n) (a : {x // x ∈ l}) :
-    l.attach.count a = l.count ↑a := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-@[simp]
-theorem count_attachWith [DecidableEq α] {p : α → Prop} (l : Vector α n) (H : ∀ a ∈ l, p a) (a : {x // p x}) :
-    (l.attachWith p H).count a = l.count ↑a := by
-  cases l
-  simp
-
-@[simp] theorem countP_pmap {p : α → Prop} (g : ∀ a, p a → β) (f : β → Bool) (l : Vector α n) (H₁) :
-    (l.pmap g H₁).countP f =
-      l.attach.countP (fun ⟨a, m⟩ => f (g a (H₁ a m))) := by
-  rcases l with ⟨l, rfl⟩
-  simp only [pmap_mk, countP_mk, Array.countP_pmap]
-  simp [Array.countP_eq_size_filter]
-
-/-! ## unattach
-
-`Vector.unattach` is the (one-sided) inverse of `Vector.attach`. It is a synonym for `Vector.map Subtype.val`.
-
-We use it by providing a simp lemma `l.attach.unattach = l`, and simp lemmas which recognize higher order
-functions applied to `l : Vector { x // p x }` which only depend on the value, not the predicate, and rewrite these
-in terms of a simpler function applied to `l.unattach`.
-
-Further, we provide simp lemmas that push `unattach` inwards.
--/
-
-/--
-A synonym for `l.map (·.val)`. Mostly this should not be needed by users.
-It is introduced as in intermediate step by lemmas such as `map_subtype`,
-and is ideally subsequently simplified away by `unattach_attach`.
-
-If not, usually the right approach is `simp [Vector.unattach, -Vector.map_subtype]` to unfold.
--/
-def unattach {α : Type _} {p : α → Prop} (l : Vector { x // p x } n) : Vector α n := l.map (·.val)
-
-@[simp] theorem unattach_nil {p : α → Prop} : (#v[] : Vector { x // p x } 0).unattach = #v[] := rfl
-@[simp] theorem unattach_push {p : α → Prop} {a : { x // p x }} {l : Vector { x // p x } n} :
-    (l.push a).unattach = l.unattach.push a.1 := by
-  simp only [unattach, Vector.map_push]
-
-@[simp] theorem unattach_mk {p : α → Prop} {l : Array { x // p x }} {h : l.size = n} :
-    (mk l h).unattach = mk l.unattach (by simpa using h) := by
-  simp [unattach]
-
-@[simp] theorem toArray_unattach {p : α → Prop} {l : Vector { x // p x } n} :
-    l.unattach.toArray = l.toArray.unattach := by
-  simp [unattach]
-
-@[simp] theorem toList_unattach {p : α → Prop} {l : Array { x // p x }} :
-    l.unattach.toList = l.toList.unattach := by
-  simp [unattach]
-
-@[simp] theorem unattach_attach {l : Vector α n} : l.attach.unattach = l := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-@[simp] theorem unattach_attachWith {p : α → Prop} {l : Vector α n}
-    {H : ∀ a ∈ l, p a} :
-    (l.attachWith p H).unattach = l := by
-  cases l
-  simp
-
-@[simp] theorem getElem?_unattach {p : α → Prop} {l : Vector { x // p x } n} (i : Nat) :
-    l.unattach[i]? = l[i]?.map Subtype.val := by
-  simp [unattach]
-
-@[simp] theorem getElem_unattach
-    {p : α → Prop} {l : Vector { x // p x } n} (i : Nat) (h : i < n) :
-    l.unattach[i] = (l[i]'(by simpa using h)).1 := by
-  simp [unattach]
-
-/-! ### Recognizing higher order functions using a function that only depends on the value. -/
-
-/--
-This lemma identifies folds over arrays of subtypes, where the function only depends on the value, not the proposition,
-and simplifies these to the function directly taking the value.
--/
-@[simp] theorem foldl_subtype {p : α → Prop} {l : Vector { x // p x } n}
-    {f : β → { x // p x } → β} {g : β → α → β} {x : β}
-    {hf : ∀ b x h, f b ⟨x, h⟩ = g b x} :
-    l.foldl f x = l.unattach.foldl g x := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.foldl_subtype (hf := hf)]
-
-/--
-This lemma identifies folds over arrays of subtypes, where the function only depends on the value, not the proposition,
-and simplifies these to the function directly taking the value.
--/
-@[simp] theorem foldr_subtype {p : α → Prop} {l : Vector { x // p x } n}
-    {f : { x // p x } → β → β} {g : α → β → β} {x : β}
-    {hf : ∀ x h b, f ⟨x, h⟩ b = g x b} :
-    l.foldr f x = l.unattach.foldr g x := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.foldr_subtype (hf := hf)]
-
-/--
-This lemma identifies maps over arrays of subtypes, where the function only depends on the value, not the proposition,
-and simplifies these to the function directly taking the value.
--/
-@[simp] theorem map_subtype {p : α → Prop} {l : Vector { x // p x } n}
-    {f : { x // p x } → β} {g : α → β} {hf : ∀ x h, f ⟨x, h⟩ = g x} :
-    l.map f = l.unattach.map g := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.map_subtype (hf := hf)]
-
-/-! ### Simp lemmas pushing `unattach` inwards. -/
-
-@[simp] theorem unattach_reverse {p : α → Prop} {l : Vector { x // p x } n} :
-    l.reverse.unattach = l.unattach.reverse := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.unattach_reverse]
-
-
-@[simp] theorem unattach_append {p : α → Prop} {l₁ l₂ : Vector { x // p x } n} :
-    (l₁ ++ l₂).unattach = l₁.unattach ++ l₂.unattach := by
-  rcases l₁
-  rcases l₂
-  simp
-
-@[simp] theorem unattach_flatten {p : α → Prop} {l : Vector (Vector { x // p x } n) n} :
-    l.flatten.unattach = (l.map unattach).flatten := by
-  unfold unattach
-  cases l using vector₂_induction
-  simp only [flatten_mk, Array.map_map, Function.comp_apply, Array.map_subtype,
-    Array.unattach_attach, Array.map_id_fun', id_eq, map_mk, Array.map_flatten, map_subtype,
-    map_id_fun', unattach_mk, eq_mk]
-  unfold Array.unattach
-  rfl
-
-@[simp] theorem unattach_mkVector {p : α → Prop} {n : Nat} {x : { x // p x }} :
-    (mkVector n x).unattach = mkVector n x.1 := by
-  simp [unattach]
-
-end Vector

src/Init/Data/Vector/Basic.lean

@@ -6,7 +6,6 @@ Authors: Shreyas Srinivas, François G. Dorais, Kim Morrison
 
 prelude
 import Init.Data.Array.Lemmas
-import Init.Data.Array.MapIdx
 import Init.Data.Range
 
 /-!
@@ -91,18 +90,20 @@ of bounds.
 /-- The last element of a vector. Panics if the vector is empty. -/
 @[inline] def back! [Inhabited α] (v : Vector α n) : α := v.toArray.back!
 
-/-- The last element of a vector, or `none` if the vector is empty. -/
+/-- The last element of a vector, or `none` if the array is empty. -/
 @[inline] def back? (v : Vector α n) : Option α := v.toArray.back?
 
 /-- The last element of a non-empty vector. -/
 @[inline] def back [NeZero n] (v : Vector α n) : α :=
-  v[n - 1]'(Nat.sub_one_lt (NeZero.ne n))
+  -- TODO: change to just `v[n]`
+  have : Inhabited α := ⟨v[0]'(Nat.pos_of_neZero n)⟩
+  v.back!
 
 /-- The first element of a non-empty vector.  -/
 @[inline] def head [NeZero n] (v : Vector α n) := v[0]'(Nat.pos_of_neZero n)
 
 /-- Push an element `x` to the end of a vector. -/
-@[inline] def push (v : Vector α n) (x : α) : Vector α (n + 1) :=
+@[inline] def push (x : α) (v : Vector α n)  : Vector α (n + 1) :=
   ⟨v.toArray.push x, by simp⟩
 
 /-- Remove the last element of a vector. -/
@@ -135,18 +136,6 @@ This will perform the update destructively provided that the vector has a refere
 @[inline] def set! (v : Vector α n) (i : Nat) (x : α) : Vector α n :=
   ⟨v.toArray.set! i x, by simp⟩
 
-@[inline] def foldlM [Monad m] (f : β → α → m β) (b : β) (v : Vector α n) : m β :=
-  v.toArray.foldlM f b
-
-@[inline] def foldrM [Monad m] (f : α → β → m β) (b : β) (v : Vector α n) : m β :=
-  v.toArray.foldrM f b
-
-@[inline] def foldl (f : β → α → β) (b : β) (v : Vector α n) : β :=
-  v.toArray.foldl f b
-
-@[inline] def foldr (f : α → β → β) (b : β) (v : Vector α n) : β :=
-  v.toArray.foldr f b
-
 /-- Append two vectors. -/
 @[inline] def append (v : Vector α n) (w : Vector α m) : Vector α (n + m) :=
   ⟨v.toArray ++ w.toArray, by simp⟩
@@ -169,25 +158,6 @@ result is empty. If `stop` is greater than the size of the vector, the size is u
 @[inline] def map (f : α → β) (v : Vector α n) : Vector β n :=
   ⟨v.toArray.map f, by simp⟩
 
-/-- Maps elements of a vector using the function `f`, which also receives the index of the element. -/
-@[inline] def mapIdx (f : Nat → α → β) (v : Vector α n) : Vector β n :=
-  ⟨v.toArray.mapIdx f, by simp⟩
-
-/-- Maps elements of a vector using the function `f`,
-which also receives the index of the element, and the fact that the index is less than the size of the vector. -/
-@[inline] def mapFinIdx (v : Vector α n) (f : (i : Nat) → α → (h : i < n) → β) : Vector β n :=
-  ⟨v.toArray.mapFinIdx (fun i a h => f i a (by simpa [v.size_toArray] using h)), by simp⟩
-
-@[inline] def flatten (v : Vector (Vector α n) m) : Vector α (m * n) :=
-  ⟨(v.toArray.map Vector.toArray).flatten,
-    by rcases v; simp_all [Function.comp_def, Array.map_const']⟩
-
-@[inline] def flatMap (v : Vector α n) (f : α → Vector β m) : Vector β (n * m) :=
-  ⟨v.toArray.flatMap fun a => (f a).toArray, by simp [Array.map_const']⟩
-
-@[inline] def zipWithIndex (v : Vector α n) : Vector (α × Nat) n :=
-  ⟨v.toArray.zipWithIndex, by simp⟩
-
 /-- Maps corresponding elements of two vectors of equal size using the function `f`. -/
 @[inline] def zipWith (a : Vector α n) (b : Vector β n) (f : α → β → φ) : Vector φ n :=
   ⟨Array.zipWith a.toArray b.toArray f, by simp⟩
@@ -312,14 +282,6 @@ no element of the index matches the given value.
 @[inline] def all (v : Vector α n) (p : α → Bool) : Bool :=
   v.toArray.all p
 
-/-- Count the number of elements of a vector that satisfy the predicate `p`. -/
-@[inline] def countP (p : α → Bool) (v : Vector α n) : Nat :=
-  v.toArray.countP p
-
-/-- Count the number of elements of a vector that are equal to `a`. -/
-@[inline] def count [BEq α] (a : α) (v : Vector α n) : Nat :=
-  v.toArray.count a
-
 /-! ### Lexicographic ordering -/
 
 instance instLT [LT α] : LT (Vector α n) := ⟨fun v w => v.toArray < w.toArray⟩

src/Init/Data/Vector/Count.lean

@@ -1,233 +0,0 @@
-/-
-Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.Array.Count
-import Init.Data.Vector.Lemmas
-
-/-!
-# Lemmas about `Vector.countP` and `Vector.count`.
--/
-
-namespace Vector
-
-open Nat
-
-/-! ### countP -/
-section countP
-
-variable (p q : α → Bool)
-
-@[simp] theorem countP_empty : countP p #v[] = 0 := rfl
-
-@[simp] theorem countP_push_of_pos (l : Vector α n) (pa : p a) : countP p (l.push a) = countP p l + 1 := by
-  rcases l with ⟨l⟩
-  simp_all
-
-@[simp] theorem countP_push_of_neg (l : Vector α n) (pa : ¬p a) : countP p (l.push a) = countP p l := by
-  rcases l with ⟨l, rfl⟩
-  simp_all
-
-theorem countP_push (a : α) (l : Vector α n) : countP p (l.push a) = countP p l + if p a then 1 else 0 := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.countP_push]
-
-@[simp] theorem countP_singleton (a : α) : countP p #v[a] = if p a then 1 else 0 := by
-  simp [countP_push]
-
-theorem size_eq_countP_add_countP (l : Vector α n) : n = countP p l + countP (fun a => ¬p a) l := by
-  rcases l with ⟨l, rfl⟩
-  simp [List.length_eq_countP_add_countP (p := p)]
-
-theorem countP_le_size {l : Vector α n} : countP p l ≤ n := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.countP_le_size (p := p)]
-
-@[simp] theorem countP_append (l₁ : Vector α n) (l₂ : Vector α m) : countP p (l₁ ++ l₂) = countP p l₁ + countP p l₂ := by
-  cases l₁
-  cases l₂
-  simp
-
-@[simp] theorem countP_pos_iff {p} : 0 < countP p l ↔ ∃ a ∈ l, p a := by
-  cases l
-  simp
-
-@[simp] theorem one_le_countP_iff {p} : 1 ≤ countP p l ↔ ∃ a ∈ l, p a :=
-  countP_pos_iff
-
-@[simp] theorem countP_eq_zero {p} : countP p l = 0 ↔ ∀ a ∈ l, ¬p a := by
-  cases l
-  simp
-
-@[simp] theorem countP_eq_size {p} : countP p l = l.size ↔ ∀ a ∈ l, p a := by
-  cases l
-  simp
-
-@[simp] theorem countP_cast (p : α → Bool) (l : Vector α n) : countP p (l.cast h) = countP p l := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-theorem countP_mkVector (p : α → Bool) (a : α) (n : Nat) :
-    countP p (mkVector n a) = if p a then n else 0 := by
-  simp only [mkVector_eq_toVector_mkArray, countP_cast, countP_mk]
-  simp [Array.countP_mkArray]
-
-theorem boole_getElem_le_countP (p : α → Bool) (l : Vector α n) (i : Nat) (h : i < n) :
-    (if p l[i] then 1 else 0) ≤ l.countP p := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.boole_getElem_le_countP]
-
-theorem countP_set (p : α → Bool) (l : Vector α n) (i : Nat) (a : α) (h : i < n) :
-    (l.set i a).countP p = l.countP p - (if p l[i] then 1 else 0) + (if p a then 1 else 0) := by
-  cases l
-  simp [Array.countP_set, h]
-
-@[simp] theorem countP_true : (countP fun (_ : α) => true) = (fun (_ : Vector α n) => n) := by
-  funext l
-  rw [countP]
-  simp only [Array.countP_true, l.2]
-
-@[simp] theorem countP_false : (countP fun (_ : α) => false) = (fun (_ : Vector α n) => 0) := by
-  funext l
-  simp
-
-@[simp] theorem countP_map (p : β → Bool) (f : α → β) (l : Vector α n) :
-    countP p (map f l) = countP (p ∘ f) l := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-@[simp] theorem countP_flatten (l : Vector (Vector α m) n) :
-    countP p l.flatten = (l.map (countP p)).sum := by
-  rcases l with ⟨l, rfl⟩
-  simp [Function.comp_def]
-
-theorem countP_flatMap (p : β → Bool) (l : Vector α n) (f : α → Vector β m) :
-    countP p (l.flatMap f) = (map (countP p ∘ f) l).sum := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.countP_flatMap, Function.comp_def]
-
-@[simp] theorem countP_reverse (l : Vector α n) : countP p l.reverse = countP p l := by
-  cases l
-  simp
-
-variable {p q}
-
-theorem countP_mono_left (h : ∀ x ∈ l, p x → q x) : countP p l ≤ countP q l := by
-  cases l
-  simpa using Array.countP_mono_left (by simpa using h)
-
-theorem countP_congr (h : ∀ x ∈ l, p x ↔ q x) : countP p l = countP q l :=
-  Nat.le_antisymm
-    (countP_mono_left fun x hx => (h x hx).1)
-    (countP_mono_left fun x hx => (h x hx).2)
-
-end countP
-
-/-! ### count -/
-section count
-
-variable [BEq α]
-
-@[simp] theorem count_empty (a : α) : count a #v[] = 0 := rfl
-
-theorem count_push (a b : α) (l : Vector α n) :
-    count a (l.push b) = count a l + if b == a then 1 else 0 := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.count_push]
-
-theorem count_eq_countP (a : α) (l : Vector α n) : count a l = countP (· == a) l := rfl
-
-theorem count_eq_countP' {a : α} : count (n := n) a = countP (· == a) := by
-  funext l
-  apply count_eq_countP
-
-theorem count_le_size (a : α) (l : Vector α n) : count a l ≤ n := countP_le_size _
-
-theorem count_le_count_push (a b : α) (l : Vector α n) : count a l ≤ count a (l.push b) := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.count_push]
-
-@[simp] theorem count_singleton (a b : α) : count a #v[b] = if b == a then 1 else 0 := by
-  simp [count_eq_countP]
-
-@[simp] theorem count_append (a : α) (l₁ : Vector α n) (l₂ : Vector α m) :
-    count a (l₁ ++ l₂) = count a l₁ + count a l₂ :=
-  countP_append ..
-
-@[simp] theorem count_flatten (a : α) (l : Vector (Vector α m) n) :
-    count a l.flatten = (l.map (count a)).sum := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.count_flatten, Function.comp_def]
-
-@[simp] theorem count_reverse (a : α) (l : Vector α n) : count a l.reverse = count a l := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-theorem boole_getElem_le_count (a : α) (l : Vector α n) (i : Nat) (h : i < n) :
-    (if l[i] == a then 1 else 0) ≤ l.count a := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.boole_getElem_le_count, h]
-
-theorem count_set (a b : α) (l : Vector α n) (i : Nat) (h : i < n) :
-    (l.set i a).count b = l.count b - (if l[i] == b then 1 else 0) + (if a == b then 1 else 0) := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.count_set, h]
-
-@[simp] theorem count_cast (l : Vector α n) : (l.cast h).count a = l.count a := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-variable [LawfulBEq α]
-
-@[simp] theorem count_push_self (a : α) (l : Vector α n) : count a (l.push a) = count a l + 1 := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.count_push_self]
-
-@[simp] theorem count_push_of_ne (h : b ≠ a) (l : Vector α n) : count a (l.push b) = count a l := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.count_push_of_ne, h]
-
-theorem count_singleton_self (a : α) : count a #v[a] = 1 := by simp
-
-@[simp]
-theorem count_pos_iff {a : α} {l : Vector α n} : 0 < count a l ↔ a ∈ l := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.count_pos_iff, beq_iff_eq, exists_eq_right]
-
-@[simp] theorem one_le_count_iff {a : α} {l : Vector α n} : 1 ≤ count a l ↔ a ∈ l :=
-  count_pos_iff
-
-theorem count_eq_zero_of_not_mem {a : α} {l : Vector α n} (h : a ∉ l) : count a l = 0 :=
-  Decidable.byContradiction fun h' => h <| count_pos_iff.1 (Nat.pos_of_ne_zero h')
-
-theorem not_mem_of_count_eq_zero {a : α} {l : Vector α n} (h : count a l = 0) : a ∉ l :=
-  fun h' => Nat.ne_of_lt (count_pos_iff.2 h') h.symm
-
-theorem count_eq_zero {l : Vector α n} : count a l = 0 ↔ a ∉ l :=
-  ⟨not_mem_of_count_eq_zero, count_eq_zero_of_not_mem⟩
-
-theorem count_eq_size {l : Vector α n} : count a l = l.size ↔ ∀ b ∈ l, a = b := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.count_eq_size]
-
-@[simp] theorem count_mkVector_self (a : α) (n : Nat) : count a (mkVector n a) = n := by
-  simp only [mkVector_eq_toVector_mkArray, count_cast, count_mk]
-  simp
-
-theorem count_mkVector (a b : α) (n : Nat) : count a (mkVector n b) = if b == a then n else 0 := by
-  simp only [mkVector_eq_toVector_mkArray, count_cast, count_mk]
-  simp [Array.count_mkArray]
-
-theorem count_le_count_map [DecidableEq β] (l : Vector α n) (f : α → β) (x : α) :
-    count x l ≤ count (f x) (map f l) := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.count_le_count_map]
-
-theorem count_flatMap {α} [BEq β] (l : Vector α n) (f : α → Vector β m) (x : β) :
-    count x (l.flatMap f) = (map (count x ∘ f) l).sum := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.count_flatMap, Function.comp_def]
-
-end count

src/Init/Data/Vector/Lex.lean

@@ -19,11 +19,6 @@ namespace Vector
 @[simp] theorem lt_toList [LT α] (l₁ l₂ : Vector α n) : l₁.toList < l₂.toList ↔ l₁ < l₂ := Iff.rfl
 @[simp] theorem le_toList [LT α] (l₁ l₂ : Vector α n) : l₁.toList ≤ l₂.toList ↔ l₁ ≤ l₂ := Iff.rfl
 
-protected theorem not_lt_iff_ge [LT α] (l₁ l₂ : Vector α n) : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
-protected theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] (l₁ l₂ : Vector α n) :
-    ¬ l₁ ≤ l₂ ↔ l₂ < l₁ :=
-  Decidable.not_not
-
 @[simp] theorem mk_lt_mk [LT α] :
     Vector.mk (α := α) (n := n) data₁ size₁ < Vector.mk data₂ size₂ ↔ data₁ < data₂ := Iff.rfl
 
@@ -138,7 +133,7 @@ protected theorem le_of_lt [DecidableEq α] [LT α] [DecidableLT α]
     {l₁ l₂ : Vector α n} (h : l₁ < l₂) : l₁ ≤ l₂ :=
   Array.le_of_lt h
 
-protected theorem le_iff_lt_or_eq [DecidableEq α] [LT α] [DecidableLT α]
+theorem le_iff_lt_or_eq [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)]
     [Std.Total (¬ · < · : α → α → Prop)]
@@ -205,14 +200,14 @@ theorem lex_eq_false_iff_exists [BEq α] [PartialEquivBEq α] (lt : α → α
   rcases l₂ with ⟨l₂, n₂⟩
   simp_all [Array.lex_eq_false_iff_exists, n₂]
 
-protected theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Vector α n} :
+theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Vector α n} :
     l₁ < l₂ ↔
       (∃ (i : Nat) (h : i < n), (∀ j, (hj : j < i) → l₁[j] = l₂[j]) ∧ l₁[i] < l₂[i]) := by
   cases l₁
   cases l₂
   simp_all [Array.lt_iff_exists]
 
-protected theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
+theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Asymm (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)] {l₁ l₂ : Vector α n} :
@@ -235,12 +230,12 @@ theorem append_left_le [DecidableEq α] [LT α] [DecidableLT α]
     l₁ ++ l₂ ≤ l₁ ++ l₃ := by
   simpa using Array.append_left_le h
 
-protected theorem map_lt [LT α] [LT β]
+theorem map_lt [LT α] [LT β]
     {l₁ l₂ : Vector α n} {f : α → β} (w : ∀ x y, x < y → f x < f y) (h : l₁ < l₂) :
     map f l₁ < map f l₂ := by
   simpa using Array.map_lt w h
 
-protected theorem map_le [DecidableEq α] [LT α] [DecidableLT α] [DecidableEq β] [LT β] [DecidableLT β]
+theorem map_le [DecidableEq α] [LT α] [DecidableLT α] [DecidableEq β] [LT β] [DecidableLT β]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Asymm (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)]

src/Init/Data/Vector/MapIdx.lean

@@ -1,333 +0,0 @@
-/-
-Copyright (c) 2025 Lean FRO. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.Array.MapIdx
-import Init.Data.Vector.Lemmas
-
-namespace Vector
-
-/-! ### mapFinIdx -/
-
-@[simp] theorem getElem_mapFinIdx (a : Vector α n) (f : (i : Nat) → α → (h : i < n) → β) (i : Nat)
-    (h : i < n) :
-    (a.mapFinIdx f)[i] = f i a[i] h := by
-  rcases a with ⟨a, rfl⟩
-  simp
-
-@[simp] theorem getElem?_mapFinIdx (a : Vector α n) (f : (i : Nat) → α → (h : i < n) → β) (i : Nat) :
-    (a.mapFinIdx f)[i]? =
-      a[i]?.pbind fun b h => f i b (getElem?_eq_some_iff.1 h).1 := by
-  simp only [getElem?_def, getElem_mapFinIdx]
-  split <;> simp_all
-
-/-! ### mapIdx -/
-
-@[simp] theorem getElem_mapIdx (f : Nat → α → β) (a : Vector α n) (i : Nat) (h : i < n) :
-    (a.mapIdx f)[i] = f i (a[i]'(by simp_all)) := by
-  rcases a with ⟨a, rfl⟩
-  simp
-
-@[simp] theorem getElem?_mapIdx (f : Nat → α → β) (a : Vector α n) (i : Nat) :
-    (a.mapIdx f)[i]? = a[i]?.map (f i) := by
-  rcases a with ⟨a, rfl⟩
-  simp
-
-end Vector
-
-namespace Array
-
-@[simp] theorem mapFinIdx_toVector (l : Array α) (f : (i : Nat) → α → (h : i < l.size) → β) :
-    l.toVector.mapFinIdx f = (l.mapFinIdx f).toVector.cast (by simp) := by
-  ext <;> simp
-
-@[simp] theorem mapIdx_toVector (f : Nat → α → β) (l : Array α) :
-    l.toVector.mapIdx f = (l.mapIdx f).toVector.cast (by simp) := by
-  ext <;> simp
-
-end Array
-
-namespace Vector
-
-/-! ### zipWithIndex -/
-
-@[simp] theorem toList_zipWithIndex (a : Vector α n) :
-    a.zipWithIndex.toList = a.toList.enum.map (fun (i, a) => (a, i)) := by
-  rcases a with ⟨a, rfl⟩
-  simp
-
-@[simp] theorem getElem_zipWithIndex (a : Vector α n) (i : Nat) (h : i < n) :
-    (a.zipWithIndex)[i] = (a[i]'(by simp_all), i) := by
-  rcases a with ⟨a, rfl⟩
-  simp
-
-@[simp] theorem zipWithIndex_toVector {l : Array α} :
-    l.toVector.zipWithIndex = l.zipWithIndex.toVector.cast (by simp) := by
-  ext <;> simp
-
-theorem mk_mem_zipWithIndex_iff_getElem? {x : α} {i : Nat} {l : Vector α n} :
-    (x, i) ∈ l.zipWithIndex ↔ l[i]? = x := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.mk_mem_zipWithIndex_iff_getElem?]
-
-theorem mem_enum_iff_getElem? {x : α × Nat} {l : Vector α n} :
-    x ∈ l.zipWithIndex ↔ l[x.2]? = some x.1 :=
-  mk_mem_zipWithIndex_iff_getElem?
-
-/-! ### mapFinIdx -/
-
-@[congr] theorem mapFinIdx_congr {xs ys : Vector α n} (w : xs = ys)
-    (f : (i : Nat) → α → (h : i < n) → β) :
-    mapFinIdx xs f = mapFinIdx ys f := by
-  subst w
-  rfl
-
-@[simp]
-theorem mapFinIdx_empty {f : (i : Nat) → α → (h : i < 0) → β} : mapFinIdx #v[] f = #v[] :=
-  rfl
-
-theorem mapFinIdx_eq_ofFn {as : Vector α n} {f : (i : Nat) → α → (h : i < n) → β} :
-    as.mapFinIdx f = Vector.ofFn fun i : Fin n => f i as[i] i.2 := by
-  rcases as with ⟨as, rfl⟩
-  simp [Array.mapFinIdx_eq_ofFn]
-
-theorem mapFinIdx_append {K : Vector α n} {L : Vector α m} {f : (i : Nat) → α → (h : i < n + m) → β} :
-    (K ++ L).mapFinIdx f =
-      K.mapFinIdx (fun i a h => f i a (by omega)) ++
-        L.mapFinIdx (fun i a h => f (i + n) a (by omega)) := by
-  rcases K with ⟨K, rfl⟩
-  rcases L with ⟨L, rfl⟩
-  simp [Array.mapFinIdx_append]
-
-@[simp]
-theorem mapFinIdx_push {l : Vector α n} {a : α} {f : (i : Nat) → α → (h : i < n + 1) → β} :
-    mapFinIdx (l.push a) f =
-      (mapFinIdx l (fun i a h => f i a (by omega))).push (f l.size a (by simp)) := by
-  simp [← append_singleton, mapFinIdx_append]
-
-theorem mapFinIdx_singleton {a : α} {f : (i : Nat) → α → (h : i < 1) → β} :
-    #v[a].mapFinIdx f = #v[f 0 a (by simp)] := by
-  simp
-
--- FIXME this lemma can't be stated until we've aligned `List/Array/Vector.attach`:
--- theorem mapFinIdx_eq_zipWithIndex_map {l : Vector α n} {f : (i : Nat) → α → (h : i < n) → β} :
---     l.mapFinIdx f = l.zipWithIndex.attach.map
---       fun ⟨⟨x, i⟩, m⟩ =>
---         f i x (by simp [mk_mem_zipWithIndex_iff_getElem?, getElem?_eq_some_iff] at m; exact m.1) := by
---   ext <;> simp
-
-theorem exists_of_mem_mapFinIdx {b : β} {l : Vector α n} {f : (i : Nat) → α → (h : i < n) → β}
-    (h : b ∈ l.mapFinIdx f) : ∃ (i : Nat) (h : i < n), f i l[i] h = b := by
-  rcases l with ⟨l, rfl⟩
-  exact List.exists_of_mem_mapFinIdx (by simpa using h)
-
-@[simp] theorem mem_mapFinIdx {b : β} {l : Vector α n} {f : (i : Nat) → α → (h : i < n) → β} :
-    b ∈ l.mapFinIdx f ↔ ∃ (i : Nat) (h : i < n), f i l[i] h = b := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-theorem mapFinIdx_eq_iff {l : Vector α n} {f : (i : Nat) → α → (h : i < n) → β} :
-    l.mapFinIdx f = l' ↔ ∀ (i : Nat) (h : i < n), l'[i] = f i l[i] h := by
-  rcases l with ⟨l, rfl⟩
-  rcases l' with ⟨l', h⟩
-  simp [mapFinIdx_mk, eq_mk, getElem_mk, Array.mapFinIdx_eq_iff, h]
-
-@[simp] theorem mapFinIdx_eq_singleton_iff {l : Vector α 1} {f : (i : Nat) → α → (h : i < 1) → β} {b : β} :
-    l.mapFinIdx f = #v[b] ↔ ∃ (a : α), l = #v[a] ∧ f 0 a (by omega) = b := by
-  rcases l with ⟨l, h⟩
-  simp only [mapFinIdx_mk, eq_mk, Array.mapFinIdx_eq_singleton_iff]
-  constructor
-  · rintro ⟨a, rfl, rfl⟩
-    exact ⟨a, by simp⟩
-  · rintro ⟨a, rfl, rfl⟩
-    exact ⟨a, by simp⟩
-
-theorem mapFinIdx_eq_append_iff {l : Vector α (n + m)} {f : (i : Nat) → α → (h : i < n + m) → β}
-    {l₁ : Vector β n} {l₂ : Vector β m} :
-    l.mapFinIdx f = l₁ ++ l₂ ↔
-      ∃ (l₁' : Vector α n) (l₂' : Vector α m), l = l₁' ++ l₂' ∧
-        l₁'.mapFinIdx (fun i a h => f i a (by omega)) = l₁ ∧
-        l₂'.mapFinIdx (fun i a h => f (i + n) a (by omega)) = l₂ := by
-  rcases l with ⟨l, h⟩
-  rcases l₁ with ⟨l₁, rfl⟩
-  rcases l₂ with ⟨l₂, rfl⟩
-  simp only [mapFinIdx_mk, mk_append_mk, eq_mk, Array.mapFinIdx_eq_append_iff, toArray_mapFinIdx,
-    mk_eq, toArray_append, exists_and_left, exists_prop]
-  constructor
-  · rintro ⟨l₁', l₂', rfl, h₁, h₂⟩
-    have h₁' := congrArg Array.size h₁
-    have h₂' := congrArg Array.size h₂
-    simp only [Array.size_mapFinIdx] at h₁' h₂'
-    exact ⟨⟨l₁', h₁'⟩, ⟨l₂', h₂'⟩, by simp_all⟩
-  · rintro ⟨⟨l₁, s₁⟩, ⟨l₂, s₂⟩, rfl, h₁, h₂⟩
-    refine ⟨l₁, l₂, by simp_all⟩
-
-theorem mapFinIdx_eq_push_iff {l : Vector α (n + 1)} {b : β} {f : (i : Nat) → α → (h : i < n + 1) → β} {l₂ : Vector β n} :
-    l.mapFinIdx f = l₂.push b ↔
-      ∃ (l₁ : Vector α n) (a : α), l = l₁.push a ∧
-        l₁.mapFinIdx (fun i a h => f i a (by omega)) = l₂ ∧ b = f n a (by omega) := by
-  rcases l with ⟨l, h⟩
-  rcases l₂ with ⟨l₂, rfl⟩
-  simp only [mapFinIdx_mk, push_mk, eq_mk, Array.mapFinIdx_eq_push_iff, mk_eq, toArray_push,
-    toArray_mapFinIdx]
-  constructor
-  · rintro ⟨l₁, a, rfl, h₁, rfl⟩
-    simp only [Array.size_push, Nat.add_right_cancel_iff] at h
-    exact ⟨⟨l₁, h⟩, a, by simp_all⟩
-  · rintro ⟨⟨l₁, h⟩, a, rfl, h₁, rfl⟩
-    exact ⟨l₁, a, by simp_all⟩
-
-theorem mapFinIdx_eq_mapFinIdx_iff {l : Vector α n} {f g : (i : Nat) → α → (h : i < n) → β} :
-    l.mapFinIdx f = l.mapFinIdx g ↔ ∀ (i : Nat) (h : i < n), f i l[i] h = g i l[i] h := by
-  rw [eq_comm, mapFinIdx_eq_iff]
-  simp
-
-@[simp] theorem mapFinIdx_mapFinIdx {l : Vector α n}
-    {f : (i : Nat) → α → (h : i < n) → β}
-    {g : (i : Nat) → β → (h : i < n) → γ} :
-    (l.mapFinIdx f).mapFinIdx g = l.mapFinIdx (fun i a h => g i (f i a h) h) := by
-  simp [mapFinIdx_eq_iff]
-
-theorem mapFinIdx_eq_mkVector_iff {l : Vector α n} {f : (i : Nat) → α → (h : i < n) → β} {b : β} :
-    l.mapFinIdx f = mkVector n b ↔ ∀ (i : Nat) (h : i < n), f i l[i] h = b := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.mapFinIdx_eq_mkArray_iff]
-
-@[simp] theorem mapFinIdx_reverse {l : Vector α n} {f : (i : Nat) → α → (h : i < n) → β} :
-    l.reverse.mapFinIdx f = (l.mapFinIdx (fun i a h => f (n - 1 - i) a (by omega))).reverse := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-/-! ### mapIdx -/
-
-@[simp]
-theorem mapIdx_empty {f : Nat → α → β} : mapIdx f #v[] = #v[] :=
-  rfl
-
-@[simp] theorem mapFinIdx_eq_mapIdx {l : Vector α n} {f : (i : Nat) → α → (h : i < n) → β} {g : Nat → α → β}
-    (h : ∀ (i : Nat) (h : i < n), f i l[i] h = g i l[i]) :
-    l.mapFinIdx f = l.mapIdx g := by
-  simp_all [mapFinIdx_eq_iff]
-
-theorem mapIdx_eq_mapFinIdx {l : Vector α n} {f : Nat → α → β} :
-    l.mapIdx f = l.mapFinIdx (fun i a _ => f i a) := by
-  simp [mapFinIdx_eq_mapIdx]
-
-theorem mapIdx_eq_zipWithIndex_map {l : Vector α n} {f : Nat → α → β} :
-    l.mapIdx f = l.zipWithIndex.map fun ⟨a, i⟩ => f i a := by
-  ext <;> simp
-
-theorem mapIdx_append {K : Vector α n} {L : Vector α m} :
-    (K ++ L).mapIdx f = K.mapIdx f ++ L.mapIdx fun i => f (i + K.size) := by
-  rcases K with ⟨K, rfl⟩
-  rcases L with ⟨L, rfl⟩
-  simp [Array.mapIdx_append]
-
-@[simp]
-theorem mapIdx_push {l : Vector α n} {a : α} :
-    mapIdx f (l.push a) = (mapIdx f l).push (f l.size a) := by
-  simp [← append_singleton, mapIdx_append]
-
-theorem mapIdx_singleton {a : α} : mapIdx f #v[a] = #v[f 0 a] := by
-  simp
-
-theorem exists_of_mem_mapIdx {b : β} {l : Vector α n}
-    (h : b ∈ l.mapIdx f) : ∃ (i : Nat) (h : i < n), f i l[i] = b := by
-  rw [mapIdx_eq_mapFinIdx] at h
-  simpa [Fin.exists_iff] using exists_of_mem_mapFinIdx h
-
-@[simp] theorem mem_mapIdx {b : β} {l : Vector α n} :
-    b ∈ l.mapIdx f ↔ ∃ (i : Nat) (h : i < n), f i l[i] = b := by
-  constructor
-  · intro h
-    exact exists_of_mem_mapIdx h
-  · rintro ⟨i, h, rfl⟩
-    rw [mem_iff_getElem]
-    exact ⟨i, by simpa using h, by simp⟩
-
-theorem mapIdx_eq_push_iff {l : Vector α (n + 1)} {b : β} :
-    mapIdx f l = l₂.push b ↔
-      ∃ (a : α) (l₁ : Vector α n), l = l₁.push a ∧ mapIdx f l₁ = l₂ ∧ f l₁.size a = b := by
-  rw [mapIdx_eq_mapFinIdx, mapFinIdx_eq_push_iff]
-  simp only [mapFinIdx_eq_mapIdx, exists_and_left, exists_prop]
-  constructor
-  · rintro ⟨l₁, a, rfl, rfl, rfl⟩
-    exact ⟨a, l₁, by simp⟩
-  · rintro ⟨a, l₁, rfl, rfl, rfl⟩
-    exact ⟨l₁, a, rfl, by simp⟩
-
-@[simp] theorem mapIdx_eq_singleton_iff {l : Vector α 1} {f : Nat → α → β} {b : β} :
-    mapIdx f l = #v[b] ↔ ∃ (a : α), l = #v[a] ∧ f 0 a = b := by
-  rcases l with ⟨l⟩
-  simp
-
-theorem mapIdx_eq_append_iff {l : Vector α (n + m)} {f : Nat → α → β} {l₁ : Vector β n} {l₂ : Vector β m} :
-    mapIdx f l = l₁ ++ l₂ ↔
-      ∃ (l₁' : Vector α n) (l₂' : Vector α m), l = l₁' ++ l₂' ∧
-        l₁'.mapIdx f = l₁ ∧
-        l₂'.mapIdx (fun i => f (i + l₁'.size)) = l₂ := by
-  rcases l with ⟨l, h⟩
-  rcases l₁ with ⟨l₁, rfl⟩
-  rcases l₂ with ⟨l₂, rfl⟩
-  rw [mapIdx_eq_mapFinIdx, mapFinIdx_eq_append_iff]
-  simp
-
-theorem mapIdx_eq_iff {l : Vector α n} :
-    mapIdx f l = l' ↔ ∀ (i : Nat) (h : i < n), f i l[i] = l'[i] := by
-  rcases l with ⟨l, rfl⟩
-  rcases l' with ⟨l', h⟩
-  simp only [mapIdx_mk, eq_mk, Array.mapIdx_eq_iff, getElem_mk]
-  constructor
-  · rintro h' i h
-    specialize h' i
-    simp_all
-  · intro h' i
-    specialize h' i
-    by_cases w : i < l.size
-    · specialize h' w
-      simp_all
-    · simp only [Nat.not_lt] at w
-      simp_all [Array.getElem?_eq_none_iff.mpr w]
-
-theorem mapIdx_eq_mapIdx_iff {l : Vector α n} :
-    mapIdx f l = mapIdx g l ↔ ∀ (i : Nat) (h : i < n), f i l[i] = g i l[i] := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.mapIdx_eq_mapIdx_iff]
-
-@[simp] theorem mapIdx_set {l : Vector α n} {i : Nat} {h : i < n} {a : α} :
-    (l.set i a).mapIdx f = (l.mapIdx f).set i (f i a) (by simpa) := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-@[simp] theorem mapIdx_setIfInBounds {l : Vector α n} {i : Nat} {a : α} :
-    (l.setIfInBounds i a).mapIdx f = (l.mapIdx f).setIfInBounds i (f i a) := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-@[simp] theorem back?_mapIdx {l : Vector α n} {f : Nat → α → β} :
-    (mapIdx f l).back? = (l.back?).map (f (l.size - 1)) := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-@[simp] theorem back_mapIdx [NeZero n] {l : Vector α n} {f : Nat → α → β} :
-    (mapIdx f l).back = f (l.size - 1) (l.back) := by
-  rcases l with ⟨l, rfl⟩
-  simp
-
-@[simp] theorem mapIdx_mapIdx {l : Vector α n} {f : Nat → α → β} {g : Nat → β → γ} :
-    (l.mapIdx f).mapIdx g = l.mapIdx (fun i => g i ∘ f i) := by
-  simp [mapIdx_eq_iff]
-
-theorem mapIdx_eq_mkVector_iff {l : Vector α n} {f : Nat → α → β} {b : β} :
-    mapIdx f l = mkVector n b ↔ ∀ (i : Nat) (h : i < n), f i l[i] = b := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.mapIdx_eq_mkArray_iff]
-
-@[simp] theorem mapIdx_reverse {l : Vector α n} {f : Nat → α → β} :
-    l.reverse.mapIdx f = (mapIdx (fun i => f (l.size - 1 - i)) l).reverse := by
-  rcases l with ⟨l, rfl⟩
-  simp [Array.mapIdx_reverse]
-
-end Vector

src/Init/Grind.lean

@@ -8,7 +8,3 @@ import Init.Grind.Norm
 import Init.Grind.Tactics
 import Init.Grind.Lemmas
 import Init.Grind.Cases
-import Init.Grind.Propagator
-import Init.Grind.Util
-import Init.Grind.Offset
-import Init.Grind.PP

src/Init/Grind/Cases.lean

@@ -5,7 +5,11 @@ Authors: Leonardo de Moura
 -/
 prelude
 import Init.Core
-import Init.Grind.Tactics
 
-attribute [grind cases eager] And Prod False Empty True Unit Exists
-attribute [grind cases] Or
+attribute [grind_cases] And Prod False Empty True Unit Exists
+
+namespace Lean.Grind.Eager
+
+attribute [scoped grind_cases] Or
+
+end Lean.Grind.Eager

src/Init/Grind/Lemmas.lean

@@ -5,105 +5,10 @@ Authors: Leonardo de Moura
 -/
 prelude
 import Init.Core
-import Init.SimpLemmas
-import Init.Classical
-import Init.ByCases
-import Init.Grind.Util
 
 namespace Lean.Grind
 
-theorem rfl_true : true = true :=
-  rfl
-
 theorem intro_with_eq (p p' q : Prop) (he : p = p') (h : p' → q) : p → q :=
   fun hp => h (he.mp hp)
 
-/-! And -/
-
-theorem and_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a ∧ b) = b := by simp [h]
-theorem and_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a ∧ b) = a := by simp [h]
-theorem and_eq_of_eq_false_left {a b : Prop} (h : a = False) : (a ∧ b) = False := by simp [h]
-theorem and_eq_of_eq_false_right {a b : Prop} (h : b = False) : (a ∧ b) = False := by simp [h]
-
-theorem eq_true_of_and_eq_true_left {a b : Prop} (h : (a ∧ b) = True) : a = True := by simp_all
-theorem eq_true_of_and_eq_true_right {a b : Prop} (h : (a ∧ b) = True) : b = True := by simp_all
-
-theorem or_of_and_eq_false {a b : Prop} (h : (a ∧ b) = False) : (¬a ∨ ¬b) := by
-  by_cases a <;> by_cases b <;> simp_all
-
-/-! Or -/
-
-theorem or_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a ∨ b) = True := by simp [h]
-theorem or_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a ∨ b) = True := by simp [h]
-theorem or_eq_of_eq_false_left {a b : Prop} (h : a = False) : (a ∨ b) = b := by simp [h]
-theorem or_eq_of_eq_false_right {a b : Prop} (h : b = False) : (a ∨ b) = a := by simp [h]
-
-theorem eq_false_of_or_eq_false_left {a b : Prop} (h : (a ∨ b) = False) : a = False := by simp_all
-theorem eq_false_of_or_eq_false_right {a b : Prop} (h : (a ∨ b) = False) : b = False := by simp_all
-
-/-! Implies -/
-
-theorem imp_eq_of_eq_false_left {a b : Prop} (h : a = False) : (a → b) = True := by simp [h]
-theorem imp_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a → b) = True := by simp [h]
-theorem imp_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a → b) = b := by simp [h]
-
-theorem eq_true_of_imp_eq_false {a b : Prop} (h : (a → b) = False) : a = True := by simp_all
-theorem eq_false_of_imp_eq_false {a b : Prop} (h : (a → b) = False) : b = False := by simp_all
-
-/-! Not -/
-
-theorem not_eq_of_eq_true {a : Prop} (h : a = True) : (Not a) = False := by simp [h]
-theorem not_eq_of_eq_false {a : Prop} (h : a = False) : (Not a) = True := by simp [h]
-
-theorem eq_false_of_not_eq_true {a : Prop} (h : (Not a) = True) : a = False := by simp_all
-theorem eq_true_of_not_eq_false {a : Prop} (h : (Not a) = False) : a = True := by simp_all
-
-theorem false_of_not_eq_self {a : Prop} (h : (Not a) = a) : False := by
-  by_cases a <;> simp_all
-
-/-! Eq -/
-
-theorem eq_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a = b) = b := by simp [h]
-theorem eq_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a = b) = a := by simp [h]
-
-theorem eq_congr  {α : Sort u} {a₁ b₁ a₂ b₂ : α} (h₁ : a₁ = a₂) (h₂ : b₁ = b₂) : (a₁ = b₁) = (a₂ = b₂) := by simp [*]
-theorem eq_congr' {α : Sort u} {a₁ b₁ a₂ b₂ : α} (h₁ : a₁ = b₂) (h₂ : b₁ = a₂) : (a₁ = b₁) = (a₂ = b₂) := by rw [h₁, h₂, Eq.comm (a := a₂)]
-
-/- The following two helper theorems are used to case-split `a = b` representing `iff`. -/
-theorem of_eq_eq_true {a b : Prop} (h : (a = b) = True) : (¬a ∨ b) ∧ (¬b ∨ a) := by
-  by_cases a <;> by_cases b <;> simp_all
-theorem of_eq_eq_false {a b : Prop} (h : (a = b) = False) : (¬a ∨ ¬b) ∧ (b ∨ a) := by
-  by_cases a <;> by_cases b <;> simp_all
-
-/-! Forall -/
-
-theorem forall_propagator (p : Prop) (q : p → Prop) (q' : Prop) (h₁ : p = True) (h₂ : q (of_eq_true h₁) = q') : (∀ hp : p, q hp) = q' := by
-  apply propext; apply Iff.intro
-  · intro h'; exact Eq.mp h₂ (h' (of_eq_true h₁))
-  · intro h'; intros; exact Eq.mpr h₂ h'
-
-theorem of_forall_eq_false (α : Sort u) (p : α → Prop) (h : (∀ x : α, p x) = False) : ∃ x : α, ¬ p x := by simp_all
-
-/-! dite -/
-
-theorem dite_cond_eq_true' {α : Sort u} {c : Prop} {_ : Decidable c} {a : c → α} {b : ¬ c → α} {r : α} (h₁ : c = True) (h₂ : a (of_eq_true h₁) = r) : (dite c a b) = r := by simp [h₁, h₂]
-theorem dite_cond_eq_false' {α : Sort u} {c : Prop} {_ : Decidable c} {a : c → α} {b : ¬ c → α} {r : α} (h₁ : c = False) (h₂ : b (of_eq_false h₁) = r) : (dite c a b) = r := by simp [h₁, h₂]
-
-/-! Casts -/
-
-theorem eqRec_heq.{u_1, u_2} {α : Sort u_2} {a : α}
-        {motive : (x : α) → a = x → Sort u_1} (v : motive a (Eq.refl a)) {b : α} (h : a = b)
-        : HEq (@Eq.rec α a motive v b h) v := by
- subst h; rfl
-
-theorem eqRecOn_heq.{u_1, u_2} {α : Sort u_2} {a : α}
-        {motive : (x : α) → a = x → Sort u_1} {b : α} (h : a = b) (v : motive a (Eq.refl a))
-        : HEq (@Eq.recOn α a motive b h v) v := by
- subst h; rfl
-
-theorem eqNDRec_heq.{u_1, u_2} {α : Sort u_2} {a : α}
-        {motive : α → Sort u_1} (v : motive a) {b : α} (h : a = b)
-        : HEq (@Eq.ndrec α a motive v b h) v := by
- subst h; rfl
-
 end Lean.Grind

src/Init/Grind/Norm.lean

@@ -5,112 +5,106 @@ Authors: Leonardo de Moura
 -/
 prelude
 import Init.SimpLemmas
-import Init.PropLemmas
 import Init.Classical
 import Init.ByCases
 
 namespace Lean.Grind
 /-!
 Normalization theorems for the `grind` tactic.
+
+We are also going to use simproc's in the future.
 -/
 
-theorem iff_eq (p q : Prop) : (p ↔ q) = (p = q) := by
+-- Not
+attribute [grind_norm] Classical.not_not
+
+-- Ne
+attribute [grind_norm] ne_eq
+
+-- Iff
+@[grind_norm] theorem iff_eq (p q : Prop) : (p ↔ q) = (p = q) := by
   by_cases p <;> by_cases q <;> simp [*]
 
-theorem eq_true_eq (p : Prop) : (p = True) = p := by simp
-theorem eq_false_eq (p : Prop) : (p = False) = ¬p := by simp
-theorem not_eq_prop (p q : Prop) : (¬(p = q)) = (p = ¬q) := by
+-- Eq
+attribute [grind_norm] eq_self heq_eq_eq
+
+-- Prop equality
+@[grind_norm] theorem eq_true_eq (p : Prop) : (p = True) = p := by simp
+@[grind_norm] theorem eq_false_eq (p : Prop) : (p = False) = ¬p := by simp
+@[grind_norm] theorem not_eq_prop (p q : Prop) : (¬(p = q)) = (p = ¬q) := by
   by_cases p <;> by_cases q <;> simp [*]
 
--- Remark: we disabled the following normalization rule because we want this information when implementing splitting heuristics
+-- True
+attribute [grind_norm] not_true
+
+-- False
+attribute [grind_norm] not_false_eq_true
+
 -- Implication as a clause
-theorem imp_eq (p q : Prop) : (p → q) = (¬ p ∨ q) := by
+@[grind_norm] theorem imp_eq (p q : Prop) : (p → q) = (¬ p ∨ q) := by
   by_cases p <;> by_cases q <;> simp [*]
 
-theorem true_imp_eq (p : Prop) : (True → p) = p := by simp
-theorem false_imp_eq (p : Prop) : (False → p) = True := by simp
-theorem imp_true_eq (p : Prop) : (p → True) = True := by simp
-theorem imp_false_eq (p : Prop) : (p → False) = ¬p := by simp
-theorem imp_self_eq (p : Prop) : (p → p) = True := by simp
-
-theorem not_and (p q : Prop) : (¬(p ∧ q)) = (¬p ∨ ¬q) := by
+-- And
+@[grind_norm↓] theorem not_and (p q : Prop) : (¬(p ∧ q)) = (¬p ∨ ¬q) := by
   by_cases p <;> by_cases q <;> simp [*]
+attribute [grind_norm] and_true true_and and_false false_and and_assoc
 
-theorem not_ite {_ : Decidable p} (q r : Prop) : (¬ite p q r) = ite p (¬q) (¬r) := by
+-- Or
+attribute [grind_norm↓] not_or
+attribute [grind_norm] or_true true_or or_false false_or or_assoc
+
+-- ite
+attribute [grind_norm] ite_true ite_false
+@[grind_norm↓] theorem not_ite {_ : Decidable p} (q r : Prop) : (¬ite p q r) = ite p (¬q) (¬r) := by
   by_cases p <;> simp [*]
 
-theorem ite_true_false {_ : Decidable p} : (ite p True False) = p := by
-  by_cases p <;> simp
+-- Forall
+@[grind_norm↓] theorem not_forall (p : α → Prop) : (¬∀ x, p x) = ∃ x, ¬p x := by simp
+attribute [grind_norm] forall_and
 
-theorem ite_false_true {_ : Decidable p} : (ite p False True) = ¬p := by
-  by_cases p <;> simp
+-- Exists
+@[grind_norm↓] theorem not_exists (p : α → Prop) : (¬∃ x, p x) = ∀ x, ¬p x := by simp
+attribute [grind_norm] exists_const exists_or
 
-theorem not_forall (p : α → Prop) : (¬∀ x, p x) = ∃ x, ¬p x := by simp
-
-theorem not_exists (p : α → Prop) : (¬∃ x, p x) = ∀ x, ¬p x := by simp
-
-theorem cond_eq_ite (c : Bool) (a b : α) : cond c a b = ite c a b := by
+-- Bool cond
+@[grind_norm] theorem cond_eq_ite (c : Bool) (a b : α) : cond c a b = ite c a b := by
   cases c <;> simp [*]
 
-theorem Nat.lt_eq (a b : Nat) : (a < b) = (a + 1 ≤ b) := by
+-- Bool or
+attribute [grind_norm]
+  Bool.or_false Bool.or_true Bool.false_or Bool.true_or Bool.or_eq_true Bool.or_assoc
+
+-- Bool and
+attribute [grind_norm]
+  Bool.and_false Bool.and_true Bool.false_and Bool.true_and Bool.and_eq_true Bool.and_assoc
+
+-- Bool not
+attribute [grind_norm]
+  Bool.not_not
+
+-- beq
+attribute [grind_norm] beq_iff_eq
+
+-- bne
+attribute [grind_norm] bne_iff_ne
+
+-- Bool not eq true/false
+attribute [grind_norm] Bool.not_eq_true Bool.not_eq_false
+
+-- decide
+attribute [grind_norm] decide_eq_true_eq decide_not not_decide_eq_true
+
+-- Nat LE
+attribute [grind_norm] Nat.le_zero_eq
+
+-- Nat/Int LT
+@[grind_norm] theorem Nat.lt_eq (a b : Nat) : (a < b) = (a + 1 ≤ b) := by
   simp [Nat.lt, LT.lt]
 
-theorem Int.lt_eq (a b : Int) : (a < b) = (a + 1 ≤ b) := by
+@[grind_norm] theorem Int.lt_eq (a b : Int) : (a < b) = (a + 1 ≤ b) := by
   simp [Int.lt, LT.lt]
 
-theorem ge_eq [LE α] (a b : α) : (a ≥ b) = (b ≤ a) := rfl
-theorem gt_eq [LT α] (a b : α) : (a > b) = (b < a) := rfl
-
-init_grind_norm
-  /- Pre theorems -/
-  not_and not_or not_ite not_forall not_exists
-  |
-  /- Post theorems -/
-  Classical.not_not
-  ne_eq iff_eq eq_self heq_eq_eq
-  -- Prop equality
-  eq_true_eq eq_false_eq not_eq_prop
-  -- True
-  not_true
-  -- False
-  not_false_eq_true
-  -- Implication
-  true_imp_eq false_imp_eq imp_true_eq imp_false_eq imp_self_eq
-  -- And
-  and_true true_and and_false false_and and_assoc
-  -- Or
-  or_true true_or or_false false_or or_assoc
-  -- ite
-  ite_true ite_false ite_true_false ite_false_true
-  -- Forall
-  forall_and
-  -- Exists
-  exists_const exists_or exists_prop exists_and_left exists_and_right
-  -- Bool cond
-  cond_eq_ite
-  -- Bool or
-  Bool.or_false Bool.or_true Bool.false_or Bool.true_or Bool.or_eq_true Bool.or_assoc
-  -- Bool and
-  Bool.and_false Bool.and_true Bool.false_and Bool.true_and Bool.and_eq_true Bool.and_assoc
-  -- Bool not
-  Bool.not_not
-  -- beq
-  beq_iff_eq
-  -- bne
-  bne_iff_ne
-  -- Bool not eq true/false
-  Bool.not_eq_true Bool.not_eq_false
-  -- decide
-  decide_eq_true_eq decide_not not_decide_eq_true
-  -- Nat LE
-  Nat.le_zero_eq
-  -- Nat/Int LT
-  Nat.lt_eq
-  -- Nat.succ
-  Nat.succ_eq_add_one
-  -- Int
-  Int.lt_eq
-  -- GT GE
-  ge_eq gt_eq
+-- GT GE
+attribute [grind_norm] GT.gt GE.ge
 
 end Lean.Grind

src/Init/Grind/Offset.lean

@@ -1,92 +0,0 @@
-/-
-Copyright (c) 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Leonardo de Moura
--/
-prelude
-import Init.Core
-import Init.Omega
-
-namespace Lean.Grind
-abbrev isLt (x y : Nat) : Bool := x < y
-abbrev isLE (x y : Nat) : Bool := x ≤ y
-
-/-! Theorems for transitivity. -/
-theorem Nat.le_ro (u w v k : Nat) : u ≤ w → w ≤ v + k → u ≤ v + k := by
-  omega
-theorem Nat.le_lo (u w v k : Nat) : u ≤ w → w + k ≤ v → u + k ≤ v := by
-  omega
-theorem Nat.lo_le (u w v k : Nat) : u + k ≤ w → w ≤ v → u + k ≤ v := by
-  omega
-theorem Nat.lo_lo (u w v k₁ k₂ : Nat) : u + k₁ ≤ w → w + k₂ ≤ v → u + (k₁ + k₂) ≤ v := by
-  omega
-theorem Nat.lo_ro_1 (u w v k₁ k₂ : Nat) : isLt k₂ k₁ = true → u + k₁ ≤ w → w ≤ v + k₂ → u + (k₁ - k₂) ≤ v := by
-  simp [isLt]; omega
-theorem Nat.lo_ro_2 (u w v k₁ k₂ : Nat) : u + k₁ ≤ w → w ≤ v + k₂ → u ≤ v + (k₂ - k₁) := by
-  omega
-theorem Nat.ro_le (u w v k : Nat) : u ≤ w + k → w ≤ v → u ≤ v + k := by
-  omega
-theorem Nat.ro_lo_1 (u w v k₁ k₂ : Nat) : u ≤ w + k₁ → w + k₂ ≤ v → u ≤ v + (k₁ - k₂) := by
-  omega
-theorem Nat.ro_lo_2 (u w v k₁ k₂ : Nat) : isLt k₁ k₂ = true → u ≤ w + k₁ → w + k₂ ≤ v → u + (k₂ - k₁) ≤ v := by
-  simp [isLt]; omega
-theorem Nat.ro_ro (u w v k₁ k₂ : Nat) : u ≤ w + k₁ → w ≤ v + k₂ → u ≤ v + (k₁ + k₂) := by
-  omega
-
-/-! Theorems for negating constraints. -/
-theorem Nat.of_le_eq_false (u v : Nat) : ((u ≤ v) = False) → v + 1 ≤ u := by
-  simp; omega
-theorem Nat.of_lo_eq_false_1 (u v : Nat) : ((u + 1 ≤ v) = False) → v ≤ u := by
-  simp; omega
-theorem Nat.of_lo_eq_false (u v k : Nat) : ((u + k ≤ v) = False) → v ≤ u + (k-1) := by
-  simp; omega
-theorem Nat.of_ro_eq_false (u v k : Nat) : ((u ≤ v + k) = False) → v + (k+1) ≤ u := by
-  simp; omega
-
-/-! Theorems for closing a goal. -/
-theorem Nat.unsat_le_lo (u v k : Nat) : isLt 0 k = true → u ≤ v → v + k ≤ u → False := by
-  simp [isLt]; omega
-theorem Nat.unsat_lo_lo (u v k₁ k₂ : Nat) : isLt 0 (k₁+k₂) = true → u + k₁ ≤ v → v + k₂ ≤ u → False := by
-  simp [isLt]; omega
-theorem Nat.unsat_lo_ro (u v k₁ k₂ : Nat) : isLt k₂ k₁ = true → u + k₁ ≤ v → v ≤ u + k₂ → False := by
-  simp [isLt]; omega
-
-/-! Theorems for propagating constraints to `True` -/
-theorem Nat.lo_eq_true_of_lo (u v k₁ k₂ : Nat) : isLE k₂ k₁ = true → u + k₁ ≤ v → (u + k₂ ≤ v) = True :=
-  by simp [isLt]; omega
-theorem Nat.le_eq_true_of_lo (u v k : Nat) : u + k ≤ v → (u ≤ v) = True :=
-  by simp; omega
-theorem Nat.le_eq_true_of_le (u v : Nat) : u ≤ v → (u ≤ v) = True :=
-  by simp
-theorem Nat.ro_eq_true_of_lo (u v k₁ k₂ : Nat) : u + k₁ ≤ v → (u ≤ v + k₂) = True :=
-  by simp; omega
-theorem Nat.ro_eq_true_of_le (u v k : Nat) : u ≤ v → (u ≤ v + k) = True :=
-  by simp; omega
-theorem Nat.ro_eq_true_of_ro (u v k₁ k₂ : Nat) : isLE k₁ k₂ = true → u ≤ v + k₁ → (u ≤ v + k₂) = True :=
-  by simp [isLE]; omega
-
-/-!
-Theorems for propagating constraints to `False`.
-They are variants of the theorems for closing a goal.
--/
-theorem Nat.lo_eq_false_of_le (u v k : Nat) : isLt 0 k = true → u ≤ v → (v + k ≤ u) = False := by
- simp [isLt]; omega
-theorem Nat.le_eq_false_of_lo (u v k : Nat) : isLt 0 k = true → u + k ≤ v → (v ≤ u) = False := by
- simp [isLt]; omega
-theorem Nat.lo_eq_false_of_lo (u v k₁ k₂ : Nat) : isLt 0 (k₁+k₂) = true → u + k₁ ≤ v → (v + k₂ ≤ u) = False := by
-  simp [isLt]; omega
-theorem Nat.ro_eq_false_of_lo (u v k₁ k₂ : Nat) : isLt k₂ k₁ = true → u + k₁ ≤ v → (v ≤ u + k₂) = False := by
-  simp [isLt]; omega
-theorem Nat.lo_eq_false_of_ro (u v k₁ k₂ : Nat) : isLt k₁ k₂ = true → u ≤ v + k₁ → (v + k₂ ≤ u) = False := by
-  simp [isLt]; omega
-
-/-!
-Helper theorems for equality propagation
--/
-
-theorem Nat.le_of_eq_1 (u v : Nat) : u = v → u ≤ v := by omega
-theorem Nat.le_of_eq_2 (u v : Nat) : u = v → v ≤ u := by omega
-theorem Nat.eq_of_le_of_le (u v : Nat) : u ≤ v → v ≤ u → u = v := by omega
-theorem Nat.le_offset (a k : Nat) : k ≤ a + k := by omega
-
-end Lean.Grind

src/Init/Grind/PP.lean

@@ -1,30 +0,0 @@
-/-
-Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Leonardo de Moura
--/
-prelude
-import Init.NotationExtra
-
-namespace Lean.Grind
-/-!
-This is a hackish module for hovering node information in the `grind` tactic state.
--/
-
-inductive NodeDef where
-  | unit
-
-set_option linter.unusedVariables false in
-def node_def (_ : Nat) {α : Sort u} {a : α} : NodeDef := .unit
-
-@[app_unexpander node_def]
-def nodeDefUnexpander : PrettyPrinter.Unexpander := fun stx => do
-  match stx with
-  | `($_ $id:num) => return mkIdent <| Name.mkSimple $ "#" ++ toString id.getNat
-  | _ => throw ()
-
-@[app_unexpander NodeDef]
-def NodeDefUnexpander : PrettyPrinter.Unexpander := fun _ => do
-  return mkIdent <| Name.mkSimple "NodeDef"
-
-end Lean.Grind

src/Init/Grind/Propagator.lean

@@ -1,27 +0,0 @@
-/-
-Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Leonardo de Moura
--/
-prelude
-import Init.NotationExtra
-
-namespace Lean.Parser
-
-/-- A user-defined propagator for the `grind` tactic. -/
--- TODO: not implemented yet
-syntax (docComment)? "grind_propagator " (Tactic.simpPre <|> Tactic.simpPost) ident " (" ident ")" " := " term : command
-
-/-- A builtin propagator for the `grind` tactic. -/
-syntax (docComment)? "builtin_grind_propagator " ident (Tactic.simpPre <|> Tactic.simpPost) ident " := " term : command
-
-/-- Auxiliary attribute for builtin `grind` propagators. -/
-syntax (name := grindPropagatorBuiltinAttr) "builtin_grind_propagator" (Tactic.simpPre <|> Tactic.simpPost) ident : attr
-
-macro_rules
-  | `($[$doc?:docComment]? builtin_grind_propagator $propagatorName:ident $direction $op:ident := $body) => do
-    let propagatorType := `Lean.Meta.Grind.Propagator
-    `($[$doc?:docComment]? def $propagatorName:ident : $(mkIdent propagatorType) := $body
-      attribute [builtin_grind_propagator $direction $op] $propagatorName)
-
-end Lean.Parser

src/Init/Grind/Tactics.lean

@@ -6,73 +6,20 @@ Authors: Leonardo de Moura
 prelude
 import Init.Tactics
 
-namespace Lean.Parser.Attr
-
-syntax grindEq     := "="
-syntax grindEqBoth := atomic("_" "=" "_")
-syntax grindEqRhs  := atomic("=" "_")
-syntax grindEqBwd  := atomic("←" "=")
-syntax grindBwd    := "←"
-syntax grindFwd    := "→"
-syntax grindCases  := &"cases"
-syntax grindCasesEager := atomic(&"cases" &"eager")
-
-syntax grindMod := grindEqBoth <|> grindEqRhs <|> grindEq <|> grindEqBwd <|> grindBwd <|> grindFwd <|> grindCasesEager <|> grindCases
-
-syntax (name := grind) "grind" (grindMod)? : attr
-
-end Lean.Parser.Attr
-
 namespace Lean.Grind
 /--
 The configuration for `grind`.
-Passed to `grind` using, for example, the `grind (config := { matchEqs := true })` syntax.
+Passed to `grind` using, for example, the `grind (config := { eager := true })` syntax.
 -/
 structure Config where
-  /-- Maximum number of case-splits in a proof search branch. It does not include splits performed during normalization. -/
-  splits : Nat := 8
-  /-- Maximum number of E-matching (aka heuristic theorem instantiation) rounds before each case split. -/
-  ematch : Nat := 5
   /--
-  Maximum term generation.
-  The input goal terms have generation 0. When we instantiate a theorem using a term from generation `n`,
-  the new terms have generation `n+1`. Thus, this parameter limits the length of an instantiation chain. -/
-  gen : Nat := 5
-  /-- Maximum number of theorem instances generated using E-matching in a proof search tree branch. -/
-  instances : Nat := 1000
-  /-- If `matchEqs` is `true`, `grind` uses `match`-equations as E-matching theorems. -/
-  matchEqs : Bool := true
-  /-- If `splitMatch` is `true`, `grind` performs case-splitting on `match`-expressions during the search. -/
-  splitMatch : Bool := true
-  /-- If `splitIte` is `true`, `grind` performs case-splitting on `if-then-else` expressions during the search. -/
-  splitIte : Bool := true
-  /--
-  If `splitIndPred` is `true`, `grind` performs case-splitting on inductive predicates.
-  Otherwise, it performs case-splitting only on types marked with `[grind cases]` attribute. -/
-  splitIndPred : Bool := false
-  /-- By default, `grind` halts as soon as it encounters a sub-goal where no further progress can be made. -/
-  failures : Nat := 1
-  /-- Maximum number of heartbeats (in thousands) the canonicalizer can spend per definitional equality test. -/
-  canonHeartbeats : Nat := 1000
-  /-- If `ext` is `true`, `grind` uses extensionality theorems available in the environment. -/
-  ext : Bool := true
+  When `eager` is true (default: `false`), `grind` eagerly splits `if-then-else` and `match`
+  expressions.
+  -/
+  eager : Bool := false
   deriving Inhabited, BEq
 
-end Lean.Grind
-
-namespace Lean.Parser.Tactic
-
 /-!
 `grind` tactic and related tactics.
 -/
-
-syntax grindErase := "-" ident
-syntax grindLemma := (Attr.grindMod)? ident
-syntax grindParam := grindErase <|> grindLemma
-
-syntax (name := grind)
-  "grind" optConfig (&" only")?
-  (" [" withoutPosition(grindParam,*) "]")?
-  ("on_failure " term)? : tactic
-
-end Lean.Parser.Tactic
+end Lean.Grind

src/Init/Grind/Util.lean

@@ -1,37 +0,0 @@
-/-
-Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Leonardo de Moura
--/
-prelude
-import Init.Core
-
-namespace Lean.Grind
-
-/-- A helper gadget for annotating nested proofs in goals. -/
-def nestedProof (p : Prop) {h : p} : p := h
-
-/--
-Gadget for marking terms that should not be normalized by `grind`s simplifier.
-`grind` uses a simproc to implement this feature.
-We use it when adding instances of `match`-equations to prevent them from being simplified to true.
--/
-def doNotSimp {α : Sort u} (a : α) : α := a
-
-/-- Gadget for representing offsets `t+k` in patterns. -/
-def offset (a b : Nat) : Nat := a + b
-
-/-- Gadget for representing `a = b` in patterns for backward propagation. -/
-def eqBwdPattern (a b : α) : Prop := a = b
-
-/--
-Gadget for annotating the equalities in `match`-equations conclusions.
-`_origin` is the term used to instantiate the `match`-equation using E-matching.
-When `EqMatch a b origin` is `True`, we mark `origin` as a resolved case-split.
--/
-def EqMatch (a b : α) {_origin : α} : Prop := a = b
-
-theorem nestedProof_congr (p q : Prop) (h : p = q) (hp : p) (hq : q) : HEq (@nestedProof p hp) (@nestedProof q hq) := by
-  subst h; apply HEq.refl
-
-end Lean.Grind

src/Init/Internal.lean

@@ -1,13 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Joachim Breitner
--/
-prelude
-import Init.Internal.Order
-
-/-!
-This directory is used for components of the standard library that are either considered
-implementation details or not yet ready for public consumption, and that should be available
-without explicit import (in contrast to `Std.Internal`)
--/

src/Init/Internal/Order.lean

@@ -1,8 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Joachim Breitner
--/
-prelude
-import Init.Internal.Order.Basic
-import Init.Internal.Order.Tactic

src/Init/Internal/Order/Basic.lean

@@ -1,693 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Joachim Breitner
--/
-prelude
-
-import Init.ByCases
-import Init.RCases
-
-/-!
-This module contains some basic definitions and results from domain theory, intended to be used as
-the underlying construction of the `partial_fixpoint` feature. It is not meant to be used as a
-general purpose library for domain theory, but can be of interest to users who want to extend
-the `partial_fixpoint` machinery (e.g. mark more functions as monotone or register more monads).
-
-This follows the corresponding
-[Isabelle development](https://isabelle.in.tum.de/library/HOL/HOL/Partial_Function.html), as also
-described in [Alexander Krauss: Recursive Definitions of Monadic Functions](https://www21.in.tum.de/~krauss/papers/mrec.pdf).
--/
-
-universe u v w
-
-namespace Lean.Order
-
-/--
-A partial order is a reflexive, transitive and antisymmetric relation.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-class PartialOrder (α : Sort u) where
-  /--
-  A “less-or-equal-to” or “approximates” relation.
-
-  This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
-  -/
-  rel : α → α → Prop
-  rel_refl : ∀ {x}, rel x x
-  rel_trans : ∀ {x y z}, rel x y → rel y z → rel x z
-  rel_antisymm : ∀ {x y}, rel x y → rel y x → x = y
-
-@[inherit_doc] scoped infix:50 " ⊑ " => PartialOrder.rel
-
-section PartialOrder
-
-variable {α  : Sort u} [PartialOrder α]
-
-theorem PartialOrder.rel_of_eq {x y : α} (h : x = y) : x ⊑ y := by cases h; apply rel_refl
-
-/--
-A chain is a totally ordered set (representing a set as a predicate).
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-def chain (c : α → Prop) : Prop := ∀ x y , c x → c y → x ⊑ y ∨ y ⊑ x
-
-end PartialOrder
-
-section CCPO
-
-/--
-A chain-complete partial order (CCPO) is a partial order where every chain a least upper bound.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-class CCPO (α : Sort u) extends PartialOrder α where
-  /--
-  The least upper bound of a chain.
-
-  This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
-  -/
-  csup : (α → Prop) → α
-  csup_spec {c : α → Prop} (hc : chain c) : csup c ⊑ x ↔ (∀ y, c y → y ⊑ x)
-
-open PartialOrder CCPO
-
-variable {α  : Sort u} [CCPO α]
-
-theorem csup_le {c : α → Prop} (hchain : chain c) : (∀ y, c y → y ⊑ x) → csup c ⊑ x :=
-  (csup_spec hchain).mpr
-
-theorem le_csup {c : α → Prop} (hchain : chain c) {y : α} (hy : c y) : y ⊑ csup c :=
-  (csup_spec hchain).mp rel_refl y hy
-
-/--
-The bottom element is the least upper bound of the empty chain.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-def bot : α := csup (fun _ => False)
-
-scoped notation "⊥" => bot
-
-theorem bot_le (x : α) : ⊥ ⊑ x := by
-  apply csup_le
-  · intro x y hx hy; contradiction
-  · intro x hx; contradiction
-
-end CCPO
-
-section monotone
-
-variable {α : Sort u} [PartialOrder α]
-variable {β : Sort v} [PartialOrder β]
-
-/--
-A function is monotone if if it maps related elements to releated elements.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-def monotone (f : α → β) : Prop := ∀ x y, x ⊑ y → f x ⊑ f y
-
-theorem monotone_const (c : β) : monotone (fun (_ : α) => c) :=
-  fun _ _ _ => PartialOrder.rel_refl
-
-theorem monotone_id : monotone (fun (x : α) => x) :=
-  fun _ _ hxy => hxy
-
-theorem monotone_compose
-    {γ : Sort w} [PartialOrder γ]
-    {f : α → β} {g : β → γ}
-    (hf : monotone f) (hg : monotone g) :
-   monotone (fun x => g (f x)) := fun _ _ hxy => hg _ _ (hf _ _ hxy)
-
-end monotone
-
-section admissibility
-
-variable {α : Sort u} [CCPO α]
-
-open PartialOrder CCPO
-
-/--
-A predicate is admissable if it can be transferred from the elements of a chain to the chains least
-upper bound. Such predicates can be used in fixpoint induction.
-
-This definition implies `P ⊥`. Sometimes (e.g. in Isabelle) the empty chain is excluded
-from this definition, and `P ⊥` is a separate condition of the induction predicate.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-def admissible (P : α → Prop) :=
-  ∀ (c : α → Prop), chain c → (∀ x, c x → P x) → P (csup c)
-
-theorem admissible_const_true : admissible (fun (_ : α) => True) :=
-  fun _ _ _ => trivial
-
-theorem admissible_and (P Q : α → Prop)
-  (hadm₁ : admissible P) (hadm₂ : admissible Q) : admissible (fun x => P x ∧ Q x) :=
-    fun c hchain h =>
-    ⟨ hadm₁ c hchain fun x hx => (h x hx).1,
-      hadm₂ c hchain fun x hx => (h x hx).2⟩
-
-theorem chain_conj (c P : α → Prop) (hchain : chain c) : chain (fun x => c x ∧ P x) := by
-  intro x y ⟨hcx, _⟩ ⟨hcy, _⟩
-  exact hchain x y hcx hcy
-
-theorem csup_conj (c P : α → Prop) (hchain : chain c) (h : ∀ x, c x → ∃ y, c y ∧ x ⊑ y ∧ P y) :
-    csup c = csup (fun x => c x ∧ P x) := by
-  apply rel_antisymm
-  · apply csup_le hchain
-    intro x hcx
-    obtain ⟨y, hcy, hxy, hPy⟩ := h x hcx
-    apply rel_trans hxy; clear x hcx hxy
-    apply le_csup (chain_conj _ _ hchain) ⟨hcy, hPy⟩
-  · apply csup_le (chain_conj _ _ hchain)
-    intro x ⟨hcx, hPx⟩
-    apply le_csup hchain hcx
-
-theorem admissible_or (P Q : α → Prop)
-  (hadm₁ : admissible P) (hadm₂ : admissible Q) : admissible (fun x => P x ∨ Q x) := by
-  intro c hchain h
-  have : (∀ x, c x → ∃ y, c y ∧ x ⊑ y ∧ P y) ∨ (∀ x, c x → ∃ y, c y ∧ x ⊑ y ∧ Q y) := by
-    open Classical in
-    apply Decidable.or_iff_not_imp_left.mpr
-    intro h'
-    simp only [not_forall, not_imp, not_exists, not_and] at h'
-    obtain ⟨x, hcx, hx⟩ := h'
-    intro y hcy
-    cases hchain x y hcx hcy  with
-    | inl hxy =>
-      refine ⟨y, hcy, rel_refl, ?_⟩
-      cases h y hcy with
-      | inl hPy => exfalso; apply hx y hcy hxy hPy
-      | inr hQy => assumption
-    | inr hyx =>
-      refine ⟨x, hcx, hyx , ?_⟩
-      cases h x hcx with
-      | inl hPx => exfalso; apply hx x hcx rel_refl hPx
-      | inr hQx => assumption
-  cases this with
-  | inl hP =>
-    left
-    rw [csup_conj (h := hP) (hchain := hchain)]
-    apply hadm₁ _ (chain_conj _ _ hchain)
-    intro x ⟨hcx, hPx⟩
-    exact hPx
-  | inr hQ =>
-    right
-    rw [csup_conj (h := hQ) (hchain := hchain)]
-    apply hadm₂ _ (chain_conj _ _ hchain)
-    intro x ⟨hcx, hQx⟩
-    exact hQx
-
-def admissible_pi (P : α → β → Prop)
-  (hadm₁ : ∀ y, admissible (fun x => P x y)) : admissible (fun x => ∀ y, P x y) :=
-    fun c hchain h y => hadm₁ y c hchain fun x hx => h x hx y
-
-end admissibility
-
-section fix
-
-open PartialOrder CCPO
-
-variable {α  : Sort u} [CCPO α]
-
-variable {c : α → Prop} (hchain : chain c)
-
-/--
-The transfinite iteration of a function `f` is a set that is `⊥ ` and is closed under application
-of `f` and `csup`.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-inductive iterates (f : α → α) : α → Prop where
-  | step : iterates f x → iterates f (f x)
-  | sup {c : α → Prop} (hc : chain c) (hi : ∀ x, c x → iterates f x) : iterates f (csup c)
-
-theorem chain_iterates {f : α → α} (hf : monotone f) : chain (iterates f) := by
-  intros x y hx hy
-  induction hx generalizing y
-  case step x hx ih =>
-    induction hy
-    case step y hy _ =>
-      cases ih y hy
-      · left; apply hf; assumption
-      · right; apply hf; assumption
-    case sup c hchain hi ih2 =>
-      show f x ⊑ csup c ∨ csup c ⊑ f x
-      by_cases h : ∃ z, c z ∧ f x ⊑ z
-      · left
-        obtain ⟨z, hz, hfz⟩ := h
-        apply rel_trans hfz
-        apply le_csup hchain hz
-      · right
-        apply csup_le hchain _
-        intro z hz
-        rw [not_exists] at h
-        specialize h z
-        rw [not_and] at h
-        specialize h hz
-        cases ih2 z hz
-        next => contradiction
-        next => assumption
-  case sup c hchain hi ih =>
-    show rel (csup c) y ∨ rel y (csup c)
-    by_cases h : ∃ z, c z ∧ rel y z
-    · right
-      obtain ⟨z, hz, hfz⟩ := h
-      apply rel_trans hfz
-      apply le_csup hchain hz
-    · left
-      apply csup_le hchain _
-      intro z hz
-      rw [not_exists] at h
-      specialize h z
-      rw [not_and] at h
-      specialize h hz
-      cases ih z hz y hy
-      next => assumption
-      next => contradiction
-
-theorem rel_f_of_iterates {f : α → α} (hf : monotone f) {x : α} (hx : iterates f x) : x ⊑ f x := by
-  induction hx
-  case step ih =>
-    apply hf
-    assumption
-  case sup c hchain hi ih =>
-    apply csup_le hchain
-    intro y hy
-    apply rel_trans (ih y hy)
-    apply hf
-    apply le_csup hchain hy
-
-set_option linter.unusedVariables false in
-/--
-The least fixpoint of a monotone function is the least upper bound of its transfinite iteration.
-
-The `monotone f` assumption is not strictly necessarily for the definition, but without this the
-definition is not very meaningful and it simplifies applying theorems like `fix_eq` if every use of
-`fix` already has the monotonicty requirement.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-def fix (f : α → α) (hmono : monotone f) := csup (iterates f)
-
-/--
-The main fixpoint theorem for fixedpoints of monotone functions in chain-complete partial orders.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-theorem fix_eq {f : α → α} (hf : monotone f) : fix f hf = f (fix f hf) := by
-  apply rel_antisymm
-  · apply rel_f_of_iterates hf
-    apply iterates.sup (chain_iterates hf)
-    exact fun _ h => h
-  · apply le_csup (chain_iterates hf)
-    apply iterates.step
-    apply iterates.sup (chain_iterates hf)
-    intro y hy
-    exact hy
-
-/--
-The fixpoint induction theme: An admissible predicate holds for a least fixpoint if it is preserved
-by the fixpoint's function.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-theorem fix_induct {f : α → α} (hf : monotone f)
-    (motive : α → Prop) (hadm: admissible motive)
-    (h : ∀ x, motive x → motive (f x)) : motive (fix f hf) := by
-  apply hadm _ (chain_iterates hf)
-  intro x hiterates
-  induction hiterates with
-  | @step x hiter ih => apply h x ih
-  | @sup c hchain hiter ih => apply hadm c hchain ih
-
-end fix
-
-section fun_order
-
-open PartialOrder
-
-variable {α : Sort u}
-variable {β : α → Sort v}
-variable {γ : Sort w}
-
-instance instOrderPi [∀ x, PartialOrder (β x)] : PartialOrder (∀ x, β x) where
-  rel f g := ∀ x, f x ⊑ g x
-  rel_refl _ := rel_refl
-  rel_trans hf hg x := rel_trans (hf x) (hg x)
-  rel_antisymm hf hg := funext (fun x => rel_antisymm (hf x) (hg x))
-
-theorem monotone_of_monotone_apply [PartialOrder γ] [∀ x, PartialOrder (β x)] (f : γ → (∀ x, β x))
-  (h : ∀ y, monotone (fun x => f x y)) : monotone f :=
-  fun x y hxy z => h z x y hxy
-
-theorem monotone_apply [PartialOrder γ] [∀ x, PartialOrder (β x)] (a : α) (f : γ → ∀ x, β x)
-    (h : monotone f) :
-    monotone (fun x => f x a) := fun _ _ hfg => h _ _ hfg a
-
-theorem chain_apply [∀ x, PartialOrder (β x)] {c : (∀ x, β x) → Prop} (hc : chain c) (x : α) :
-    chain (fun y => ∃ f, c f ∧ f x = y) := by
-  intro _ _ ⟨f, hf, hfeq⟩ ⟨g, hg, hgeq⟩
-  subst hfeq; subst hgeq
-  cases hc f g hf hg
-  next h => left; apply h x
-  next h => right; apply h x
-
-def fun_csup [∀ x, CCPO (β x)] (c : (∀ x, β x) → Prop) (x : α) :=
-  CCPO.csup (fun y => ∃ f, c f ∧ f x = y)
-
-instance instCCPOPi [∀ x, CCPO (β x)] : CCPO (∀ x, β x) where
-  csup := fun_csup
-  csup_spec := by
-    intro f c hc
-    constructor
-    next =>
-      intro hf g hg x
-      apply rel_trans _ (hf x); clear hf
-      apply le_csup (chain_apply hc x)
-      exact ⟨g, hg, rfl⟩
-    next =>
-      intro h x
-      apply csup_le (chain_apply hc x)
-      intro y ⟨z, hz, hyz⟩
-      subst y
-      apply h z hz
-
-def admissible_apply [∀ x, CCPO (β x)] (P : ∀ x, β x → Prop) (x : α)
-  (hadm : admissible (P x)) : admissible (fun (f : ∀ x, β x) => P x (f x)) := by
-  intro c hchain h
-  apply hadm _ (chain_apply hchain x)
-  rintro _ ⟨f, hcf, rfl⟩
-  apply h _ hcf
-
-def admissible_pi_apply [∀ x, CCPO (β x)] (P : ∀ x, β x → Prop) (hadm : ∀ x, admissible (P x)) :
-    admissible (fun (f : ∀ x, β x) => ∀ x, P x (f x)) := by
-  apply admissible_pi
-  intro
-  apply admissible_apply
-  apply hadm
-
-end fun_order
-
-section monotone_lemmas
-
-theorem monotone_letFun
-    {α : Sort u} {β : Sort v} {γ : Sort w} [PartialOrder α] [PartialOrder β]
-    (v : γ) (k : α → γ → β)
-    (hmono : ∀ y, monotone (fun x => k x y)) :
-  monotone fun (x : α) => letFun v (k x) := hmono v
-
-theorem monotone_ite
-    {α : Sort u} {β : Sort v} [PartialOrder α] [PartialOrder β]
-    (c : Prop) [Decidable c]
-    (k₁ : α → β) (k₂ : α → β)
-    (hmono₁ : monotone k₁) (hmono₂ : monotone k₂) :
-  monotone fun x => if c then k₁ x else k₂ x := by
-    split
-    · apply hmono₁
-    · apply hmono₂
-
-theorem monotone_dite
-    {α : Sort u} {β : Sort v} [PartialOrder α] [PartialOrder β]
-    (c : Prop) [Decidable c]
-    (k₁ : α → c → β) (k₂ : α → ¬ c → β)
-    (hmono₁ : monotone k₁) (hmono₂ : monotone k₂) :
-  monotone fun x => dite c (k₁ x) (k₂ x) := by
-    split
-    · apply monotone_apply _ _ hmono₁
-    · apply monotone_apply _ _ hmono₂
-
-end monotone_lemmas
-
-section pprod_order
-
-open PartialOrder
-
-variable {α : Sort u}
-variable {β : Sort v}
-variable {γ : Sort w}
-
-instance [PartialOrder α] [PartialOrder β] : PartialOrder (α ×' β) where
-  rel a b := a.1 ⊑ b.1 ∧ a.2 ⊑ b.2
-  rel_refl := ⟨rel_refl, rel_refl⟩
-  rel_trans ha hb := ⟨rel_trans ha.1 hb.1, rel_trans ha.2 hb.2⟩
-  rel_antisymm := fun {a} {b} ha hb => by
-    cases a; cases b;
-    dsimp at *
-    rw [rel_antisymm ha.1 hb.1, rel_antisymm ha.2 hb.2]
-
-theorem monotone_pprod [PartialOrder α] [PartialOrder β] [PartialOrder γ]
-    {f : γ → α} {g : γ → β} (hf : monotone f) (hg : monotone g) :
-    monotone (fun x => PProd.mk (f x) (g x)) :=
-  fun _ _ h12 => ⟨hf _ _ h12, hg _ _ h12⟩
-
-theorem monotone_pprod_fst [PartialOrder α] [PartialOrder β] [PartialOrder γ]
-    {f : γ → α ×' β} (hf : monotone f) : monotone (fun x => (f x).1) :=
-  fun _ _ h12 => (hf _ _ h12).1
-
-theorem monotone_pprod_snd [PartialOrder α] [PartialOrder β] [PartialOrder γ]
-    {f : γ → α ×' β} (hf : monotone f) : monotone (fun x => (f x).2) :=
-  fun _ _ h12 => (hf _ _ h12).2
-
-def chain_pprod_fst [CCPO α] [CCPO β] (c : α ×' β → Prop) : α → Prop := fun a => ∃ b, c ⟨a, b⟩
-def chain_pprod_snd [CCPO α] [CCPO β] (c : α ×' β → Prop) : β → Prop := fun b => ∃ a, c ⟨a, b⟩
-
-theorem chain.pprod_fst [CCPO α] [CCPO β] (c : α ×' β → Prop) (hchain : chain c) :
-    chain (chain_pprod_fst c) := by
-  intro a₁ a₂ ⟨b₁, h₁⟩ ⟨b₂, h₂⟩
-  cases hchain ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ h₁ h₂
-  case inl h => left; exact h.1
-  case inr h => right; exact h.1
-
-theorem chain.pprod_snd [CCPO α] [CCPO β] (c : α ×' β → Prop) (hchain : chain c) :
-    chain (chain_pprod_snd c) := by
-  intro b₁ b₂ ⟨a₁, h₁⟩ ⟨a₂, h₂⟩
-  cases hchain ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ h₁ h₂
-  case inl h => left; exact h.2
-  case inr h => right; exact h.2
-
-instance [CCPO α] [CCPO β] : CCPO (α ×' β) where
-  csup c := ⟨CCPO.csup (chain_pprod_fst c), CCPO.csup (chain_pprod_snd c)⟩
-  csup_spec := by
-    intro ⟨a, b⟩ c hchain
-    dsimp
-    constructor
-    next =>
-      intro ⟨h₁, h₂⟩ ⟨a', b'⟩ cab
-      constructor <;> dsimp at *
-      · apply rel_trans ?_ h₁
-        apply le_csup hchain.pprod_fst
-        exact ⟨b', cab⟩
-      · apply rel_trans ?_ h₂
-        apply le_csup hchain.pprod_snd
-        exact ⟨a', cab⟩
-    next =>
-      intro h
-      constructor <;> dsimp
-      · apply csup_le hchain.pprod_fst
-        intro a' ⟨b', hcab⟩
-        apply (h _ hcab).1
-      · apply csup_le hchain.pprod_snd
-        intro b' ⟨a', hcab⟩
-        apply (h _ hcab).2
-
-theorem admissible_pprod_fst {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] (P : α → Prop)
-    (hadm : admissible P) : admissible (fun (x : α ×' β) => P x.1) := by
-  intro c hchain h
-  apply hadm _ hchain.pprod_fst
-  intro x ⟨y, hxy⟩
-  apply h ⟨x,y⟩ hxy
-
-theorem admissible_pprod_snd {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] (P : β → Prop)
-    (hadm : admissible P) : admissible (fun (x : α ×' β) => P x.2) := by
-  intro c hchain h
-  apply hadm _ hchain.pprod_snd
-  intro y ⟨x, hxy⟩
-  apply h ⟨x,y⟩ hxy
-
-end pprod_order
-
-section flat_order
-
-variable {α : Sort u}
-
-set_option linter.unusedVariables false in
-/--
-`FlatOrder b` wraps the type `α` with the flat partial order generated by `∀ x, b ⊑ x`.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-def FlatOrder {α : Sort u} (b : α) := α
-
-variable {b : α}
-
-/--
-The flat partial order generated by `∀ x, b ⊑ x`.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-inductive FlatOrder.rel : (x y : FlatOrder b) → Prop where
-  | bot : rel b x
-  | refl : rel x x
-
-instance FlatOrder.instOrder : PartialOrder (FlatOrder b) where
-  rel := rel
-  rel_refl := .refl
-  rel_trans {x y z : α} (hxy : rel x y) (hyz : rel y z) := by
-    cases hxy <;> cases hyz <;> constructor
-  rel_antisymm {x y : α} (hxy : rel x y) (hyz : rel y x) : x = y := by
-    cases hxy <;> cases hyz <;> constructor
-
-open Classical in
-private theorem Classical.some_spec₂ {α : Sort _} {p : α → Prop} {h : ∃ a, p a} (q : α → Prop)
-    (hpq : ∀ a, p a → q a) : q (choose h) := hpq _ <| choose_spec _
-
-noncomputable def flat_csup (c : FlatOrder b → Prop) : FlatOrder b := by
-  by_cases h : ∃ (x : FlatOrder b), c x ∧ x ≠ b
-  · exact Classical.choose h
-  · exact b
-
-noncomputable instance FlatOrder.instCCPO : CCPO (FlatOrder b) where
-  csup := flat_csup
-  csup_spec := by
-    intro x c hc
-    unfold flat_csup
-    split
-    next hex =>
-      apply Classical.some_spec₂ (q := (· ⊑ x ↔ (∀ y, c y → y ⊑ x)))
-      clear hex
-      intro z ⟨hz, hnb⟩
-      constructor
-      · intro h y hy
-        apply PartialOrder.rel_trans _ h; clear h
-        cases hc y z hy hz
-        next => assumption
-        next h =>
-          cases h
-          · contradiction
-          · constructor
-      · intro h
-        cases h z hz
-        · contradiction
-        · constructor
-    next hnotex =>
-      constructor
-      · intro h y hy; clear h
-        suffices y = b by rw [this]; exact rel.bot
-        rw [not_exists] at hnotex
-        specialize hnotex y
-        rw [not_and] at hnotex
-        specialize hnotex hy
-        rw [@Classical.not_not] at hnotex
-        assumption
-      · intro; exact rel.bot
-
-theorem admissible_flatOrder (P : FlatOrder b → Prop) (hnot : P b) : admissible P := by
-  intro c hchain h
-  by_cases h' : ∃ (x : FlatOrder b), c x ∧ x ≠ b
-  · simp [CCPO.csup, flat_csup, h']
-    apply Classical.some_spec₂ (q := (P ·))
-    intro x ⟨hcx, hneb⟩
-    apply h x hcx
-  · simp [CCPO.csup, flat_csup, h', hnot]
-
-end flat_order
-
-section mono_bind
-
-/--
-The class `MonoBind m` indicates that every `m α` has a `PartialOrder`, and that the bind operation
-on `m` is monotone in both arguments with regard to that order.
-
-This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
--/
-class MonoBind (m : Type u → Type v) [Bind m] [∀ α, PartialOrder (m α)] where
-  bind_mono_left {a₁ a₂ : m α} {f : α → m b} (h : a₁ ⊑ a₂) : a₁ >>= f ⊑ a₂ >>= f
-  bind_mono_right {a : m α} {f₁ f₂ : α → m b} (h : ∀ x, f₁ x ⊑ f₂ x) : a >>= f₁ ⊑ a >>= f₂
-
-theorem monotone_bind
-    (m : Type u → Type v) [Bind m] [∀ α, PartialOrder (m α)] [MonoBind m]
-    {α β : Type u}
-    {γ : Type w} [PartialOrder γ]
-    (f : γ → m α) (g : γ → α → m β)
-    (hmono₁ : monotone f)
-    (hmono₂ : monotone g) :
-    monotone (fun (x : γ) => f x >>= g x) := by
-  intro x₁ x₂ hx₁₂
-  apply PartialOrder.rel_trans
-  · apply MonoBind.bind_mono_left (hmono₁ _ _ hx₁₂)
-  · apply MonoBind.bind_mono_right (fun y => monotone_apply y _ hmono₂ _ _ hx₁₂)
-
-instance : PartialOrder (Option α) := inferInstanceAs (PartialOrder (FlatOrder none))
-noncomputable instance : CCPO (Option α) := inferInstanceAs (CCPO (FlatOrder none))
-noncomputable instance : MonoBind Option where
-  bind_mono_left h := by
-    cases h
-    · exact FlatOrder.rel.bot
-    · exact FlatOrder.rel.refl
-  bind_mono_right h := by
-    cases ‹Option _›
-    · exact FlatOrder.rel.refl
-    · exact h _
-
-theorem admissible_eq_some (P : Prop) (y : α) :
-    admissible (fun (x : Option α) => x = some y → P) := by
-  apply admissible_flatOrder; simp
-
-instance [Monad m] [inst : ∀ α, PartialOrder (m α)] : PartialOrder (ExceptT ε m α) := inst _
-instance [Monad m] [∀ α, PartialOrder (m α)] [inst : ∀ α, CCPO (m α)] : CCPO (ExceptT ε m α) := inst _
-instance [Monad m] [∀ α, PartialOrder (m α)] [∀ α, CCPO (m α)] [MonoBind m] : MonoBind (ExceptT ε m) where
-  bind_mono_left h₁₂ := by
-    apply MonoBind.bind_mono_left (m := m)
-    exact h₁₂
-  bind_mono_right h₁₂ := by
-    apply MonoBind.bind_mono_right (m := m)
-    intro x
-    cases x
-    · apply PartialOrder.rel_refl
-    · apply h₁₂
-
-end mono_bind
-
-namespace Example
-
-def findF (P : Nat → Bool) (rec : Nat → Option Nat) (x : Nat) : Option Nat :=
-  if P x then
-    some x
-  else
-    rec (x + 1)
-
-noncomputable def find (P : Nat → Bool) : Nat → Option Nat := fix (findF P) <| by
-  unfold findF
-  apply monotone_of_monotone_apply
-  intro n
-  split
-  · apply monotone_const
-  · apply monotone_apply
-    apply monotone_id
-
-theorem find_eq : find P = findF P (find P) := fix_eq ..
-
-theorem find_spec : ∀ n m, find P n = some m → n ≤ m ∧ P m := by
-  unfold find
-  refine fix_induct (motive := fun (f : Nat → Option Nat) => ∀ n m, f n = some m → n ≤ m ∧ P m) _ ?hadm ?hstep
-  case hadm =>
-    -- apply admissible_pi_apply does not work well, hard to infer everything
-    exact admissible_pi_apply _ (fun n => admissible_pi _ (fun m => admissible_eq_some _ m))
-  case hstep =>
-    intro f ih n m heq
-    simp only [findF] at heq
-    split at heq
-    · simp_all
-    · obtain ⟨ih1, ih2⟩ := ih _ _ heq
-      constructor
-      · exact Nat.le_trans (Nat.le_add_right _ _ ) ih1
-      · exact ih2
-
-end Example
-
-end Lean.Order

src/Init/Internal/Order/Tactic.lean

@@ -1,20 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Joachim Breitner
--/
-
-prelude
-import Init.Notation
-
-namespace Lean.Order
-/--
-`monotonicity` performs one compositional step solving `monotone` goals,
-using lemma tagged with `@[partial_fixpoint_monotone]`.
-
-This tactic is mostly used internally by lean in `partial_fixpoint` definitions, but
-can be useful on its own for debugging or when proving new `@[partial_fixpoint_monotone]` lemmas.
--/
-scoped syntax (name := monotonicity) "monotonicity" : tactic
-
-end Lean.Order

src/Init/Prelude.lean

@@ -150,9 +150,6 @@ It can also be written as `()`.
 /-- Marker for information that has been erased by the code generator. -/
 unsafe axiom lcErased : Type
 
-/-- Marker for type dependency that has been erased by the code generator. -/
-unsafe axiom lcAny : Type
-
 /--
 Auxiliary unsafe constant used by the Compiler when erasing proofs from code.
 
@@ -4173,16 +4170,6 @@ def withRef [Monad m] [MonadRef m] {α} (ref : Syntax) (x : m α) : m α :=
   let ref := replaceRef ref oldRef
   MonadRef.withRef ref x
 
-/--
-If `ref? = some ref`, run `x : m α` with a modified value for the `ref` by calling `withRef`.
-Otherwise, run `x` directly.
--/
-@[always_inline, inline]
-def withRef? [Monad m] [MonadRef m] {α} (ref? : Option Syntax) (x : m α) : m α :=
-  match ref? with
-  | some ref => withRef ref x
-  | _        => x
-
 /-- A monad that supports syntax quotations. Syntax quotations (in term
     position) are monadic values that when executed retrieve the current "macro
     scope" from the monad and apply it to every identifier they introduce

src/Init/Tactics.lean

@@ -818,7 +818,7 @@ syntax inductionAlt  := ppDedent(ppLine) inductionAltLHS+ " => " (hole <|> synth
 After `with`, there is an optional tactic that runs on all branches, and
 then a list of alternatives.
 -/
-syntax inductionAlts := " with" (ppSpace colGt tactic)? withPosition((colGe inductionAlt)*)
+syntax inductionAlts := " with" (ppSpace colGt tactic)? withPosition((colGe inductionAlt)+)
 
 /--
 Assuming `x` is a variable in the local context with an inductive type,
@@ -1648,6 +1648,17 @@ If there are several with the same priority, it is uses the "most recent one". E
 -/
 syntax (name := simp) "simp" (Tactic.simpPre <|> Tactic.simpPost)? patternIgnore("← " <|> "<- ")? (ppSpace prio)? : attr
 
+/--
+Theorems tagged with the `grind_norm` attribute are used by the `grind` tactic normalizer/pre-processor.
+-/
+syntax (name := grind_norm) "grind_norm" (Tactic.simpPre <|> Tactic.simpPost)? (ppSpace prio)? : attr
+
+/--
+Simplification procedures tagged with the `grind_norm_proc` attribute are used by the `grind` tactic normalizer/pre-processor.
+-/
+syntax (name := grind_norm_proc) "grind_norm_proc" (Tactic.simpPre <|> Tactic.simpPost)? : attr
+
+
 /-- The possible `norm_cast` kinds: `elim`, `move`, or `squash`. -/
 syntax normCastLabel := &"elim" <|> &"move" <|> &"squash"
 

src/Lean/AddDecl.lean

@@ -14,54 +14,26 @@ register_builtin_option debug.skipKernelTC : Bool := {
   descr    := "skip kernel type checker. WARNING: setting this option to true may compromise soundness because your proofs will not be checked by the Lean kernel"
 }
 
-/-- Adds given declaration to the environment, respecting `debug.skipKernelTC`. -/
-def Kernel.Environment.addDecl (env : Environment) (opts : Options) (decl : Declaration)
-    (cancelTk? : Option IO.CancelToken := none) : Except Exception Environment :=
+def Environment.addDecl (env : Environment) (opts : Options) (decl : Declaration)
+    (cancelTk? : Option IO.CancelToken := none) : Except KernelException Environment :=
   if debug.skipKernelTC.get opts then
     addDeclWithoutChecking env decl
   else
     addDeclCore env (Core.getMaxHeartbeats opts).toUSize decl cancelTk?
 
-private def Environment.addDeclAux (env : Environment) (opts : Options) (decl : Declaration)
-    (cancelTk? : Option IO.CancelToken := none) : Except Kernel.Exception Environment :=
-  env.addDeclCore (Core.getMaxHeartbeats opts).toUSize decl cancelTk? (!debug.skipKernelTC.get opts)
-
-@[deprecated "use `Lean.addDecl` instead to ensure new namespaces are registered" (since := "2024-12-03")]
-def Environment.addDecl (env : Environment) (opts : Options) (decl : Declaration)
-    (cancelTk? : Option IO.CancelToken := none) : Except Kernel.Exception Environment :=
-  Environment.addDeclAux env opts decl cancelTk?
-
-private def isNamespaceName : Name → Bool
-  | .str .anonymous _ => true
-  | .str p _          => isNamespaceName p
-  | _                 => false
-
-private def registerNamePrefixes (env : Environment) (name : Name) : Environment :=
-  match name with
-    | .str _ s =>
-      if s.get 0 == '_' then
-        -- Do not register namespaces that only contain internal declarations.
-        env
-      else
-        go env name
-    | _ => env
-where go env
-  | .str p _ => if isNamespaceName p then go (env.registerNamespace p) p else env
-  | _        => env
+def Environment.addAndCompile (env : Environment) (opts : Options) (decl : Declaration)
+    (cancelTk? : Option IO.CancelToken := none) : Except KernelException Environment := do
+  let env ← addDecl env opts decl cancelTk?
+  compileDecl env opts decl
 
 def addDecl (decl : Declaration) : CoreM Unit := do
   profileitM Exception "type checking" (← getOptions) do
-    let mut env ← withTraceNode `Kernel (fun _ => return m!"typechecking declaration") do
+    withTraceNode `Kernel (fun _ => return m!"typechecking declaration") do
       if !(← MonadLog.hasErrors) && decl.hasSorry then
         logWarning "declaration uses 'sorry'"
-      (← getEnv).addDeclAux (← getOptions) decl (← read).cancelTk? |> ofExceptKernelException
-
-    -- register namespaces for newly added constants; this used to be done by the kernel itself
-    -- but that is incompatible with moving it to a separate task
-    env := decl.getNames.foldl registerNamePrefixes env
-    if let .inductDecl _ _ types _ := decl then
-      env := types.foldl (registerNamePrefixes · <| ·.name ++ `rec) env
-    setEnv env
+      match (← getEnv).addDecl (← getOptions) decl (← read).cancelTk? with
+      | .ok    env => setEnv env
+      | .error ex  => throwKernelException ex
 
 def addAndCompile (decl : Declaration) : CoreM Unit := do
   addDecl decl

src/Lean/Compiler/ExternAttr.lean

@@ -18,7 +18,6 @@ inductive ExternEntry where
   | inline   (backend : Name) (pattern : String)
   | standard (backend : Name) (fn : String)
   | foreign  (backend : Name) (fn : String)
-  deriving BEq, Hashable
 
 /--
 - `@[extern]`
@@ -37,7 +36,7 @@ inductive ExternEntry where
 structure ExternAttrData where
   arity?   : Option Nat := none
   entries  : List ExternEntry
-  deriving Inhabited, BEq, Hashable
+  deriving Inhabited
 
 -- def externEntry := leading_parser optional ident >> optional (nonReservedSymbol "inline ") >> strLit
 -- @[builtin_attr_parser] def extern     := leading_parser nonReservedSymbol "extern " >> optional numLit >> many externEntry

src/Lean/Compiler/InitAttr.lean

@@ -144,7 +144,11 @@ def declareBuiltin (forDecl : Name) (value : Expr) : CoreM Unit := do
   let type := mkApp (mkConst `IO) (mkConst `Unit)
   let decl := Declaration.defnDecl { name, levelParams := [], type, value, hints := ReducibilityHints.opaque,
                                      safety := DefinitionSafety.safe }
-  addAndCompile decl
-  IO.ofExcept (setBuiltinInitAttr (← getEnv) name) >>= setEnv
+  match (← getEnv).addAndCompile {} decl with
+  -- TODO: pretty print error
+  | Except.error e => do
+    let msg ← (e.toMessageData {}).toString
+    throwError "failed to emit registration code for builtin '{forDecl}': {msg}"
+  | Except.ok env  => IO.ofExcept (setBuiltinInitAttr env name) >>= setEnv
 
 end Lean

src/Lean/Compiler/LCNF/Basic.lean

@@ -7,7 +7,6 @@ prelude
 import Init.Data.List.BasicAux
 import Lean.Expr
 import Lean.Meta.Instances
-import Lean.Compiler.ExternAttr
 import Lean.Compiler.InlineAttrs
 import Lean.Compiler.Specialize
 import Lean.Compiler.LCNF.Types
@@ -430,80 +429,6 @@ where
     | .cases c => c.alts.forM fun alt => go alt.getCode
     | .unreach .. | .return .. | .jmp .. => return ()
 
-partial def Code.instantiateValueLevelParams (code : Code) (levelParams : List Name) (us : List Level) : Code :=
-  instCode code
-where
-  instLevel (u : Level) :=
-    u.instantiateParams levelParams us
-
-  instExpr (e : Expr) :=
-    e.instantiateLevelParamsNoCache levelParams us
-
-  instParams (ps : Array Param) :=
-    ps.mapMono fun p => p.updateCore (instExpr p.type)
-
-  instAlt (alt : Alt) :=
-    match alt with
-    | .default k => alt.updateCode (instCode k)
-    | .alt _ ps k => alt.updateAlt! (instParams ps) (instCode k)
-
-  instArg (arg : Arg) : Arg :=
-    match arg with
-    | .type e => arg.updateType! (instExpr e)
-    | .fvar .. | .erased => arg
-
-  instLetValue (e : LetValue) : LetValue :=
-    match e with
-    | .const declName vs args => e.updateConst! declName (vs.mapMono instLevel) (args.mapMono instArg)
-    | .fvar fvarId args => e.updateFVar! fvarId (args.mapMono instArg)
-    | .proj .. | .value .. | .erased => e
-
-  instLetDecl (decl : LetDecl) :=
-    decl.updateCore (instExpr decl.type) (instLetValue decl.value)
-
-  instFunDecl (decl : FunDecl) :=
-    decl.updateCore (instExpr decl.type) (instParams decl.params) (instCode decl.value)
-
-  instCode (code : Code) :=
-    match code with
-    | .let decl k => code.updateLet! (instLetDecl decl) (instCode k)
-    | .jp decl k | .fun decl k => code.updateFun! (instFunDecl decl) (instCode k)
-    | .cases c => code.updateCases! (instExpr c.resultType) c.discr (c.alts.mapMono instAlt)
-    | .jmp fvarId args => code.updateJmp! fvarId (args.mapMono instArg)
-    | .return .. => code
-    | .unreach type => code.updateUnreach! (instExpr type)
-
-inductive DeclValue where
-  | code (code : Code)
-  | extern (externAttrData : ExternAttrData)
-  deriving Inhabited, BEq
-
-partial def DeclValue.size : DeclValue → Nat
-  | .code c => c.size
-  | .extern .. => 0
-
-def DeclValue.mapCode (f : Code → Code) : DeclValue → DeclValue :=
-  fun
-    | .code c => .code (f c)
-    | .extern e => .extern e
-
-def DeclValue.mapCodeM [Monad m] (f : Code → m Code) : DeclValue → m DeclValue :=
-  fun v => do
-    match v with
-    | .code c => return .code (← f c)
-    | .extern .. => return v
-
-def DeclValue.forCodeM [Monad m] (f : Code → m Unit) : DeclValue → m Unit :=
-  fun v => do
-    match v with
-    | .code c => f c
-    | .extern .. => return ()
-
-def DeclValue.isCodeAndM [Monad m] (v : DeclValue) (f : Code → m Bool) : m Bool :=
-  match v with
-  | .code c => f c
-  | .extern .. => pure false
-
 /--
 Declaration being processed by the Lean to Lean compiler passes.
 -/
@@ -530,7 +455,7 @@ structure Decl where
   The body of the declaration, usually changes as it progresses
   through compiler passes.
   -/
-  value : DeclValue
+  value : Code
   /--
   We set this flag to true during LCNF conversion. When we receive
   a block of functions to be compiled, we set this flag to `true`
@@ -611,9 +536,7 @@ We use this function to decide whether we should inline a declaration tagged wit
 `[inline_if_reduce]` or not.
 -/
 def Decl.isCasesOnParam? (decl : Decl) : Option Nat :=
-  match decl.value with
-  | .code c => go c
-  | .extern .. => none
+  go decl.value
 where
   go (code : Code) : Option Nat :=
     match code with
@@ -627,6 +550,49 @@ def Decl.instantiateTypeLevelParams (decl : Decl) (us : List Level) : Expr :=
 def Decl.instantiateParamsLevelParams (decl : Decl) (us : List Level) : Array Param :=
   decl.params.mapMono fun param => param.updateCore (param.type.instantiateLevelParamsNoCache decl.levelParams us)
 
+partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code :=
+  instCode decl.value
+where
+  instLevel (u : Level) :=
+    u.instantiateParams decl.levelParams us
+
+  instExpr (e : Expr) :=
+    e.instantiateLevelParamsNoCache decl.levelParams us
+
+  instParams (ps : Array Param) :=
+    ps.mapMono fun p => p.updateCore (instExpr p.type)
+
+  instAlt (alt : Alt) :=
+    match alt with
+    | .default k => alt.updateCode (instCode k)
+    | .alt _ ps k => alt.updateAlt! (instParams ps) (instCode k)
+
+  instArg (arg : Arg) : Arg :=
+    match arg with
+    | .type e => arg.updateType! (instExpr e)
+    | .fvar .. | .erased => arg
+
+  instLetValue (e : LetValue) : LetValue :=
+    match e with
+    | .const declName vs args => e.updateConst! declName (vs.mapMono instLevel) (args.mapMono instArg)
+    | .fvar fvarId args => e.updateFVar! fvarId (args.mapMono instArg)
+    | .proj .. | .value .. | .erased => e
+
+  instLetDecl (decl : LetDecl) :=
+    decl.updateCore (instExpr decl.type) (instLetValue decl.value)
+
+  instFunDecl (decl : FunDecl) :=
+    decl.updateCore (instExpr decl.type) (instParams decl.params) (instCode decl.value)
+
+  instCode (code : Code) :=
+    match code with
+    | .let decl k => code.updateLet! (instLetDecl decl) (instCode k)
+    | .jp decl k | .fun decl k => code.updateFun! (instFunDecl decl) (instCode k)
+    | .cases c => code.updateCases! (instExpr c.resultType) c.discr (c.alts.mapMono instAlt)
+    | .jmp fvarId args => code.updateJmp! fvarId (args.mapMono instArg)
+    | .return .. => code
+    | .unreach type => code.updateUnreach! (instExpr type)
+
 /--
 Return `true` if the arrow type contains an instance implicit argument.
 -/
@@ -727,7 +693,7 @@ where
       visit k
 
   go : StateM NameSet Unit :=
-    decls.forM (·.value.forCodeM visit)
+    decls.forM fun decl => visit decl.value
 
 def instantiateRangeArgs (e : Expr) (beginIdx endIdx : Nat) (args : Array Arg) : Expr :=
   if !e.hasLooseBVars then

src/Lean/Compiler/LCNF/Bind.lean

@@ -123,10 +123,7 @@ def FunDeclCore.etaExpand (decl : FunDecl) : CompilerM FunDecl := do
   decl.update decl.type params value
 
 def Decl.etaExpand (decl : Decl) : CompilerM Decl := do
-  match decl.value with
-  | .code code =>
-    let some (params, newCode) ← etaExpandCore? decl.type decl.params code | return decl
-    return { decl with params, value := .code newCode}
-  | .extern .. => return decl
+  let some (params, value) ← etaExpandCore? decl.type decl.params decl.value | return decl
+  return { decl with params, value }
 
 end Lean.Compiler.LCNF

src/Lean/Compiler/LCNF/CSE.lean

@@ -102,7 +102,7 @@ end CSE
 Common sub-expression elimination
 -/
 def Decl.cse (decl : Decl) : CompilerM Decl := do
-  let value ← decl.value.mapCodeM (·.cse)
+  let value ← decl.value.cse
   return { decl with value }
 
 def cse (phase : Phase := .base) (occurrence := 0) : Pass :=

src/Lean/Compiler/LCNF/Check.lean

@@ -261,7 +261,7 @@ def run (x : CheckM α) : CompilerM α :=
 end Check
 
 def Decl.check (decl : Decl) : CompilerM Unit := do
-  Check.run do decl.value.forCodeM (Check.checkFunDeclCore decl.name decl.params decl.type)
+  Check.run do Check.checkFunDeclCore decl.name decl.params decl.type decl.value
 
 /--
 Check whether every local declaration in the local context is used in one of given `decls`.
@@ -299,7 +299,7 @@ where
 
   visitDecl (decl : Decl) : StateM FVarIdHashSet Unit := do
     visitParams decl.params
-    decl.value.forCodeM visitCode
+    visitCode decl.value
 
   visitDecls (decls : Array Decl) : StateM FVarIdHashSet Unit :=
     decls.forM visitDecl

src/Lean/Compiler/LCNF/CompilerM.lean

@@ -148,7 +148,7 @@ def eraseCodeDecls (decls : Array CodeDecl) : CompilerM Unit := do
 
 def eraseDecl (decl : Decl) : CompilerM Unit := do
   eraseParams decl.params
-  decl.value.forCodeM eraseCode
+  eraseCode decl.value
 
 abbrev Decl.erase (decl : Decl) : CompilerM Unit :=
   eraseDecl decl

src/Lean/Compiler/LCNF/DeclHash.lean

@@ -38,7 +38,6 @@ end
 instance : Hashable Code where
   hash c := hashCode c
 
-deriving instance Hashable for DeclValue
 deriving instance Hashable for Decl
 
-end Lean.Compiler.LCNF
+end Lean.Compiler.LCNF

src/Lean/Compiler/LCNF/ElimDead.lean

@@ -95,6 +95,6 @@ def Code.elimDead (code : Code) : CompilerM Code :=
   ElimDead.elimDead code |>.run' {}
 
 def Decl.elimDead (decl : Decl) : CompilerM Decl := do
-  return { decl with value := (← decl.value.mapCodeM Code.elimDead) }
+  return { decl with value := (← decl.value.elimDead) }
 
 end Lean.Compiler.LCNF

src/Lean/Compiler/LCNF/ElimDeadBranches.lean

@@ -513,7 +513,7 @@ def inferStep : InterpM Bool := do
     let currentVal ← getFunVal idx
     withReader (fun ctx => { ctx with currFnIdx := idx }) do
       decl.params.forM fun p => updateVarAssignment p.fvarId .top
-      decl.value.forCodeM interpCode
+      interpCode decl.value
     let newVal ← getFunVal idx
     if currentVal != newVal then
       return true
@@ -538,7 +538,7 @@ Use the information produced by the abstract interpreter to:
 -/
 partial def elimDead (assignment : Assignment) (decl : Decl) : CompilerM Decl := do
   trace[Compiler.elimDeadBranches] s!"Eliminating {decl.name} with {repr (← assignment.toArray |>.mapM (fun (name, val) => do return (toString (← getBinderName name), val)))}"
-  return { decl with value := (← decl.value.mapCodeM go) }
+  return { decl with value := (← go decl.value) }
 where
   go (code : Code) : CompilerM Code := do
     match code with

src/Lean/Compiler/LCNF/FixedParams.lean

@@ -141,9 +141,8 @@ partial def evalApp (declName : Name) (args : Array Arg) : FixParamM Unit := do
       let key := (declName, values)
       unless (← get).visited.contains key do
         modify fun s => { s with visited := s.visited.insert key }
-        decl.value.forCodeM fun c =>
-          let assignment := mkAssignment decl values
-          withReader (fun ctx => { ctx with assignment }) <| evalCode c
+        let assignment := mkAssignment decl values
+        withReader (fun ctx => { ctx with assignment }) <| evalCode decl.value
 
 end
 
@@ -170,12 +169,8 @@ def mkFixedParamsMap (decls : Array Decl) : NameMap (Array Bool) := Id.run do
     let values := mkInitialValues decl.params.size
     let assignment := mkAssignment decl values
     let fixed := Array.mkArray decl.params.size true
-    match decl.value with
-    | .code c =>
-      match evalCode c |>.run { main := decl, decls, assignment } |>.run { fixed } with
-      | .ok _ s | .error _ s => result := result.insert decl.name s.fixed
-    | .extern .. =>
-      result := result.insert decl.name fixed
+    match evalCode decl.value |>.run { main := decl, decls, assignment } |>.run { fixed } with
+    | .ok _ s | .error _ s => result := result.insert decl.name s.fixed
   return result
 
 end Lean.Compiler.LCNF

src/Lean/Compiler/LCNF/FloatLetIn.lean

@@ -239,7 +239,7 @@ Iterate through `decl`, pushing local declarations that are only used in one
 control flow arm into said arm in order to avoid useless computations.
 -/
 partial def floatLetIn (decl : Decl) : CompilerM Decl := do
-  let newValue ← decl.value.mapCodeM go |>.run {}
+  let newValue ← go decl.value |>.run {}
   return { decl with value := newValue }
 where
   /--

src/Lean/Compiler/LCNF/Internalize.lean

@@ -108,7 +108,7 @@ where
   go (decl : Decl) : InternalizeM Decl := do
     let type ← normExpr decl.type
     let params ← decl.params.mapM internalizeParam
-    let value ← decl.value.mapCodeM internalizeCode
+    let value ← internalizeCode decl.value
     return { decl with type, params, value }
 
 /--

src/Lean/Compiler/LCNF/JoinPoints.lean

@@ -133,7 +133,7 @@ this. This is because otherwise the calls to `myjp` in `f` and `g` would
 produce out of scope join point jumps.
 -/
 partial def find (decl : Decl) : CompilerM FindState := do
-  let (_, candidates) ← decl.value.forCodeM go |>.run none |>.run {} |>.run' {}
+  let (_, candidates) ← go decl.value |>.run none |>.run {} |>.run' {}
   return candidates
 where
   go : Code → FindM Unit
@@ -178,7 +178,7 @@ and all calls to them with `jmp`s.
 partial def replace (decl : Decl) (state : FindState) : CompilerM Decl := do
   let mapper := fun acc cname _ => do return acc.insert cname (← mkFreshJpName)
   let replaceCtx : ReplaceCtx ← state.candidates.foldM (init := .empty) mapper
-  let newValue ← decl.value.mapCodeM go |>.run replaceCtx
+  let newValue ← go decl.value |>.run replaceCtx
   return { decl with value := newValue }
 where
   go (code : Code) : ReplaceM Code := do
@@ -389,7 +389,7 @@ position within the code so we can pull them out as far as possible, hopefully
 enabling new inlining possibilities in the next simplifier run.
 -/
 partial def extend (decl : Decl) : CompilerM Decl := do
-  let newValue ← decl.value.mapCodeM go |>.run {} |>.run' {} |>.run' {}
+  let newValue ← go decl.value |>.run {} |>.run' {} |>.run' {}
   let decl := { decl with value := newValue }
   decl.pullFunDecls
 where
@@ -510,8 +510,8 @@ After we have performed all of these optimizations we can take away the
 code that has as little arguments as possible in the join points.
 -/
 partial def reduce (decl : Decl) : CompilerM Decl := do
-  let (_, analysis) ← decl.value.forCodeM goAnalyze |>.run {} |>.run {} |>.run' {}
-  let newValue ← decl.value.mapCodeM goReduce |>.run analysis
+  let (_, analysis) ← goAnalyze decl.value |>.run {} |>.run {} |>.run' {}
+  let newValue ← goReduce decl.value |>.run analysis
   return { decl with value := newValue }
 where
   goAnalyzeFunDecl (fn : FunDecl) : ReduceAnalysisM Unit := do

src/Lean/Compiler/LCNF/LambdaLifting.lean

@@ -108,10 +108,9 @@ def mkAuxDecl (closure : Array Param) (decl : FunDecl) : LiftM LetDecl := do
 where
   go (nameNew : Name) (safe : Bool) (inlineAttr? : Option InlineAttributeKind) : InternalizeM Decl := do
     let params := (← closure.mapM internalizeParam) ++ (← decl.params.mapM internalizeParam)
-    let code ← internalizeCode decl.value
-    let type ← code.inferType
+    let value ← internalizeCode decl.value
+    let type ← value.inferType
     let type ← mkForallParams params type
-    let value := .code code
     let decl := { name := nameNew, levelParams := [], params, type, value, safe, inlineAttr?, recursive := false : Decl }
     return decl.setLevelParams
 
@@ -150,7 +149,7 @@ mutual
 end
 
 def main (decl : Decl) : LiftM Decl := do
-  let value ← withParams decl.params <| decl.value.mapCodeM visitCode
+  let value ← withParams decl.params <| visitCode decl.value
   return { decl with value }
 
 end LambdaLifting

src/Lean/Compiler/LCNF/Level.lean

@@ -139,10 +139,6 @@ mutual
     | .jmp _ args => visitArgs args
 end
 
-def visitDeclValue : DeclValue → Visitor
-  | .code c => visitCode c
-  | .extern .. => id
-
 end CollectLevelParams
 
 open Lean.CollectLevelParams
@@ -153,7 +149,7 @@ Collect universe level parameters collecting in the type, parameters, and value,
 set `decl.levelParams` with the resulting value.
 -/
 def Decl.setLevelParams (decl : Decl) : Decl :=
-  let levelParams := (visitDeclValue decl.value ∘ visitParams decl.params ∘ visitType decl.type) {} |>.params.toList
+  let levelParams := (visitCode decl.value ∘ visitParams decl.params ∘ visitType decl.type) {} |>.params.toList
   { decl with levelParams }
 
 end Lean.Compiler.LCNF

src/Lean/Compiler/LCNF/Main.lean

@@ -28,10 +28,10 @@ and `[specialize]` since they can be partially applied.
 -/
 def shouldGenerateCode (declName : Name) : CoreM Bool := do
   if (← isCompIrrelevant |>.run') then return false
-  let env ← getEnv
-  if isExtern env declName then return true
   let some info ← getDeclInfo? declName | return false
   unless info.hasValue (allowOpaque := true) do return false
+  let env ← getEnv
+  if isExtern env declName then return false
   if hasMacroInlineAttribute env declName then return false
   if (← Meta.isMatcher declName) then return false
   if isCasesOnRecursor env declName then return false

src/Lean/Compiler/LCNF/MonoTypes.lean

@@ -74,6 +74,8 @@ partial def toMonoType (type : Expr) : CoreM Expr := do
   let type := type.headBeta
   if type.isErased then
     return erasedExpr
+  else if type.isErased then
+    return erasedExpr
   else if isTypeFormerType type then
     return erasedExpr
   else match type with

src/Lean/Compiler/LCNF/PrettyPrinter.lean

@@ -105,11 +105,6 @@ mutual
         return f!"⊥ : {← ppExpr type}"
       else
         return "⊥"
-
-  partial def ppDeclValue (b : DeclValue) : M Format := do
-    match b with
-    | .code c => ppCode c
-    | .extern .. => return "extern"
 end
 
 def run (x : M α) : CompilerM α :=
@@ -126,7 +121,7 @@ def ppLetValue (e : LetValue) : CompilerM Format :=
 
 def ppDecl (decl : Decl) : CompilerM Format :=
   PP.run do
-    return f!"def {decl.name}{← PP.ppParams decl.params} : {← PP.ppExpr (← PP.getFunType decl.params decl.type)} :={indentD (← PP.ppDeclValue decl.value)}"
+    return f!"def {decl.name}{← PP.ppParams decl.params} : {← PP.ppExpr (← PP.getFunType decl.params decl.type)} :={indentD (← PP.ppCode decl.value)}"
 
 def ppFunDecl (decl : FunDecl) : CompilerM Format :=
   PP.run do