initial exploration for a ExtHashMapD

.github/workflows/awaiting-mathlib.yml

@@ -10,29 +10,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check awaiting-mathlib label
-        id: check-awaiting-mathlib-label
         if: github.event_name == 'pull_request'
         uses: actions/github-script@v7
         with:
           script: |
-            const { labels, number: prNumber } = context.payload.pull_request;
-            const hasAwaiting = labels.some(label => label.name == "awaiting-mathlib");
-            const hasBreaks = labels.some(label => label.name == "breaks-mathlib");
-            const hasBuilds = labels.some(label => label.name == "builds-mathlib");
-
-            if (hasAwaiting && hasBreaks) {
-              core.setFailed('PR has both "awaiting-mathlib" and "breaks-mathlib" labels.');
-            } else if (hasAwaiting && !hasBreaks && !hasBuilds) {
-              core.info('PR is marked "awaiting-mathlib" but neither "breaks-mathlib" nor "builds-mathlib" labels are present.');
-              core.setOutput('awaiting', 'true');
+            const { labels } = context.payload.pull_request;
+            if (labels.some(label => label.name == "awaiting-mathlib") && !labels.some(label => label.name == "builds-mathlib")) {
+              core.setFailed('PR is marked "awaiting-mathlib" but "builds-mathlib" label has not been applied yet by the bot');
             }
-      
-      - name: Wait for mathlib compatibility
-        if: github.event_name == 'pull_request' && steps.check-awaiting-mathlib-label.outputs.awaiting == 'true'
-        run: |
-          echo "::notice title=Awaiting mathlib::PR is marked 'awaiting-mathlib' but neither 'breaks-mathlib' nor 'builds-mathlib' labels are present."
-          echo "This check will remain in progress until the PR is updated with appropriate mathlib compatibility labels."
-          # Keep the job running indefinitely to show "in progress" status
-          while true; do
-            sleep 3600  # Sleep for 1 hour at a time
-          done

.github/workflows/build-template.yml

@@ -105,11 +105,11 @@ jobs:
           path: |
             .ccache
             ${{ matrix.name == 'Linux Lake' && 'build/stage1/**/*.trace
-            build/stage1/**/*.olean*
+            build/stage1/**/*.olean
             build/stage1/**/*.ilean
             build/stage1/**/*.c
             build/stage1/**/*.c.o*' || '' }}
-          key: ${{ matrix.name }}-build-v3-${{ github.sha }}
+          key: ${{ matrix.name }}-build-v3-${{ github.event.pull_request.head.sha }}
           # fall back to (latest) previous cache
           restore-keys: |
             ${{ matrix.name }}-build-v3
@@ -243,7 +243,7 @@ jobs:
           path: |
             .ccache
             ${{ matrix.name == 'Linux Lake' && 'build/stage1/**/*.trace
-            build/stage1/**/*.olean*
+            build/stage1/**/*.olean
             build/stage1/**/*.ilean
             build/stage1/**/*.c
             build/stage1/**/*.c.o*' || '' }}

.github/workflows/ci.yml

@@ -103,13 +103,6 @@ jobs:
             echo "Tag ${TAG_NAME} did not match SemVer regex."
           fi
 
-      - name: Check for custom releases (e.g., not in the main lean repository)
-        if: startsWith(github.ref, 'refs/tags/') && github.repository != 'leanprover/lean4'
-        id: set-release-custom
-        run: |
-          TAG_NAME="${GITHUB_REF##*/}"
-          echo "RELEASE_TAG=$TAG_NAME" >> "$GITHUB_OUTPUT"
-
       - name: Set check level
         id: set-level
         # We do not use github.event.pull_request.labels.*.name here because
@@ -118,7 +111,7 @@ jobs:
         run: |
           check_level=0
 
-          if [[ -n "${{ steps.set-nightly.outputs.nightly }}" || -n "${{ steps.set-release.outputs.RELEASE_TAG }}" || -n "${{ steps.set-release-custom.outputs.RELEASE_TAG }}" ]]; then
+          if [[ -n "${{ steps.set-nightly.outputs.nightly }}" || -n "${{ steps.set-release.outputs.RELEASE_TAG }}" ]]; then
             check_level=2
           elif [[ "${{ github.event_name }}" != "pull_request" ]]; then
             check_level=1

.github/workflows/pr-release.yml

@@ -34,7 +34,7 @@ jobs:
       - name: Download artifact from the previous workflow.
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
         id: download-artifact
-        uses: dawidd6/action-download-artifact@v10 # https://github.com/marketplace/actions/download-workflow-artifact
+        uses: dawidd6/action-download-artifact@v9 # https://github.com/marketplace/actions/download-workflow-artifact
         with:
           run_id: ${{ github.event.workflow_run.id }}
           path: artifacts

.github/workflows/update-stage0.yml

@@ -40,24 +40,34 @@ jobs:
       run: |
           git config --global user.name "Lean stage0 autoupdater"
           git config --global user.email "<>"
+    # Would be nice, but does not work yet:
+    # https://github.com/DeterminateSystems/magic-nix-cache/issues/39
+    # This action does not run that often and building runs in a few minutes, so ok for now
+    #- if: env.should_update_stage0 == 'yes'
+    #  uses: DeterminateSystems/magic-nix-cache-action@v2
+    - if: env.should_update_stage0 == 'yes'
+      name: Restore Build Cache
+      uses: actions/cache/restore@v4
+      with:
+        path: nix-store-cache
+        key: Nix Linux-nix-store-cache-${{ github.sha }}
+        # fall back to (latest) previous cache
+        restore-keys: |
+          Nix Linux-nix-store-cache
+    - if: env.should_update_stage0 == 'yes'
+      name: Further Set Up Nix Cache
+      shell: bash -euxo pipefail {0}
+      run: |
+        # Nix seems to mutate the cache, so make a copy
+        cp -r nix-store-cache nix-store-cache-copy || true
     - if: env.should_update_stage0 == 'yes'
       name: Install Nix
       uses: DeterminateSystems/nix-installer-action@main
-    - name: Open Nix shell once
-      if: env.should_update_stage0 == 'yes'
-      run: true
-      shell: 'nix develop -c bash -euxo pipefail {0}'
-    - name: Set up NPROC
-      if: env.should_update_stage0 == 'yes'
-      run: |
-        echo "NPROC=$(nproc 2>/dev/null || sysctl -n hw.logicalcpu 2>/dev/null || echo 4)" >> $GITHUB_ENV
-      shell: 'nix develop -c bash -euxo pipefail {0}'
+      with:
+        extra-conf: |
+          substituters = file://${{ github.workspace }}/nix-store-cache-copy?priority=10&trusted=true https://cache.nixos.org  
     - if: env.should_update_stage0 == 'yes'
-      run: cmake --preset release
-      shell: 'nix develop -c bash -euxo pipefail {0}'
-    - if: env.should_update_stage0 == 'yes'
-      run: make -j$NPROC -C build/release  update-stage0-commit
-      shell: 'nix develop -c bash -euxo pipefail {0}'
+      run: nix run .#update-stage0-commit
     - if: env.should_update_stage0 == 'yes'
       run: git show --stat
     - if: env.should_update_stage0 == 'yes' && github.event_name == 'push'

doc/std/README.md

@@ -1,9 +0,0 @@
-# The Lean standard library
-
-This directory contains development information about the Lean standard library. The user-facing documentation of the standard library
-is part of the [Lean Language Reference](https://lean-lang.org/doc/reference/latest/).
-
-Here you will find
-* the [standard library vision document](./vision.md), including the call for contributions,
-* the [standard library style guide](./style.md), and
-* the [standard library naming conventions](./naming.md).

doc/std/naming.md

@@ -1,260 +0,0 @@
-# Standard library naming conventions
-
-The easiest way to access a result in the standard library is to correctly guess the name of the declaration (possibly with the help of identifier autocompletion). This is faster and has lower friction than more sophisticated search tools, so easily guessable names (which are still reasonably short) make Lean users more productive.
-
-The guide that follows contains very few hard rules, many heuristics and a selection of examples. It cannot and does not present a deterministic algorithm for choosing good names in all situations. It is intended as a living document that gets clarified and expanded as situations arise during code reviews for the standard library. If applying one of the suggestions in this guide leads to nonsensical results in a certain situation, it is
-probably safe to ignore the suggestion (or even better, suggest a way to improve the suggestion).
-
-## Prelude
-
-Identifiers use a mix of `UpperCamelCase`, `lowerCamelCase` and `snake_case`, used for types, data, and theorems, respectively.
-
-Structure fields should be named such that the projections have the correct names.
-
-## Naming convention for types
-
-When defining a type, i.e., a (possibly 0-ary) function whose codomain is Sort u for some u, it should be named in UpperCamelCase. Examples include `List`, and `List.IsPrefix`.
-
-When defining a predicate, prefix the name by `Is`, like in `List.IsPrefix`. The `Is` prefix may be omitted if
-* the resulting name would be ungrammatical, or
-* the predicate depends on additional data in a way where the `Is` prefix would be confusing (like `List.Pairwise`), or
-* the name is an adjective (like `Std.Time.Month.Ordinal.Valid`)
-
-## Namespaces and generalized projection notation
-
-Almost always, definitions and theorems relating to a type should be placed in a namespace with the same name as the type. For example, operations and theorems about lists should be placed in the `List` namespace, and operations and theorems about `Std.Time.PlainDate` should be placed in the `Std.Time.PlainDate` namespace.
-
-Declarations in the root namespace will be relatively rare. The most common type of declaration in the root namespace are declarations about data and properties exported by notation type classes, as long as they are not about a specific type implementing that type class. For example, we have
-
-```lean
-theorem beq_iff_eq [BEq α] [LawfulBEq α] {a b : α} : a == b ↔ a = b := sorry
-```
-
-in the root namespace, but
-
-```lean
-theorem List.cons_beq_cons [BEq α] {a b : α} {l₁ l₂ : List α} :
-    (a :: l₁ == b :: l₂) = (a == b && l₁ == l₂) := rfl
-```
-
-belongs in the `List` namespace.
-
-Subtleties arise when multiple namespaces are in play. Generally, place your theorem in the most specific namespace that appears in one of the hypotheses of the theorem. The following names are both correct according to this convention:
-
-```lean
-theorem List.Sublist.reverse : l₁ <+ l₂ → l₁.reverse <+ l₂.reverse := sorry
-theorem List.reverse_sublist : l₁.reverse <+ l₂.reverse ↔ l₁ <+ l₂ := sorry
-```
-
-Notice that the second theorem does not have a hypothesis of type `List.Sublist l` for some `l`, so the name `List.Sublist.reverse_iff` would be incorrect.
-
-The advantage of placing results in a namespace like `List.Sublist` is that it enables generalized projection notation, i.e., given `h : l₁ <+ l₂`,
-one can write `h.reverse` to obtain a proof of `l₁.reverse <+ l₂.reverse`. Thinking about which dot notations are convenient can act as a guideline
-for deciding where to place a theorem, and is, on occasion, a good reason to duplicate a theorem into multiple namespaces.
-
-### The `Std` namespace
-
-New types that are added will usually be placed in the `Std` namespace and in the `Std/` source directory, unless there are good reasons to place
-them elsewhere.
-
-Inside the `Std` namespace, all internal declarations should be `private` or else have a name component that clearly marks them as internal, preferably
-`Internal`.
-
-
-## Naming convention for data
-
-When defining data, i.e., a (possibly 0-ary) function whose codomain is not Sort u, but has type Type u for some u, it should be named in lowerCamelCase. Examples include `List.append` and `List.isPrefixOf`.
-If your data is morally fully specified by its type, then use the naming procedure for theorems described below and convert the result to lower camel case.
-
-If your function returns an `Option`, consider adding `?` as a suffix. If your function may panic, consider adding `!` as a suffix. In many cases, there will be multiple variants of a function; one returning an option, one that may panic and possibly one that takes a proof argument.
-
-## Naming algorithm for theorems and some definitions
-
-There is, in principle, a general algorithm for naming a theorem. The problem with this algorithm is that it produces very long and unwieldy names which need to be shortened. So choosing a name for a declaration can be thought of as consisting of a mechanical part and a creative part.
-
-Usually the first part is to decide which namespace the result should live in, according to the guidelines described above.
-
-Next, consider the type of your declaration as a tree. Inner nodes of this tree are function types or function applications. Leaves of the tree are 0-ary functions or bound variables.
-
-As an example, consider the following result from the standard library:
-
-```lean
-example {α : Type u} {β : Type v} [BEq α] [Hashable α] [EquivBEq α] [LawfulHashable α]
-    [Inhabited β] {m : Std.HashMap α β} {a : α} {h' : a ∈ m} : m[a]? = some (m[a]'h') :=
-  sorry
-```
-
-The correct namespace is clearly `Std.HashMap`. The corresponding tree looks like this:
-
-![](naming-tree.svg)
-
-The preferred spelling of a notation can be looked up by hovering over the notation.
-
-Now traverse the tree and build a name according to the following rules:
-
-* When encountering a function type, first turn the result type into a name, then all of the argument types from left to right, and join the names using `_of_`.
-* When encountering a function that is neither an infix notation nor a structure projection, first put the function name and then the arguments, joined by an underscore.
-* When encountering an infix notation, join the arguments using the name of the notation, separated by underscores.
-* When encountering a structure projection, proceed as for normal functions, but put the name of the projection last.
-* When encountering a name, put it in lower camel case.
-* Skip bound variables and proofs.
-* Type class arguments are also generally skipped.
-
-When encountering namespaces names, concatenate them in lower camel case.
-
-Applying this algorithm to our example yields the name `Std.HashMap.getElem?_eq_optionSome_getElem_of_mem`.
-
-From there, the name should be shortened, using the following heuristics:
-
-* The namespace of functions can be omitted if it is clear from context or if the namespace is the current one. This is almost always the case.
-* For infix operators, it is possible to leave out the RHS or the name of the notation and the RHS if they are clear from context.
-* Hypotheses can be left out if it is clear that they are required or if they appear in the conclusion.
-
-Based on this, here are some possible names for our example:
-
-1. `Std.HashMap.getElem?_eq`
-2. `Std.HashMap.getElem?_eq_of_mem`
-3. `Std.HashMap.getElem?_eq_some`
-4. `Std.HashMap.getElem?_eq_some_of_mem`
-5. `Std.HashMap.getElem?_eq_some_getElem`
-6. `Std.Hashmap.getElem?_eq_some_getElem_of_mem`
-
-Choosing a good name among these then requires considering the context of the lemma. In this case it turns out that the first four options are underspecified as there is also a lemma relating `m[a]?` and `m[a]!` which could have the same name. This leaves the last two options, the first of which is shorter, and this is how the lemma is called in the Lean standard library.
-
-Here are some additional examples:
-
-```lean
-example {x y : List α} (h : x <+: y) (hx : x ≠ []) :
-  x.head hx = y.head (h.ne_nil hx) := sorry
-```
-
-Since we have an `IsPrefix` parameter, this should live in the `List.IsPrefix` namespace, and the algorithm suggests `List.IsPrefix.head_eq_head_of_ne_nil`, which is shortened to `List.IsPrefix.head`. Note here the difference between the namespace name (`IsPrefix`) and the recommended spelling of the corresponding notation (`prefix`).
-
-```lean
-example : l₁ <+: l₂ → reverse l₁ <:+ reverse l₂ := sorry
-```
-
-Again, this result should be in the `List.IsPrefix` namespace; the algorithm suggests `List.IsPrefix.reverse_prefix_reverse`, which becomes `List.IsPrefix.reverse`.
-
-The following examples show how the traversal order often matters.
-
-```lean
-theorem Nat.mul_zero (n : Nat) : n * 0 = 0 := sorry
-theorem Nat.zero_mul (n : Nat) : 0 * n = 0 := sorry
-```
-
-Here we see that one name may be a prefix of another name:
-
-```lean
-theorem Int.mul_ne_zero {a b : Int} (a0 : a ≠ 0) (b0 : b ≠ 0) : a * b ≠ 0 := sorry
-theorem Int.mul_ne_zero_iff {a b : Int} : a * b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0 := sorry
-```
-
-It is usually a good idea to include the `iff` in a theorem name even if the name would still be unique without the name. For example,
-
-```lean
-theorem List.head?_eq_none_iff : l.head? = none ↔ l = [] := sorry
-```
-
-is a good name: if the lemma was simply called `List.head?_eq_none`, users might try to `apply` it when the goal is `l.head? = none`, leading
-to confusion.
-
-The more common you expect (or want) a theorem to be, the shorter you should try to make the name. For example, we have both
-
-```lean
-theorem Std.HashMap.getElem?_eq_none_of_contains_eq_false {a : α} : m.contains a = false → m[a]? = none := sorry
-theorem Std.HashMap.getElem?_eq_none {a : α} : ¬a ∈ m → m[a]? = none := sorry
-```
-
-As users of the hash map are encouraged to use ∈ rather than contains, the second lemma gets the shorter name.
-
-## Special cases
-
-There are certain special “keywords” that may appear in identifiers.
-
-| Keyword | Meaning | Example |
-| :---- | :---- | :---- |
-| `def` | Unfold a definition. Avoid this for public APIs. | `Nat.max_def` |
-| `refl` | Theorems of the form `a R a`, where R is a reflexive relation and `a` is an explicit parameter | `Nat.le_refl` |
-| `rfl` | Like `refl`, but with `a` implicit | `Nat.le_rfl` |
-| `irrefl` | Theorems of the form `¬a R a`, where R is an irreflexive relation | `Nat.lt_irrefl` |
-| `symm` | Theorems of the form `a R b → b R a`, where R is a symmetric relation (compare `comm` below) | `Eq.symm` |
-| `trans` | Theorems of the form `a R b → b R c → a R c`, where R is a transitive relation (R may carry data) | `Eq.trans` |
-| `antisymmm` | Theorems of the form `a R b → b R a → a = b`, where R is an antisymmetric relation | `Nat.le_antisymm` |
-| `congr` | Theorems of the form `a R b → f a S f b`, where R and S are usually equivalence relations | `Std.HashMap.mem_congr` |
-| `comm` | Theorems of the form `f a b = f b a` (compare `symm` above) | `Eq.comm`, `Nat.add_comm` |
-| `assoc` | Theorems of the form `g (f a b) c = f a (g b c)` (note the order! In most cases, we have f = g) | `Nat.add_sub_assoc` |
-| `distrib` | Theorems of the form `f (g a b) = g (f a) (f b)` | `Nat.add_left_distrib` |
-| `self` | May be used if a variable appears multiple times in the conclusion | `List.mem_cons_self` |
-| `inj` | Theorems of the form `f a = f b ↔ a = b`. | `Int.neg_inj`, `Nat.add_left_inj` |
-| `cancel` | Theorems which have one of the forms `f a = f b → a = b` or `g (f a) = a`, where `f` and `g` usually involve a binary operator | `Nat.add_sub_cancel` |
-| `cancel_iff` | Same as `inj`, but with different conventions for left and right (see below) | `Nat.add_right_cancel_iff` |
-| `ext` | Theorems of the form `f a = f b → a = b`, where `f` usually involves some kind of projection | `List.ext_getElem`
-| `mono` | Theorems of the form `a R b → f a R f b`, where `R` is a transitive relation | `List.countP_mono_left`
-
-### Left and right
-
-The keywords left and right are useful to disambiguate symmetric variants of theorems.
-
-```lean
-theorem imp_congr_left (h : a ↔ b) : (a → c) ↔ (b → c) := sorry
-theorem imp_congr_right (h : a → (b ↔ c)) : (a → b) ↔ (a → c) := sorry
-```
-
-It is not always obvious which version of a theorem should be “left” and which should be “right”.
-Heuristically, the theorem should name the side which is “more variable”, but there are exceptions. For some of the special keywords discussed in this section, there are conventions which should be followed, as laid out in the following examples:
-
-```lean
-theorem Nat.left_distrib (n m k : Nat) : n * (m + k) = n * m + n * k := sorry
-theorem Nat.right_distrib (n m k : Nat) : (n + m) * k = n * k + m * k := sorry
-theorem Nat.add_left_cancel {n m k : Nat} : n + m = n + k → m = k := sorry
-theorem Nat.add_right_cancel {n m k : Nat} : n + m = k + m → n = k := sorry
-theorem Nat.add_left_cancel_iff {m k n : Nat} : n + m = n + k ↔ m = k := sorry
-theorem Nat.add_right_cancel_iff {m k n : Nat} : m + n = k + n ↔ m = k := sorry
-theorem Nat.add_left_inj {m k n : Nat} : m + n = k + n ↔ m = k := sorry
-theorem Nat.add_right_inj {m k n : Nat} : n + m = n + k ↔ m = k := sorry
-```
-
-Note in particular that the convention is opposite for `cancel_iff` and `inj`.
-
-```lean
-theorem Nat.add_sub_self_left (a b : Nat) : (a + b) - a = b := sorry
-theorem Nat.add_sub_self_right (a b : Nat) : (a + b) - b = a := sorry
-theorem Nat.add_sub_cancel (n m : Nat) : (n + m) - m = n := sorry
-```
-
-## Primed names
-
-Avoid disambiguating variants of a concept by appending the `'` character (e.g., introducing both `BitVec.sshiftRight` and `BitVec.sshiftRight'`), as it is impossible to tell the difference without looking at the type signature, the documentation or even the code, and even if you know what the two variants are there is no way to tell which is which. Prefer descriptive pairs `BitVec.sshiftRightNat`/`BitVec.sshiftRight`.
-
-## Acronyms
-
-For acronyms which are three letters or shorter, all letters should use the same case as dictated by the convention. For example, `IO` is a correct name for a type and the name `IO.Ref` may become `IORef` when used as part of a definition name and `ioRef` when used as part of a theorem name.
-
-For acronyms which are at least four letters long, switch to lower case starting from the second letter. For example, `Json` is a correct name for a type, as is `JsonRPC`.
-
-If an acronym is typically spelled using mixed case, this mixed spelling may be used in identifiers (for example `Std.Net.IPv4Addr`).
-
-## Simp sets
-
-Simp sets centered around a conversion function should be called `source_to_target`. For example, a simp set for the `BitVec.toNat` function, which goes from `BitVec` to
-`Nat`, should be called `bitvec_to_nat`.
-
-## Variable names
-
-We make the following recommendations for variable names, but without insisting on them:
-* Simple hypotheses should be named `h`, `h'`, or using a numerical sequence `h₁`, `h₂`, etc.
-* Another common name for a simple hypothesis is `w` (for "witness").
-* `List`s should be named `l`, `l'`, `l₁`, etc, or `as`, `bs`, etc.
-  (Use of `as`, `bs` is encouraged when the lists are of different types, e.g. `as : List α` and `bs : List β`.)
-  `xs`, `ys`, `zs` are allowed, but it is better if these are reserved for `Array` and `Vector`.
-  A list of lists may be named `L`.
-* `Array`s should be named `xs`, `ys`, `zs`, although `as`, `bs` are encouraged when the arrays are of different types, e.g. `as : Array α` and `bs : Array β`.
-  An array of arrays may be named `xss`.
-* `Vector`s should be named `xs`, `ys`, `zs`, although `as`, `bs` are encouraged when the vectors are of different types, e.g. `as : Vector α n` and `bs : Vector β n`.
-  A vector of vectors may be named `xss`.
-* A common exception for `List` / `Array` / `Vector` is to use `acc` for an accumulator in a recursive function.
-* `i`, `j`, `k` are preferred for numerical indices.
-  Descriptive names such as `start`, `stop`, `lo`, and `hi` are encouraged when they increase readability.
-* `n`, `m` are preferred for sizes, e.g. in `Vector α n` or `xs.size = n`.
-* `w` is preferred for the width of a `BitVec`.

doc/std/style.md

@@ -1,522 +0,0 @@
-# Standard library style
-
-Please take some time to familiarize yourself with the stylistic conventions of
-the project and the specific part of the library you are planning to contribute
-to. While the Lean compiler may not enforce strict formatting rules,
-consistently formatted code is much easier for others to read and maintain.
-Attention to formatting is more than a cosmetic concern—it reflects the same
-level of precision and care required to meet the deeper standards of the Lean 4
-standard library.
-
-Below we will give specific formatting prescriptions for various language constructs. Note that this style guide only applies to the Lean standard library, even though some examples in the guide are taken from other parts of the Lean code base.
-
-## Basic whitespace rules
-
-Syntactic elements (like `:`, `:=`, `|`, `::`) are surrounded by single spaces, with the exception of `,` and `;`, which are followed by a space but not preceded by one. Delimiters (like `()`, `{}`) do not have spaces on the inside, with the exceptions of subtype notation and structure instance notation.
-
-Examples of correctly formatted function parameters:
-
-* `{α : Type u}`
-* `[BEq α]`
-* `(cmp : α → α → Ordering)`
-* `(hab : a = b)`
-* `{d : { l : List ((n : Nat) × Vector Nat n) // l.length % 2 = 0 }}`
-
-Examples of correctly formatted terms:
-
-* `1 :: [2, 3]`
-* `letI : Ord α := ⟨cmp⟩; True`
-* `(⟨2, 3⟩ : Nat × Nat)`
-* `((2, 3) : Nat × Nat)`
-* `{ x with fst := f (4 + f 0), snd := 4, .. }`
-* `match 1 with | 0 => 0 | _ => 0`
-* `fun ⟨a, b⟩ _ _ => by cases hab <;> apply id; rw [hbc]`
-
-Configure your editor to remove trailing whitespace. If you have set up Visual Studio Code for Lean development in the recommended way then the correct setting is applied automatically.
-
-## Splitting terms across multiple lines
-
-When splitting a term across multiple lines, increase indentation by two spaces starting from the second line. When splitting a function application, try to split at argument boundaries. If an argument itself needs to be split, increase indentation further as appropriate.
-
-When splitting at an infix operator, the operator goes at the end of the first line, not at the beginning of the second line. When splitting at an infix operator, you may or may not increase indentation depth, depending on what is more readable.
-
-When splitting an `if`-`then`-`else` expression, the `then` keyword wants to stay with the condition and the `else` keyword wants to stay with the alternative term. Otherwise, indent as if the `if` and `else` keywords were arguments to the same function.
-
-When splitting a comma-separated bracketed sequence (i.e., anonymous constructor application, list/array/vector literal, tuple) it is allowed to indent subsequent lines for alignment, but indenting by two spaces is also allowed.
-
-Do not orphan parentheses.
-
-Correct:
-```lean
-def MacroScopesView.isPrefixOf (v₁ v₂ : MacroScopesView) : Bool :=
-  v₁.name.isPrefixOf v₂.name &&
-  v₁.scopes == v₂.scopes &&
-  v₁.mainModule == v₂.mainModule &&
-  v₁.imported == v₂.imported
-```
-
-Correct:
-```lean
-theorem eraseP_eq_iff {p} {l : List α} :
-    l.eraseP p = l' ↔
-      ((∀ a ∈ l, ¬ p a) ∧ l = l') ∨
-        ∃ a l₁ l₂, (∀ b ∈ l₁, ¬ p b) ∧ p a ∧
-          l = l₁ ++ a :: l₂ ∧ l' = l₁ ++ l₂ :=
-  sorry
-```
-
-Correct:
-```lean
-example : Nat :=
-  functionWithAVeryLongNameSoThatSomeArgumentsWillNotFit firstArgument secondArgument
-    (firstArgumentWithAnEquallyLongNameAndThatFunctionDoesHaveMoreArguments firstArgument
-      secondArgument)
-    secondArgument
-```
-
-Correct:
-```lean
-theorem size_alter [LawfulBEq α] {k : α} {f : Option (β k) → Option (β k)} (h : m.WF) :
-    (m.alter k f).size =
-      if m.contains k && (f (m.get? k)).isNone then
-        m.size - 1
-      else if !m.contains k && (f (m.get? k)).isSome then
-        m.size + 1
-      else
-        m.size := by
- simp_to_raw using Raw₀.size_alter
-```
-
-Correct:
-```lean
-theorem get?_alter [LawfulBEq α] {k k' : α} {f : Option (β k) → Option (β k)} (h : m.WF) :
-    (m.alter k f).get? k' =
-      if h : k == k' then
-        cast (congrArg (Option ∘ β) (eq_of_beq h)) (f (m.get? k))
-      else m.get? k' := by
- simp_to_raw using Raw₀.get?_alter
-```
-
-Correct:
-```lean
-example : Nat × Nat :=
-  ⟨imagineThisWasALongTerm,
-   imagineThisWasAnotherLongTerm⟩
-```
-
-Correct:
-```lean
-example : Nat × Nat :=
-  ⟨imagineThisWasALongTerm,
-    imagineThisWasAnotherLongTerm⟩
-```
-
-Correct:
-```lean
-example : Vector Nat :=
-  #v[imagineThisWasALongTerm,
-     imagineThisWasAnotherLongTerm]
-```
-
-## Basic file structure
-
-Every file should start with a copyright header, imports (in the standard library, this always includes a `prelude` declaration) and a module documentation string. There should not be a blank line between the copyright header and the imports. There should be a blank line between the imports and the module documentation string.
-
-If you explicitly declare universe variables, do so at the top of the file, after the module documentation.
-
-Correct:
-```lean
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro,
-  Yury Kudryashov
--/
-prelude
-import Init.Data.List.Pairwise
-import Init.Data.List.Find
-
-/-!
-**# Lemmas about `List.eraseP` and `List.erase`.**
--/
-
-universe u u'
-```
-
-Syntax that is not supposed to be user-facing must be scoped. New public syntax must always be discussed explicitly in an RFC.
-
-## Top-level commands and declarations
-
-All top-level commands are unindented. Sectioning commands like `section` and `namespace` do not increase the indentation level.
-
-Attributes may be placed on the same line as the rest of the command or on a separate line.
-
-Multi-line declaration headers are indented by four spaces starting from the second line. The colon that indicates the type of a declaration may not be placed at the start of a line or on its own line.
-
-Declaration bodies are indented by two spaces. Short declaration bodies may be placed on the same line as the declaration type.
-
-Correct:
-```lean
-theorem eraseP_eq_iff {p} {l : List α} :
-    l.eraseP p = l' ↔
-      ((∀ a ∈ l, ¬ p a) ∧ l = l') ∨
-        ∃ a l₁ l₂, (∀ b ∈ l₁, ¬ p b) ∧ p a ∧
-          l = l₁ ++ a :: l₂ ∧ l' = l₁ ++ l₂ :=
-  sorry
-```
-
-Correct:
-```lean
-@[simp] theorem eraseP_nil : [].eraseP p = [] := rfl
-```
-
-Correct:
-```lean
-@[simp]
-theorem eraseP_nil : [].eraseP p = [] := rfl
-```
-
-### Documentation comments
-
-Note to external contributors: this is a section where the Lean style and the mathlib style are different.
-
-Declarations should be documented as required by the `docBlame` linter, which may be activated in a file using
-`set_option linter.missingDocs true` (we allow these to stay in the file).
-
-Single-line documentation comments should go on the same line as `/--`/`-/`, while multi-line documentation strings
-should have these delimiters on their own line, with the documentation comment itself unindented.
-
-Documentation comments must be written in the indicative mood. Use American orthography.
-
-Correct:
-```lean
-/-- Carries out a monadic action on each mapping in the hash map in some order. -/
-@[inline] def forM (f : (a : α) → β a → m PUnit) (b : Raw α β) : m PUnit :=
-  b.buckets.forM (AssocList.forM f)
-```
-
-Correct:
-```lean
-/--
-Monadically computes a value by folding the given function over the mappings in the hash
-map in some order.
--/
-@[inline] def foldM (f : δ → (a : α) → β a → m δ) (init : δ) (b : Raw α β) : m δ :=
-  b.buckets.foldlM (fun acc l => l.foldlM f acc) init
-```
-
-### Where clauses
-
-The `where` keyword should be unindented, and all declarations bound by it should be indented with two spaces.
-
-Blank lines before and after `where` and between declarations bound by `where` are optional and should be chosen
-to maximize readability.
-
-Correct:
-```lean
-@[simp] theorem partition_eq_filter_filter (p : α → Bool) (l : List α) :
-    partition p l = (filter p l, filter (not ∘ p) l) := by
-  simp [partition, aux]
-where
-  aux (l) {as bs} : partition.loop p l (as, bs) =
-      (as.reverse ++ filter p l, bs.reverse ++ filter (not ∘ p) l) :=
-    match l with
-    | [] => by simp [partition.loop, filter]
-    | a :: l => by cases pa : p a <;> simp [partition.loop, pa, aux, filter, append_assoc]
-```
-
-### Termination arguments
-
-The `termination_by`, `decreasing_by`, `partial_fixpoint` keywords should be unindented. The associated terms should be indented like declaration bodies.
-
-Correct:
-```lean
-@[inline] def multiShortOption (handle : Char → m PUnit) (opt : String) : m PUnit := do
-  let rec loop (p : String.Pos) := do
-    if h : opt.atEnd p then
-      return
-    else
-      handle (opt.get' p h)
-      loop (opt.next' p h)
-  termination_by opt.utf8ByteSize - p.byteIdx
-  decreasing_by
-    simp [String.atEnd] at h
-    apply Nat.sub_lt_sub_left h
-    simp [String.lt_next opt p]
-  loop ⟨1⟩
-```
-
-Correct:
-```lean
-def substrEq (s1 : String) (off1 : String.Pos) (s2 : String) (off2 : String.Pos) (sz : Nat) : Bool :=
-  off1.byteIdx + sz ≤ s1.endPos.byteIdx && off2.byteIdx + sz ≤ s2.endPos.byteIdx && loop off1 off2 { byteIdx := off1.byteIdx + sz }
-where
-  loop (off1 off2 stop1 : Pos) :=
-    if _h : off1.byteIdx < stop1.byteIdx then
-      let c₁ := s1.get off1
-      let c₂ := s2.get off2
-      c₁ == c₂ && loop (off1 + c₁) (off2 + c₂) stop1
-    else true
-  termination_by stop1.1 - off1.1
-  decreasing_by
-    have := Nat.sub_lt_sub_left _h (Nat.add_lt_add_left c₁.utf8Size_pos off1.1)
-    decreasing_tactic
-```
-
-Correct:
-```lean
-theorem div_add_mod (m n : Nat) : n * (m / n) + m % n = m := by
-  rw [div_eq, mod_eq]
-  have h : Decidable (0 < n ∧ n ≤ m) := inferInstance
-  cases h with
-  | isFalse h => simp [h]
-  | isTrue h =>
-    simp [h]
-    have ih := div_add_mod (m - n) n
-    rw [Nat.left_distrib, Nat.mul_one, Nat.add_assoc, Nat.add_left_comm, ih, Nat.add_comm, Nat.sub_add_cancel h.2]
-decreasing_by apply div_rec_lemma; assumption
-```
-
-### Deriving
-
-The `deriving` clause should be unindented.
-
-Correct:
-```lean
-structure Iterator where
-  array : ByteArray
-  idx : Nat
-deriving Inhabited
-```
-
-## Notation and Unicode
-
-We generally prefer to use notation as available. We usually prefer the Unicode versions of notations over non-Unicode alternatives.
-
-There are some rules and exceptions regarding specific notations which are listed below:
-
-* Sigma types: use `(a : α) × β a` instead of `Σ a, β a` or `Sigma β`.
-* Function arrows: use `fun a => f x` instead of `fun x ↦ f x` or `λ x => f x` or any other variant.
-
-## Language constructs
-
-### Pattern matching, induction etc.
-
-Match arms are indented at the indentation level that the match statement would have if it was on its own line. If the match is implicit, then the arms should be indented as if the match was explicitly given. The content of match arms is indented two spaces, so that it appears on the same level as the match pattern.
-
-Correct:
-```lean
-def alter [BEq α] {β : Type v} (a : α) (f : Option β → Option β) :
-    AssocList α (fun _ => β) → AssocList α (fun _ => β)
-  | nil => match f none with
-    | none => nil
-    | some b => AssocList.cons a b nil
-  | cons k v l =>
-    if k == a then
-      match f v with
-      | none => l
-      | some b => cons a b l
-    else
-      cons k v (alter a f l)
-```
-
-Correct:
-```lean
-theorem eq_append_cons_of_mem {a : α} {xs : List α} (h : a ∈ xs) :
-    ∃ as bs, xs = as ++ a :: bs ∧ a ∉ as := by
-  induction xs with
-  | nil => cases h
-  | cons x xs ih =>
-    simp at h
-    cases h with
-    | inl h => exact ⟨[], xs, by simp_all⟩
-    | inr h =>
-      by_cases h' : a = x
-      · subst h'
-        exact ⟨[], xs, by simp⟩
-      · obtain ⟨as, bs, rfl, h⟩ := ih h
-        exact ⟨x :: as, bs, rfl, by simp_all⟩
-```
-
-Aligning match arms is allowed, but not required.
-
-Correct:
-```lean
-def mkEqTrans? (h₁? h₂? : Option Expr) : MetaM (Option Expr) :=
-  match h₁?, h₂? with
-  | none, none       => return none
-  | none, some h     => return h
-  | some h, none     => return h
-  | some h₁, some h₂ => mkEqTrans h₁ h₂
-```
-
-Correct:
-```lean
-def mkEqTrans? (h₁? h₂? : Option Expr) : MetaM (Option Expr) :=
-  match h₁?, h₂? with
-  | none, none => return none
-  | none, some h => return h
-  | some h, none => return h
-  | some h₁, some h₂ => mkEqTrans h₁ h₂
-```
-
-Correct:
-```lean
-def mkEqTrans? (h₁? h₂? : Option Expr) : MetaM (Option Expr) :=
-  match h₁?, h₂? with
-  | none,    none    => return none
-  | none,    some h  => return h
-  | some h,  none    => return h
-  | some h₁, some h₂ => mkEqTrans h₁ h₂
-```
-
-### Structures
-
-Note to external contributors: this is a section where the Lean style and the mathlib style are different.
-
-When using structure instance syntax over multiple lines, the opening brace should go on the preceding line, while the closing brace should go on its own line. The rest of the syntax should be indented by one level. During structure updates, the `with` clause goes on the same line as the opening brace. Aligning at the assignment symbol is allowed but not required.
-
-Correct:
-```lean
-def addConstAsync (env : Environment) (constName : Name) (kind : ConstantKind) (reportExts := true) :
-    IO AddConstAsyncResult := do
-  let sigPromise ← IO.Promise.new
-  let infoPromise ← IO.Promise.new
-  let extensionsPromise ← IO.Promise.new
-  let checkedEnvPromise ← IO.Promise.new
-  let asyncConst := {
-    constInfo := {
-      name := constName
-      kind
-      sig := sigPromise.result
-      constInfo := infoPromise.result
-    }
-    exts? := guard reportExts *> some extensionsPromise.result
-  }
-  return {
-    constName, kind
-    mainEnv := { env with
-      asyncConsts := env.asyncConsts.add asyncConst
-      checked := checkedEnvPromise.result }
-    asyncEnv := { env with
-      asyncCtx? := some { declPrefix := privateToUserName constName.eraseMacroScopes }
-    }
-    sigPromise, infoPromise, extensionsPromise, checkedEnvPromise
-  }
-```
-
-Correct:
-```lean
-instance [Inhabited α] : Inhabited (Descr α β σ) where
-  default := {
-    name         := default
-    mkInitial    := default
-    ofOLeanEntry := default
-    toOLeanEntry := default
-    addEntry     := fun s _ => s
-  }
-```
-
-### Declaring structures
-
-When defining structure types, do not parenthesize structure fields.
-
-When declaring a structure type with a custom constructor name, put the custom name on its own line, indented like the
-structure fields, and add a documentation comment.
-
-Correct:
-
-```lean
-/--
-A bitvector of the specified width.
-
-This is represented as the underlying `Nat` number in both the runtime
-and the kernel, inheriting all the special support for `Nat`.
--/
-structure BitVec (w : Nat) where
-  /--
-  Constructs a `BitVec w` from a number less than `2^w`.
-  O(1), because we use `Fin` as the internal representation of a bitvector.
-  -/
-  ofFin ::
-  /--
-  Interprets a bitvector as a number less than `2^w`.
-  O(1), because we use `Fin` as the internal representation of a bitvector.
-  -/
-  toFin : Fin (2 ^ w)
-```
-
-## Tactic proofs
-
-Tactic proofs are the most common thing to break during any kind of upgrade, so it is important to write them in a way that minimizes the likelihood of proofs breaking and that makes it easy to debug breakages if they do occur.
-
-If there are multiple goals, either use a tactic combinator (like `all_goals`) to operate on all of them or a clearly specified subset, or use focus dots to work on goals one at a time. Using structured proofs (e.g., `induction … with`) is encouraged but not mandatory.
-
-Squeeze non-terminal `simp`s (i.e., calls to `simp` which do not close the goal). Squeezing terminal `simp`s is generally discouraged, although there are exceptions (for example if squeezing yields a noticeable performance improvement).
-
-Do not over-golf proofs in ways that are likely to lead to hard-to-debug breakage. Examples of things to avoid include complex multi-goal manipulation using lots of tactic combinators, complex uses of the substitution operator (`▸`) and clever point-free expressions (possibly involving anonymous function notation for multiple arguments).
-
-Do not under-golf proofs: for routine tasks, use the most powerful tactics available.
-
-Do not use `erw`. Avoid using `rfl` after `simp` or `rw`, as this usually indicates a missing lemma that should be used instead of `rfl`.
-
-Use `(d)simp` or `rw` instead of `delta` or `unfold`. Use `refine` instead of `refine’`. Use `haveI` and `letI` only if they are actually required.
-
-Prefer highly automated tactics (like `grind` and `omega`) over low-level proofs, unless the automated tactic requires unacceptable additional imports or has bad performance. If you decide against using a highly automated tactic, leave a comment explaining the decision.
-
-## `do` notation
-
-The `do` keyword goes on the same line as the corresponding `:=` (or `=>`, or similar). `Id.run do` should be treated as if it was a bare `do`.
-
-Use early `return` statements to reduce nesting depth and make the non-exceptional control flow of a function easier to see.
-
-Alternatives for `let` matches may be placed in the same line or in the next line, indented by two spaces. If the term that is
-being matched on is itself more than one line and there is an alternative present, consider breaking immediately after `←` and indent
-as far as necessary to ensure readability.
-
-Correct:
-```lean
-def getFunDecl (fvarId : FVarId) : CompilerM FunDecl := do
-  let some decl ← findFunDecl? fvarId | throwError "unknown local function {fvarId.name}"
-  return decl
-```
-
-Correct:
-```lean
-def getFunDecl (fvarId : FVarId) : CompilerM FunDecl := do
-  let some decl ←
-        findFunDecl? fvarId
-    | throwError "unknown local function {fvarId.name}"
-  return decl
-```
-
-Correct:
-```lean
-def getFunDecl (fvarId : FVarId) : CompilerM FunDecl := do
-  let some decl ← findFunDecl?
-      fvarId
-    | throwError "unknown local function {fvarId.name}"
-  return decl
-```
-
-Correct:
-```lean
-def tagUntaggedGoals (parentTag : Name) (newSuffix : Name) (newGoals : List MVarId) : TacticM Unit := do
-  let mctx ← getMCtx
-  let mut numAnonymous := 0
-  for g in newGoals do
-    if mctx.isAnonymousMVar g then
-      numAnonymous := numAnonymous + 1
-  modifyMCtx fun mctx => Id.run do
-    let mut mctx := mctx
-    let mut idx  := 1
-    for g in newGoals do
-      if mctx.isAnonymousMVar g then
-        if numAnonymous == 1 then
-          mctx := mctx.setMVarUserName g parentTag
-        else
-          mctx := mctx.setMVarUserName g (parentTag ++ newSuffix.appendIndexAfter idx)
-        idx := idx + 1
-    pure mctx
-```
-

doc/std/vision.md

@@ -1,98 +0,0 @@
-# The Lean 4 standard library
-
-Maintainer team (in alphabetical order): Henrik Böving, Markus Himmel
-(community contact & external contribution coordinator), Kim Morrison, Paul
-Reichert, Sofia Rodrigues.
-
-The Lean 4 standard library is a core part of the Lean distribution, providing
-essential building blocks for functional programming, verified software
-development, and software verification. Unlike the standard libraries of most
-other languages, many of its components are formally verified and can be used
-as part of verified applications.
-
-The standard library is a public API that contains the components listed in the
-standard library outline below. Not all public APIs in the Lean distribution
-are part of the standard library, and the standard library does not correspond
-to a certain directory within the Lean source repository (like `Std`). For
-example, the metaprogramming framework is not part of the standard library, but
-basic types like `True` and `Nat` are.
-
-The standard library is under active development. Our guiding principles are:
-
-* Provide comprehensive, verified building blocks for real-world software.
-* Build a public API of the highest quality with excellent internal consistency.
-* Carefully optimize components that may be used in performance-critical software.
-* Ensure smooth adoption and maintenance for users.
-* Offer excellent documentation, example projects, and guides.
-* Provide a reliable and extensible basis that libraries for software
-  development, software verification and mathematics can build on.
-
-The standard library is principally developed by the Lean FRO. Community
-contributions are welcome. If you would like to contribute, please refer to the
-call for contributions below.
-
-### Standard library outline
-
-1. Core types and operations
-   1. Basic types
-   2. Numeric types, including floating point numbers
-   3. Containers
-   4. Strings and formatting
-2. Language constructs
-   1. Ranges and iterators
-   2. Comparison, ordering, hashing and related type classes
-   3. Basic monad infrastructure
-3. Libraries
-   1. Random numbers
-   2. Dates and times
-4. Operating system abstractions
-   1. Concurrency and parallelism primitives
-   2. Asynchronous I/O
-   3. FFI helpers
-   4. Environment, file system, processes
-   5. Locales
-
-The material covered in the first three sections (core types and operations,
-language constructs and libraries) will be verified, with the exception of
-floating point numbers and the parts of the libraries that interface with the
-operating system (e.g., sources of operating system randomness or time zone
-database access).
-
-### Call for contributions
-
-Thank you for taking interest in contributing to the Lean standard library\!
-There are two main ways for community members to contribute to the Lean
-standard library: by contributing experience reports or by contributing code
-and lemmas.
-
-**If you are using Lean for software verification or verified software
-development:** hearing about your experiences using Lean and its standard
-library for software verification is extremely valuable to us. We are committed
-to building a standard library suitable for real-world applications and your
-input will directly influence the continued evolution of the Lean standard
-library. Please reach out to the standard library maintainer team via Zulip
-(either in a public thread in the \#lean4 channel or via direct message). Even
-just a link to your code helps. Thanks\!
-
-**If you have code that you believe could enhance the Lean 4 standard
-library:** we encourage you to initiate a discussion in the \#lean4 channel on
-Zulip. This is the most effective way to receive preliminary feedback on your
-contribution. The Lean standard library has a very precise scope and it has
-very high quality standards, so at the moment we are mostly interested in
-contributions that expand upon existing material rather than introducing novel
-concepts.
-
-**If you would like to contribute code to the standard library but don’t know
-what to work on:** we are always excited to meet motivated community members
-who would like to contribute, and there is always impactful work that is
-suitable for new contributors. Please reach out to Markus Himmel on Zulip to
-discuss possible contributions.
-
-As laid out in the [project-wide External Contribution
-Guidelines](../../CONTRIBUTING.md),
-PRs are much more likely to be merged if they are preceded by an RFC or if you
-discussed your planned contribution with a member of the standard library
-maintainer team. When in doubt, introducing yourself is always a good idea.
-
-All code in the standard library is expected to strictly adhere to the
-[standard library coding conventions](./style.md).

src/Init/Classical.lean

@@ -107,8 +107,8 @@ noncomputable def epsilon {α : Sort u} [h : Nonempty α] (p : α → Prop) : α
 theorem epsilon_spec_aux {α : Sort u} (h : Nonempty α) (p : α → Prop) : (∃ y, p y) → p (@epsilon α h p) :=
   (strongIndefiniteDescription p h).property
 
-theorem epsilon_spec {α : Sort u} {p : α → Prop} (hex : ∃ y, p y) : p (@epsilon α hex.nonempty p) :=
-  epsilon_spec_aux hex.nonempty p hex
+theorem epsilon_spec {α : Sort u} {p : α → Prop} (hex : ∃ y, p y) : p (@epsilon α (nonempty_of_exists hex) p) :=
+  epsilon_spec_aux (nonempty_of_exists hex) p hex
 
 theorem epsilon_singleton {α : Sort u} (x : α) : @epsilon α ⟨x⟩ (fun y => y = x) = x :=
   @epsilon_spec α (fun y => y = x) ⟨x, rfl⟩

src/Init/Control/Basic.lean

@@ -49,7 +49,7 @@ abbrev forIn_eq_forin' := @forIn_eq_forIn'
 /--
 Extracts the value from a `ForInStep`, ignoring whether it is `ForInStep.done` or `ForInStep.yield`.
 -/
-@[expose] def ForInStep.value (x : ForInStep α) : α :=
+def ForInStep.value (x : ForInStep α) : α :=
   match x with
   | ForInStep.done b => b
   | ForInStep.yield b => b

src/Init/Control/Except.lean

@@ -136,7 +136,7 @@ may throw the corresponding exception.
 
 This is the inverse of `ExceptT.run`.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def ExceptT.mk {ε : Type u} {m : Type u → Type v} {α : Type u} (x : m (Except ε α)) : ExceptT ε m α := x
 
 /--
@@ -144,7 +144,7 @@ Use a monadic action that may throw an exception as an action that may return an
 
 This is the inverse of `ExceptT.mk`.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def ExceptT.run {ε : Type u} {m : Type u → Type v} {α : Type u} (x : ExceptT ε m α) : m (Except ε α) := x
 
 namespace ExceptT
@@ -154,14 +154,14 @@ variable {ε : Type u} {m : Type u → Type v} [Monad m]
 /--
 Returns the value `a` without throwing exceptions or having any other effect.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def pure {α : Type u} (a : α) : ExceptT ε m α :=
   ExceptT.mk <| pure (Except.ok a)
 
 /--
 Handles exceptions thrown by an action that can have no effects _other_ than throwing exceptions.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def bindCont {α β : Type u} (f : α → ExceptT ε m β) : Except ε α → m (Except ε β)
   | Except.ok a    => f a
   | Except.error e => pure (Except.error e)
@@ -170,14 +170,14 @@ protected def bindCont {α β : Type u} (f : α → ExceptT ε m β) : Except ε
 Sequences two actions that may throw exceptions. Typically used via `do`-notation or the `>>=`
 operator.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def bind {α β : Type u} (ma : ExceptT ε m α) (f : α → ExceptT ε m β) : ExceptT ε m β :=
   ExceptT.mk <| ma >>= ExceptT.bindCont f
 
 /--
 Transforms a successful computation's value using `f`. Typically used via the `<$>` operator.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def map {α β : Type u} (f : α → β) (x : ExceptT ε m α) : ExceptT ε m β :=
   ExceptT.mk <| x >>= fun a => match a with
     | (Except.ok a)    => pure <| Except.ok (f a)
@@ -186,7 +186,7 @@ protected def map {α β : Type u} (f : α → β) (x : ExceptT ε m α) : Excep
 /--
 Runs a computation from an underlying monad in the transformed monad with exceptions.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def lift {α : Type u} (t : m α) : ExceptT ε m α :=
   ExceptT.mk <| Except.ok <$> t
 
@@ -197,7 +197,7 @@ instance : MonadLift m (ExceptT ε m) := ⟨ExceptT.lift⟩
 /--
 Handles exceptions produced in the `ExceptT ε` transformer.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def tryCatch {α : Type u} (ma : ExceptT ε m α) (handle : ε → ExceptT ε m α) : ExceptT ε m α :=
   ExceptT.mk <| ma >>= fun res => match res with
    | Except.ok a    => pure (Except.ok a)

src/Init/Control/ExceptCps.lean

@@ -25,7 +25,7 @@ namespace ExceptCpsT
 /--
 Use a monadic action that may throw an exception as an action that may return an exception's value.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def run {ε α : Type u} [Monad m] (x : ExceptCpsT ε m α) : m (Except ε α) :=
   x _ (fun a => pure (Except.ok a)) (fun e => pure (Except.error e))
 
@@ -43,7 +43,7 @@ Returns the value of a computation, forgetting whether it was an exception or a
 
 This corresponds to early return.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def runCatch [Monad m] (x : ExceptCpsT α m α) : m α :=
   x α pure pure
 
@@ -63,7 +63,7 @@ instance : MonadExceptOf ε (ExceptCpsT ε m) where
 /--
 Run an action from the transformed monad in the exception monad.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def lift [Monad m] (x : m α) : ExceptCpsT ε m α :=
   fun _ k _ => x >>= k
 

src/Init/Control/Lawful.lean

@@ -9,4 +9,3 @@ prelude
 import Init.Control.Lawful.Basic
 import Init.Control.Lawful.Instances
 import Init.Control.Lawful.Lemmas
-import Init.Control.Lawful.MonadLift

src/Init/Control/Lawful/Basic.lean

@@ -6,7 +6,6 @@ Authors: Sebastian Ullrich, Leonardo de Moura, Mario Carneiro
 module
 
 prelude
-import Init.Ext
 import Init.SimpLemmas
 import Init.Meta
 
@@ -242,23 +241,13 @@ theorem LawfulMonad.mk' (m : Type u → Type v) [Monad m]
 
 namespace Id
 
-@[ext] theorem ext {x y : Id α} (h : x.run = y.run) : x = y := h
+@[simp] theorem map_eq (x : Id α) (f : α → β) : f <$> x = f x := rfl
+@[simp] theorem bind_eq (x : Id α) (f : α → id β) : x >>= f = f x := rfl
+@[simp] theorem pure_eq (a : α) : (pure a : Id α) = a := rfl
 
 instance : LawfulMonad Id := by
   refine LawfulMonad.mk' _ ?_ ?_ ?_ <;> intros <;> rfl
 
-@[simp] theorem run_map (x : Id α) (f : α → β) : (f <$> x).run = f x.run := rfl
-@[simp] theorem run_bind (x : Id α) (f : α → Id β) : (x >>= f).run = (f x.run).run := rfl
-@[simp] theorem run_pure (a : α) : (pure a : Id α).run = a := rfl
-@[simp] theorem run_seqRight (x y : Id α) : (x *> y).run = y.run := rfl
-@[simp] theorem run_seqLeft (x y : Id α) : (x <* y).run = x.run := rfl
-@[simp] theorem run_seq (f : Id (α → β)) (x : Id α) : (f <*> x).run = f.run x.run := rfl
-
--- These lemmas are bad as they abuse the defeq of `Id α` and `α`
-@[deprecated run_map (since := "2025-03-05")] theorem map_eq (x : Id α) (f : α → β) : f <$> x = f x := rfl
-@[deprecated run_bind (since := "2025-03-05")] theorem bind_eq (x : Id α) (f : α → id β) : x >>= f = f x := rfl
-@[deprecated run_pure (since := "2025-03-05")] theorem pure_eq (a : α) : (pure a : Id α) = a := rfl
-
 end Id
 
 /-! # Option -/

src/Init/Control/Lawful/MonadLift.lean

@@ -1,11 +0,0 @@
-/-
-Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Paul Reichert
--/
-module
-
-prelude
-import Init.Control.Lawful.MonadLift.Basic
-import Init.Control.Lawful.MonadLift.Lemmas
-import Init.Control.Lawful.MonadLift.Instances

src/Init/Control/Lawful/MonadLift/Basic.lean

@@ -1,52 +0,0 @@
-/-
-Copyright (c) 2025 Quang Dao. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Quang Dao
--/
-module
-
-prelude
-import Init.Control.Basic
-
-/-!
-# LawfulMonadLift and LawfulMonadLiftT
-
-This module provides classes asserting that `MonadLift` and `MonadLiftT` are lawful, which means
-that `monadLift` is compatible with `pure` and `bind`.
--/
-
-section MonadLift
-
-/-- The `MonadLift` typeclass only contains the lifting operation. `LawfulMonadLift` further
-  asserts that lifting commutes with `pure` and `bind`:
-```
-monadLift (pure a) = pure a
-monadLift (ma >>= f) = monadLift ma >>= monadLift ∘ f
-```
--/
-class LawfulMonadLift (m : semiOutParam (Type u → Type v)) (n : Type u → Type w)
-    [Monad m] [Monad n] [inst : MonadLift m n] : Prop where
-  /-- Lifting preserves `pure` -/
-  monadLift_pure {α : Type u} (a : α) : inst.monadLift (pure a) = pure a
-  /-- Lifting preserves `bind` -/
-  monadLift_bind {α β : Type u} (ma : m α) (f : α → m β) :
-    inst.monadLift (ma >>= f) = inst.monadLift ma >>= (fun x => inst.monadLift (f x))
-
-/-- The `MonadLiftT` typeclass only contains the transitive lifting operation.
-  `LawfulMonadLiftT` further asserts that lifting commutes with `pure` and `bind`:
-```
-monadLift (pure a) = pure a
-monadLift (ma >>= f) = monadLift ma >>= monadLift ∘ f
-```
--/
-class LawfulMonadLiftT (m : Type u → Type v) (n : Type u → Type w) [Monad m] [Monad n]
-    [inst : MonadLiftT m n] : Prop where
-  /-- Lifting preserves `pure` -/
-  monadLift_pure {α : Type u} (a : α) : inst.monadLift (pure a) = pure a
-  /-- Lifting preserves `bind` -/
-  monadLift_bind {α β : Type u} (ma : m α) (f : α → m β) :
-    inst.monadLift (ma >>= f) = monadLift ma >>= (fun x => monadLift (f x))
-
-export LawfulMonadLiftT (monadLift_pure monadLift_bind)
-
-end MonadLift

src/Init/Control/Lawful/MonadLift/Instances.lean

@@ -1,137 +0,0 @@
-/-
-Copyright (c) 2025 Quang Dao. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Quang Dao, Paul Reichert
--/
-module
-
-prelude
-import all Init.Control.Option
-import all Init.Control.Except
-import all Init.Control.ExceptCps
-import all Init.Control.StateRef
-import all Init.Control.StateCps
-import Init.Control.Lawful.MonadLift.Lemmas
-import Init.Control.Lawful.Instances
-
-universe u v w x
-
-variable {m : Type u → Type v} {n : Type u → Type w} {o : Type u → Type x}
-
-variable (m n o) in
-instance [Monad m] [Monad n] [Monad o] [MonadLift n o] [MonadLiftT m n]
-    [LawfulMonadLift n o] [LawfulMonadLiftT m n] : LawfulMonadLiftT m o where
-  monadLift_pure := fun a => by
-    simp only [monadLift, LawfulMonadLift.monadLift_pure, liftM_pure]
-  monadLift_bind := fun ma f => by
-    simp only [monadLift, LawfulMonadLift.monadLift_bind, liftM_bind]
-
-variable (m) in
-instance [Monad m] : LawfulMonadLiftT m m where
-  monadLift_pure _ := rfl
-  monadLift_bind _ _ := rfl
-
-namespace StateT
-
-variable [Monad m] [LawfulMonad m]
-
-instance {σ : Type u} : LawfulMonadLift m (StateT σ m) where
-  monadLift_pure _ := by ext; simp [MonadLift.monadLift]
-  monadLift_bind _ _ := by ext; simp [MonadLift.monadLift]
-
-end StateT
-
-namespace ReaderT
-
-variable [Monad m]
-
-instance {ρ : Type u} : LawfulMonadLift m (ReaderT ρ m) where
-  monadLift_pure _ := rfl
-  monadLift_bind _ _ := rfl
-
-end ReaderT
-
-namespace OptionT
-
-variable [Monad m] [LawfulMonad m]
-
-@[simp]
-theorem lift_pure {α : Type u} (a : α) : OptionT.lift (pure a : m α) = pure a := by
-  simp only [OptionT.lift, OptionT.mk, bind_pure_comp, map_pure, pure, OptionT.pure]
-
-@[simp]
-theorem lift_bind {α β : Type u} (ma : m α) (f : α → m β) :
-    OptionT.lift (ma >>= f) = OptionT.lift ma >>= (fun a => OptionT.lift (f a)) := by
-  simp only [instMonad, OptionT.bind, OptionT.mk, OptionT.lift, bind_pure_comp, bind_map_left,
-    map_bind]
-
-instance : LawfulMonadLift m (OptionT m) where
-  monadLift_pure := lift_pure
-  monadLift_bind := lift_bind
-
-end OptionT
-
-namespace ExceptT
-
-variable [Monad m] [LawfulMonad m]
-
-@[simp]
-theorem lift_bind {α β ε : Type u} (ma : m α) (f : α → m β) :
-    ExceptT.lift (ε := ε) (ma >>= f) = ExceptT.lift ma >>= (fun a => ExceptT.lift (f a)) := by
-  simp only [instMonad, ExceptT.bind, mk, ExceptT.lift, bind_map_left, ExceptT.bindCont, map_bind]
-
-instance : LawfulMonadLift m (ExceptT ε m) where
-  monadLift_pure := lift_pure
-  monadLift_bind := lift_bind
-
-instance : LawfulMonadLift (Except ε) (ExceptT ε m) where
-  monadLift_pure _ := by
-    simp only [MonadLift.monadLift, mk, pure, Except.pure, ExceptT.pure]
-  monadLift_bind ma _ := by
-    simp only [instMonad, ExceptT.bind, mk, MonadLift.monadLift, pure_bind, ExceptT.bindCont,
-      Except.instMonad, Except.bind]
-    rcases ma with _ | _ <;> simp
-
-end ExceptT
-
-namespace StateRefT'
-
-instance {ω σ : Type} {m : Type → Type} [Monad m] : LawfulMonadLift m (StateRefT' ω σ m) where
-  monadLift_pure _ := by
-    simp only [MonadLift.monadLift, pure]
-    unfold StateRefT'.lift ReaderT.pure
-    simp only
-  monadLift_bind _ _ := by
-    simp only [MonadLift.monadLift, bind]
-    unfold StateRefT'.lift ReaderT.bind
-    simp only
-
-end StateRefT'
-
-namespace StateCpsT
-
-instance {σ : Type u} [Monad m] [LawfulMonad m] : LawfulMonadLift m (StateCpsT σ m) where
-  monadLift_pure _ := by
-    simp only [MonadLift.monadLift, pure]
-    unfold StateCpsT.lift
-    simp only [pure_bind]
-  monadLift_bind _ _ := by
-    simp only [MonadLift.monadLift, bind]
-    unfold StateCpsT.lift
-    simp only [bind_assoc]
-
-end StateCpsT
-
-namespace ExceptCpsT
-
-instance {ε : Type u} [Monad m] [LawfulMonad m] : LawfulMonadLift m (ExceptCpsT ε m) where
-  monadLift_pure _ := by
-    simp only [MonadLift.monadLift, pure]
-    unfold ExceptCpsT.lift
-    simp only [pure_bind]
-  monadLift_bind _ _ := by
-    simp only [MonadLift.monadLift, bind]
-    unfold ExceptCpsT.lift
-    simp only [bind_assoc]
-
-end ExceptCpsT

src/Init/Control/Lawful/MonadLift/Lemmas.lean

@@ -1,63 +0,0 @@
-/-
-Copyright (c) 2025 Quang Dao. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Quang Dao
--/
-module
-
-prelude
-import Init.Control.Lawful.Basic
-import Init.Control.Lawful.MonadLift.Basic
-
-universe u v w
-
-variable {m : Type u → Type v} {n : Type u → Type w} [Monad m] [Monad n] [MonadLiftT m n]
-  [LawfulMonadLiftT m n] {α β : Type u}
-
-theorem monadLift_map [LawfulMonad m] [LawfulMonad n] (f : α → β) (ma : m α) :
-    monadLift (f <$> ma) = f <$> (monadLift ma : n α) := by
-  rw [← bind_pure_comp, ← bind_pure_comp, monadLift_bind]
-  simp only [bind_pure_comp, monadLift_pure]
-
-theorem monadLift_seq [LawfulMonad m] [LawfulMonad n] (mf : m (α → β)) (ma : m α) :
-    monadLift (mf <*> ma) = monadLift mf <*> (monadLift ma : n α) := by
-  simp only [seq_eq_bind, monadLift_map, monadLift_bind]
-
-theorem monadLift_seqLeft [LawfulMonad m] [LawfulMonad n] (x : m α) (y : m β) :
-    monadLift (x <* y) = (monadLift x : n α) <* (monadLift y : n β) := by
-  simp only [seqLeft_eq, monadLift_map, monadLift_seq]
-
-theorem monadLift_seqRight [LawfulMonad m] [LawfulMonad n] (x : m α) (y : m β) :
-    monadLift (x *> y) = (monadLift x : n α) *> (monadLift y : n β) := by
-  simp only [seqRight_eq, monadLift_map, monadLift_seq]
-
-/-! We duplicate the theorems for `monadLift` to `liftM` since `rw` matches on syntax only. -/
-
-@[simp]
-theorem liftM_pure (a : α) : liftM (pure a : m α) = pure (f := n) a :=
-  monadLift_pure _
-
-@[simp]
-theorem liftM_bind (ma : m α) (f : α → m β) :
-    liftM (n := n) (ma >>= f) = liftM ma >>= (fun a => liftM (f a)) :=
-  monadLift_bind _ _
-
-@[simp]
-theorem liftM_map [LawfulMonad m] [LawfulMonad n] (f : α → β) (ma : m α) :
-    liftM (f <$> ma) = f <$> (liftM ma : n α) :=
-  monadLift_map _ _
-
-@[simp]
-theorem liftM_seq [LawfulMonad m] [LawfulMonad n] (mf : m (α → β)) (ma : m α) :
-    liftM (mf <*> ma) = liftM mf <*> (liftM ma : n α) :=
-  monadLift_seq _ _
-
-@[simp]
-theorem liftM_seqLeft [LawfulMonad m] [LawfulMonad n] (x : m α) (y : m β) :
-    liftM (x <* y) = (liftM x : n α) <* (liftM y : n β) :=
-  monadLift_seqLeft _ _
-
-@[simp]
-theorem liftM_seqRight [LawfulMonad m] [LawfulMonad n] (x : m α) (y : m β) :
-    liftM (x *> y) = (liftM x : n α) *> (liftM y : n β) :=
-  monadLift_seqRight _ _

src/Init/Control/State.lean

@@ -29,7 +29,7 @@ of a value and a state.
 Executes an action from a monad with added state in the underlying monad `m`. Given an initial
 state, it returns a value paired with the final state.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def StateT.run {σ : Type u} {m : Type u → Type v} {α : Type u} (x : StateT σ m α) (s : σ) : m (α × σ) :=
   x s
 
@@ -37,7 +37,7 @@ def StateT.run {σ : Type u} {m : Type u → Type v} {α : Type u} (x : StateT
 Executes an action from a monad with added state in the underlying monad `m`. Given an initial
 state, it returns a value, discarding the final state.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def StateT.run' {σ : Type u} {m : Type u → Type v} [Functor m] {α : Type u} (x : StateT σ m α) (s : σ) : m α :=
   (·.1) <$> x s
 
@@ -66,21 +66,21 @@ variable [Monad m] {α β : Type u}
 /--
 Returns the given value without modifying the state. Typically used via `Pure.pure`.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def pure (a : α) : StateT σ m α :=
   fun s => pure (a, s)
 
 /--
 Sequences two actions. Typically used via the `>>=` operator.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def bind (x : StateT σ m α) (f : α → StateT σ m β) : StateT σ m β :=
   fun s => do let (a, s) ← x s; f a s
 
 /--
 Modifies the value returned by a computation. Typically used via the `<$>` operator.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def map (f : α → β) (x : StateT σ m α) : StateT σ m β :=
   fun s => do let (a, s) ← x s; pure (f a, s)
 
@@ -114,14 +114,14 @@ Retrieves the current value of the monad's mutable state.
 
 This increments the reference count of the state, which may inhibit in-place updates.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def get : StateT σ m σ :=
   fun s => pure (s, s)
 
 /--
 Replaces the mutable state with a new value.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def set : σ → StateT σ m PUnit :=
   fun s' _ => pure (⟨⟩, s')
 
@@ -133,7 +133,7 @@ It is equivalent to `do let (a, s) := f (← StateT.get); StateT.set s; pure a`.
 `StateT.modifyGet` may lead to better performance because it doesn't add a new reference to the
 state value, and additional references can inhibit in-place updates of data.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def modifyGet (f : σ → α × σ) : StateT σ m α :=
   fun s => pure (f s)
 
@@ -143,7 +143,7 @@ Runs an action from the underlying monad in the monad with state. The state is n
 This function is typically implicitly accessed via a `MonadLiftT` instance as part of [automatic
 lifting](lean-manual://section/monad-lifting).
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def lift {α : Type u} (t : m α) : StateT σ m α :=
   fun s => do let a ← t; pure (a, s)
 

src/Init/Control/StateCps.lean

@@ -28,7 +28,7 @@ variable {α σ : Type u} {m : Type u → Type v}
 Runs a stateful computation that's represented using continuation passing style by providing it with
 an initial state and a continuation.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def runK (x : StateCpsT σ m α) (s : σ) (k : α → σ → m β) : m β :=
   x _ s k
 
@@ -39,7 +39,7 @@ state, it returns a value paired with the final state.
 While the state is internally represented in continuation passing style, the resulting value is the
 same as for a non-CPS state monad.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def run [Monad m] (x : StateCpsT σ m α) (s : σ) : m (α × σ) :=
   runK x s (fun a s => pure (a, s))
 
@@ -47,7 +47,7 @@ def run [Monad m] (x : StateCpsT σ m α) (s : σ) : m (α × σ) :=
 Executes an action from a monad with added state in the underlying monad `m`. Given an initial
 state, it returns a value, discarding the final state.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def run' [Monad m] (x : StateCpsT σ m α) (s : σ) : m α :=
   runK x s (fun a _ => pure a)
 
@@ -72,7 +72,7 @@ Runs an action from the underlying monad in the monad with state. The state is n
 This function is typically implicitly accessed via a `MonadLiftT` instance as part of [automatic
 lifting](lean-manual://section/monad-lifting).
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 protected def lift [Monad m] (x : m α) : StateCpsT σ m α :=
   fun _ s k => x >>= (k . s)
 

src/Init/Core.lean

@@ -43,14 +43,14 @@ and `flip (·<·)` is the greater-than relation.
 theorem Function.comp_def {α β δ} (f : β → δ) (g : α → β) : f ∘ g = fun x => f (g x) := rfl
 
 @[simp] theorem Function.const_comp {f : α → β} {c : γ} :
-    (Function.const β c ∘ f) = Function.const α c :=
+    (Function.const β c ∘ f) = Function.const α c := by
   rfl
 @[simp] theorem Function.comp_const {f : β → γ} {b : β} :
-    (f ∘ Function.const α b) = Function.const α (f b) :=
+    (f ∘ Function.const α b) = Function.const α (f b) := by
   rfl
-@[simp] theorem Function.true_comp {f : α → β} : ((fun _ => true) ∘ f) = fun _ => true :=
+@[simp] theorem Function.true_comp {f : α → β} : ((fun _ => true) ∘ f) = fun _ => true := by
   rfl
-@[simp] theorem Function.false_comp {f : α → β} : ((fun _ => false) ∘ f) = fun _ => false :=
+@[simp] theorem Function.false_comp {f : α → β} : ((fun _ => false) ∘ f) = fun _ => false := by
   rfl
 
 @[simp] theorem Function.comp_id (f : α → β) : f ∘ id = f := rfl
@@ -95,8 +95,7 @@ structure Thunk (α : Type u) : Type u where
   -/
   mk ::
   /-- Extract the getter function out of a thunk. Use `Thunk.get` instead. -/
-  -- The field is public so as to allow computation through it.
-  fn : Unit → α
+  private fn : Unit → α
 
 attribute [extern "lean_mk_thunk"] Thunk.mk
 
@@ -118,10 +117,6 @@ Computed values are cached, so the value is not recomputed.
 @[extern "lean_thunk_get_own"] protected def Thunk.get (x : @& Thunk α) : α :=
   x.fn ()
 
--- Ensure `Thunk.fn` is still computable even if it shouldn't be accessed directly.
-@[inline] private def Thunk.fnImpl (x : Thunk α) : Unit → α := fun _ => x.get
-@[csimp] private theorem Thunk.fn_eq_fnImpl : @Thunk.fn = @Thunk.fnImpl := rfl
-
 /--
 Constructs a new thunk that forces `x` and then applies `x` to the result. Upon forcing, the result
 of `f` is cached and the reference to the thunk `x` is dropped.
@@ -902,43 +897,43 @@ section
 variable {α β φ : Sort u} {a a' : α} {b b' : β} {c : φ}
 
 /-- Non-dependent recursor for `HEq` -/
-noncomputable def HEq.ndrec.{u1, u2} {α : Sort u2} {a : α} {motive : {β : Sort u2} → β → Sort u1} (m : motive a) {β : Sort u2} {b : β} (h : a ≍ b) : motive b :=
+noncomputable def HEq.ndrec.{u1, u2} {α : Sort u2} {a : α} {motive : {β : Sort u2} → β → Sort u1} (m : motive a) {β : Sort u2} {b : β} (h : HEq a b) : motive b :=
   h.rec m
 
 /-- `HEq.ndrec` variant -/
-noncomputable def HEq.ndrecOn.{u1, u2} {α : Sort u2} {a : α} {motive : {β : Sort u2} → β → Sort u1} {β : Sort u2} {b : β} (h : a ≍ b) (m : motive a) : motive b :=
+noncomputable def HEq.ndrecOn.{u1, u2} {α : Sort u2} {a : α} {motive : {β : Sort u2} → β → Sort u1} {β : Sort u2} {b : β} (h : HEq a b) (m : motive a) : motive b :=
   h.rec m
 
 /-- `HEq.ndrec` variant -/
-noncomputable def HEq.elim {α : Sort u} {a : α} {p : α → Sort v} {b : α} (h₁ : a ≍ b) (h₂ : p a) : p b :=
+noncomputable def HEq.elim {α : Sort u} {a : α} {p : α → Sort v} {b : α} (h₁ : HEq a b) (h₂ : p a) : p b :=
   eq_of_heq h₁ ▸ h₂
 
 /-- Substitution with heterogeneous equality. -/
-theorem HEq.subst {p : (T : Sort u) → T → Prop} (h₁ : a ≍ b) (h₂ : p α a) : p β b :=
+theorem HEq.subst {p : (T : Sort u) → T → Prop} (h₁ : HEq a b) (h₂ : p α a) : p β b :=
   HEq.ndrecOn h₁ h₂
 
 /-- Heterogeneous equality is symmetric. -/
-@[symm] theorem HEq.symm (h : a ≍ b) : b ≍ a :=
+@[symm] theorem HEq.symm (h : HEq a b) : HEq b a :=
   h.rec (HEq.refl a)
 
 /-- Propositionally equal terms are also heterogeneously equal. -/
-theorem heq_of_eq (h : a = a') : a ≍ a' :=
+theorem heq_of_eq (h : a = a') : HEq a a' :=
   Eq.subst h (HEq.refl a)
 
 /-- Heterogeneous equality is transitive. -/
-theorem HEq.trans (h₁ : a ≍ b) (h₂ : b ≍ c) : a ≍ c :=
+theorem HEq.trans (h₁ : HEq a b) (h₂ : HEq b c) : HEq a c :=
   HEq.subst h₂ h₁
 
 /-- Heterogeneous equality precomposes with propositional equality. -/
-theorem heq_of_heq_of_eq (h₁ : a ≍ b) (h₂ : b = b') : a ≍ b' :=
+theorem heq_of_heq_of_eq (h₁ : HEq a b) (h₂ : b = b') : HEq a b' :=
   HEq.trans h₁ (heq_of_eq h₂)
 
 /-- Heterogeneous equality postcomposes with propositional equality. -/
-theorem heq_of_eq_of_heq (h₁ : a = a') (h₂ : a' ≍ b) : a ≍ b :=
+theorem heq_of_eq_of_heq (h₁ : a = a') (h₂ : HEq a' b) : HEq a b :=
   HEq.trans (heq_of_eq h₁) h₂
 
 /-- If two terms are heterogeneously equal then their types are propositionally equal. -/
-theorem type_eq_of_heq (h : a ≍ b) : α = β :=
+theorem type_eq_of_heq (h : HEq a b) : α = β :=
   h.rec (Eq.refl α)
 
 end
@@ -947,7 +942,7 @@ end
 Rewriting inside `φ` using `Eq.recOn` yields a term that's heterogeneously equal to the original
 term.
 -/
-theorem eqRec_heq {α : Sort u} {φ : α → Sort v} {a a' : α} : (h : a = a') → (p : φ a) → Eq.recOn (motive := fun x _ => φ x) h p ≍ p
+theorem eqRec_heq {α : Sort u} {φ : α → Sort v} {a a' : α} : (h : a = a') → (p : φ a) → HEq (Eq.recOn (motive := fun x _ => φ x) h p) p
   | rfl, p => HEq.refl p
 
 /--
@@ -955,8 +950,8 @@ Heterogeneous equality with an `Eq.rec` application on the left is equivalent to
 equality on the original term.
 -/
 theorem eqRec_heq_iff {α : Sort u} {a : α} {motive : (b : α) → a = b → Sort v}
-    {b : α} {refl : motive a (Eq.refl a)} {h : a = b} {c : motive b h}
-    : @Eq.rec α a motive refl b h ≍ c ↔ refl ≍ c :=
+    {b : α} {refl : motive a (Eq.refl a)} {h : a = b} {c : motive b h} :
+    HEq (@Eq.rec α a motive refl b h) c ↔ HEq refl c :=
   h.rec (fun _ => ⟨id, id⟩) c
 
 /--
@@ -965,7 +960,7 @@ equality on the original term.
 -/
 theorem heq_eqRec_iff {α : Sort u} {a : α} {motive : (b : α) → a = b → Sort v}
     {b : α} {refl : motive a (Eq.refl a)} {h : a = b} {c : motive b h} :
-    c ≍ @Eq.rec α a motive refl b h ↔ c ≍ refl :=
+    HEq c (@Eq.rec α a motive refl b h) ↔ HEq c refl :=
   h.rec (fun _ => ⟨id, id⟩) c
 
 /--
@@ -982,7 +977,7 @@ theorem apply_eqRec {α : Sort u} {a : α} (motive : (b : α) → a = b → Sort
 If casting a term with `Eq.rec` to another type makes it equal to some other term, then the two
 terms are heterogeneously equal.
 -/
-theorem heq_of_eqRec_eq {α β : Sort u} {a : α} {b : β} (h₁ : α = β) (h₂ : Eq.rec (motive := fun α _ => α) a h₁ = b) : a ≍ b := by
+theorem heq_of_eqRec_eq {α β : Sort u} {a : α} {b : β} (h₁ : α = β) (h₂ : Eq.rec (motive := fun α _ => α) a h₁ = b) : HEq a b := by
   subst h₁
   apply heq_of_eq
   exact h₂
@@ -990,7 +985,7 @@ theorem heq_of_eqRec_eq {α β : Sort u} {a : α} {b : β} (h₁ : α = β) (h
 /--
 The result of casting a term with `cast` is heterogeneously equal to the original term.
 -/
-theorem cast_heq {α β : Sort u} : (h : α = β) → (a : α) → cast h a ≍ a
+theorem cast_heq {α β : Sort u} : (h : α = β) → (a : α) → HEq (cast h a) a
   | rfl, a => HEq.refl a
 
 variable {a b c d : Prop}
@@ -1019,8 +1014,8 @@ instance : Trans Iff Iff Iff where
 theorem Eq.comm {a b : α} : a = b ↔ b = a := Iff.intro Eq.symm Eq.symm
 theorem eq_comm {a b : α} : a = b ↔ b = a := Eq.comm
 
-theorem HEq.comm {a : α} {b : β} : a ≍ b ↔ b ≍ a := Iff.intro HEq.symm HEq.symm
-theorem heq_comm {a : α} {b : β} : a ≍ b ↔ b ≍ a := HEq.comm
+theorem HEq.comm {a : α} {b : β} : HEq a b ↔ HEq b a := Iff.intro HEq.symm HEq.symm
+theorem heq_comm {a : α} {b : β} : HEq a b ↔ HEq b a := HEq.comm
 
 @[symm] theorem Iff.symm (h : a ↔ b) : b ↔ a := Iff.intro h.mpr h.mp
 theorem Iff.comm : (a ↔ b) ↔ (b ↔ a) := Iff.intro Iff.symm Iff.symm
@@ -1053,6 +1048,11 @@ theorem Exists.elim {α : Sort u} {p : α → Prop} {b : Prop}
   | isFalse _ => rfl
   | isTrue h  => False.elim h
 
+set_option linter.missingDocs false in
+@[deprecated decide_true (since := "2024-11-05")] abbrev decide_true_eq_true := decide_true
+set_option linter.missingDocs false in
+@[deprecated decide_false (since := "2024-11-05")] abbrev decide_false_eq_false := decide_false
+
 /-- Similar to `decide`, but uses an explicit instance -/
 @[inline] def toBoolUsing {p : Prop} (d : Decidable p) : Bool :=
   decide (h := d)
@@ -1212,7 +1212,10 @@ abbrev noConfusionEnum {α : Sort u} {β : Sort v} [inst : DecidableEq β] (f :
 instance : Inhabited Prop where
   default := True
 
-deriving instance Inhabited for NonScalar, PNonScalar, True
+deriving instance Inhabited for NonScalar, PNonScalar, True, ForInStep
+
+theorem nonempty_of_exists {α : Sort u} {p : α → Prop} : Exists (fun x => p x) → Nonempty α
+  | ⟨w, _⟩ => ⟨w⟩
 
 /-! # Subsingleton -/
 
@@ -1239,7 +1242,7 @@ protected theorem Subsingleton.elim {α : Sort u} [h : Subsingleton α] : (a b :
 If two types are equal and one of them is a subsingleton, then all of their elements are
 [heterogeneously equal](lean-manual://section/HEq).
 -/
-protected theorem Subsingleton.helim {α β : Sort u} [h₁ : Subsingleton α] (h₂ : α = β) (a : α) (b : β) : a ≍ b := by
+protected theorem Subsingleton.helim {α β : Sort u} [h₁ : Subsingleton α] (h₂ : α = β) (a : α) (b : β) : HEq a b := by
   subst h₂
   apply heq_of_eq
   apply Subsingleton.elim
@@ -1386,7 +1389,16 @@ instance Sum.nonemptyLeft [h : Nonempty α] : Nonempty (Sum α β) :=
 instance Sum.nonemptyRight [h : Nonempty β] : Nonempty (Sum α β) :=
   Nonempty.elim h (fun b => ⟨Sum.inr b⟩)
 
-deriving instance DecidableEq for Sum
+instance {α : Type u} {β : Type v} [DecidableEq α] [DecidableEq β] : DecidableEq (Sum α β) := fun a b =>
+  match a, b with
+  | Sum.inl a, Sum.inl b =>
+    if h : a = b then isTrue (h ▸ rfl)
+    else isFalse fun h' => Sum.noConfusion h' fun h' => absurd h' h
+  | Sum.inr a, Sum.inr b =>
+    if h : a = b then isTrue (h ▸ rfl)
+    else isFalse fun h' => Sum.noConfusion h' fun h' => absurd h' h
+  | Sum.inr _, Sum.inl _ => isFalse fun h => Sum.noConfusion h
+  | Sum.inl _, Sum.inr _ => isFalse fun h => Sum.noConfusion h
 
 end
 
@@ -1690,7 +1702,7 @@ theorem true_iff_false : (True ↔ False) ↔ False := iff_false_intro (·.mp  T
 theorem false_iff_true : (False ↔ True) ↔ False := iff_false_intro (·.mpr True.intro)
 
 theorem iff_not_self : ¬(a ↔ ¬a) | H => let f h := H.1 h h; f (H.2 f)
-theorem heq_self_iff_true (a : α) : a ≍ a ↔ True := iff_true_intro HEq.rfl
+theorem heq_self_iff_true (a : α) : HEq a a ↔ True := iff_true_intro HEq.rfl
 
 /-! ## implies -/
 
@@ -1890,7 +1902,7 @@ a structure.
 protected abbrev hrecOn
     (q : Quot r)
     (f : (a : α) → motive (Quot.mk r a))
-    (c : (a b : α) → (p : r a b) → f a ≍ f b)
+    (c : (a b : α) → (p : r a b) → HEq (f a) (f b))
     : motive q :=
   Quot.recOn q f fun a b p => eq_of_heq (eqRec_heq_iff.mpr (c a b p))
 
@@ -2088,7 +2100,7 @@ a structure.
 protected abbrev hrecOn
     (q : Quotient s)
     (f : (a : α) → motive (Quotient.mk s a))
-    (c : (a b : α) → (p : a ≈ b) → f a ≍ f b)
+    (c : (a b : α) → (p : a ≈ b) → HEq (f a) (f b))
     : motive q :=
   Quot.hrecOn q f c
 end

src/Init/Data/Array/Attach.lean

@@ -22,7 +22,7 @@ an array `xs : Array α`, given a proof that every element of `xs` in fact satis
 
 `Array.pmap`, named for “partial map,” is the equivalent of `Array.map` for such partial functions.
 -/
-@[expose]
+
 def pmap {P : α → Prop} (f : ∀ a, P a → β) (xs : Array α) (H : ∀ a ∈ xs, P a) : Array β :=
   (xs.toList.pmap f (fun a m => H a (mem_def.mpr m))).toArray
 
@@ -39,7 +39,7 @@ of elements in the corresponding subtype `{ x // P x }`.
 
 `O(1)`.
 -/
-@[implemented_by attachWithImpl, expose] def attachWith
+@[implemented_by attachWithImpl] def attachWith
     (xs : Array α) (P : α → Prop) (H : ∀ x ∈ xs, P x) : Array {x // P x} :=
   ⟨xs.toList.attachWith P fun x h => H x (Array.Mem.mk h)⟩
 
@@ -54,7 +54,7 @@ recursion](lean-manual://section/well-founded-recursion) that use higher-order f
 `Array.map`) to prove that an value taken from a list is smaller than the list. This allows the
 well-founded recursion mechanism to prove that the function terminates.
 -/
-@[inline, expose] def attach (xs : Array α) : Array {x // x ∈ xs} := xs.attachWith _ fun _ => id
+@[inline] def attach (xs : Array α) : Array {x // x ∈ xs} := xs.attachWith _ fun _ => id
 
 @[simp, grind =] theorem _root_.List.attachWith_toArray {l : List α} {P : α → Prop} {H : ∀ x ∈ l.toArray, P x} :
     l.toArray.attachWith P H = (l.attachWith P (by simpa using H)).toArray := by
@@ -69,11 +69,11 @@ well-founded recursion mechanism to prove that the function terminates.
   simp [pmap]
 
 @[simp] theorem toList_attachWith {xs : Array α} {P : α → Prop} {H : ∀ x ∈ xs, P x} :
-   (xs.attachWith P H).toList = xs.toList.attachWith P (by simpa [mem_toList_iff] using H) := by
+   (xs.attachWith P H).toList = xs.toList.attachWith P (by simpa [mem_toList] using H) := by
   simp [attachWith]
 
 @[simp] theorem toList_attach {xs : Array α} :
-    xs.attach.toList = xs.toList.attachWith (· ∈ xs) (by simp [mem_toList_iff]) := by
+    xs.attach.toList = xs.toList.attachWith (· ∈ xs) (by simp [mem_toList]) := by
   simp [attach]
 
 @[simp] theorem toList_pmap {xs : Array α} {P : α → Prop} {f : ∀ a, P a → β} {H : ∀ a ∈ xs, P a} :
@@ -574,12 +574,9 @@ state, the right approach is usually the tactic `simp [Array.unattach, -Array.ma
 -/
 def unattach {α : Type _} {p : α → Prop} (xs : Array { x // p x }) : Array α := xs.map (·.val)
 
-@[simp] theorem unattach_empty {p : α → Prop} : (#[] : Array { x // p x }).unattach = #[] := by
+@[simp] theorem unattach_nil {p : α → Prop} : (#[] : Array { x // p x }).unattach = #[] := by
   simp [unattach]
 
-@[deprecated unattach_empty (since := "2025-05-26")]
-abbrev unattach_nil := @unattach_empty
-
 @[simp] theorem unattach_push {p : α → Prop} {a : { x // p x }} {xs : Array { x // p x }} :
     (xs.push a).unattach = xs.unattach.push a.1 := by
   simp only [unattach, Array.map_push]

src/Init/Data/Array/Basic.lean

@@ -91,8 +91,7 @@ theorem ext' {xs ys : Array α} (h : xs.toList = ys.toList) : xs = ys := by
 @[simp, grind =] theorem getElem_toList {xs : Array α} {i : Nat} (h : i < xs.size) : xs.toList[i] = xs[i] := rfl
 
 @[simp, grind =] theorem getElem?_toList {xs : Array α} {i : Nat} : xs.toList[i]? = xs[i]? := by
-  simp only [getElem?_def, getElem_toList]
-  simp only [Array.size]
+  simp [getElem?_def]
 
 /-- `a ∈ as` is a predicate which asserts that `a` is in the array `as`. -/
 -- NB: This is defined as a structure rather than a plain def so that a lemma
@@ -113,10 +112,6 @@ theorem mem_def {a : α} {as : Array α} : a ∈ as ↔ a ∈ as.toList :=
   rw [Array.mem_def, ← getElem_toList]
   apply List.getElem_mem
 
-@[simp, grind =] theorem emptyWithCapacity_eq {α n} : @emptyWithCapacity α n = #[] := rfl
-
-@[simp] theorem mkEmpty_eq {α n} : @mkEmpty α n = #[] := rfl
-
 end Array
 
 namespace List
@@ -168,7 +163,7 @@ Low-level indexing operator which is as fast as a C array read.
 
 This avoids overhead due to unboxing a `Nat` used as an index.
 -/
-@[extern "lean_array_uget", simp, expose]
+@[extern "lean_array_uget", simp]
 def uget (a : @& Array α) (i : USize) (h : i.toNat < a.size) : α :=
   a[i.toNat]
 
@@ -191,7 +186,7 @@ Examples:
 * `#["orange", "yellow"].pop = #["orange"]`
 * `(#[] : Array String).pop = #[]`
 -/
-@[extern "lean_array_pop", expose]
+@[extern "lean_array_pop"]
 def pop (xs : Array α) : Array α where
   toList := xs.toList.dropLast
 
@@ -210,7 +205,7 @@ Examples:
  * `Array.replicate 3 () = #[(), (), ()]`
  * `Array.replicate 0 "anything" = #[]`
 -/
-@[extern "lean_mk_array", expose]
+@[extern "lean_mk_array"]
 def replicate {α : Type u} (n : Nat) (v : α) : Array α where
   toList := List.replicate n v
 
@@ -238,7 +233,7 @@ Examples:
 * `#["red", "green", "blue", "brown"].swap 1 2 = #["red", "blue", "green", "brown"]`
 * `#["red", "green", "blue", "brown"].swap 3 0 = #["brown", "green", "blue", "red"]`
 -/
-@[extern "lean_array_fswap", expose]
+@[extern "lean_array_fswap"]
 def swap (xs : Array α) (i j : @& Nat) (hi : i < xs.size := by get_elem_tactic) (hj : j < xs.size := by get_elem_tactic) : Array α :=
   let v₁ := xs[i]
   let v₂ := xs[j]
@@ -268,6 +263,8 @@ def swapIfInBounds (xs : Array α) (i j : @& Nat) : Array α :=
   else xs
   else xs
 
+@[deprecated swapIfInBounds (since := "2024-11-24")] abbrev swap! := @swapIfInBounds
+
 /-! ### GetElem instance for `USize`, backed by `uget` -/
 
 instance : GetElem (Array α) USize α fun xs i => i.toNat < xs.size where
@@ -289,7 +286,6 @@ Examples:
  * `#[1, 2].isEmpty = false`
  * `#[()].isEmpty = false`
 -/
-@[expose]
 def isEmpty (xs : Array α) : Bool :=
   xs.size = 0
 
@@ -331,16 +327,12 @@ Examples:
  * `Array.ofFn (n := 3) toString = #["0", "1", "2"]`
  * `Array.ofFn (fun i => #["red", "green", "blue"].get i.val i.isLt) = #["red", "green", "blue"]`
 -/
-def ofFn {n} (f : Fin n → α) : Array α := go (emptyWithCapacity n) n (Nat.le_refl n) where
-  /-- Auxiliary for `ofFn`. `ofFn.go f acc i h = acc ++ #[f (n - i), ..., f(n - 1)]` -/
-  go (acc : Array α) : (i : Nat) → i ≤ n → Array α
-  | i + 1, h =>
-     have w : n - i - 1 < n :=
-       Nat.lt_of_lt_of_le (Nat.sub_one_lt (Nat.sub_ne_zero_iff_lt.mpr h)) (Nat.sub_le n i)
-     go (acc.push (f ⟨n - i - 1, w⟩)) i (Nat.le_of_succ_le h)
-  | 0, _ => acc
-
--- See also `Array.ofFnM` defined in `Init.Data.Array.OfFn`.
+def ofFn {n} (f : Fin n → α) : Array α := go 0 (emptyWithCapacity n) where
+  /-- Auxiliary for `ofFn`. `ofFn.go f i acc = acc ++ #[f i, ..., f(n - 1)]` -/
+  @[semireducible] -- This is otherwise irreducible because it uses well-founded recursion.
+  go (i : Nat) (acc : Array α) : Array α :=
+    if h : i < n then go (i+1) (acc.push (f ⟨i, h⟩)) else acc
+  decreasing_by simp_wf; decreasing_trivial_pre_omega
 
 /--
 Constructs an array that contains all the numbers from `0` to `n`, exclusive.
@@ -375,7 +367,7 @@ Examples:
  * `Array.singleton 5 = #[5]`
  * `Array.singleton "one" = #["one"]`
 -/
-@[inline, expose] protected def singleton (v : α) : Array α := #[v]
+@[inline] protected def singleton (v : α) : Array α := #[v]
 
 /--
 Returns the last element of an array, or panics if the array is empty.
@@ -404,7 +396,7 @@ that requires a proof the array is non-empty.
 def back? (xs : Array α) : Option α :=
   xs[xs.size - 1]?
 
-@[deprecated "Use `a[i]?` instead." (since := "2025-02-12"), expose]
+@[deprecated "Use `a[i]?` instead." (since := "2025-02-12")]
 def get? (xs : Array α) (i : Nat) : Option α :=
   if h : i < xs.size then some xs[i] else none
 
@@ -418,7 +410,7 @@ Examples:
 * `#["spinach", "broccoli", "carrot"].swapAt 1 "pepper" = ("broccoli", #["spinach", "pepper", "carrot"])`
 * `#["spinach", "broccoli", "carrot"].swapAt 2 "pepper" = ("carrot", #["spinach", "broccoli", "pepper"])`
 -/
-@[inline, expose] def swapAt (xs : Array α) (i : Nat) (v : α) (hi : i < xs.size := by get_elem_tactic) : α × Array α :=
+@[inline] def swapAt (xs : Array α) (i : Nat) (v : α) (hi : i < xs.size := by get_elem_tactic) : α × Array α :=
   let e := xs[i]
   let xs' := xs.set i v
   (e, xs')
@@ -433,7 +425,7 @@ Examples:
 * `#["spinach", "broccoli", "carrot"].swapAt! 1 "pepper" = (#["spinach", "pepper", "carrot"], "broccoli")`
 * `#["spinach", "broccoli", "carrot"].swapAt! 2 "pepper" = (#["spinach", "broccoli", "pepper"], "carrot")`
 -/
-@[inline, expose]
+@[inline]
 def swapAt! (xs : Array α) (i : Nat) (v : α) : α × Array α :=
   if h : i < xs.size then
     swapAt xs i v
@@ -546,7 +538,7 @@ Examples:
 -/
 @[inline]
 def modify (xs : Array α) (i : Nat) (f : α → α) : Array α :=
-  Id.run <| modifyM xs i (pure <| f ·)
+  Id.run <| modifyM xs i f
 
 set_option linter.indexVariables false in -- Changing `idx` causes bootstrapping issues, haven't investigated.
 /--
@@ -579,7 +571,7 @@ def modifyOp (xs : Array α) (idx : Nat) (f : α → α) : Array α :=
   loop 0 b
 
 /-- Reference implementation for `forIn'` -/
-@[implemented_by Array.forIn'Unsafe, expose]
+@[implemented_by Array.forIn'Unsafe]
 protected def forIn' {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (b : β) (f : (a : α) → a ∈ as → β → m (ForInStep β)) : m β :=
   let rec loop (i : Nat) (h : i ≤ as.size) (b : β) : m β := do
     match i, h with
@@ -646,7 +638,7 @@ example [Monad m] (f : α → β → m α) :
 ```
 -/
 -- Reference implementation for `foldlM`
-@[implemented_by foldlMUnsafe, expose]
+@[implemented_by foldlMUnsafe]
 def foldlM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (init : β) (as : Array α) (start := 0) (stop := as.size) : m β :=
   let fold (stop : Nat) (h : stop ≤ as.size) :=
     let rec loop (i : Nat) (j : Nat) (b : β) : m β := do
@@ -711,7 +703,7 @@ example [Monad m] (f : α → β → m β) :
 ```
 -/
 -- Reference implementation for `foldrM`
-@[implemented_by foldrMUnsafe, expose]
+@[implemented_by foldrMUnsafe]
 def foldrM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → β → m β) (init : β) (as : Array α) (start := as.size) (stop := 0) : m β :=
   let rec fold (i : Nat) (h : i ≤ as.size) (b : β) : m β := do
     if i == stop then
@@ -766,11 +758,13 @@ def mapM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α
   decreasing_by simp_wf; decreasing_trivial_pre_omega
   map 0 (emptyWithCapacity as.size)
 
+@[deprecated mapM (since := "2024-11-11")] abbrev sequenceMap := @mapM
+
 /--
 Applies the monadic action `f` to every element in the array, along with the element's index and a
 proof that the index is in bounds, from left to right. Returns the array of results.
 -/
-@[inline, expose]
+@[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 β) :=
   let rec @[specialize] map (i : Nat) (j : Nat) (inv : i + j = as.size) (bs : Array β) : m (Array β) := do
@@ -788,7 +782,7 @@ def mapFinIdxM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m]
 Applies the monadic action `f` to every element in the array, along with the element's index, from
 left to right. Returns the array of results.
 -/
-@[inline, expose]
+@[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
 
@@ -834,7 +828,7 @@ Almost! 5
 some 10
 ```
 -/
-@[inline, expose]
+@[inline]
 def findSomeM? {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → m (Option β)) (as : Array α) : m (Option β) := do
   for a in as do
     match (← f a) with
@@ -915,7 +909,7 @@ The optional parameters `start` and `stop` control the region of the array to be
 elements with indices from `start` (inclusive) to `stop` (exclusive) are checked. By default, the
 entire array is checked.
 -/
-@[implemented_by anyMUnsafe, expose]
+@[implemented_by anyMUnsafe]
 def anyM {α : Type u} {m : Type → Type w} [Monad m] (p : α → m Bool) (as : Array α) (start := 0) (stop := as.size) : m Bool :=
   let any (stop : Nat) (h : stop ≤ as.size) :=
     let rec @[semireducible] -- This is otherwise irreducible because it uses well-founded recursion.
@@ -1057,9 +1051,9 @@ Examples:
  * `#[1, 2, 3].foldl (· ++ toString ·) "" = "123"`
  * `#[1, 2, 3].foldl (s!"({·} {·})") "" = "((( 1) 2) 3)"`
 -/
-@[inline, expose]
+@[inline]
 def foldl {α : Type u} {β : Type v} (f : β → α → β) (init : β) (as : Array α) (start := 0) (stop := as.size) : β :=
-  Id.run <| as.foldlM (pure <| f · ·) init start stop
+  Id.run <| as.foldlM f init start stop
 
 /--
 Folds a function over an array from the right, accumulating a value starting with `init`. The
@@ -1074,9 +1068,9 @@ Examples:
  * `#[1, 2, 3].foldr (toString · ++ ·) "" = "123"`
  * `#[1, 2, 3].foldr (s!"({·} {·})") "!" = "(1 (2 (3 !)))"`
 -/
-@[inline, expose]
+@[inline]
 def foldr {α : Type u} {β : Type v} (f : α → β → β) (init : β) (as : Array α) (start := as.size) (stop := 0) : β :=
-  Id.run <| as.foldrM (pure <| f · ·) init start stop
+  Id.run <| as.foldrM f init start stop
 
 /--
 Computes the sum of the elements of an array.
@@ -1085,7 +1079,7 @@ Examples:
  * `#[a, b, c].sum = a + (b + (c + 0))`
  * `#[1, 2, 5].sum = 8`
 -/
-@[inline, expose]
+@[inline]
 def sum {α} [Add α] [Zero α] : Array α → α :=
   foldr (· + ·) 0
 
@@ -1097,7 +1091,7 @@ Examples:
  * `#[1, 2, 3, 4, 5].countP (· < 5) = 4`
  * `#[1, 2, 3, 4, 5].countP (· > 5) = 0`
 -/
-@[inline, expose]
+@[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
 
@@ -1109,7 +1103,7 @@ Examples:
  * `#[1, 1, 2, 3, 5].count 5 = 1`
  * `#[1, 1, 2, 3, 5].count 4 = 0`
 -/
-@[inline, expose]
+@[inline]
 def count {α : Type u} [BEq α] (a : α) (as : Array α) : Nat :=
   countP (· == a) as
 
@@ -1122,9 +1116,9 @@ Examples:
 * `#["one", "two", "three"].map (·.length) = #[3, 3, 5]`
 * `#["one", "two", "three"].map (·.reverse) = #["eno", "owt", "eerht"]`
 -/
-@[inline, expose]
+@[inline]
 def map {α : Type u} {β : Type v} (f : α → β) (as : Array α) : Array β :=
-  Id.run <| as.mapM (pure <| f ·)
+  Id.run <| as.mapM f
 
 instance : Functor Array where
   map := map
@@ -1137,9 +1131,9 @@ that the index is valid.
 `Array.mapIdx` is a variant that does not provide the function with evidence that the index is
 valid.
 -/
-@[inline, expose]
+@[inline]
 def mapFinIdx {α : Type u} {β : Type v} (as : Array α) (f : (i : Nat) → α → (h : i < as.size) → β) : Array β :=
-  Id.run <| as.mapFinIdxM (pure <| f · · ·)
+  Id.run <| as.mapFinIdxM f
 
 /--
 Applies a function to each element of the array along with the index at which that element is found,
@@ -1148,9 +1142,9 @@ returning the array of results.
 `Array.mapFinIdx` is a variant that additionally provides the function with a proof that the index
 is valid.
 -/
-@[inline, expose]
+@[inline]
 def mapIdx {α : Type u} {β : Type v} (f : Nat → α → β) (as : Array α) : Array β :=
-  Id.run <| as.mapIdxM (pure <| f · ·)
+  Id.run <| as.mapIdxM f
 
 /--
 Pairs each element of an array with its index, optionally starting from an index other than `0`.
@@ -1159,7 +1153,6 @@ Examples:
 * `#[a, b, c].zipIdx = #[(a, 0), (b, 1), (c, 2)]`
 * `#[a, b, c].zipIdx 5 = #[(a, 5), (b, 6), (c, 7)]`
 -/
-@[expose]
 def zipIdx (xs : Array α) (start := 0) : Array (α × Nat) :=
   xs.mapIdx fun i a => (a, start + i)
 
@@ -1173,7 +1166,7 @@ Examples:
 * `#[7, 6, 5, 8, 1, 2, 6].find? (· < 5) = some 1`
 * `#[7, 6, 5, 8, 1, 2, 6].find? (· < 1) = none`
 -/
-@[inline, expose]
+@[inline]
 def find? {α : Type u} (p : α → Bool) (as : Array α) : Option α :=
   Id.run do
     for a in as do
@@ -1197,9 +1190,9 @@ Example:
 some 10
 ```
 -/
-@[inline, expose]
+@[inline]
 def findSome? {α : Type u} {β : Type v} (f : α → Option β) (as : Array α) : Option β :=
-  Id.run <| as.findSomeM? (pure <| f ·)
+  Id.run <| as.findSomeM? f
 
 /--
 Returns the first non-`none` result of applying the function `f` to each element of the
@@ -1233,7 +1226,7 @@ Examples:
 -/
 @[inline]
 def findSomeRev? {α : Type u} {β : Type v} (f : α → Option β) (as : Array α) : Option β :=
-  Id.run <| as.findSomeRevM? (pure <| f ·)
+  Id.run <| as.findSomeRevM? f
 
 /--
 Returns the last element of the array for which the predicate `p` returns `true`, or `none` if no
@@ -1245,7 +1238,7 @@ Examples:
 -/
 @[inline]
 def findRev? {α : Type} (p : α → Bool) (as : Array α) : Option α :=
-  Id.run <| as.findRevM? (pure <| p ·)
+  Id.run <| as.findRevM? p
 
 /--
 Returns the index of the first element for which `p` returns `true`, or `none` if there is no such
@@ -1255,7 +1248,7 @@ Examples:
 * `#[7, 6, 5, 8, 1, 2, 6].findIdx (· < 5) = some 4`
 * `#[7, 6, 5, 8, 1, 2, 6].findIdx (· < 1) = none`
 -/
-@[inline, expose]
+@[inline]
 def findIdx? {α : Type u} (p : α → Bool) (as : Array α) : Option Nat :=
   let rec @[semireducible] -- This is otherwise irreducible because it uses well-founded recursion.
   loop (j : Nat) :=
@@ -1309,7 +1302,7 @@ Examples:
 * `#[7, 6, 5, 8, 1, 2, 6].findIdx (· < 5) = 4`
 * `#[7, 6, 5, 8, 1, 2, 6].findIdx (· < 1) = 7`
 -/
-@[inline, expose]
+@[inline]
 def findIdx (p : α → Bool) (as : Array α) : Nat := (as.findIdx? p).getD as.size
 
 @[semireducible] -- This is otherwise irreducible because it uses well-founded recursion.
@@ -1363,6 +1356,10 @@ Examples:
 def idxOf? [BEq α] (xs : Array α) (v : α) : Option Nat :=
   (xs.finIdxOf? v).map (·.val)
 
+@[deprecated idxOf? (since := "2024-11-20")]
+def getIdx? [BEq α] (xs : Array α) (v : α) : Option Nat :=
+  xs.findIdx? fun a => a == v
+
 /--
 Returns `true` if `p` returns `true` for any element of `as`.
 
@@ -1378,9 +1375,9 @@ Examples:
 * `#[2, 4, 5, 6].any (· % 2 = 0) = true`
 * `#[2, 4, 5, 6].any (· % 2 = 1) = true`
 -/
-@[inline, expose]
+@[inline]
 def any (as : Array α) (p : α → Bool) (start := 0) (stop := as.size) : Bool :=
-  Id.run <| as.anyM (pure <| p ·) start stop
+  Id.run <| as.anyM p start stop
 
 /--
 Returns `true` if `p` returns `true` for every element of `as`.
@@ -1398,7 +1395,7 @@ Examples:
 -/
 @[inline]
 def all (as : Array α) (p : α → Bool) (start := 0) (stop := as.size) : Bool :=
-  Id.run <| as.allM (pure <| p ·) start stop
+  Id.run <| as.allM p start stop
 
 /--
 Checks whether `a` is an element of `as`, using `==` to compare elements.
@@ -1409,7 +1406,6 @@ Examples:
 * `#[1, 4, 2, 3, 3, 7].contains 3 = true`
 * `Array.contains #[1, 4, 2, 3, 3, 7] 5 = false`
 -/
-@[expose]
 def contains [BEq α] (as : Array α) (a : α) : Bool :=
   as.any (a == ·)
 
@@ -1458,7 +1454,6 @@ Examples:
   * `#[] ++ #[4, 5] = #[4, 5]`.
   * `#[1, 2, 3] ++ #[] = #[1, 2, 3]`.
 -/
-@[expose]
 protected def append (as : Array α) (bs : Array α) : Array α :=
   bs.foldl (init := as) fun xs v => xs.push v
 
@@ -1496,7 +1491,7 @@ Examples:
 * `#[2, 3, 2].flatMap Array.range = #[0, 1, 0, 1, 2, 0, 1]`
 * `#[['a', 'b'], ['c', 'd', 'e']].flatMap List.toArray = #['a', 'b', 'c', 'd', 'e']`
 -/
-@[inline, expose]
+@[inline]
 def flatMap (f : α → Array β) (as : Array α) : Array β :=
   as.foldl (init := empty) fun bs a => bs ++ f a
 
@@ -1509,7 +1504,7 @@ Examples:
  * `#[#[0, 1], #[], #[2], #[1, 0, 1]].flatten = #[0, 1, 2, 1, 0, 1]`
  * `(#[] : Array Nat).flatten = #[]`
 -/
-@[inline, expose] def flatten (xss : Array (Array α)) : Array α :=
+@[inline] def flatten (xss : Array (Array α)) : Array α :=
   xss.foldl (init := empty) fun acc xs => acc ++ xs
 
 /--
@@ -1522,7 +1517,6 @@ Examples:
 * `#[0, 1].reverse = #[1, 0]`
 * `#[0, 1, 2].reverse = #[2, 1, 0]`
 -/
-@[expose]
 def reverse (as : Array α) : Array α :=
   if h : as.size ≤ 1 then
     as
@@ -1555,7 +1549,7 @@ Examples:
 * `#[1, 2, 5, 2, 7, 7].filter (fun _ => true) (start := 3) = #[2, 7, 7]`
 * `#[1, 2, 5, 2, 7, 7].filter (fun _ => true) (stop := 3) = #[1, 2, 5]`
 -/
-@[inline, expose]
+@[inline]
 def filter (p : α → Bool) (as : Array α) (start := 0) (stop := as.size) : Array α :=
   as.foldl (init := #[]) (start := start) (stop := stop) fun acc a =>
     if p a then acc.push a else acc
@@ -1648,7 +1642,7 @@ Examining 7
 #[10, 14, 14]
 ```
 -/
-@[specialize, expose]
+@[specialize]
 def filterMapM [Monad m] (f : α → m (Option β)) (as : Array α) (start := 0) (stop := as.size) : m (Array β) :=
   as.foldlM (init := #[]) (start := start) (stop := stop) fun bs a => do
     match (← f a) with
@@ -1668,9 +1662,9 @@ Example:
 #[10, 14, 14]
 ```
 -/
-@[inline, expose]
+@[inline]
 def filterMap (f : α → Option β) (as : Array α) (start := 0) (stop := as.size) : Array β :=
-  Id.run <| as.filterMapM (pure <| f ·) (start := start) (stop := stop)
+  Id.run <| as.filterMapM f (start := start) (stop := stop)
 
 /--
 Returns the largest element of the array, as determined by the comparison `lt`, or `none` if
@@ -1881,6 +1875,8 @@ Examples:
   let as := as.push a
   loop as ⟨j, size_push .. ▸ j.lt_succ_self⟩
 
+@[deprecated insertIdx (since := "2024-11-20")] abbrev insertAt := @insertIdx
+
 /--
 Inserts an element into an array at the specified index. Panics if the index is greater than the
 size of the array.
@@ -1901,6 +1897,8 @@ def insertIdx! (as : Array α) (i : Nat) (a : α) : Array α :=
     insertIdx as i a
   else panic! "invalid index"
 
+@[deprecated insertIdx! (since := "2024-11-20")] abbrev insertAt! := @insertIdx!
+
 /--
 Inserts an element into an array at the specified index. The array is returned unmodified if the
 index is greater than the size of the array.
@@ -2023,6 +2021,11 @@ Examples:
 def unzip (as : Array (α × β)) : Array α × Array β :=
   as.foldl (init := (#[], #[])) fun (as, bs) (a, b) => (as.push a, bs.push b)
 
+@[deprecated partition (since := "2024-11-06")]
+def split (as : Array α) (p : α → Bool) : Array α × Array α :=
+  as.foldl (init := (#[], #[])) fun (as, bs) a =>
+    if p a then (as.push a, bs) else (as, bs.push a)
+
 /--
 Replaces the first occurrence of `a` with `b` in an array. The modification is performed in-place
 when the reference to the array is unique. Returns the array unmodified when `a` is not present.

src/Init/Data/Array/BasicAux.lean

@@ -88,4 +88,4 @@ pointer equality, and does not allocate a new array if the result of each functi
 pointer-equal to its argument.
 -/
 @[inline] def Array.mapMono (as : Array α) (f : α → α) : Array α :=
-  Id.run <| as.mapMonoM (pure <| f ·)
+  Id.run <| as.mapMonoM f

src/Init/Data/Array/BinSearch.lean

@@ -129,6 +129,6 @@ Examples:
 * `#[].binInsert (· < ·) 1 = #[1]`
 -/
 @[inline] def binInsert {α : Type u} (lt : α → α → Bool) (as : Array α) (k : α) : Array α :=
-  Id.run <| binInsertM lt (fun _ => pure k) (fun _ => pure k) as k
+  Id.run <| binInsertM lt (fun _ => k) (fun _ => k) as k
 
 end Array

src/Init/Data/Array/Bootstrap.lean

@@ -40,7 +40,7 @@ Use the indexing notation `a[i]!` instead.
 
 Access an element from an array, or panic if the index is out of bounds.
 -/
-@[deprecated "Use indexing notation `as[i]!` instead" (since := "2025-02-17"), expose]
+@[deprecated "Use indexing notation `as[i]!` instead" (since := "2025-02-17")]
 def get! {α : Type u} [Inhabited α] (a : @& Array α) (i : @& Nat) : α :=
   Array.getD a i default
 
@@ -78,8 +78,7 @@ theorem foldrM_eq_reverse_foldlM_toList [Monad m] {f : α → β → m β} {init
   have : xs = #[] ∨ 0 < xs.size :=
     match xs with | ⟨[]⟩ => .inl rfl | ⟨a::l⟩ => .inr (Nat.zero_lt_succ _)
   match xs, this with | _, .inl rfl => simp [foldrM] | xs, .inr h => ?_
-  simp only [foldrM, h, ← foldrM_eq_reverse_foldlM_toList.aux]
-  simp [Array.size]
+  simp [foldrM, h, ← foldrM_eq_reverse_foldlM_toList.aux, List.take_length]
 
 @[simp, grind =] theorem foldrM_toList [Monad m]
     {f : α → β → m β} {init : β} {xs : Array α} :
@@ -90,13 +89,9 @@ theorem foldrM_eq_reverse_foldlM_toList [Monad m] {f : α → β → m β} {init
     xs.toList.foldr f init = xs.foldr f init :=
   List.foldr_eq_foldrM .. ▸ foldrM_toList ..
 
-@[simp, grind =] theorem toList_push {xs : Array α} {x : α} : (xs.push x).toList = xs.toList ++ [x] := by
-  rcases xs with ⟨xs⟩
+@[simp, grind =] theorem push_toList {xs : Array α} {a : α} : (xs.push a).toList = xs.toList ++ [a] := by
   simp [push, List.concat_eq_append]
 
-@[deprecated toList_push (since := "2025-05-26")]
-abbrev push_toList := @toList_push
-
 @[simp, grind =] theorem toListAppend_eq {xs : Array α} {l : List α} : xs.toListAppend l = xs.toList ++ l := by
   simp [toListAppend, ← foldr_toList]
 
@@ -143,4 +138,26 @@ abbrev nil_append := @empty_append
 @[deprecated toList_appendList (since := "2024-12-11")]
 abbrev appendList_toList := @toList_appendList
 
+@[deprecated "Use the reverse direction of `foldrM_toList`." (since := "2024-11-13")]
+theorem foldrM_eq_foldrM_toList [Monad m]
+    {f : α → β → m β} {init : β} {xs : Array α} :
+    xs.foldrM f init = xs.toList.foldrM f init := by
+  simp
+
+@[deprecated "Use the reverse direction of `foldlM_toList`." (since := "2024-11-13")]
+theorem foldlM_eq_foldlM_toList [Monad m]
+    {f : β → α → m β} {init : β} {xs : Array α} :
+    xs.foldlM f init = xs.toList.foldlM f init:= by
+  simp
+
+@[deprecated "Use the reverse direction of `foldr_toList`." (since := "2024-11-13")]
+theorem foldr_eq_foldr_toList {f : α → β → β} {init : β} {xs : Array α} :
+    xs.foldr f init = xs.toList.foldr f init := by
+  simp
+
+@[deprecated "Use the reverse direction of `foldl_toList`." (since := "2024-11-13")]
+theorem foldl_eq_foldl_toList {f : β → α → β} {init : β} {xs : Array α} :
+    xs.foldl f init = xs.toList.foldl f init:= by
+  simp
+
 end Array

src/Init/Data/Array/Count.lean

@@ -52,8 +52,8 @@ theorem countP_push {a : α} {xs : Array α} : countP p (xs.push a) = countP p x
   rcases xs with ⟨xs⟩
   simp_all
 
-theorem countP_singleton {a : α} : countP p #[a] = if p a then 1 else 0 := by
-  simp
+@[simp] theorem countP_singleton {a : α} : countP p #[a] = if p a then 1 else 0 := by
+  simp [countP_push]
 
 theorem size_eq_countP_add_countP {xs : Array α} : xs.size = countP p xs + countP (fun a => ¬p a) xs := by
   rcases xs with ⟨xs⟩
@@ -105,7 +105,6 @@ theorem boole_getElem_le_countP {xs : Array α} {i : Nat} (h : i < xs.size) :
 theorem countP_set {xs : Array α} {i : Nat} {a : α} (h : i < xs.size) :
     (xs.set i a).countP p = xs.countP p - (if p xs[i] then 1 else 0) + (if p a then 1 else 0) := by
   rcases xs with ⟨xs⟩
-  simp at h
   simp [List.countP_set, h]
 
 theorem countP_filter {xs : Array α} :

src/Init/Data/Array/DecidableEq.lean

@@ -69,7 +69,7 @@ theorem isEqv_eq_decide (xs ys : Array α) (r) :
     simpa [isEqv_iff_rel] using h'
 
 @[simp, grind =] theorem isEqv_toList [BEq α] (xs ys : Array α) : (xs.toList.isEqv ys.toList r) = (xs.isEqv ys r) := by
-  simp [isEqv_eq_decide, List.isEqv_eq_decide, Array.size]
+  simp [isEqv_eq_decide, List.isEqv_eq_decide]
 
 theorem eq_of_isEqv [DecidableEq α] (xs ys : Array α) (h : Array.isEqv xs ys (fun x y => x = y)) : xs = ys := by
   have ⟨h, h'⟩ := rel_of_isEqv h
@@ -100,7 +100,7 @@ theorem beq_eq_decide [BEq α] (xs ys : Array α) :
   simp [BEq.beq, isEqv_eq_decide]
 
 @[simp, grind =] theorem beq_toList [BEq α] (xs ys : Array α) : (xs.toList == ys.toList) = (xs == ys) := by
-  simp [beq_eq_decide, List.beq_eq_decide, Array.size]
+  simp [beq_eq_decide, List.beq_eq_decide]
 
 end Array
 

src/Init/Data/Array/Erase.lean

@@ -24,7 +24,7 @@ open Nat
 
 /-! ### eraseP -/
 
-theorem eraseP_empty : #[].eraseP p = #[] := by simp
+@[simp] theorem eraseP_empty : #[].eraseP p = #[] := by simp
 
 theorem eraseP_of_forall_mem_not {xs : Array α} (h : ∀ a, a ∈ xs → ¬p a) : xs.eraseP p = xs := by
   rcases xs with ⟨xs⟩

src/Init/Data/Array/Extract.lean

@@ -238,9 +238,11 @@ theorem extract_append_left {as bs : Array α} :
     (as ++ bs).extract 0 as.size = as.extract 0 as.size := by
   simp
 
-theorem extract_append_right {as bs : Array α} :
+@[simp] theorem extract_append_right {as bs : Array α} :
     (as ++ bs).extract as.size (as.size + i) = bs.extract 0 i := by
-  simp
+  simp only [extract_append, extract_size_left, Nat.sub_self, empty_append]
+  congr 1
+  omega
 
 @[simp] theorem map_extract {as : Array α} {i j : Nat} :
     (as.extract i j).map f = (as.map f).extract i j := by

src/Init/Data/Array/Find.lean

@@ -142,9 +142,9 @@ abbrev findSome?_mkArray_of_isNone := @findSome?_replicate_of_isNone
 
 @[simp] theorem find?_empty : find? p #[] = none := rfl
 
-theorem find?_singleton {a : α} {p : α → Bool} :
+@[simp] theorem find?_singleton {a : α} {p : α → Bool} :
     #[a].find? p = if p a then some a else none := by
-  simp
+  simp [singleton_eq_toArray_singleton]
 
 @[simp] theorem findRev?_push_of_pos {xs : Array α} (h : p a) :
     findRev? p (xs.push a) = some a := by
@@ -347,8 +347,7 @@ theorem find?_eq_some_iff_getElem {xs : Array α} {p : α → Bool} {b : α} :
 
 /-! ### findIdx -/
 
-theorem findIdx_empty : findIdx p #[] = 0 := rfl
-
+@[simp] theorem findIdx_empty : findIdx p #[] = 0 := rfl
 theorem findIdx_singleton {a : α} {p : α → Bool} :
     #[a].findIdx p = if p a then 0 else 1 := by
   simp
@@ -601,8 +600,7 @@ theorem findIdx?_eq_some_le_of_findIdx?_eq_some {xs : Array α} {p q : α → Bo
 
 /-! ### findFinIdx? -/
 
-theorem findFinIdx?_empty {p : α → Bool} : findFinIdx? p #[] = none := by simp
-
+@[simp] theorem findFinIdx?_empty {p : α → Bool} : findFinIdx? p #[] = none := by simp
 theorem findFinIdx?_singleton {a : α} {p : α → Bool} :
     #[a].findFinIdx? p = if p a then some ⟨0, by simp⟩ else none := by
   simp
@@ -655,13 +653,13 @@ theorem findFinIdx?_append {xs ys : Array α} {p : α → Bool} :
 theorem isSome_findFinIdx? {xs : Array α} {p : α → Bool} :
     (xs.findFinIdx? p).isSome = xs.any p := by
   rcases xs with ⟨xs⟩
-  simp [Array.size]
+  simp
 
 @[simp]
 theorem isNone_findFinIdx? {xs : Array α} {p : α → Bool} :
     (xs.findFinIdx? p).isNone = xs.all (fun x => ¬ p x) := by
   rcases xs with ⟨xs⟩
-  simp [Array.size]
+  simp
 
 @[simp] theorem findFinIdx?_subtype {p : α → Prop} {xs : Array { x // p x }}
     {f : { x // p x } → Bool} {g : α → Bool} (hf : ∀ x h, f ⟨x, h⟩ = g x) :
@@ -669,8 +667,7 @@ theorem isNone_findFinIdx? {xs : Array α} {p : α → Bool} :
   cases xs
   simp only [List.findFinIdx?_toArray, hf, List.findFinIdx?_subtype]
   rw [findFinIdx?_congr List.unattach_toArray]
-  simp only [Option.map_map, Function.comp_def, Fin.cast_trans]
-  simp [Array.size]
+  simp [Function.comp_def]
 
 /-! ### idxOf
 
@@ -702,7 +699,7 @@ The verification API for `idxOf?` is still incomplete.
 The lemmas below should be made consistent with those for `findIdx?` (and proved using them).
 -/
 
-theorem idxOf?_empty [BEq α] : (#[] : Array α).idxOf? a = none := by simp
+@[simp] theorem idxOf?_empty [BEq α] : (#[] : Array α).idxOf? a = none := by simp
 
 @[simp] theorem idxOf?_eq_none_iff [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
     xs.idxOf? a = none ↔ a ∉ xs := by
@@ -715,10 +712,14 @@ theorem isSome_idxOf? [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
   rcases xs with ⟨xs⟩
   simp
 
+@[simp]
 theorem isNone_idxOf? [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
     (xs.idxOf? a).isNone = ¬ a ∈ xs := by
+  rcases xs with ⟨xs⟩
   simp
 
+
+
 /-! ### finIdxOf?
 
 The verification API for `finIdxOf?` is still incomplete.
@@ -729,27 +730,28 @@ theorem idxOf?_eq_map_finIdxOf?_val [BEq α] {xs : Array α} {a : α} :
     xs.idxOf? a = (xs.finIdxOf? a).map (·.val) := by
   simp [idxOf?, finIdxOf?, findIdx?_eq_map_findFinIdx?_val]
 
-theorem finIdxOf?_empty [BEq α] : (#[] : Array α).finIdxOf? a = none := by simp
+@[simp] theorem finIdxOf?_empty [BEq α] : (#[] : Array α).finIdxOf? a = none := by simp
 
 @[simp] theorem finIdxOf?_eq_none_iff [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
     xs.finIdxOf? a = none ↔ a ∉ xs := by
   rcases xs with ⟨xs⟩
-  simp [List.finIdxOf?_eq_none_iff, Array.size]
+  simp [List.finIdxOf?_eq_none_iff]
 
 @[simp] theorem finIdxOf?_eq_some_iff [BEq α] [LawfulBEq α] {xs : Array α} {a : α} {i : Fin xs.size} :
     xs.finIdxOf? a = some i ↔ xs[i] = a ∧ ∀ j (_ : j < i), ¬xs[j] = a := by
   rcases xs with ⟨xs⟩
-  unfold Array.size at i ⊢
   simp [List.finIdxOf?_eq_some_iff]
 
 @[simp]
 theorem isSome_finIdxOf? [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
     (xs.finIdxOf? a).isSome ↔ a ∈ xs := by
   rcases xs with ⟨xs⟩
-  simp [Array.size]
+  simp
 
+@[simp]
 theorem isNone_finIdxOf? [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
     (xs.finIdxOf? a).isNone = ¬ a ∈ xs := by
+  rcases xs with ⟨xs⟩
   simp
 
 end Array

src/Init/Data/Array/InsertIdx.lean

@@ -44,7 +44,6 @@ theorem insertIdx_zero {xs : Array α} {x : α} : xs.insertIdx 0 x = #[x] ++ xs
 
 @[simp] theorem size_insertIdx {xs : Array α} (h : i ≤ xs.size) : (xs.insertIdx i a).size = xs.size + 1 := by
   rcases xs with ⟨xs⟩
-  simp at h
   simp [List.length_insertIdx, h]
 
 theorem eraseIdx_insertIdx {i : Nat} {xs : Array α} (h : i ≤ xs.size) :

src/Init/Data/Array/Lemmas.lean

@@ -61,9 +61,14 @@ theorem toArray_eq : List.toArray as = xs ↔ as = xs.toList := by
 
 @[grind] theorem size_empty : (#[] : Array α).size = 0 := rfl
 
+@[simp] theorem emptyWithCapacity_eq {α n} : @emptyWithCapacity α n = #[] := rfl
+
+@[deprecated emptyWithCapacity_eq (since := "2025-03-12")]
+theorem mkEmpty_eq {α n} : @mkEmpty α n = #[] := rfl
+
 /-! ### size -/
 
-theorem eq_empty_of_size_eq_zero (h : xs.size = 0) : xs = #[] := by
+@[grind →] theorem eq_empty_of_size_eq_zero (h : xs.size = 0) : xs = #[] := by
   cases xs
   simp_all
 
@@ -75,7 +80,8 @@ theorem ne_empty_of_size_pos (h : 0 < xs.size) : xs ≠ #[] := by
   cases xs
   simpa using List.ne_nil_of_length_pos h
 
-@[simp] theorem size_eq_zero_iff : xs.size = 0 ↔ xs = #[] :=
+@[grind]
+theorem size_eq_zero_iff : xs.size = 0 ↔ xs = #[] :=
   ⟨eq_empty_of_size_eq_zero, fun h => h ▸ rfl⟩
 
 @[deprecated size_eq_zero_iff (since := "2025-02-24")]
@@ -116,11 +122,14 @@ abbrev size_eq_one := @size_eq_one_iff
 
 /-! ## L[i] and L[i]? -/
 
-theorem getElem?_eq_none_iff {xs : Array α} : xs[i]? = none ↔ xs.size ≤ i := by
-  simp
+@[simp] theorem getElem?_eq_none_iff {xs : Array α} : xs[i]? = none ↔ xs.size ≤ i := by
+  by_cases h : i < xs.size
+  · simp [getElem?_pos, h]
+  · rw [getElem?_neg xs i h]
+    simp_all
 
-theorem none_eq_getElem?_iff {xs : Array α} {i : Nat} : none = xs[i]? ↔ xs.size ≤ i := by
-  simp
+@[simp] theorem none_eq_getElem?_iff {xs : Array α} {i : Nat} : none = xs[i]? ↔ xs.size ≤ i := by
+  simp [eq_comm (a := none)]
 
 theorem getElem?_eq_none {xs : Array α} (h : xs.size ≤ i) : xs[i]? = none := by
   simp [getElem?_eq_none_iff, h]
@@ -130,8 +139,8 @@ grind_pattern Array.getElem?_eq_none => xs.size ≤ i, xs[i]?
 @[simp] theorem getElem?_eq_getElem {xs : Array α} {i : Nat} (h : i < xs.size) : xs[i]? = some xs[i] :=
   getElem?_pos ..
 
-theorem getElem?_eq_some_iff {xs : Array α} : xs[i]? = some b ↔ ∃ h : i < xs.size, xs[i] = b :=
-  _root_.getElem?_eq_some_iff
+theorem getElem?_eq_some_iff {xs : Array α} : xs[i]? = some b ↔ ∃ h : i < xs.size, xs[i] = b := by
+  simp [getElem?_def]
 
 @[grind →]
 theorem getElem_of_getElem? {xs : Array α} : xs[i]? = some a → ∃ h : i < xs.size, xs[i] = a :=
@@ -140,13 +149,13 @@ theorem getElem_of_getElem? {xs : Array α} : xs[i]? = some a → ∃ h : i < xs
 theorem some_eq_getElem?_iff {xs : Array α} : some b = xs[i]? ↔ ∃ h : i < xs.size, xs[i] = b := by
   rw [eq_comm, getElem?_eq_some_iff]
 
-theorem some_getElem_eq_getElem?_iff (xs : Array α) (i : Nat) (h : i < xs.size) :
+@[simp] theorem some_getElem_eq_getElem?_iff (xs : Array α) (i : Nat) (h : i < xs.size) :
     (some xs[i] = xs[i]?) ↔ True := by
-  simp
+  simp [h]
 
-theorem getElem?_eq_some_getElem_iff (xs : Array α) (i : Nat) (h : i < xs.size) :
+@[simp] theorem getElem?_eq_some_getElem_iff (xs : Array α) (i : Nat) (h : i < xs.size) :
     (xs[i]? = some xs[i]) ↔ True := by
-  simp
+  simp [h]
 
 theorem getElem_eq_iff {xs : Array α} {i : Nat} {h : i < xs.size} : xs[i] = x ↔ xs[i]? = some x := by
   simp only [getElem?_eq_some_iff]
@@ -169,7 +178,6 @@ theorem getD_getElem? {xs : Array α} {i : Nat} {d : α} :
 theorem getElem_push_lt {xs : Array α} {x : α} {i : Nat} (h : i < xs.size) :
     have : i < (xs.push x).size := by simp [*, Nat.lt_succ_of_le, Nat.le_of_lt]
     (xs.push x)[i] = xs[i] := by
-  rw [Array.size] at h
   simp only [push, ← getElem_toList, List.concat_eq_append, List.getElem_append_left, h]
 
 @[simp] theorem getElem_push_eq {xs : Array α} {x : α} : (xs.push x)[xs.size] = x := by
@@ -183,15 +191,16 @@ theorem getElem_push {xs : Array α} {x : α} {i : Nat} (h : i < (xs.push x).siz
   · simp at h
     simp [getElem_push_lt, Nat.le_antisymm (Nat.le_of_lt_succ h) (Nat.ge_of_not_lt h')]
 
-@[grind =] theorem getElem?_push {xs : Array α} {x} : (xs.push x)[i]? = if i = xs.size then some x else xs[i]? := by
+theorem getElem?_push {xs : Array α} {x} : (xs.push x)[i]? = if i = xs.size then some x else xs[i]? := by
   simp [getElem?_def, getElem_push]
   (repeat' split) <;> first | rfl | omega
 
-theorem getElem?_push_size {xs : Array α} {x} : (xs.push x)[xs.size]? = some x := by
-  simp
+@[simp] theorem getElem?_push_size {xs : Array α} {x} : (xs.push x)[xs.size]? = some x := by
+  simp [getElem?_push]
 
-theorem getElem_singleton {a : α} {i : Nat} (h : i < 1) : #[a][i] = a := by
-  simp
+@[simp] theorem getElem_singleton {a : α} {i : Nat} (h : i < 1) : #[a][i] = a :=
+  match i, h with
+  | 0, _ => rfl
 
 @[grind]
 theorem getElem?_singleton {a : α} {i : Nat} : #[a][i]? = if i = 0 then some a else none := by
@@ -238,8 +247,6 @@ theorem back?_pop {xs : Array α} :
 
 /-! ### push -/
 
-@[simp] theorem push_empty : #[].push x = #[x] := rfl
-
 @[simp] theorem push_ne_empty {a : α} {xs : Array α} : xs.push a ≠ #[] := by
   cases xs
   simp
@@ -419,7 +426,8 @@ theorem eq_empty_iff_forall_not_mem {xs : Array α} : xs = #[] ↔ ∀ a, a ∉
 theorem eq_of_mem_singleton (h : a ∈ #[b]) : a = b := by
   simpa using h
 
-theorem mem_singleton {a b : α} : a ∈ #[b] ↔ a = b := by simp
+@[simp] theorem mem_singleton {a b : α} : a ∈ #[b] ↔ a = b :=
+  ⟨eq_of_mem_singleton, (by simp [·])⟩
 
 theorem forall_mem_push {p : α → Prop} {xs : Array α} {a : α} :
     (∀ x, x ∈ xs.push a → p x) ↔ p a ∧ ∀ x, x ∈ xs → p x := by
@@ -604,13 +612,13 @@ theorem anyM_loop_cons [Monad m] {p : α → m Bool} {a : α} {as : List α} {st
 
 -- Auxiliary for `any_iff_exists`.
 theorem anyM_loop_iff_exists {p : α → Bool} {as : Array α} {start stop} (h : stop ≤ as.size) :
-    (anyM.loop (m := Id) (pure <| p ·) as stop h start).run = true ↔
+    anyM.loop (m := Id) p as stop h start = true ↔
       ∃ (i : Nat) (_ : i < as.size), start ≤ i ∧ i < stop ∧ p as[i] = true := by
   unfold anyM.loop
   split <;> rename_i h₁
   · dsimp
     split <;> rename_i h₂
-    · simp only [true_iff, Id.run_pure]
+    · simp only [true_iff]
       refine ⟨start, by omega, by omega, by omega, h₂⟩
     · rw [anyM_loop_iff_exists]
       constructor
@@ -627,9 +635,9 @@ termination_by stop - start
 -- This could also be proved from `SatisfiesM_anyM_iff_exists` in `Batteries.Data.Array.Init.Monadic`
 theorem any_iff_exists {p : α → Bool} {as : Array α} {start stop} :
     as.any p start stop ↔ ∃ (i : Nat) (_ : i < as.size), start ≤ i ∧ i < stop ∧ p as[i] := by
-  dsimp [any, anyM]
+  dsimp [any, anyM, Id.run]
   split
-  · rw [anyM_loop_iff_exists (p := p)]
+  · rw [anyM_loop_iff_exists]
   · rw [anyM_loop_iff_exists]
     constructor
     · rintro ⟨i, hi, ge, _, h⟩
@@ -763,7 +771,6 @@ theorem all_eq_false' {p : α → Bool} {as : Array α} :
   rw [Bool.eq_false_iff, Ne, all_eq_true']
   simp
 
-@[grind =]
 theorem any_eq {xs : Array α} {p : α → Bool} : xs.any p = decide (∃ i : Nat, ∃ h, p (xs[i]'h)) := by
   by_cases h : xs.any p
   · simp_all [any_eq_true]
@@ -778,7 +785,6 @@ theorem any_eq' {xs : Array α} {p : α → Bool} : xs.any p = decide (∃ x, x
     simp only [any_eq_false'] at h
     simpa using h
 
-@[grind =]
 theorem all_eq {xs : Array α} {p : α → Bool} : xs.all p = decide (∀ i, (_ : i < xs.size) → p xs[i]) := by
   by_cases h : xs.all p
   · simp_all [all_eq_true]
@@ -865,8 +871,8 @@ theorem elem_eq_mem [BEq α] [LawfulBEq α] {a : α} {xs : Array α} :
 @[simp, grind] theorem contains_eq_mem [BEq α] [LawfulBEq α] {a : α} {xs : Array α} :
     xs.contains a = decide (a ∈ xs) := by rw [← elem_eq_contains, elem_eq_mem]
 
-@[grind] theorem any_empty [BEq α] {p : α → Bool} : (#[] : Array α).any p = false := by simp
-@[grind] theorem all_empty [BEq α] {p : α → Bool} : (#[] : Array α).all p = true := by simp
+@[simp, grind] theorem any_empty [BEq α] {p : α → Bool} : (#[] : Array α).any p = false := by simp
+@[simp, grind] theorem all_empty [BEq α] {p : α → Bool} : (#[] : Array α).all p = true := by simp
 
 /-- Variant of `any_push` with a side condition on `stop`. -/
 @[simp, grind] theorem any_push' [BEq α] {xs : Array α} {a : α} {p : α → Bool} (h : stop = xs.size + 1) :
@@ -1225,7 +1231,7 @@ where
 @[simp] theorem mapM_empty [Monad m] (f : α → m β) : mapM f #[] = pure #[] := by
   rw [mapM, mapM.map]; rfl
 
-@[grind] theorem map_empty {f : α → β} : map f #[] = #[] := by simp
+@[simp, grind] theorem map_empty {f : α → β} : map f #[] = #[] := mapM_empty f
 
 @[simp, grind] theorem map_push {f : α → β} {as : Array α} {x : α} :
     (as.push x).map f = (as.map f).push (f x) := by
@@ -1260,8 +1266,7 @@ theorem map_singleton {f : α → β} {a : α} : map f #[a] = #[f a] := by simp
 
 -- We use a lower priority here as there are more specific lemmas in downstream libraries
 -- which should be able to fire first.
-@[simp 500, grind =] theorem mem_map {f : α → β} {xs : Array α} :
-    b ∈ xs.map f ↔ ∃ a, a ∈ xs ∧ f a = b := by
+@[simp 500] theorem mem_map {f : α → β} {xs : Array α} : b ∈ xs.map f ↔ ∃ a, a ∈ xs ∧ f a = b := by
   simp only [mem_def, toList_map, List.mem_map]
 
 theorem exists_of_mem_map (h : b ∈ map f l) : ∃ a, a ∈ l ∧ f a = b := mem_map.1 h
@@ -1364,17 +1369,17 @@ theorem mapM_eq_mapM_toList [Monad m] [LawfulMonad m] {f : α → m β} {xs : Ar
 
 @[deprecated "Use `mapM_eq_foldlM` instead" (since := "2025-01-08")]
 theorem mapM_map_eq_foldl {as : Array α} {f : α → β} {i : Nat} :
-    mapM.map (m := Id) (pure <| f ·) as i b = pure (as.foldl (start := i) (fun acc a => acc.push (f a)) b) := by
+    mapM.map (m := Id) f as i b = as.foldl (start := i) (fun acc a => acc.push (f a)) b := by
   unfold mapM.map
   split <;> rename_i h
-  · ext : 1
-    dsimp [foldl, foldlM]
+  · simp only [Id.bind_eq]
+    dsimp [foldl, Id.run, foldlM]
     rw [mapM_map_eq_foldl, dif_pos (by omega), foldlM.loop, dif_pos h]
     -- Calling `split` here gives a bad goal.
     have : size as - i = Nat.succ (size as - i - 1) := by omega
     rw [this]
-    simp [foldl, foldlM, Nat.sub_add_eq]
-  · dsimp [foldl, foldlM]
+    simp [foldl, foldlM, Id.run, Nat.sub_add_eq]
+  · dsimp [foldl, Id.run, foldlM]
     rw [dif_pos (by omega), foldlM.loop, dif_neg h]
     rfl
 termination_by as.size - i
@@ -1596,8 +1601,8 @@ theorem filterMap_congr {as bs : Array α} (h : as = bs)
     as.toList ++ List.filterMap f xs := ?_
   exact this #[]
   induction xs
-  · simp_all
-  · simp_all [List.filterMap_cons]
+  · simp_all [Id.run]
+  · simp_all [Id.run, List.filterMap_cons]
     split <;> simp_all
 
 @[grind] theorem toList_filterMap {f : α → Option β} {xs : Array α} :
@@ -1811,8 +1816,7 @@ theorem toArray_append {xs : List α} {ys : Array α} :
 
 theorem singleton_eq_toArray_singleton {a : α} : #[a] = [a].toArray := rfl
 
-@[deprecated empty_append (since := "2025-05-26")]
-theorem empty_append_fun : ((#[] : Array α) ++ ·) = id := by
+@[simp] theorem empty_append_fun : ((#[] : Array α) ++ ·) = id := by
   funext ⟨l⟩
   simp
 
@@ -1862,7 +1866,7 @@ theorem getElem_append_right {xs ys : Array α} {h : i < (xs ++ ys).size} (hle :
     (xs ++ ys)[i] = ys[i - xs.size]'(Nat.sub_lt_left_of_lt_add hle (size_append .. ▸ h)) := by
   simp only [← getElem_toList]
   have h' : i < (xs.toList ++ ys.toList).length := by rwa [← length_toList, toList_append] at h
-  conv => rhs; unfold Array.size; rw [← List.getElem_append_right (h₁ := hle) (h₂ := h')]
+  conv => rhs; rw [← List.getElem_append_right (h₁ := hle) (h₂ := h')]
   apply List.get_of_eq; rw [toList_append]
 
 theorem getElem?_append_left {xs ys : Array α} {i : Nat} (hn : i < xs.size) :
@@ -1963,8 +1967,8 @@ theorem append_left_inj {xs₁ xs₂ : Array α} (ys) : xs₁ ++ ys = xs₂ ++ y
 theorem eq_empty_of_append_eq_empty {xs ys : Array α} (h : xs ++ ys = #[]) : xs = #[] ∧ ys = #[] :=
   append_eq_empty_iff.mp h
 
-theorem empty_eq_append_iff {xs ys : Array α} : #[] = xs ++ ys ↔ xs = #[] ∧ ys = #[] := by
-  simp
+@[simp] theorem empty_eq_append_iff {xs ys : Array α} : #[] = xs ++ ys ↔ xs = #[] ∧ ys = #[] := by
+  rw [eq_comm, append_eq_empty_iff]
 
 theorem append_ne_empty_of_left_ne_empty {xs ys : Array α} (h : xs ≠ #[]) : xs ++ ys ≠ #[] := by
   simp_all
@@ -2029,10 +2033,10 @@ theorem append_eq_append_iff {ws xs ys zs : Array α} :
         xs ++ ys.set (i - xs.size) x (by simp at h; omega) := by
   rcases xs with ⟨s⟩
   rcases ys with ⟨t⟩
-  simp only [List.append_toArray, List.set_toArray, List.set_append, Array.size]
+  simp only [List.append_toArray, List.set_toArray, List.set_append]
   split <;> simp
 
-@[simp] theorem set_append_left {xs ys : Array α} {i : Nat} {x : α} (h : i < xs.size)  :
+@[simp] theorem set_append_left {xs ys : Array α} {i : Nat} {x : α} (h : i < xs.size) :
     (xs ++ ys).set i x (by simp; omega) = xs.set i x ++ ys := by
   simp [set_append, h]
 
@@ -2049,7 +2053,7 @@ theorem append_eq_append_iff {ws xs ys zs : Array α} :
         xs ++ ys.setIfInBounds (i - xs.size) x := by
   rcases xs with ⟨s⟩
   rcases ys with ⟨t⟩
-  simp only [List.append_toArray, List.setIfInBounds_toArray, List.set_append, Array.size]
+  simp only [List.append_toArray, List.setIfInBounds_toArray, List.set_append]
   split <;> simp
 
 @[simp] theorem setIfInBounds_append_left {xs ys : Array α} {i : Nat} {x : α} (h : i < xs.size) :
@@ -2107,13 +2111,14 @@ theorem append_eq_map_iff {f : α → β} :
   | nil => simp
   | cons as => induction as.toList <;> simp [*]
 
-@[simp] theorem flatten_toArray_map {L : List (List α)} :
-    (L.map List.toArray).toArray.flatten = L.flatten.toArray := by
+@[simp] theorem flatten_map_toArray {L : List (List α)} :
+    (L.toArray.map List.toArray).flatten = L.flatten.toArray := by
   apply ext'
   simp [Function.comp_def]
 
-theorem flatten_map_toArray {L : List (List α)} :
-    (L.toArray.map List.toArray).flatten = L.flatten.toArray := by
+@[simp] theorem flatten_toArray_map {L : List (List α)} :
+    (L.map List.toArray).toArray.flatten = L.flatten.toArray := by
+  rw [← flatten_map_toArray]
   simp
 
 -- We set this to lower priority so that `flatten_toArray_map` is applied first when relevant.
@@ -2141,8 +2146,8 @@ theorem mem_flatten : ∀ {xss : Array (Array α)}, a ∈ xss.flatten ↔ ∃ xs
   induction xss using array₂_induction
   simp
 
-theorem empty_eq_flatten_iff {xss : Array (Array α)} : #[] = xss.flatten ↔ ∀ xs ∈ xss, xs = #[] := by
-  simp
+@[simp] theorem empty_eq_flatten_iff {xss : Array (Array α)} : #[] = xss.flatten ↔ ∀ xs ∈ xss, xs = #[] := by
+  rw [eq_comm, flatten_eq_empty_iff]
 
 theorem flatten_ne_empty_iff {xss : Array (Array α)} : xss.flatten ≠ #[] ↔ ∃ xs, xs ∈ xss ∧ xs ≠ #[] := by
   simp
@@ -2282,9 +2287,15 @@ theorem eq_iff_flatten_eq {xss₁ xss₂ : Array (Array α)} :
       rw [List.map_inj_right]
       simp +contextual
 
-theorem flatten_toArray_map_toArray {xss : List (List α)} :
+@[simp] theorem flatten_toArray_map_toArray {xss : List (List α)} :
     (xss.map List.toArray).toArray.flatten = xss.flatten.toArray := by
-  simp
+  simp [flatten]
+  suffices ∀ as, List.foldl (fun acc bs => acc ++ bs) as (List.map List.toArray xss) = as ++ xss.flatten.toArray by
+    simpa using this #[]
+  intro as
+  induction xss generalizing as with
+  | nil => simp
+  | cons xs xss ih => simp [ih]
 
 /-! ### flatMap -/
 
@@ -2314,9 +2325,13 @@ theorem flatMap_toArray_cons {β} {f : α → Array β} {a : α} {as : List α}
   intro cs
   induction as generalizing cs <;> simp_all
 
-theorem flatMap_toArray {β} {f : α → Array β} {as : List α} :
+@[simp, grind =] theorem flatMap_toArray {β} {f : α → Array β} {as : List α} :
     as.toArray.flatMap f = (as.flatMap (fun a => (f a).toList)).toArray := by
-  simp
+  induction as with
+  | nil => simp
+  | cons a as ih =>
+    apply ext'
+    simp [ih, flatMap_toArray_cons]
 
 @[simp] theorem flatMap_id {xss : Array (Array α)} : xss.flatMap id = xss.flatten := by simp [flatMap_def]
 
@@ -2782,7 +2797,7 @@ theorem reverse_eq_iff {xs ys : Array α} : xs.reverse = ys ↔ xs = ys.reverse
   cases xs
   simp
 
-@[grind _=_] theorem filterMap_reverse {f : α → Option β} {xs : Array α} : (xs.reverse.filterMap f) = (xs.filterMap f).reverse := by
+@[grind _=_]theorem filterMap_reverse {f : α → Option β} {xs : Array α} : (xs.reverse.filterMap f) = (xs.filterMap f).reverse := by
   cases xs
   simp
 
@@ -3018,21 +3033,19 @@ theorem take_size {xs : Array α} : xs.take xs.size = xs := by
   | succ n ih =>
     simp [shrink.loop, ih]
 
--- This doesn't need to be a simp lemma, as shortly we will simplify `shrink` to `take`.
-theorem size_shrink {xs : Array α} {i : Nat} : (xs.shrink i).size = min i xs.size := by
+@[simp] theorem size_shrink {xs : Array α} {i : Nat} : (xs.shrink i).size = min i xs.size := by
   simp [shrink]
   omega
 
--- This doesn't need to be a simp lemma, as shortly we will simplify `shrink` to `take`.
-theorem getElem_shrink {xs : Array α} {i j : Nat} (h : j < (xs.shrink i).size) :
-    (xs.shrink i)[j] = xs[j]'(by simp [size_shrink] at h; omega) := by
+@[simp] theorem getElem_shrink {xs : Array α} {i j : Nat} (h : j < (xs.shrink i).size) :
+    (xs.shrink i)[j] = xs[j]'(by simp at h; omega) := by
   simp [shrink]
 
-@[simp] theorem shrink_eq_take {xs : Array α} {i : Nat} : xs.shrink i = xs.take i := by
-  ext <;> simp [size_shrink, getElem_shrink]
+@[simp] theorem toList_shrink {xs : Array α} {i : Nat} : (xs.shrink i).toList = xs.toList.take i := by
+  apply List.ext_getElem <;> simp
 
-theorem toList_shrink {xs : Array α} {i : Nat} : (xs.shrink i).toList = xs.toList.take i := by
-  simp
+@[simp] theorem shrink_eq_take {xs : Array α} {i : Nat} : xs.shrink i = xs.take i := by
+  ext <;> simp
 
 /-! ### foldlM and foldrM -/
 
@@ -3201,16 +3214,18 @@ theorem foldlM_push [Monad m] [LawfulMonad m] {xs : Array α} {a : α} {f : β
   rw [foldr, foldrM_start_stop, ← foldrM_toList, List.foldrM_pure, foldr_toList, foldr, ← foldrM_start_stop]
 
 theorem foldl_eq_foldlM {f : β → α → β} {b} {xs : Array α} {start stop : Nat} :
-    xs.foldl f b start stop = (xs.foldlM (m := Id) (pure <| f · ·) b start stop).run := rfl
+    xs.foldl f b start stop = xs.foldlM (m := Id) f b start stop := by
+  simp [foldl, Id.run]
 
 theorem foldr_eq_foldrM {f : α → β → β} {b} {xs : Array α} {start stop : Nat} :
-    xs.foldr f b start stop = (xs.foldrM (m := Id) (pure <| f · ·) b start stop).run := rfl
+    xs.foldr f b start stop = xs.foldrM (m := Id) f b start stop := by
+  simp [foldr, Id.run]
 
 @[simp] theorem id_run_foldlM {f : β → α → Id β} {b} {xs : Array α} {start stop : Nat} :
-    Id.run (xs.foldlM f b start stop) = xs.foldl (f · · |>.run) b start stop := rfl
+    Id.run (xs.foldlM f b start stop) = xs.foldl f b start stop := foldl_eq_foldlM.symm
 
 @[simp] theorem id_run_foldrM {f : α → β → Id β} {b} {xs : Array α} {start stop : Nat} :
-    Id.run (xs.foldrM f b start stop) = xs.foldr (f · · |>.run) b start stop := rfl
+    Id.run (xs.foldrM f b start stop) = xs.foldr f b start stop := foldr_eq_foldrM.symm
 
 /-- Variant of `foldlM_reverse` with a side condition for the `stop` argument. -/
 @[simp] theorem foldlM_reverse' [Monad m] {xs : Array α} {f : β → α → m β} {b} {stop : Nat}
@@ -3239,7 +3254,7 @@ theorem foldrM_reverse [Monad m] {xs : Array α} {f : α → β → m β} {b} :
 
 theorem foldrM_push [Monad m] {f : α → β → m β} {init : β} {xs : Array α} {a : α} :
     (xs.push a).foldrM f init = f a init >>= xs.foldrM f := by
-  simp only [foldrM_eq_reverse_foldlM_toList, toList_push, List.reverse_append, List.reverse_cons,
+  simp only [foldrM_eq_reverse_foldlM_toList, push_toList, List.reverse_append, List.reverse_cons,
     List.reverse_nil, List.nil_append, List.singleton_append, List.foldlM_cons, List.foldlM_reverse]
 
 /--
@@ -3251,22 +3266,6 @@ rather than `(arr.push a).size` as the argument.
     (xs.push a).foldrM f init start = f a init >>= xs.foldrM f := by
   simp [← foldrM_push, h]
 
-@[simp, grind] theorem _root_.List.foldrM_push_eq_append [Monad m] [LawfulMonad m] {l : List α} {f : α → m β} {xs : Array β} :
-    l.foldrM (fun x xs => xs.push <$> f x) xs = do return xs ++ (← l.reverse.mapM f).toArray := by
-  induction l with
-  | nil => simp
-  | cons a l ih =>
-    simp [ih]
-    congr 1
-    funext l'
-    congr 1
-    funext x
-    simp
-
-@[simp, grind] theorem _root_.List.foldlM_push_eq_append [Monad m] [LawfulMonad m] {l : List α} {f : α → m β} {xs : Array β} :
-    l.foldlM (fun xs x => xs.push <$> f x) xs = do return xs ++ (← l.mapM f).toArray := by
-  induction l generalizing xs <;> simp [*]
-
 /-! ### foldl / foldr -/
 
 @[grind] theorem foldl_empty {f : β → α → β} {init : β} : (#[].foldl f init) = init := rfl
@@ -3363,32 +3362,6 @@ rather than `(arr.push a).size` as the argument.
   rcases as with ⟨as⟩
   simp
 
-@[simp, grind] theorem _root_.List.foldr_push_eq_append {l : List α} {f : α → β} {xs : Array β} :
-    l.foldr (fun x xs => xs.push (f x)) xs = xs ++ (l.reverse.map f).toArray := by
-  induction l <;> simp [*]
-
-/-- Variant of `List.foldr_push_eq_append` specialized to `f = id`. -/
-@[simp, grind] theorem _root_.List.foldr_push_eq_append' {l : List α} {xs : Array α} :
-    l.foldr (fun x xs => xs.push x) xs = xs ++ l.reverse.toArray := by
-  induction l <;> simp [*]
-
-@[simp, grind] theorem _root_.List.foldl_push_eq_append {l : List α} {f : α → β} {xs : Array β} :
-    l.foldl (fun xs x => xs.push (f x)) xs = xs ++ (l.map f).toArray := by
-  induction l generalizing xs <;> simp [*]
-
-/-- Variant of `List.foldl_push_eq_append` specialized to `f = id`. -/
-@[simp, grind] theorem _root_.List.foldl_push_eq_append' {l : List α} {xs : Array α} :
-    l.foldl (fun xs x => xs.push x) xs = xs ++ l.toArray := by
-  simpa using List.foldl_push_eq_append (f := id)
-
-@[deprecated _root_.List.foldl_push_eq_append' (since := "2025-05-18")]
-theorem _root_.List.foldl_push {l : List α} {as : Array α} : l.foldl Array.push as = as ++ l.toArray := by
-  induction l generalizing as <;> simp [*]
-
-@[deprecated _root_.List.foldr_push_eq_append' (since := "2025-05-18")]
-theorem _root_.List.foldr_push {l : List α} {as : Array α} : l.foldr (fun a bs => push bs a) as = as ++ l.reverse.toArray := by
-  rw [List.foldr_eq_foldl_reverse, List.foldl_push_eq_append']
-
 @[simp, grind] theorem foldr_append_eq_append {xs : Array α} {f : α → Array β} {ys : Array β} :
     xs.foldr (f · ++ ·) ys = (xs.map f).flatten ++ ys := by
   rcases xs with ⟨xs⟩
@@ -3510,16 +3483,17 @@ theorem foldrM_append [Monad m] [LawfulMonad m] {f : α → β → m β} {b} {xs
 
 @[simp] theorem foldr_append' {f : α → β → β} {b} {xs ys : Array α} {start : Nat}
     (w : start = xs.size + ys.size) :
-    (xs ++ ys).foldr f b start 0 = xs.foldr f (ys.foldr f b) :=
-  foldrM_append' w
+    (xs ++ ys).foldr f b start 0 = xs.foldr f (ys.foldr f b) := by
+  subst w
+  simp [foldr_eq_foldrM]
 
-@[grind _=_] theorem foldl_append {β : Type _} {f : β → α → β} {b} {xs ys : Array α} :
-    (xs ++ ys).foldl f b = ys.foldl f (xs.foldl f b) :=
-  foldlM_append
+@[grind _=_]theorem foldl_append {β : Type _} {f : β → α → β} {b} {xs ys : Array α} :
+    (xs ++ ys).foldl f b = ys.foldl f (xs.foldl f b) := by
+  simp [foldl_eq_foldlM]
 
 @[grind _=_] theorem foldr_append {f : α → β → β} {b} {xs ys : Array α} :
-    (xs ++ ys).foldr f b = xs.foldr f (ys.foldr f b) :=
-  foldrM_append
+    (xs ++ ys).foldr f b = xs.foldr f (ys.foldr f b) := by
+  simp [foldr_eq_foldrM]
 
 @[simp] theorem foldl_flatten' {f : β → α → β} {b} {xss : Array (Array α)} {stop : Nat}
     (w : stop = xss.flatten.size) :
@@ -3548,22 +3522,21 @@ theorem foldrM_append [Monad m] [LawfulMonad m] {f : α → β → m β} {b} {xs
 /-- Variant of `foldl_reverse` with a side condition for the `stop` argument. -/
 @[simp] theorem foldl_reverse' {xs : Array α} {f : β → α → β} {b} {stop : Nat}
     (w : stop = xs.size) :
-    xs.reverse.foldl f b 0 stop = xs.foldr (fun x y => f y x) b :=
-  foldlM_reverse' w
+    xs.reverse.foldl f b 0 stop = xs.foldr (fun x y => f y x) b := by
+  simp [w, foldl_eq_foldlM, foldr_eq_foldrM]
 
 /-- Variant of `foldr_reverse` with a side condition for the `start` argument. -/
 @[simp] theorem foldr_reverse' {xs : Array α} {f : α → β → β} {b} {start : Nat}
     (w : start = xs.size) :
-    xs.reverse.foldr f b start 0 = xs.foldl (fun x y => f y x) b :=
-  foldrM_reverse' w
+    xs.reverse.foldr f b start 0 = xs.foldl (fun x y => f y x) b := by
+  simp [w, foldl_eq_foldlM, foldr_eq_foldrM]
 
 @[grind] theorem foldl_reverse {xs : Array α} {f : β → α → β} {b} :
-    xs.reverse.foldl f b = xs.foldr (fun x y => f y x) b :=
-  foldlM_reverse
+    xs.reverse.foldl f b = xs.foldr (fun x y => f y x) b := by simp [foldl_eq_foldlM, foldr_eq_foldrM]
 
 @[grind] theorem foldr_reverse {xs : Array α} {f : α → β → β} {b} :
     xs.reverse.foldr f b = xs.foldl (fun x y => f y x) b :=
-  foldrM_reverse
+  (foldl_reverse ..).symm.trans <| by simp
 
 theorem foldl_eq_foldr_reverse {xs : Array α} {f : β → α → β} {b} :
     xs.foldl f b = xs.reverse.foldr (fun x y => f y x) b := by simp
@@ -3644,7 +3617,7 @@ theorem foldr_rel {xs : Array α} {f g : α → β → β} {a b : β} {r : β
 theorem back?_eq_some_iff {xs : Array α} {a : α} :
     xs.back? = some a ↔ ∃ ys : Array α, xs = ys.push a := by
   rcases xs with ⟨xs⟩
-  simp only [List.back?_toArray, List.getLast?_eq_some_iff, toArray_eq, toList_push]
+  simp only [List.back?_toArray, List.getLast?_eq_some_iff, toArray_eq, push_toList]
   constructor
   · rintro ⟨ys, rfl⟩
     exact ⟨ys.toArray, by simp⟩
@@ -3734,7 +3707,7 @@ theorem back?_replicate {a : α} {n : Nat} :
 @[deprecated back?_replicate (since := "2025-03-18")]
 abbrev back?_mkArray := @back?_replicate
 
-@[simp] theorem back_replicate {xs : Array α} (w : 0 < n) : (replicate n xs).back (by simpa using w) = xs := by
+@[simp] theorem back_replicate (w : 0 < n) : (replicate n a).back (by simpa using w) = a := by
   simp [back_eq_getElem]
 
 @[deprecated back_replicate (since := "2025-03-18")]
@@ -3769,7 +3742,7 @@ theorem contains_iff_exists_mem_beq [BEq α] {xs : Array α} {a : α} :
   rcases xs with ⟨xs⟩
   simp [List.contains_iff_exists_mem_beq]
 
-@[grind _=_]
+@[grind]
 theorem contains_iff_mem [BEq α] [LawfulBEq α] {xs : Array α} {a : α} :
     xs.contains a ↔ a ∈ xs := by
   simp
@@ -4077,19 +4050,18 @@ abbrev all_mkArray := @all_replicate
 
 /-! ### modify -/
 
-@[simp, grind =] theorem size_modify {xs : Array α} {i : Nat} {f : α → α} : (xs.modify i f).size = xs.size := by
-  unfold modify modifyM
+@[simp] theorem size_modify {xs : Array α} {i : Nat} {f : α → α} : (xs.modify i f).size = xs.size := by
+  unfold modify modifyM Id.run
   split <;> simp
 
-@[grind =] theorem getElem_modify {xs : Array α} {j i} (h : i < (xs.modify j f).size) :
+theorem getElem_modify {xs : Array α} {j i} (h : i < (xs.modify j f).size) :
     (xs.modify j f)[i] = if j = i then f (xs[i]'(by simpa using h)) else xs[i]'(by simpa using h) := by
-  simp only [modify, modifyM]
+  simp only [modify, modifyM, Id.run, Id.pure_eq]
   split
-  · simp only [getElem_set, Id.run_pure, Id.run_bind]; split <;> simp [*]
-  · simp only [Id.run_pure]
-    rw [if_neg (mt (by rintro rfl; exact h) (by simp_all))]
+  · simp only [Id.bind_eq, getElem_set]; split <;> simp [*]
+  · rw [if_neg (mt (by rintro rfl; exact h) (by simp_all))]
 
-@[simp, grind =] theorem toList_modify {xs : Array α} {f : α → α} {i : Nat} :
+@[simp] theorem toList_modify {xs : Array α} {f : α → α} {i : Nat} :
     (xs.modify i f).toList = xs.toList.modify i f := by
   apply List.ext_getElem
   · simp
@@ -4104,7 +4076,7 @@ theorem getElem_modify_of_ne {xs : Array α} {i : Nat} (h : i ≠ j)
     (xs.modify i f)[j] = xs[j]'(by simpa using hj) := by
   simp [getElem_modify hj, h]
 
-@[grind =] theorem getElem?_modify {xs : Array α} {i : Nat} {f : α → α} {j : Nat} :
+theorem getElem?_modify {xs : Array α} {i : Nat} {f : α → α} {j : Nat} :
     (xs.modify i f)[j]? = if i = j then xs[j]?.map f else xs[j]? := by
   simp only [getElem?_def, size_modify, getElem_modify, Option.map_dif]
   split <;> split <;> rfl
@@ -4153,18 +4125,20 @@ theorem swap_comm {xs : Array α} {i j : Nat} (hi hj) : xs.swap i j hi hj = xs.s
     · split <;> simp_all
     · split <;> simp_all
 
-@[simp, grind =] theorem size_swapIfInBounds {xs : Array α} {i j : Nat} :
+@[simp] theorem size_swapIfInBounds {xs : Array α} {i j : Nat} :
     (xs.swapIfInBounds i j).size = xs.size := by unfold swapIfInBounds; split <;> (try split) <;> simp [size_swap]
 
+@[deprecated size_swapIfInBounds (since := "2024-11-24")] abbrev size_swap! := @size_swapIfInBounds
+
 /-! ### swapAt -/
 
-@[simp, grind =] theorem swapAt_def {xs : Array α} {i : Nat} {v : α} (hi) :
+@[simp] theorem swapAt_def {xs : Array α} {i : Nat} {v : α} (hi) :
     xs.swapAt i v hi = (xs[i], xs.set i v) := rfl
 
 theorem size_swapAt {xs : Array α} {i : Nat} {v : α} (hi) :
     (xs.swapAt i v hi).2.size = xs.size := by simp
 
-@[simp, grind =]
+@[simp]
 theorem swapAt!_def {xs : Array α} {i : Nat} {v : α} (h : i < xs.size) :
     xs.swapAt! i v = (xs[i], xs.set i v) := by simp [swapAt!, h]
 
@@ -4287,44 +4261,42 @@ Examples:
 
 /-! ### Preliminaries about `ofFn` -/
 
-@[simp] theorem size_ofFn_go {n} {f : Fin n → α} {i acc h} :
-    (ofFn.go f acc i h).size = acc.size + i := by
-  induction i generalizing acc with
-  | zero => simp [ofFn.go]
-  | succ i ih =>
-    simpa [ofFn.go, ih] using Nat.succ_add_eq_add_succ acc.size i
+@[simp] theorem size_ofFn_go {n} {f : Fin n → α} {i acc} :
+    (ofFn.go f i acc).size = acc.size + (n - i) := by
+  if hin : i < n then
+    unfold ofFn.go
+    have : 1 + (n - (i + 1)) = n - i :=
+      Nat.sub_sub .. ▸ Nat.add_sub_cancel' (Nat.le_sub_of_add_le (Nat.add_comm .. ▸ hin))
+    rw [dif_pos hin, size_ofFn_go, size_push, Nat.add_assoc, this]
+  else
+    have : n - i = 0 := Nat.sub_eq_zero_of_le (Nat.le_of_not_lt hin)
+    unfold ofFn.go
+    simp [hin, this]
+termination_by n - i
 
 @[simp] theorem size_ofFn {n : Nat} {f : Fin n → α} : (ofFn f).size = n := by simp [ofFn]
 
--- Recall `ofFn.go f acc i h = acc ++ #[f (n - i), ..., f(n - 1)]`
-theorem getElem_ofFn_go {f : Fin n → α} {acc i k} (h : i ≤ n) (w₁ : k < acc.size + i) :
-    (ofFn.go f acc i h)[k]'(by simpa using w₁) =
-      if w₂ : k < acc.size then acc[k] else f ⟨n - i + k - acc.size, by omega⟩ := by
-  induction i generalizing acc k with
-  | zero =>
-    simp at w₁
-    simp_all [ofFn.go]
-  | succ i ih =>
-    unfold ofFn.go
-    rw [ih]
-    · simp only [size_push]
-      split <;> rename_i h'
-      · rw [Array.getElem_push]
-        split
-        · rfl
-        · congr 2
-          omega
-      · split
-        · omega
-        · congr 2
-          omega
-    · simp
-      omega
+theorem getElem_ofFn_go {f : Fin n → α} {i} {acc k}
+    (hki : k < n) (hin : i ≤ n) (hi : i = acc.size)
+    (hacc : ∀ j, ∀ hj : j < acc.size, acc[j] = f ⟨j, Nat.lt_of_lt_of_le hj (hi ▸ hin)⟩) :
+    haveI : acc.size + (n - acc.size) = n := Nat.add_sub_cancel' (hi ▸ hin)
+    (ofFn.go f i acc)[k]'(by simp [*]) = f ⟨k, hki⟩ := by
+  unfold ofFn.go
+  if hin : i < n then
+    have : 1 + (n - (i + 1)) = n - i :=
+      Nat.sub_sub .. ▸ Nat.add_sub_cancel' (Nat.le_sub_of_add_le (Nat.add_comm .. ▸ hin))
+    simp only [dif_pos hin]
+    rw [getElem_ofFn_go _ hin (by simp [*]) (fun j hj => ?hacc)]
+    cases (Nat.lt_or_eq_of_le <| Nat.le_of_lt_succ (by simpa using hj)) with
+    | inl hj => simp [getElem_push, hj, hacc j hj]
+    | inr hj => simp [getElem_push, *]
+  else
+    simp [hin, hacc k (Nat.lt_of_lt_of_le hki (Nat.le_of_not_lt (hi ▸ hin)))]
+termination_by n - i
 
 @[simp] theorem getElem_ofFn {f : Fin n → α} {i : Nat} (h : i < (ofFn f).size) :
-    (ofFn f)[i] = f ⟨i, size_ofFn (f := f) ▸ h⟩ := by
-  unfold ofFn
-  rw [getElem_ofFn_go] <;> simp_all
+    (ofFn f)[i] = f ⟨i, size_ofFn (f := f) ▸ h⟩ :=
+  getElem_ofFn_go _ (by simp) (by simp) nofun
 
 theorem getElem?_ofFn {f : Fin n → α} {i : Nat} :
     (ofFn f)[i]? = if h : i < n then some (f ⟨i, h⟩) else none := by
@@ -4332,44 +4304,42 @@ theorem getElem?_ofFn {f : Fin n → α} {i : Nat} :
 
 /-! ### Preliminaries about `range` and `range'` -/
 
-@[simp, grind =] theorem size_range' {start size step} : (range' start size step).size = size := by
+@[simp] theorem size_range' {start size step} : (range' start size step).size = size := by
   simp [range']
 
-@[simp, grind =] theorem toList_range' {start size step} :
+@[simp] theorem toList_range' {start size step} :
      (range' start size step).toList = List.range' start size step := by
   apply List.ext_getElem <;> simp [range']
 
-@[simp, grind =]
+@[simp]
 theorem getElem_range' {start size step : Nat} {i : Nat}
     (h : i < (Array.range' start size step).size) :
     (Array.range' start size step)[i] = start + step * i := by
   simp [← getElem_toList]
 
-@[grind =]
 theorem getElem?_range' {start size step : Nat} {i : Nat} :
     (Array.range' start size step)[i]? = if i < size then some (start + step * i) else none := by
   simp [getElem?_def, getElem_range']
 
-@[simp, grind =] theorem _root_.List.toArray_range' {start size step : Nat} :
+@[simp] theorem _root_.List.toArray_range' {start size step : Nat} :
     (List.range' start size step).toArray = Array.range' start size step := by
   apply ext'
   simp
 
-@[simp, grind =] theorem size_range {n : Nat} : (range n).size = n := by
+@[simp] theorem size_range {n : Nat} : (range n).size = n := by
   simp [range]
 
-@[simp, grind =] theorem toList_range {n : Nat} : (range n).toList = List.range n := by
+@[simp] theorem toList_range {n : Nat} : (range n).toList = List.range n := by
   apply List.ext_getElem <;> simp [range]
 
-@[simp, grind =]
+@[simp]
 theorem getElem_range {n : Nat} {i : Nat} (h : i < (Array.range n).size) : (Array.range n)[i] = i := by
   simp [← getElem_toList]
 
-@[grind =]
 theorem getElem?_range {n : Nat} {i : Nat} : (Array.range n)[i]? = if i < n then some i else none := by
   simp [getElem?_def, getElem_range]
 
-@[simp, grind =] theorem _root_.List.toArray_range {n : Nat} : (List.range n).toArray = Array.range n := by
+@[simp] theorem _root_.List.toArray_range {n : Nat} : (List.range n).toArray = Array.range n := by
   apply ext'
   simp
 
@@ -4417,8 +4387,7 @@ theorem getElem!_eq_getD [Inhabited α] {xs : Array α} {i} : xs[i]! = xs.getD i
 
 /-! # mem -/
 
-@[deprecated mem_toList_iff (since := "2025-05-26")]
-theorem mem_toList {a : α} {xs : Array α} : a ∈ xs.toList ↔ a ∈ xs := mem_def.symm
+@[simp, grind =] theorem mem_toList {a : α} {xs : Array α} : a ∈ xs.toList ↔ a ∈ xs := mem_def.symm
 
 @[deprecated not_mem_empty (since := "2025-03-25")]
 theorem not_mem_nil (a : α) : ¬ a ∈ #[] := nofun
@@ -4438,7 +4407,7 @@ theorem getElem?_size_le {xs : Array α} {i : Nat} (h : xs.size ≤ i) : xs[i]?
   simp [getElem?_neg, h]
 
 theorem getElem_mem_toList {xs : Array α} {i : Nat} (h : i < xs.size) : xs[i] ∈ xs.toList := by
-  simp only [← getElem_toList, List.getElem_mem, ugetElem_eq_getElem]
+  simp only [← getElem_toList, List.getElem_mem]
 
 theorem back!_eq_back? [Inhabited α] {xs : Array α} : xs.back! = xs.back?.getD default := by
   simp [back!, back?, getElem!_def, Option.getD]; rfl
@@ -4467,7 +4436,7 @@ theorem getElem?_push_eq {xs : Array α} {x : α} : (xs.push x)[xs.size]? = some
   simp
 
 @[simp, grind =] theorem forIn'_toList [Monad m] {xs : Array α} {b : β} {f : (a : α) → a ∈ xs.toList → β → m (ForInStep β)} :
-    forIn' xs.toList b f = forIn' xs b (fun a m b => f a (mem_toList_iff.mpr m) b) := by
+    forIn' xs.toList b f = forIn' xs b (fun a m b => f a (mem_toList.mpr m) b) := by
   cases xs
   simp
 
@@ -4506,7 +4475,6 @@ abbrev contains_def [DecidableEq α] {a : α} {xs : Array α} : xs.contains a
 @[simp] theorem size_zipWith {xs : Array α} {ys : Array β} {f : α → β → γ} :
     (zipWith f xs ys).size = min xs.size ys.size := by
   rw [size_eq_length_toList, toList_zipWith, List.length_zipWith]
-  simp only [Array.size]
 
 @[simp] theorem size_zip {xs : Array α} {ys : Array β} :
     (zip xs ys).size = min xs.size ys.size :=
@@ -4565,8 +4533,8 @@ Our goal is to have `simp` "pull `List.toArray` outwards" as much as possible.
 
 theorem toListRev_toArray {l : List α} : l.toArray.toListRev = l.reverse := by simp
 
-@[grind =] theorem take_toArray {l : List α} {i : Nat} : l.toArray.take i = (l.take i).toArray := by
-  simp
+@[simp, grind =] theorem take_toArray {l : List α} {i : Nat} : l.toArray.take i = (l.take i).toArray := by
+  apply Array.ext <;> simp
 
 @[simp, grind =] theorem mapM_toArray [Monad m] [LawfulMonad m] {f : α → m β} {l : List α} :
     l.toArray.mapM f = List.toArray <$> l.mapM f := by
@@ -4579,7 +4547,7 @@ theorem toListRev_toArray {l : List α} : l.toArray.toListRev = l.reverse := by
   | nil => simp
   | cons a l ih =>
     simp only [foldlM_toArray] at ih
-    rw [size_toArray, mapM'_cons]
+    rw [size_toArray, mapM'_cons, foldlM_toArray]
     simp [ih]
 
 theorem uset_toArray {l : List α} {i : USize} {a : α} {h : i.toNat < l.toArray.size} :
@@ -4632,12 +4600,12 @@ namespace Array
 @[simp] theorem findSomeRev?_eq_findSome?_reverse {f : α → Option β} {xs : Array α} :
     xs.findSomeRev? f = xs.reverse.findSome? f := by
   cases xs
-  simp [findSomeRev?]
+  simp [findSomeRev?, Id.run]
 
 @[simp] theorem findRev?_eq_find?_reverse {f : α → Bool} {xs : Array α} :
     xs.findRev? f = xs.reverse.find? f := by
   cases xs
-  simp [findRev?]
+  simp [findRev?, Id.run]
 
 /-! ### unzip -/
 
@@ -4693,6 +4661,13 @@ namespace List
 end List
 
 /-! ### Deprecations -/
+
+namespace List
+
+@[deprecated setIfInBounds_toArray (since := "2024-11-24")] abbrev setD_toArray := @setIfInBounds_toArray
+
+end List
+
 namespace Array
 
 @[deprecated size_toArray (since := "2024-12-11")]
@@ -4745,6 +4720,17 @@ theorem get_set_eq (xs : Array α) (i : Nat) (v : α) (h : i < xs.size) :
     (xs.set i v h)[i]'(by simp [h]) = v := by
   simp only [set, ← getElem_toList, List.getElem_set_self]
 
+@[deprecated set!_is_setIfInBounds (since := "2024-11-24")] abbrev set_is_setIfInBounds := @set!_eq_setIfInBounds
+@[deprecated size_setIfInBounds (since := "2024-11-24")] abbrev size_setD := @size_setIfInBounds
+@[deprecated getElem_setIfInBounds_eq (since := "2024-11-24")] abbrev getElem_setD_eq := @getElem_setIfInBounds_self
+@[deprecated getElem?_setIfInBounds_eq (since := "2024-11-24")] abbrev get?_setD_eq := @getElem?_setIfInBounds_self
+@[deprecated getD_getElem?_setIfInBounds (since := "2025-04-04")] abbrev getD_get?_setIfInBounds := @getD_getElem?_setIfInBounds
+@[deprecated getD_getElem?_setIfInBounds (since := "2024-11-24")] abbrev getD_setD := @getD_getElem?_setIfInBounds
+@[deprecated getElem_setIfInBounds (since := "2024-11-24")] abbrev getElem_setD := @getElem_setIfInBounds
+
+@[deprecated List.getElem_toArray (since := "2024-11-29")]
+theorem getElem_mk {xs : List α} {i : Nat} (h : i < xs.length) : (Array.mk xs)[i] = xs[i] := rfl
+
 @[deprecated Array.getElem_toList (since := "2024-12-08")]
 theorem getElem_eq_getElem_toList {xs : Array α} (h : i < xs.size) : xs[i] = xs.toList[i] := rfl
 

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

@@ -29,12 +29,16 @@ protected theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] {xs ys
   Decidable.not_not
 
 @[simp] theorem lex_empty [BEq α] {lt : α → α → Bool} {xs : Array α} : xs.lex #[] lt = false := by
-  simp [lex]
+  simp [lex, Id.run]
+
+@[simp] theorem singleton_lex_singleton [BEq α] {lt : α → α → Bool} : #[a].lex #[b] lt = lt a b := by
+  simp only [lex, List.getElem_toArray, List.getElem_singleton]
+  cases lt a b <;> cases a != b <;> simp [Id.run]
 
 private theorem cons_lex_cons [BEq α] {lt : α → α → Bool} {a b : α} {xs ys : Array α} :
      (#[a] ++ xs).lex (#[b] ++ ys) lt =
        (lt a b || a == b && xs.lex ys lt) := by
-  simp only [lex]
+  simp only [lex, Id.run]
   simp only [Std.Range.forIn'_eq_forIn'_range', size_append, List.size_toArray, List.length_singleton,
     Nat.add_comm 1]
   simp [Nat.add_min_add_right, List.range'_succ, getElem_append_left, List.range'_succ_left,
@@ -47,16 +51,13 @@ private theorem cons_lex_cons [BEq α] {lt : α → α → Bool} {a b : α} {xs
 @[simp, grind =] theorem _root_.List.lex_toArray [BEq α] {lt : α → α → Bool} {l₁ l₂ : List α} :
     l₁.toArray.lex l₂.toArray lt = l₁.lex l₂ lt := by
   induction l₁ generalizing l₂ with
-  | nil => cases l₂ <;> simp [lex]
+  | nil => cases l₂ <;> simp [lex, Id.run]
   | cons x l₁ ih =>
     cases l₂ with
-    | nil => simp [lex]
+    | nil => simp [lex, Id.run]
     | cons y l₂ =>
       rw [List.toArray_cons, List.toArray_cons y, cons_lex_cons, List.lex, ih]
 
-theorem singleton_lex_singleton [BEq α] {lt : α → α → Bool} : #[a].lex #[b] lt = lt a b := by
-  simp
-
 @[simp, grind =] theorem lex_toList [BEq α] {lt : α → α → Bool} {xs ys : Array α} :
     xs.toList.lex ys.toList lt = xs.lex ys lt := by
   cases xs <;> cases ys <;> simp

src/Init/Data/Array/MapIdx.lean

@@ -27,7 +27,7 @@ theorem mapFinIdx_induction (xs : Array α) (f : (i : Nat) → α → (h : i < x
     motive xs.size ∧ ∃ eq : (Array.mapFinIdx xs f).size = xs.size,
       ∀ i h, p i ((Array.mapFinIdx xs 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) :
-    let as : Array β := Id.run <| Array.mapFinIdxM.map xs (pure <| f · · ·) i j h bs
+    let as : Array β := Array.mapFinIdxM.map (m := Id) xs f i j h bs
     motive xs.size ∧ ∃ eq : as.size = xs.size, ∀ i h, p i as[i] h := by
     induction i generalizing j bs with simp [mapFinIdxM.map]
     | zero =>
@@ -192,8 +192,7 @@ theorem mapFinIdx_empty {f : (i : Nat) → α → (h : i < 0) → β} : mapFinId
 theorem mapFinIdx_eq_ofFn {xs : Array α} {f : (i : Nat) → α → (h : i < xs.size) → β} :
     xs.mapFinIdx f = Array.ofFn fun i : Fin xs.size => f i xs[i] i.2 := by
   cases xs
-  simp only [List.mapFinIdx_toArray, List.mapFinIdx_eq_ofFn, Fin.getElem_fin, List.getElem_toArray]
-  simp [Array.size]
+  simp [List.mapFinIdx_eq_ofFn]
 
 theorem mapFinIdx_append {xs ys : Array α} {f : (i : Nat) → α → (h : i < (xs ++ ys).size) → β} :
     (xs ++ ys).mapFinIdx f =
@@ -201,7 +200,7 @@ theorem mapFinIdx_append {xs ys : Array α} {f : (i : Nat) → α → (h : i < (
         ys.mapFinIdx (fun i a h => f (i + xs.size) a (by simp; omega)) := by
   cases xs
   cases ys
-  simp [List.mapFinIdx_append, Array.size]
+  simp [List.mapFinIdx_append]
 
 @[simp]
 theorem mapFinIdx_push {xs : Array α} {a : α} {f : (i : Nat) → α → (h : i < (xs.push a).size) → β} :
@@ -265,12 +264,12 @@ theorem mapFinIdx_eq_append_iff {xs : Array α} {f : (i : Nat) → α → (h : i
     toArray_eq_append_iff]
   constructor
   · rintro ⟨l₁, l₂, rfl, rfl, rfl⟩
-    refine ⟨l₁.toArray, l₂.toArray, by simp_all [Array.size]⟩
+    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 [Array.size]⟩
+    refine ⟨l₁, l₂, by simp_all⟩
 
 theorem mapFinIdx_eq_push_iff {xs : Array α} {b : β} {f : (i : Nat) → α → (h : i < xs.size) → β} :
     xs.mapFinIdx f = ys.push b ↔
@@ -308,7 +307,7 @@ abbrev mapFinIdx_eq_mkArray_iff := @mapFinIdx_eq_replicate_iff
 @[simp] theorem mapFinIdx_reverse {xs : Array α} {f : (i : Nat) → α → (h : i < xs.reverse.size) → β} :
     xs.reverse.mapFinIdx f = (xs.mapFinIdx (fun i a h => f (xs.size - 1 - i) a (by simp; omega))).reverse := by
   rcases xs with ⟨l⟩
-  simp [List.mapFinIdx_reverse, Array.size]
+  simp [List.mapFinIdx_reverse]
 
 /-! ### mapIdx -/
 
@@ -414,7 +413,7 @@ theorem mapIdx_eq_mapIdx_iff {xs : Array α} :
   rcases xs with ⟨xs⟩
   simp [List.mapIdx_eq_mapIdx_iff]
 
-@[simp] theorem mapIdx_set {f : Nat → α → β} {xs : Array α} {i : Nat} {h : i < xs.size} {a : α} :
+@[simp] theorem mapIdx_set {xs : Array α} {i : Nat} {h : i < xs.size} {a : α} :
     (xs.set i a).mapIdx f = (xs.mapIdx f).set i (f i a) (by simpa) := by
   rcases xs with ⟨xs⟩
   simp [List.mapIdx_set]
@@ -487,7 +486,7 @@ namespace List
     | x :: xs => simp only [mapFinIdxM.go, mapIdxM.go, go]
   unfold Array.mapIdxM
   rw [mapFinIdxM_toArray]
-  simp only [mapFinIdxM, mapIdxM, Array.size]
+  simp only [mapFinIdxM, mapIdxM]
   rw [go]
 
 end List

src/Init/Data/Array/Monadic.lean

@@ -25,29 +25,15 @@ open Nat
 
 /-! ## Monadic operations -/
 
-theorem map_toList_inj [Monad m] [LawfulMonad m]
-    {xs : m (Array α)} {ys : m (Array α)} :
-   toList <$> xs = toList <$> ys ↔ xs = ys := by
-  simp
-
 /-! ### mapM -/
 
 @[simp] theorem mapM_pure [Monad m] [LawfulMonad m] {xs : Array α} {f : α → β} :
     xs.mapM (m := m) (pure <| f ·) = pure (xs.map f) := by
   induction xs; simp_all
 
-@[simp] theorem idRun_mapM {xs : Array α} {f : α → Id β} : (xs.mapM f).run = xs.map (f · |>.run) :=
+@[simp] theorem mapM_id {xs : Array α} {f : α → Id β} : xs.mapM f = xs.map f :=
   mapM_pure
 
-@[deprecated idRun_mapM (since := "2025-05-21")]
-theorem mapM_id {xs : Array α} {f : α → Id β} : xs.mapM f = xs.map f :=
-  mapM_pure
-
-@[simp] theorem mapM_map [Monad m] [LawfulMonad m] {f : α → β} {g : β → m γ} {xs : Array α} :
-    (xs.map f).mapM g = xs.mapM (g ∘ f) := by
-  rcases xs with ⟨xs⟩
-  simp
-
 @[simp] theorem mapM_append [Monad m] [LawfulMonad m] {f : α → m β} {xs ys : Array α} :
     (xs ++ ys).mapM f = (return (← xs.mapM f) ++ (← ys.mapM f)) := by
   rcases xs with ⟨xs⟩
@@ -195,18 +181,12 @@ theorem forIn'_eq_foldlM [Monad m] [LawfulMonad m]
   rcases xs with ⟨xs⟩
   simp [List.forIn'_pure_yield_eq_foldl, List.foldl_map]
 
-theorem idRun_forIn'_yield_eq_foldl
-    {xs : Array α} (f : (a : α) → a ∈ xs → β → Id β) (init : β) :
-    (forIn' xs init (fun a m b => .yield <$> f a m b)).run =
-      xs.attach.foldl (fun b ⟨a, h⟩ => f a h b |>.run) init := by
-  simp
-
-@[deprecated idRun_forIn'_yield_eq_foldl (since := "2025-05-21")]
-theorem forIn'_yield_eq_foldl
+@[simp] theorem forIn'_yield_eq_foldl
     {xs : Array α} (f : (a : α) → a ∈ xs → β → β) (init : β) :
     forIn' (m := Id) xs init (fun a m b => .yield (f a m b)) =
-      xs.attach.foldl (fun b ⟨a, h⟩ => f a h b) init :=
-  forIn'_pure_yield_eq_foldl _ _
+      xs.attach.foldl (fun b ⟨a, h⟩ => f a h b) init := by
+  rcases xs with ⟨xs⟩
+  simp [List.foldl_map]
 
 @[simp] theorem forIn'_map [Monad m] [LawfulMonad m]
     {xs : Array α} (g : α → β) (f : (b : β) → b ∈ xs.map g → γ → m (ForInStep γ)) :
@@ -243,18 +223,12 @@ theorem forIn_eq_foldlM [Monad m] [LawfulMonad m]
   rcases xs with ⟨xs⟩
   simp [List.forIn_pure_yield_eq_foldl, List.foldl_map]
 
-theorem idRun_forIn_yield_eq_foldl
-    {xs : Array α} (f : α → β → Id β) (init : β) :
-    (forIn xs init (fun a b => .yield <$> f a b)).run =
-      xs.foldl (fun b a => f a b |>.run) init := by
-  simp
-
-@[deprecated idRun_forIn_yield_eq_foldl (since := "2025-05-21")]
-theorem forIn_yield_eq_foldl
+@[simp] theorem forIn_yield_eq_foldl
     {xs : Array α} (f : α → β → β) (init : β) :
     forIn (m := Id) xs init (fun a b => .yield (f a b)) =
-      xs.foldl (fun b a => f a b) init :=
-  forIn_pure_yield_eq_foldl _ _
+      xs.foldl (fun b a => f a b) init := by
+  rcases xs with ⟨xs⟩
+  simp [List.foldl_map]
 
 @[simp] theorem forIn_map [Monad m] [LawfulMonad m]
     {xs : Array α} {g : α → β} {f : β → γ → m (ForInStep γ)} :
@@ -310,7 +284,7 @@ namespace List
 @[simp] theorem filterM_toArray' [Monad m] [LawfulMonad m] {l : List α} {p : α → m Bool} (w : stop = l.length) :
     l.toArray.filterM p 0 stop = toArray <$> l.filterM p := by
   subst w
-  simp [← filterM_toArray]
+  rw [filterM_toArray]
 
 @[grind =] theorem filterRevM_toArray [Monad m] [LawfulMonad m] {l : List α} {p : α → m Bool} :
     l.toArray.filterRevM p = toArray <$> l.filterRevM p := by
@@ -322,7 +296,7 @@ namespace List
 @[simp] theorem filterRevM_toArray' [Monad m] [LawfulMonad m] {l : List α} {p : α → m Bool} (w : start = l.length) :
     l.toArray.filterRevM p start 0 = toArray <$> l.filterRevM p := by
   subst w
-  simp [← filterRevM_toArray]
+  rw [filterRevM_toArray]
 
 @[grind =] theorem filterMapM_toArray [Monad m] [LawfulMonad m] {l : List α} {f : α → m (Option β)} :
     l.toArray.filterMapM f = toArray <$> l.filterMapM f := by
@@ -340,7 +314,7 @@ namespace List
 @[simp] theorem filterMapM_toArray' [Monad m] [LawfulMonad m] {l : List α} {f : α → m (Option β)} (w : stop = l.length) :
     l.toArray.filterMapM f 0 stop = toArray <$> l.filterMapM f := by
   subst w
-  simp [← filterMapM_toArray]
+  rw [filterMapM_toArray]
 
 @[simp, grind =] theorem flatMapM_toArray [Monad m] [LawfulMonad m] {l : List α} {f : α → m (Array β)} :
     l.toArray.flatMapM f = toArray <$> l.flatMapM (fun a => Array.toList <$> f a) := by

src/Init/Data/Array/OfFn.lean

@@ -8,9 +8,7 @@ module
 prelude
 import all Init.Data.Array.Basic
 import Init.Data.Array.Lemmas
-import Init.Data.Array.Monadic
 import Init.Data.List.OfFn
-import Init.Data.List.FinRange
 
 /-!
 # Theorems about `Array.ofFn`
@@ -21,8 +19,6 @@ set_option linter.indexVariables true -- Enforce naming conventions for index va
 
 namespace Array
 
-/-! ### ofFn -/
-
 @[simp] theorem ofFn_zero {f : Fin 0 → α} : ofFn f = #[] := by
   simp [ofFn, ofFn.go]
 
@@ -36,23 +32,12 @@ theorem ofFn_succ {f : Fin (n+1) → α} :
     intro h₃
     simp only [show i = n by omega]
 
-theorem ofFn_add {n m} {f : Fin (n + m) → α} :
-    ofFn f = (ofFn (fun i => f (i.castLE (Nat.le_add_right n m)))) ++ (ofFn (fun i => f (i.natAdd n))) := by
-  induction m with
-  | zero => simp
-  | succ m ih => simp [ofFn_succ, ih]
-
 @[simp] theorem _root_.List.toArray_ofFn {f : Fin n → α} : (List.ofFn f).toArray = Array.ofFn f := by
   ext <;> simp
 
 @[simp] theorem toList_ofFn {f : Fin n → α} : (Array.ofFn f).toList = List.ofFn f := by
   apply List.ext_getElem <;> simp
 
-theorem ofFn_succ' {f : Fin (n+1) → α} :
-    ofFn f = #[f 0] ++ ofFn (fun i => f i.succ) := by
-  apply Array.toList_inj.mp
-  simp [List.ofFn_succ]
-
 @[simp]
 theorem ofFn_eq_empty_iff {f : Fin n → α} : ofFn f = #[] ↔ n = 0 := by
   rw [← Array.toList_inj]
@@ -67,70 +52,4 @@ theorem mem_ofFn {n} {f : Fin n → α} {a : α} : a ∈ ofFn f ↔ ∃ i, f i =
   · rintro ⟨i, rfl⟩
     apply mem_of_getElem (i := i) <;> simp
 
-/-! ### ofFnM -/
-
-/-- Construct (in a monadic context) an array by applying a monadic function to each index. -/
-def ofFnM {n} [Monad m] (f : Fin n → m α) : m (Array α) :=
-  Fin.foldlM n (fun xs i => xs.push <$> f i) (Array.emptyWithCapacity n)
-
-@[simp]
-theorem ofFnM_zero [Monad m] {f : Fin 0 → m α} : ofFnM f = pure #[] := by
-  simp [ofFnM]
-
-theorem ofFnM_succ' {n} [Monad m] [LawfulMonad m] {f : Fin (n + 1) → m α} :
-    ofFnM f = (do
-      let a ← f 0
-      let as ← ofFnM fun i => f i.succ
-      pure (#[a] ++ as)) := by
-  simp [ofFnM, Fin.foldlM_eq_foldlM_finRange, List.foldlM_push_eq_append, List.finRange_succ, Function.comp_def]
-
-theorem ofFnM_succ {n} [Monad m] [LawfulMonad m] {f : Fin (n + 1) → m α} :
-    ofFnM f = (do
-      let as ← ofFnM fun i => f i.castSucc
-      let a  ← f (Fin.last n)
-      pure (as.push a)) := by
-  simp [ofFnM, Fin.foldlM_succ_last]
-
-theorem ofFnM_add {n m} [Monad m] [LawfulMonad m] {f : Fin (n + k) → m α} :
-    ofFnM f = (do
-      let as ← ofFnM fun i : Fin n => f (i.castLE (Nat.le_add_right n k))
-      let bs ← ofFnM fun i : Fin k => f (i.natAdd n)
-      pure (as ++ bs)) := by
-  induction k with
-  | zero => simp
-  | succ k ih =>
-    simp only [ofFnM_succ, Nat.add_eq, ih, Fin.castSucc_castLE, Fin.castSucc_natAdd, bind_pure_comp,
-      bind_assoc, bind_map_left, Fin.natAdd_last, map_bind, Functor.map_map]
-    congr 1
-    funext xs
-    congr 1
-    funext ys
-    congr 1
-    funext x
-    simp
-
-@[simp] theorem toList_ofFnM [Monad m] [LawfulMonad m] {f : Fin n → m α} :
-    toList <$> ofFnM f = List.ofFnM f := by
-  induction n with
-  | zero => simp
-  | succ n ih => simp [ofFnM_succ, List.ofFnM_succ_last, ← ih]
-
-@[simp]
-theorem ofFnM_pure_comp [Monad m] [LawfulMonad m] {n} {f : Fin n → α} :
-    ofFnM (pure ∘ f) = (pure (ofFn f) : m (Array α)) := by
-  apply Array.map_toList_inj.mp
-  simp
-
--- Variant of `ofFnM_pure_comp` using a lambda.
--- This is not marked a `@[simp]` as it would match on every occurrence of `ofFnM`.
-theorem ofFnM_pure [Monad m] [LawfulMonad m] {n} {f : Fin n → α} :
-    ofFnM (fun i => pure (f i)) = (pure (ofFn f) : m (Array α)) :=
-  ofFnM_pure_comp
-
-@[simp, grind =] theorem idRun_ofFnM {f : Fin n → Id α} :
-    Id.run (ofFnM f) = ofFn (fun i => Id.run (f i)) := by
-  induction n with
-  | zero => simp
-  | succ n ih => simp [ofFnM_succ', ofFn_succ', ih]
-
 end Array

src/Init/Data/Array/QSort/Basic.lean

@@ -27,27 +27,23 @@ Internal implementation of `Array.qsort`.
 
 It does so by first swapping the elements at indices `lo`, `mid := (lo + hi) / 2`, and `hi`
 if necessary so that the middle (pivot) element is at index `hi`.
-We then iterate from `k = lo` to `k = hi`, with a pointer `i` starting at `lo`, and
+We then iterate from `j = lo` to `j = hi`, with a pointer `i` starting at `lo`, and
 swapping each element which is less than the pivot to position `i`, and then incrementing `i`.
 -/
-def qpartition {n} (as : Vector α n) (lt : α → α → Bool) (lo hi : Nat) (w : lo ≤ hi := by omega)
-    (hlo : lo < n := by omega) (hhi : hi < n := by omega) : {m : Nat // lo ≤ m ∧ m ≤ hi} × Vector α n :=
+def qpartition {n} (as : Vector α n) (lt : α → α → Bool) (lo hi : Nat)
+    (hlo : lo < n := by omega) (hhi : hi < n := by omega) : {m : Nat // lo ≤ m ∧ m < n} × Vector α n :=
   let mid := (lo + hi) / 2
   let as  := if lt as[mid] as[lo] then as.swap lo mid else as
   let as  := if lt as[hi]  as[lo] then as.swap lo hi  else as
   let as  := if lt as[mid] as[hi] then as.swap mid hi else as
   let pivot := as[hi]
-  -- During this loop, elements below in `[lo, i)` are less than `pivot`,
-  -- elements in `[i, k)` are greater than or equal to `pivot`,
-  -- elements in `[k, hi)` are unexamined,
-  -- while `as[hi]` is (by definition) the pivot.
-  let rec loop (as : Vector α n) (i k : Nat)
-      (ilo : lo ≤ i := by omega) (ik : i ≤ k := by omega) (w : k ≤ hi := by omega) :=
-    if h : k < hi then
-      if lt as[k] pivot then
-        loop (as.swap i k) (i+1) (k+1)
+  let rec loop (as : Vector α n) (i j : Nat)
+      (ilo : lo ≤ i := by omega) (jh : j < n := by omega) (w : i ≤ j := by omega) :=
+    if h : j < hi then
+      if lt as[j] pivot then
+        loop (as.swap i j) (i+1) (j+1)
       else
-        loop as i (k+1)
+        loop as i (j+1)
     else
       (⟨i, ilo, by omega⟩, as.swap i hi)
   loop as lo lo
@@ -55,28 +51,25 @@ def qpartition {n} (as : Vector α n) (lt : α → α → Bool) (lo hi : Nat) (w
 /--
 In-place quicksort.
 
-`qsort as lt lo hi` sorts the subarray `as[lo:hi+1]` in-place using `lt` to compare elements.
+`qsort as lt low high` sorts the subarray `as[low:high+1]` in-place using `lt` to compare elements.
 -/
 @[inline] def qsort (as : Array α) (lt : α → α → Bool := by exact (· < ·))
-    (lo := 0) (hi := as.size - 1) : Array α :=
-  let rec @[specialize] sort {n} (as : Vector α n) (lo hi : Nat) (w : lo ≤ hi := by omega)
+    (low := 0) (high := as.size - 1) : Array α :=
+  let rec @[specialize] sort {n} (as : Vector α n) (lo hi : Nat)
       (hlo : lo < n := by omega) (hhi : hi < n := by omega) :=
     if h₁ : lo < hi then
       let ⟨⟨mid, hmid⟩, as⟩ := qpartition as lt lo hi
       if h₂ : mid ≥ hi then
-        -- This only occurs when `hi ≤ lo`,
-        -- and thus `as[lo:hi+1]` is trivially already sorted.
         as
       else
-        -- Otherwise, we recursively sort the two subarrays.
         sort (sort as lo mid) (mid+1) hi
     else as
   if h : as.size = 0 then
     as
   else
-    let lo := min lo (as.size - 1)
-    let hi := max lo (min hi (as.size - 1))
-    sort as.toVector lo hi |>.toArray
+    let low := min low (as.size - 1)
+    let high := min high (as.size - 1)
+    sort as.toVector low high |>.toArray
 
 set_option linter.unusedVariables.funArgs false in
 /--

src/Init/Data/Array/Range.lean

@@ -29,7 +29,6 @@ open Nat
 
 /-! ### range' -/
 
-@[grind _=_]
 theorem range'_succ {s n step} : range' s (n + 1) step = #[s] ++ range' (s + step) n step := by
   rw [← toList_inj]
   simp [List.range'_succ]
@@ -40,17 +39,16 @@ theorem range'_succ {s n step} : range' s (n + 1) step = #[s] ++ range' (s + ste
 theorem range'_ne_empty_iff : range' s n step ≠ #[] ↔ n ≠ 0 := by
   cases n <;> simp
 
-@[simp, grind =] theorem range'_zero : range' s 0 step = #[] := by
+@[simp] theorem range'_zero : range' s 0 step = #[] := by
   simp
 
-@[simp, grind =] theorem range'_one {s step : Nat} : range' s 1 step = #[s] := by
+@[simp] theorem range'_one {s step : Nat} : range' s 1 step = #[s] := by
   simp [range', ofFn, ofFn.go]
 
 @[simp] theorem range'_inj : range' s n = range' s' n' ↔ n = n' ∧ (n = 0 ∨ s = s') := by
   rw [← toList_inj]
   simp [List.range'_inj]
 
-@[grind =]
 theorem mem_range' {n} : m ∈ range' s n step ↔ ∃ i < n, m = s + step * i := by
   simp [range']
   constructor
@@ -59,7 +57,6 @@ theorem mem_range' {n} : m ∈ range' s n step ↔ ∃ i < n, m = s + step * i :
   · rintro ⟨i, w, h'⟩
     exact ⟨⟨i, w⟩, by simp_all⟩
 
-@[simp, grind =]
 theorem pop_range' : (range' s n step).pop = range' s (n - 1) step := by
   ext <;> simp
 
@@ -69,7 +66,6 @@ theorem map_add_range' {a} (s n step) : map (a + ·) (range' s n step) = range'
 theorem range'_succ_left : range' (s + 1) n step = (range' s n step).map (· + 1) := by
   ext <;> simp <;> omega
 
-@[grind _=_]
 theorem range'_append {s m n step : Nat} :
     range' s m step ++ range' (s + step * m) n step = range' s (m + n) step := by
   ext i h₁ h₂
@@ -81,8 +77,7 @@ theorem range'_append {s m n step : Nat} :
     have : step * m ≤ step * i := by exact mul_le_mul_left step h
     omega
 
-@[simp, grind _=_]
-theorem range'_append_1 {s m n : Nat} :
+@[simp] theorem range'_append_1 {s m n : Nat} :
     range' s m ++ range' (s + m) n = range' s (m + n) := by simpa using range'_append (step := 1)
 
 theorem range'_concat {s n : Nat} : range' s (n + 1) step = range' s n step ++ #[s + step * n] := by
@@ -91,7 +86,7 @@ theorem range'_concat {s n : Nat} : range' s (n + 1) step = range' s n step ++ #
 theorem range'_1_concat {s n : Nat} : range' s (n + 1) = range' s n ++ #[s + n] := by
   simp [range'_concat]
 
-@[simp, grind =] theorem mem_range'_1 : m ∈ range' s n ↔ s ≤ m ∧ m < s + n := by
+@[simp] theorem mem_range'_1 : m ∈ range' s n ↔ s ≤ m ∧ m < s + n := by
   simp [mem_range']; exact ⟨
     fun ⟨i, h, e⟩ => e ▸ ⟨Nat.le_add_right .., Nat.add_lt_add_left h _⟩,
     fun ⟨h₁, h₂⟩ => ⟨m - s, Nat.sub_lt_left_of_lt_add h₁ h₂, (Nat.add_sub_cancel' h₁).symm⟩⟩
@@ -121,7 +116,6 @@ theorem range'_eq_append_iff : range' s n = xs ++ ys ↔ ∃ k, k ≤ n ∧ xs =
   simp only [List.find?_toArray]
   simp
 
-@[grind =]
 theorem erase_range' :
     (range' s n).erase i =
       range' s (min n (i - s)) ++ range' (max s (i + 1)) (min s (i + 1) + n - (i + 1)) := by
@@ -130,7 +124,6 @@ theorem erase_range' :
 
 /-! ### range -/
 
-@[grind _=_]
 theorem range_eq_range' {n : Nat} : range n = range' 0 n := by
   simp [range, range']
 
@@ -152,7 +145,6 @@ theorem range'_eq_map_range {s n : Nat} : range' s n = map (s + ·) (range n) :=
 theorem range_ne_empty_iff {n : Nat} : range n ≠ #[] ↔ n ≠ 0 := by
   cases n <;> simp
 
-@[grind _=_]
 theorem range_succ {n : Nat} : range (succ n) = range n ++ #[n] := by
   ext i h₁ h₂
   · simp
@@ -168,7 +160,7 @@ theorem range_add {n m : Nat} : range (n + m) = range n ++ (range m).map (n + ·
 theorem reverse_range' {s n : Nat} : reverse (range' s n) = map (s + n - 1 - ·) (range n) := by
   simp [← toList_inj, List.reverse_range']
 
-@[simp, grind =]
+@[simp]
 theorem mem_range {m n : Nat} : m ∈ range n ↔ m < n := by
   simp only [range_eq_range', mem_range'_1, Nat.zero_le, true_and, Nat.zero_add]
 
@@ -176,7 +168,7 @@ theorem not_mem_range_self {n : Nat} : n ∉ range n := by simp
 
 theorem self_mem_range_succ {n : Nat} : n ∈ range (n + 1) := by simp
 
-@[simp, grind =] theorem take_range {i n : Nat} : take (range n) i = range (min i n) := by
+@[simp] theorem take_range {i n : Nat} : take (range n) i = range (min i n) := by
   ext <;> simp
 
 @[simp] theorem find?_range_eq_some {n : Nat} {i : Nat} {p : Nat → Bool} :
@@ -187,7 +179,6 @@ theorem self_mem_range_succ {n : Nat} : n ∈ range (n + 1) := by simp
     (range n).find? p = none ↔ ∀ i, i < n → !p i := by
   simp only [← List.toArray_range, List.find?_toArray, List.find?_range_eq_none]
 
-@[grind =]
 theorem erase_range : (range n).erase i = range (min n i) ++ range' (i + 1) (n - (i + 1)) := by
   simp [range_eq_range', erase_range']
 

src/Init/Data/Array/Set.lean

@@ -24,7 +24,7 @@ Examples:
 * `#[0, 1, 2].set 1 5 = #[0, 5, 2]`
 * `#["orange", "apple"].set 1 "grape" = #["orange", "grape"]`
 -/
-@[extern "lean_array_fset", expose]
+@[extern "lean_array_fset"]
 def Array.set (xs : Array α) (i : @& Nat) (v : α) (h : i < xs.size := by get_elem_tactic) :
     Array α where
   toList := xs.toList.set i v
@@ -40,15 +40,17 @@ Examples:
 * `#["orange", "apple"].setIfInBounds 1 "grape" = #["orange", "grape"]`
 * `#["orange", "apple"].setIfInBounds 5 "grape" = #["orange", "apple"]`
 -/
-@[inline, expose] def Array.setIfInBounds (xs : Array α) (i : Nat) (v : α) : Array α :=
+@[inline] def Array.setIfInBounds (xs : Array α) (i : Nat) (v : α) : Array α :=
   dite (LT.lt i xs.size) (fun h => xs.set i v h) (fun _ => xs)
 
+@[deprecated Array.setIfInBounds (since := "2024-11-24")] abbrev Array.setD := @Array.setIfInBounds
+
 /--
 Set an element in an array, or panic if the index is out of bounds.
 
 This will perform the update destructively provided that `a` has a reference
 count of 1 when called.
 -/
-@[extern "lean_array_set", expose]
+@[extern "lean_array_set"]
 def Array.set! (xs : Array α) (i : @& Nat) (v : α) : Array α :=
   Array.setIfInBounds xs i v

src/Init/Data/Array/Subarray.lean

@@ -290,7 +290,7 @@ Examples:
 -/
 @[inline]
 def foldl {α : Type u} {β : Type v} (f : β → α → β) (init : β) (as : Subarray α) : β :=
-  Id.run <| as.foldlM (pure <| f · ·) (init := init)
+  Id.run <| as.foldlM f (init := init)
 
 /--
 Folds an operation from right to left over the elements in a subarray.
@@ -304,7 +304,7 @@ Examples:
 -/
 @[inline]
 def foldr {α : Type u} {β : Type v} (f : α → β → β) (init : β) (as : Subarray α) : β :=
-  Id.run <| as.foldrM (pure <| f · ·) (init := init)
+  Id.run <| as.foldrM f (init := init)
 
 /--
 Checks whether any of the elements in a subarray satisfy a Boolean predicate.
@@ -314,7 +314,7 @@ an element that satisfies the predicate is found.
 -/
 @[inline]
 def any {α : Type u} (p : α → Bool) (as : Subarray α) : Bool :=
-  Id.run <| as.anyM (pure <| p ·)
+  Id.run <| as.anyM p
 
 /--
 Checks whether all of the elements in a subarray satisfy a Boolean predicate.
@@ -324,7 +324,7 @@ an element that does not satisfy the predicate is found.
 -/
 @[inline]
 def all {α : Type u} (p : α → Bool) (as : Subarray α) : Bool :=
-  Id.run <| as.allM (pure <| p ·)
+  Id.run <| as.allM p
 
 /--
 Applies a monadic function to each element in a subarray in reverse order, stopping at the first
@@ -394,7 +394,7 @@ Examples:
 -/
 @[inline]
 def findRev? {α : Type} (as : Subarray α) (p : α → Bool) : Option α :=
-  Id.run <| as.findRevM? (pure <| p ·)
+  Id.run <| as.findRevM? p
 
 end Subarray
 

src/Init/Data/Array/Zip.lean

@@ -334,13 +334,11 @@ abbrev zipWithAll_mkArray := @zipWithAll_replicate
 
 /-! ### unzip -/
 
-@[deprecated fst_unzip (since := "2025-05-26")]
-theorem unzip_fst : (unzip l).fst = l.map Prod.fst := by
-  simp
+@[simp] theorem unzip_fst : (unzip l).fst = l.map Prod.fst := by
+  induction l <;> simp_all
 
-@[deprecated snd_unzip (since := "2025-05-26")]
-theorem unzip_snd : (unzip l).snd = l.map Prod.snd := by
-  simp
+@[simp] theorem unzip_snd : (unzip l).snd = l.map Prod.snd := by
+  induction l <;> simp_all
 
 theorem unzip_eq_map {xs : Array (α × β)} : unzip xs = (xs.map Prod.fst, xs.map Prod.snd) := by
   cases xs
@@ -373,7 +371,7 @@ theorem unzip_zip {as : Array α} {bs : Array β} (h : as.size = bs.size) :
 
 theorem zip_of_prod {as : Array α} {bs : Array β} {xs : Array (α × β)} (hl : xs.map Prod.fst = as)
     (hr : xs.map Prod.snd = bs) : xs = as.zip bs := by
-  rw [← hl, ← hr, ← zip_unzip xs, ← fst_unzip, ← snd_unzip, zip_unzip, zip_unzip]
+  rw [← hl, ← hr, ← zip_unzip xs, ← unzip_fst, ← unzip_snd, zip_unzip, zip_unzip]
 
 @[simp] theorem unzip_replicate {n : Nat} {a : α} {b : β} :
     unzip (replicate n (a, b)) = (replicate n a, replicate n b) := by

src/Init/Data/BEq.lean

@@ -27,7 +27,7 @@ class EquivBEq (α) [BEq α] : Prop extends PartialEquivBEq α, ReflBEq α
 theorem BEq.symm [BEq α] [PartialEquivBEq α] {a b : α} : a == b → b == a :=
   PartialEquivBEq.symm
 
-theorem BEq.comm [BEq α] [PartialEquivBEq α] {a b : α} : (a == b) = (b == a) :=
+@[grind] theorem BEq.comm [BEq α] [PartialEquivBEq α] {a b : α} : (a == b) = (b == a) :=
   Bool.eq_iff_iff.2 ⟨BEq.symm, BEq.symm⟩
 
 theorem bne_comm [BEq α] [PartialEquivBEq α] {a b : α} : (a != b) = (b != a) := by

src/Init/Data/BitVec/Basic.lean

@@ -61,7 +61,7 @@ end subsingleton
 section zero_allOnes
 
 /-- Returns a bitvector of size `n` where all bits are `0`. -/
-@[expose] protected def zero (n : Nat) : BitVec n := .ofNatLT 0 (Nat.two_pow_pos n)
+protected def zero (n : Nat) : BitVec n := .ofNatLT 0 (Nat.two_pow_pos n)
 instance : Inhabited (BitVec n) where default := .zero n
 
 /-- Returns a bitvector of size `n` where all bits are `1`. -/
@@ -77,10 +77,10 @@ Returns the `i`th least significant bit.
 
 This will be renamed `getLsb` after the existing deprecated alias is removed.
 -/
-@[inline, expose] def getLsb' (x : BitVec w) (i : Fin w) : Bool := x.toNat.testBit i
+@[inline] def getLsb' (x : BitVec w) (i : Fin w) : Bool := x.toNat.testBit i
 
 /-- Returns the `i`th least significant bit, or `none` if `i ≥ w`. -/
-@[inline, expose] def getLsb? (x : BitVec w) (i : Nat) : Option Bool :=
+@[inline] def getLsb? (x : BitVec w) (i : Nat) : Option Bool :=
   if h : i < w then some (getLsb' x ⟨i, h⟩) else none
 
 /--
@@ -95,7 +95,7 @@ This will be renamed `BitVec.getMsb` after the existing deprecated alias is remo
   if h : i < w then some (getMsb' x ⟨i, h⟩) else none
 
 /-- Returns the `i`th least significant bit or `false` if `i ≥ w`. -/
-@[inline, expose] def getLsbD (x : BitVec w) (i : Nat) : Bool :=
+@[inline] def getLsbD (x : BitVec w) (i : Nat) : Bool :=
   x.toNat.testBit i
 
 /-- Returns the `i`th most significant bit, or `false` if `i ≥ w`. -/
@@ -134,7 +134,6 @@ section Int
 /--
 Interprets the bitvector as an integer stored in two's complement form.
 -/
-@[expose]
 protected def toInt (x : BitVec n) : Int :=
   if 2 * x.toNat < 2^n then
     x.toNat
@@ -148,7 +147,6 @@ over- and underflowing as needed.
 The underlying `Nat` is `(2^n + (i mod 2^n)) mod 2^n`. Converting the bitvector back to an `Int`
 with `BitVec.toInt` results in the value `i.bmod (2^n)`.
 -/
-@[expose]
 protected def ofInt (n : Nat) (i : Int) : BitVec n := .ofNatLT (i % (Int.ofNat (2^n))).toNat (by
   apply (Int.toNat_lt _).mpr
   · apply Int.emod_lt_of_pos
@@ -220,14 +218,12 @@ Usually accessed via the `-` prefix operator.
 
 SMT-LIB name: `bvneg`.
 -/
-@[expose]
 protected def neg (x : BitVec n) : BitVec n := .ofNat n (2^n - x.toNat)
 instance : Neg (BitVec n) := ⟨.neg⟩
 
 /--
 Returns the absolute value of a signed bitvector.
 -/
-@[expose]
 protected def abs (x : BitVec n) : BitVec n := if x.msb then .neg x else x
 
 /--
@@ -236,7 +232,6 @@ modulo `2^n`. Usually accessed via the `*` operator.
 
 SMT-LIB name: `bvmul`.
 -/
-@[expose]
 protected def mul (x y : BitVec n) : BitVec n := BitVec.ofNat n (x.toNat * y.toNat)
 instance : Mul (BitVec n) := ⟨.mul⟩
 
@@ -247,7 +242,6 @@ Note that this is currently an inefficient implementation,
 and should be replaced via an `@[extern]` with a native implementation.
 See https://github.com/leanprover/lean4/issues/7887.
 -/
-@[expose]
 protected def pow (x : BitVec n) (y : Nat) : BitVec n :=
   match y with
   | 0 => 1
@@ -259,7 +253,6 @@ instance : Pow (BitVec n) Nat where
 Unsigned division of bitvectors using the Lean convention where division by zero returns zero.
 Usually accessed via the `/` operator.
 -/
-@[expose]
 def udiv (x y : BitVec n) : BitVec n :=
   (x.toNat / y.toNat)#'(Nat.lt_of_le_of_lt (Nat.div_le_self _ _) x.isLt)
 instance : Div (BitVec n) := ⟨.udiv⟩
@@ -269,7 +262,6 @@ Unsigned modulo for bitvectors. Usually accessed via the `%` operator.
 
 SMT-LIB name: `bvurem`.
 -/
-@[expose]
 def umod (x y : BitVec n) : BitVec n :=
   (x.toNat % y.toNat)#'(Nat.lt_of_le_of_lt (Nat.mod_le _ _) x.isLt)
 instance : Mod (BitVec n) := ⟨.umod⟩
@@ -281,7 +273,6 @@ where division by zero returns `BitVector.allOnes n`.
 
 SMT-LIB name: `bvudiv`.
 -/
-@[expose]
 def smtUDiv (x y : BitVec n) : BitVec n := if y = 0 then allOnes n else udiv x y
 
 /--
@@ -351,7 +342,6 @@ end arithmetic
 section bool
 
 /-- Turns a `Bool` into a bitvector of length `1`. -/
-@[expose]
 def ofBool (b : Bool) : BitVec 1 := cond b 1 0
 
 @[simp] theorem ofBool_false : ofBool false = 0 := by trivial
@@ -369,7 +359,6 @@ Unsigned less-than for bitvectors.
 
 SMT-LIB name: `bvult`.
 -/
-@[expose]
 protected def ult (x y : BitVec n) : Bool := x.toNat < y.toNat
 
 /--
@@ -377,7 +366,6 @@ Unsigned less-than-or-equal-to for bitvectors.
 
 SMT-LIB name: `bvule`.
 -/
-@[expose]
 protected def ule (x y : BitVec n) : Bool := x.toNat ≤ y.toNat
 
 /--
@@ -389,7 +377,6 @@ Examples:
  * `BitVec.slt 6#4 7 = true`
  * `BitVec.slt 7#4 8 = false`
 -/
-@[expose]
 protected def slt (x y : BitVec n) : Bool := x.toInt < y.toInt
 
 /--
@@ -397,7 +384,6 @@ Signed less-than-or-equal-to for bitvectors.
 
 SMT-LIB name: `bvsle`.
 -/
-@[expose]
 protected def sle (x y : BitVec n) : Bool := x.toInt ≤ y.toInt
 
 end relations
@@ -411,7 +397,7 @@ width `m`.
 Using `x.cast eq` should be preferred over `eq ▸ x` because there are special-purpose `simp` lemmas
 that can more consistently simplify `BitVec.cast` away.
 -/
-@[inline, expose] protected def cast (eq : n = m) (x : BitVec n) : BitVec m := .ofNatLT x.toNat (eq ▸ x.isLt)
+@[inline] protected def cast (eq : n = m) (x : BitVec n) : BitVec m := .ofNatLT x.toNat (eq ▸ x.isLt)
 
 @[simp] theorem cast_ofNat {n m : Nat} (h : n = m) (x : Nat) :
     (BitVec.ofNat n x).cast h = BitVec.ofNat m x := by
@@ -427,7 +413,6 @@ that can more consistently simplify `BitVec.cast` away.
 Extracts the bits `start` to `start + len - 1` from a bitvector of size `n` to yield a
 new bitvector of size `len`. If `start + len > n`, then the bitvector is zero-extended.
 -/
-@[expose]
 def extractLsb' (start len : Nat) (x : BitVec n) : BitVec len := .ofNat _ (x.toNat >>> start)
 
 /--
@@ -438,7 +423,6 @@ The resulting bitvector has size `hi - lo + 1`.
 
 SMT-LIB name: `extract`.
 -/
-@[expose]
 def extractLsb (hi lo : Nat) (x : BitVec n) : BitVec (hi - lo + 1) := extractLsb' lo _ x
 
 /--
@@ -447,7 +431,6 @@ Increases the width of a bitvector to one that is at least as large by zero-exte
 This is a constant-time operation because the underlying `Nat` is unmodified; because the new width
 is at least as large as the old one, no overflow is possible.
 -/
-@[expose]
 def setWidth' {n w : Nat} (le : n ≤ w) (x : BitVec n) : BitVec w :=
   x.toNat#'(by
     apply Nat.lt_of_lt_of_le x.isLt
@@ -456,7 +439,6 @@ def setWidth' {n w : Nat} (le : n ≤ w) (x : BitVec n) : BitVec w :=
 /--
 Returns `zeroExtend (w+n) x <<< n` without needing to compute `x % 2^(2+n)`.
 -/
-@[expose]
 def shiftLeftZeroExtend (msbs : BitVec w) (m : Nat) : BitVec (w + m) :=
   let shiftLeftLt {x : Nat} (p : x < 2^w) (m : Nat) : x <<< m < 2^(w + m) := by
         simp [Nat.shiftLeft_eq, Nat.pow_add]
@@ -513,7 +495,6 @@ SMT-LIB name: `bvand`.
 Example:
  * `0b1010#4 &&& 0b0110#4 = 0b0010#4`
 -/
-@[expose]
 protected def and (x y : BitVec n) : BitVec n :=
   (x.toNat &&& y.toNat)#'(Nat.and_lt_two_pow x.toNat y.isLt)
 instance : AndOp (BitVec w) := ⟨.and⟩
@@ -526,7 +507,6 @@ SMT-LIB name: `bvor`.
 Example:
  * `0b1010#4 ||| 0b0110#4 = 0b1110#4`
 -/
-@[expose]
 protected def or (x y : BitVec n) : BitVec n :=
   (x.toNat ||| y.toNat)#'(Nat.or_lt_two_pow x.isLt y.isLt)
 instance : OrOp (BitVec w) := ⟨.or⟩
@@ -539,7 +519,6 @@ SMT-LIB name: `bvxor`.
 Example:
  * `0b1010#4 ^^^ 0b0110#4 = 0b1100#4`
 -/
-@[expose]
 protected def xor (x y : BitVec n) : BitVec n :=
   (x.toNat ^^^ y.toNat)#'(Nat.xor_lt_two_pow x.isLt y.isLt)
 instance : Xor (BitVec w) := ⟨.xor⟩
@@ -552,7 +531,6 @@ SMT-LIB name: `bvnot`.
 Example:
  * `~~~(0b0101#4) == 0b1010`
 -/
-@[expose]
 protected def not (x : BitVec n) : BitVec n := allOnes n ^^^ x
 instance : Complement (BitVec w) := ⟨.not⟩
 
@@ -562,7 +540,6 @@ equivalent to `x * 2^s`, modulo `2^n`.
 
 SMT-LIB name: `bvshl` except this operator uses a `Nat` shift value.
 -/
-@[expose]
 protected def shiftLeft (x : BitVec n) (s : Nat) : BitVec n := BitVec.ofNat n (x.toNat <<< s)
 instance : HShiftLeft (BitVec w) Nat (BitVec w) := ⟨.shiftLeft⟩
 
@@ -574,7 +551,6 @@ As a numeric operation, this is equivalent to `x / 2^s`, rounding down.
 
 SMT-LIB name: `bvlshr` except this operator uses a `Nat` shift value.
 -/
-@[expose]
 def ushiftRight (x : BitVec n) (s : Nat) : BitVec n :=
   (x.toNat >>> s)#'(by
   let ⟨x, lt⟩ := x
@@ -592,7 +568,6 @@ As a numeric operation, this is equivalent to `x.toInt >>> s`.
 
 SMT-LIB name: `bvashr` except this operator uses a `Nat` shift value.
 -/
-@[expose]
 def sshiftRight (x : BitVec n) (s : Nat) : BitVec n := .ofInt n (x.toInt >>> s)
 
 instance {n} : HShiftLeft  (BitVec m) (BitVec n) (BitVec m) := ⟨fun x y => x <<< y.toNat⟩
@@ -606,12 +581,10 @@ As a numeric operation, this is equivalent to `a.toInt >>> s.toNat`.
 
 SMT-LIB name: `bvashr`.
 -/
-@[expose]
 def sshiftRight' (a : BitVec n) (s : BitVec m) : BitVec n := a.sshiftRight s.toNat
 
 /-- Auxiliary function for `rotateLeft`, which does not take into account the case where
 the rotation amount is greater than the bitvector width. -/
-@[expose]
 def rotateLeftAux (x : BitVec w) (n : Nat) : BitVec w :=
   x <<< n ||| x >>> (w - n)
 
@@ -626,7 +599,6 @@ SMT-LIB name: `rotate_left`, except this operator uses a `Nat` shift amount.
 Example:
  * `(0b0011#4).rotateLeft 3 = 0b1001`
 -/
-@[expose]
 def rotateLeft (x : BitVec w) (n : Nat) : BitVec w := rotateLeftAux x (n % w)
 
 
@@ -634,7 +606,6 @@ def rotateLeft (x : BitVec w) (n : Nat) : BitVec w := rotateLeftAux x (n % w)
 Auxiliary function for `rotateRight`, which does not take into account the case where
 the rotation amount is greater than the bitvector width.
 -/
-@[expose]
 def rotateRightAux (x : BitVec w) (n : Nat) : BitVec w :=
   x >>> n ||| x <<< (w - n)
 
@@ -649,7 +620,6 @@ SMT-LIB name: `rotate_right`, except this operator uses a `Nat` shift amount.
 Example:
  * `rotateRight 0b01001#5 1 = 0b10100`
 -/
-@[expose]
 def rotateRight (x : BitVec w) (n : Nat) : BitVec w := rotateRightAux x (n % w)
 
 /--
@@ -661,7 +631,6 @@ SMT-LIB name: `concat`.
 Example:
  * `0xAB#8 ++ 0xCD#8 = 0xABCD#16`.
 -/
-@[expose]
 def append (msbs : BitVec n) (lsbs : BitVec m) : BitVec (n+m) :=
   shiftLeftZeroExtend msbs m ||| setWidth' (Nat.le_add_left m n) lsbs
 
@@ -684,7 +653,6 @@ result of appending a single bit to the front in the naive implementation).
 
 /-- Append a single bit to the end of a bitvector, using big endian order (see `append`).
     That is, the new bit is the least significant bit. -/
-@[expose]
 def concat {n} (msbs : BitVec n) (lsb : Bool) : BitVec (n+1) := msbs ++ (ofBool lsb)
 
 /--
@@ -692,7 +660,6 @@ Shifts all bits of `x` to the left by `1` and sets the least significant bit to
 
 This is a non-dependent version of `BitVec.concat` that does not change the total bitwidth.
 -/
-@[expose]
 def shiftConcat (x : BitVec n) (b : Bool) : BitVec n :=
   (x.concat b).truncate n
 
@@ -701,7 +668,6 @@ Prepends a single bit to the front of a bitvector, using big-endian order (see `
 
 The new bit is the most significant bit.
 -/
-@[expose]
 def cons {n} (msb : Bool) (lsbs : BitVec n) : BitVec (n+1) :=
   ((ofBool msb) ++ lsbs).cast (Nat.add_comm ..)
 
@@ -786,7 +752,6 @@ Checks whether subtraction of `x` and `y` results in *unsigned* overflow.
 
 SMT-Lib name: `bvusubo`.
 -/
-@[expose]
 def usubOverflow {w : Nat} (x y : BitVec w) : Bool := x.toNat < y.toNat
 
 /--
@@ -795,7 +760,6 @@ Checks whether the subtraction of `x` and `y` results in *signed* overflow, trea
 
 SMT-Lib name: `bvssubo`.
 -/
-@[expose]
 def ssubOverflow {w : Nat} (x y : BitVec w) : Bool :=
   (x.toInt - y.toInt ≥ 2 ^ (w - 1)) || (x.toInt - y.toInt < - 2 ^ (w - 1))
 
@@ -806,7 +770,6 @@ For a bitvector `x` with nonzero width, this only happens if `x = intMin`.
 
 SMT-Lib name: `bvnego`.
 -/
-@[expose]
 def negOverflow {w : Nat} (x : BitVec w) : Bool :=
   x.toInt == - 2 ^ (w - 1)
 
@@ -816,7 +779,6 @@ For BitVecs `x` and `y` with nonzero width, this only happens if `x = intMin` an
 
 SMT-LIB name: `bvsdivo`.
 -/
-@[expose]
 def sdivOverflow {w : Nat} (x y : BitVec w) : Bool :=
   (2 ^ (w - 1) ≤ x.toInt / y.toInt) || (x.toInt / y.toInt <  - 2 ^ (w - 1))
 

src/Init/Data/BitVec/BasicAux.lean

@@ -24,7 +24,7 @@ The bitvector with value `i mod 2^n`.
 -/
 @[expose, match_pattern]
 protected def ofNat (n : Nat) (i : Nat) : BitVec n where
-  toFin := Fin.ofNat (2^n) i
+  toFin := Fin.ofNat' (2^n) i
 
 instance instOfNat : OfNat (BitVec n) i where ofNat := .ofNat n i
 
@@ -41,7 +41,6 @@ Usually accessed via the `+` operator.
 
 SMT-LIB name: `bvadd`.
 -/
-@[expose]
 protected def add (x y : BitVec n) : BitVec n := .ofNat n (x.toNat + y.toNat)
 instance : Add (BitVec n) := ⟨BitVec.add⟩
 
@@ -50,7 +49,6 @@ Subtracts one bitvector from another. This can be interpreted as either signed o
 modulo `2^n`. Usually accessed via the `-` operator.
 
 -/
-@[expose]
 protected def sub (x y : BitVec n) : BitVec n := .ofNat n ((2^n - y.toNat) + x.toNat)
 instance : Sub (BitVec n) := ⟨BitVec.sub⟩
 

src/Init/Data/BitVec/Bitblast.lean

@@ -631,7 +631,6 @@ A recurrence that describes multiplication as repeated addition.
 
 This function is useful for bit blasting multiplication.
 -/
-@[expose]
 def mulRec (x y : BitVec w) (s : Nat) : BitVec w :=
   let cur := if y.getLsbD s then (x <<< s) else 0
   match s with
@@ -1092,7 +1091,6 @@ theorem lawful_divSubtractShift (qr : DivModState w) (h : qr.Poised args) :
 /-! ### Core division algorithm circuit -/
 
 /-- A recursive definition of division for bit blasting, in terms of a shift-subtraction circuit. -/
-@[expose]
 def divRec {w : Nat} (m : Nat) (args : DivModArgs w) (qr : DivModState w) :
     DivModState w :=
   match m with
@@ -1752,116 +1750,6 @@ theorem toInt_srem (x y : BitVec w) : (x.srem y).toInt = x.toInt.tmod y.toInt :=
         ((not_congr neg_eq_zero_iff).mpr hyz)]
       exact neg_le_intMin_of_msb_eq_true h'
 
-@[simp]
-theorem msb_intMin_umod_neg_of_msb_true {y : BitVec w} (hy : y.msb = true) :
-    (intMin w % -y).msb = false := by
-  by_cases hyintmin : y = intMin w
-  · simp [hyintmin]
-  · rw [msb_umod_of_msb_false_of_ne_zero (by simp [hyintmin, hy])]
-    simp [hy]
-
-@[simp]
-theorem msb_neg_umod_neg_of_msb_true_of_msb_true {x y : BitVec w} (hx : x.msb = true) (hy : y.msb = true) :
-      (-x % -y).msb = false := by
-  by_cases hx' : x = intMin w
-  · simp only [hx', neg_intMin, msb_intMin_umod_neg_of_msb_true hy]
-  · simp [show (-x).msb = false by simp [hx, hx']]
-
-theorem toInt_dvd_toInt_iff {x y : BitVec w} :
-    y.toInt ∣ x.toInt ↔ (if x.msb then -x else x) % (if y.msb then -y else y) = 0#w := by
-  constructor
-  <;> by_cases hxmsb : x.msb <;> by_cases hymsb: y.msb
-  <;> intros h
-  <;> simp only [hxmsb, hymsb, reduceIte, false_eq_true, toNat_eq, toNat_umod, toNat_ofNat,
-        zero_mod, toInt_eq_neg_toNat_neg_of_msb_true, Int.dvd_neg, Int.neg_dvd,
-        toInt_eq_toNat_of_msb] at h
-  <;> simp only [hxmsb, hymsb, toInt_eq_neg_toNat_neg_of_msb_true, toInt_eq_toNat_of_msb,
-        Int.dvd_neg, Int.neg_dvd, toNat_eq, toNat_umod, reduceIte, toNat_ofNat, zero_mod]
-  <;> norm_cast
-  <;> norm_cast at h
-  <;> simp only [dvd_of_mod_eq_zero, h, dvd_iff_mod_eq_zero.mp, reduceIte]
-
-theorem toInt_dvd_toInt_iff_of_msb_true_msb_false {x y : BitVec w} (hx : x.msb = true) (hy : y.msb = false) :
-    y.toInt ∣ x.toInt ↔ (-x) % y = 0#w := by
-  simpa [hx, hy] using toInt_dvd_toInt_iff (x := x) (y := y)
-
-theorem toInt_dvd_toInt_iff_of_msb_false_msb_true {x y : BitVec w} (hx : x.msb = false) (hy : y.msb = true) :
-    y.toInt ∣ x.toInt ↔ x % (-y) = 0#w := by
-  simpa [hx, hy] using toInt_dvd_toInt_iff (x := x) (y := y)
-
-@[simp]
-theorem neg_toInt_neg_umod_eq_of_msb_true_msb_true {x y : BitVec w} (hx : x.msb = true) (hy : y.msb = true) :
-    -(-(-x % -y)).toInt = (-x % -y).toNat := by
-  rw [neg_toInt_neg]
-  by_cases h : -x % -y = 0#w
-  · simp [h]
-  · rw [msb_neg_umod_neg_of_msb_true_of_msb_true hx hy]
-
-@[simp]
-theorem toInt_umod_neg_add {x y : BitVec w} (hymsb : y.msb = true) (hxmsb : x.msb = false) (hdvd : ¬y.toInt ∣ x.toInt) :
-    (x % -y + y).toInt = x.toInt % y.toInt + y.toInt := by
-  rcases w with _|w ; simp [of_length_zero]
-  have hypos : 0 < y.toNat := toNat_pos_of_ne_zero (by simp [hymsb])
-  have hxnonneg := toInt_nonneg_of_msb_false hxmsb
-  have hynonpos := toInt_neg_of_msb_true hymsb
-  have hylt : (-y).toNat ≤ 2 ^ (w) := toNat_neg_lt_of_msb y hymsb
-  have hmodlt := Nat.mod_lt x.toNat (y := (-y).toNat)
-      (by rw [toNat_neg, Nat.mod_eq_of_lt (by omega)]; omega)
-  simp only [hdvd, reduceIte, toInt_add, hxnonneg, show ¬0 ≤ y.toInt by omega]
-  rw [toInt_umod, toInt_eq_neg_toNat_neg_of_msb_true hymsb, Int.bmod_add_bmod,
-    Int.bmod_eq_of_le (by omega) (by omega),
-    toInt_eq_toNat_of_msb hxmsb, Int.emod_neg]
-
-@[simp]
-theorem toInt_sub_neg_umod {x y : BitVec w} (hxmsb : x.msb = true) (hymsb : y.msb = false) (hdvd : ¬y.toInt ∣ x.toInt) :
-    (y - -x % y).toInt = x.toInt % y.toInt := by
-  rcases w with _|w
-  · simp [of_length_zero]
-  · have : y.toNat < 2 ^ w := toNat_lt_of_msb_false hymsb
-    by_cases hyzero : y = 0#(w+1)
-    · subst hyzero; simp
-    · simp only [toNat_eq, toNat_ofNat, zero_mod] at hyzero
-      have hypos : 0 < y.toNat := by omega
-      simp only [reduceIte, toInt_sub, toInt_eq_toNat_of_msb hymsb, toInt_umod,
-        Int.sub_bmod_bmod, toInt_eq_neg_toNat_neg_of_msb_true hxmsb, Int.neg_emod]
-      have hmodlt := Nat.mod_lt (x := (-x).toNat) (y := y.toNat) hypos
-      rw [Int.bmod_eq_of_le (by omega) (by omega)]
-      simp only [toInt_eq_toNat_of_msb hymsb, BitVec.toInt_eq_neg_toNat_neg_of_msb_true hxmsb,
-        Int.dvd_neg] at hdvd
-      simp only [hdvd, ↓reduceIte, Int.natAbs_cast]
-
-theorem toInt_smod {x y : BitVec w} :
-    (x.smod y).toInt = x.toInt.fmod y.toInt := by
-  rcases w with _|w
-  · decide +revert
-  · by_cases hyzero : y = 0#(w + 1)
-    · simp [hyzero]
-    · rw [smod_eq]
-      cases hxmsb : x.msb <;> cases hymsb : y.msb
-      <;> simp only [umod_eq]
-      · have : 0 < y.toNat := by simp [toNat_eq] at hyzero; omega
-        have : y.toNat < 2 ^ w := toNat_lt_of_msb_false hymsb
-        have : x.toNat % y.toNat < y.toNat := Nat.mod_lt x.toNat (by omega)
-        rw [toInt_umod, Int.fmod_eq_emod_of_nonneg x.toInt (toInt_nonneg_of_msb_false hymsb),
-          toInt_eq_toNat_of_msb hxmsb, toInt_eq_toNat_of_msb hymsb,
-          Int.bmod_eq_of_le_mul_two (by omega) (by omega)]
-      · have := toInt_dvd_toInt_iff_of_msb_false_msb_true hxmsb hymsb
-        by_cases hx_dvd_y : y.toInt ∣ x.toInt
-        · simp [show x % -y = 0#(w + 1) by simp_all, hx_dvd_y, Int.fmod_eq_zero_of_dvd]
-        · have hynonpos := toInt_neg_of_msb_true hymsb
-          simp only [show ¬x % -y = 0#(w + 1) by simp_all, ↓reduceIte,
-            toInt_umod_neg_add hymsb hxmsb hx_dvd_y, Int.fmod_eq_emod, show ¬0 ≤ y.toInt by omega,
-            hx_dvd_y, _root_.or_self]
-      · have hynonneg := toInt_nonneg_of_msb_false hymsb
-        rw [Int.fmod_eq_emod_of_nonneg x.toInt (b := y.toInt) (by omega)]
-        have hdvd := toInt_dvd_toInt_iff_of_msb_true_msb_false hxmsb hymsb
-        by_cases hx_dvd_y : y.toInt ∣ x.toInt
-        · simp [show -x % y = 0#(w + 1) by simp_all, hx_dvd_y, Int.emod_eq_zero_of_dvd]
-        · simp [show ¬-x % y = 0#(w + 1) by simp_all, toInt_sub_neg_umod hxmsb hymsb hx_dvd_y]
-      · rw [←Int.neg_inj, neg_toInt_neg_umod_eq_of_msb_true_msb_true hxmsb hymsb]
-        simp [BitVec.toInt_eq_neg_toNat_neg_of_msb_true, hxmsb, hymsb,
-          Int.fmod_eq_emod_of_nonneg _, show 0 ≤ (-y).toNat by omega]
-
 /-! ### Lemmas that use bit blasting circuits -/
 
 theorem add_sub_comm {x y : BitVec w} : x + y - z = x - z + y := by

src/Init/Data/BitVec/Lemmas.lean

@@ -68,11 +68,11 @@ theorem lt_of_getMsbD {x : BitVec w} {i : Nat} : getMsbD x i = true → i < w :=
 @[simp] theorem getElem?_eq_getElem {l : BitVec w} {n} (h : n < w) : l[n]? = some l[n] := by
   simp only [getElem?_def, h, ↓reduceDIte]
 
-theorem getElem?_eq_some_iff {l : BitVec w} : l[n]? = some a ↔ ∃ h : n < w, l[n] = a :=
-  _root_.getElem?_eq_some_iff
-
-theorem some_eq_getElem?_iff {l : BitVec w} : some a = l[n]? ↔ ∃ h : n < w, l[n] = a :=
-  _root_.some_eq_getElem?_iff
+theorem getElem?_eq_some_iff {l : BitVec w} : l[n]? = some a ↔ ∃ h : n < w, l[n] = a := by
+  simp only [getElem?_def]
+  split
+  · simp_all
+  · simp; omega
 
 theorem getElem_of_getElem? {l : BitVec w} : l[n]? = some a → ∃ h : n < w, l[n] = a :=
   getElem?_eq_some_iff.mp
@@ -81,11 +81,11 @@ set_option linter.missingDocs false in
 @[deprecated getElem?_eq_some_iff (since := "2025-02-17")]
 abbrev getElem?_eq_some := @getElem?_eq_some_iff
 
-theorem getElem?_eq_none_iff {l : BitVec w} : l[n]? = none ↔ w ≤ n := by
-  simp
-
-theorem none_eq_getElem?_iff {l : BitVec w} : none = l[n]? ↔ w ≤ n := by
-  simp
+@[simp] theorem getElem?_eq_none_iff {l : BitVec w} : l[n]? = none ↔ w ≤ n := by
+  simp only [getElem?_def]
+  split
+  · simp_all
+  · simp; omega
 
 theorem getElem?_eq_none {l : BitVec w} (h : w ≤ n) : l[n]? = none := getElem?_eq_none_iff.mpr h
 
@@ -93,13 +93,13 @@ theorem getElem?_eq (l : BitVec w) (i : Nat) :
     l[i]? = if h : i < w then some l[i] else none := by
   split <;> simp_all
 
-theorem some_getElem_eq_getElem? (l : BitVec w) (i : Nat) (h : i < w) :
+@[simp] theorem some_getElem_eq_getElem? (l : BitVec w) (i : Nat) (h : i < w) :
     (some l[i] = l[i]?) ↔ True := by
-  simp
+  simp [h]
 
-theorem getElem?_eq_some_getElem (l : BitVec w) (i : Nat) (h : i < w) :
+@[simp] theorem getElem?_eq_some_getElem (l : BitVec w) (i : Nat) (h : i < w) :
     (l[i]? = some l[i]) ↔ True := by
-  simp
+  simp [h]
 
 theorem getElem_eq_iff {l : BitVec w} {n : Nat} {h : n < w} : l[n] = x ↔ l[n]? = some x := by
   simp only [getElem?_eq_some_iff]
@@ -125,7 +125,7 @@ theorem getElem_of_getLsbD_eq_true {x : BitVec w} {i : Nat} (h : x.getLsbD i = t
 This normalized a bitvec using `ofFin` to `ofNat`.
 -/
 theorem ofFin_eq_ofNat : @BitVec.ofFin w (Fin.mk x lt) = BitVec.ofNat w x := by
-  simp only [BitVec.ofNat, Fin.ofNat, lt, Nat.mod_eq_of_lt]
+  simp only [BitVec.ofNat, Fin.ofNat', lt, Nat.mod_eq_of_lt]
 
 /-- Prove equality of bitvectors in terms of nat operations. -/
 theorem eq_of_toNat_eq {n} : ∀ {x y : BitVec n}, x.toNat = y.toNat → x = y
@@ -314,7 +314,7 @@ theorem length_pos_of_ne {x y : BitVec w} (h : x ≠ y) : 0 < w :=
 
 theorem ofFin_ofNat (n : Nat) :
     ofFin (no_index (OfNat.ofNat n : Fin (2^w))) = OfNat.ofNat n := by
-  simp only [OfNat.ofNat, Fin.ofNat, BitVec.ofNat, Nat.and_two_pow_sub_one_eq_mod]
+  simp only [OfNat.ofNat, Fin.ofNat', BitVec.ofNat, Nat.and_two_pow_sub_one_eq_mod]
 
 @[simp] theorem ofFin_neg {x : Fin (2 ^ w)} : ofFin (-x) = -(ofFin x) := by
   rfl
@@ -346,11 +346,11 @@ theorem toFin_one  : toFin (1 : BitVec w) = 1 := by
 @[simp] theorem toInt_ofBool (b : Bool) : (ofBool b).toInt = -b.toInt := by
   cases b <;> simp
 
-@[simp] theorem toFin_ofBool (b : Bool) : (ofBool b).toFin = Fin.ofNat 2 (b.toNat) := by
+@[simp] theorem toFin_ofBool (b : Bool) : (ofBool b).toFin = Fin.ofNat' 2 (b.toNat) := by
   cases b <;> rfl
 
 theorem ofNat_one (n : Nat) : BitVec.ofNat 1 n = BitVec.ofBool (n % 2 = 1) :=  by
-  rcases (Nat.mod_two_eq_zero_or_one n) with h | h <;> simp [h, BitVec.ofNat, Fin.ofNat]
+  rcases (Nat.mod_two_eq_zero_or_one n) with h | h <;> simp [h, BitVec.ofNat, Fin.ofNat']
 
 theorem ofBool_eq_iff_eq : ∀ {b b' : Bool}, BitVec.ofBool b = BitVec.ofBool b' ↔ b = b' := by
   decide
@@ -390,12 +390,12 @@ theorem getMsbD_ofNatLt {n x i : Nat} (h : x < 2^n) :
     getMsbD (x#'h) i = (decide (i < n) && x.testBit (n - 1 - i)) := getMsbD_ofNatLT h
 
 @[simp, bitvec_to_nat] theorem toNat_ofNat (x w : Nat) : (BitVec.ofNat w x).toNat = x % 2^w := by
-  simp [BitVec.toNat, BitVec.ofNat, Fin.ofNat]
+  simp [BitVec.toNat, BitVec.ofNat, Fin.ofNat']
 
 theorem ofNatLT_eq_ofNat {w : Nat} {n : Nat} (hn) : BitVec.ofNatLT n hn = BitVec.ofNat w n :=
   eq_of_toNat_eq (by simp [Nat.mod_eq_of_lt hn])
 
-@[simp] theorem toFin_ofNat (x : Nat) : toFin (BitVec.ofNat w x) = Fin.ofNat (2^w) x := rfl
+@[simp] theorem toFin_ofNat (x : Nat) : toFin (BitVec.ofNat w x) = Fin.ofNat' (2^w) x := rfl
 
 @[simp] theorem finMk_toNat (x : BitVec w) : Fin.mk x.toNat x.isLt = x.toFin := rfl
 
@@ -415,7 +415,7 @@ theorem ofNatLT_eq_ofNat {w : Nat} {n : Nat} (hn) : BitVec.ofNatLT n hn = BitVec
 -- If `x` and `n` are not literals, applying this theorem eagerly may not be a good idea.
 theorem getLsbD_ofNat (n : Nat) (x : Nat) (i : Nat) :
   getLsbD (BitVec.ofNat n x) i = (i < n && x.testBit i) := by
-  simp [getLsbD, BitVec.ofNat, Fin.val_ofNat]
+  simp [getLsbD, BitVec.ofNat, Fin.val_ofNat']
 
 @[simp] theorem getLsbD_zero : (0#w).getLsbD i = false := by simp [getLsbD]
 
@@ -505,7 +505,7 @@ theorem getLsbD_ofBool (b : Bool) (i : Nat) : (ofBool b).getLsbD i = ((i = 0) &&
   · simp only [ofBool, ofNat_eq_ofNat, cond_true, getLsbD_ofNat, Bool.and_true]
     by_cases hi : i = 0 <;> simp [hi] <;> omega
 
-theorem getElem_ofBool_zero {b : Bool} : (ofBool b)[0] = b := by simp
+@[simp] theorem getElem_ofBool_zero {b : Bool} : (ofBool b)[0] = b := by simp
 
 @[simp]
 theorem getElem_ofBool {b : Bool} {h : i < 1}: (ofBool b)[i] = b := by
@@ -909,7 +909,7 @@ theorem zeroExtend_eq_setWidth {v : Nat} {x : BitVec w} :
   simp [toInt_eq_toNat_bmod, toNat_setWidth, Int.emod_bmod, -Int.natCast_pow]
 
 @[simp] theorem toFin_setWidth {x : BitVec w} :
-    (x.setWidth v).toFin = Fin.ofNat (2^v) x.toNat := by
+    (x.setWidth v).toFin = Fin.ofNat' (2^v) x.toNat := by
   ext; simp
 
 @[simp] theorem setWidth_eq (x : BitVec n) : setWidth n x = x := by
@@ -1105,7 +1105,7 @@ theorem toInt_setWidth' {m n : Nat} (p : m ≤ n) {x : BitVec m} :
 @[simp] theorem toFin_setWidth' {m n : Nat} (p : m ≤ n) (x : BitVec m) :
     (setWidth' p x).toFin = x.toFin.castLE (Nat.pow_le_pow_right (by omega) (by omega)) := by
   ext
-  rw [setWidth'_eq, toFin_setWidth, Fin.val_ofNat, Fin.coe_castLE, val_toFin,
+  rw [setWidth'_eq, toFin_setWidth, Fin.val_ofNat', Fin.coe_castLE, val_toFin,
     Nat.mod_eq_of_lt (by apply BitVec.toNat_lt_twoPow_of_le p)]
 
 /-! ## extractLsb -/
@@ -1135,11 +1135,11 @@ protected theorem extractLsb_ofNat (x n : Nat) (hi lo : Nat) :
   simp [extractLsb, toInt_ofNat]
 
 @[simp] theorem toFin_extractLsb' {s m : Nat} {x : BitVec n} :
-    (extractLsb' s m x).toFin = Fin.ofNat (2 ^ m) (x.toNat >>> s) := by
+    (extractLsb' s m x).toFin = Fin.ofNat' (2 ^ m) (x.toNat >>> s) := by
   simp [extractLsb', toInt_ofNat]
 
 @[simp] theorem toFin_extractLsb {hi lo : Nat} {x : BitVec n} :
-  (extractLsb hi lo x).toFin = Fin.ofNat (2 ^ (hi - lo + 1)) (x.toNat >>> lo) := by
+  (extractLsb hi lo x).toFin = Fin.ofNat' (2 ^ (hi - lo + 1)) (x.toNat >>> lo) := by
   simp [extractLsb, toInt_ofNat]
 
 @[simp] theorem getElem_extractLsb' {start len : Nat} {x : BitVec n} {i : Nat} (h : i < len) :
@@ -1310,7 +1310,7 @@ theorem extractLsb'_eq_zero {x : BitVec w} {start : Nat} :
     simp [BitVec.toInt, -Int.natCast_pow]
     omega
 
-@[simp] theorem toFin_allOnes : (allOnes w).toFin = Fin.ofNat (2^w) (2^w - 1) := by
+@[simp] theorem toFin_allOnes : (allOnes w).toFin = Fin.ofNat' (2^w) (2^w - 1) := by
   ext
   simp
 
@@ -1847,7 +1847,7 @@ theorem not_xor_right {x y : BitVec w} : ~~~ (x ^^^ y) = x ^^^ ~~~ y := by
   simp [-Int.natCast_pow]
 
 @[simp] theorem toFin_shiftLeft {n : Nat} (x : BitVec w) :
-    (x <<< n).toFin = Fin.ofNat (2^w) (x.toNat <<< n) := rfl
+    (x <<< n).toFin = Fin.ofNat' (2^w) (x.toNat <<< n) := rfl
 
 @[simp]
 theorem shiftLeft_zero (x : BitVec w) : x <<< 0 = x := by
@@ -2089,7 +2089,7 @@ theorem toInt_ushiftRight {x : BitVec w} {n : Nat} :
 
 @[simp]
 theorem toFin_ushiftRight {x : BitVec w} {n : Nat} :
-    (x >>> n).toFin = x.toFin / (Fin.ofNat (2^w) (2^n)) := by
+    (x >>> n).toFin = x.toFin / (Fin.ofNat' (2^w) (2^n)) := by
   apply Fin.eq_of_val_eq
   by_cases hn : n < w
   · simp [Nat.shiftRight_eq_div_pow, Nat.mod_eq_of_lt (Nat.pow_lt_pow_of_lt Nat.one_lt_two hn)]
@@ -2340,26 +2340,26 @@ theorem toNat_sshiftRight {x : BitVec w} {n : Nat} :
     simp [toNat_sshiftRight_of_msb_false, h]
 
 theorem toFin_sshiftRight_of_msb_true {x : BitVec w} {n : Nat} (h : x.msb = true) :
-    (x.sshiftRight n).toFin = Fin.ofNat (2^w) (2 ^ w - 1 - (2 ^ w - 1 - x.toNat) >>> n) := by
+    (x.sshiftRight n).toFin = Fin.ofNat' (2^w) (2 ^ w - 1 - (2 ^ w - 1 - x.toNat) >>> n) := by
   apply Fin.eq_of_val_eq
-  simp only [val_toFin, toNat_sshiftRight, h, ↓reduceIte, Fin.val_ofNat]
+  simp only [val_toFin, toNat_sshiftRight, h, ↓reduceIte, Fin.val_ofNat']
   rw [Nat.mod_eq_of_lt]
   have := x.isLt
   have ineq : ∀ y, 2 ^ w - 1 - y < 2 ^ w := by omega
   exact ineq ((2 ^ w - 1 - x.toNat) >>> n)
 
 theorem toFin_sshiftRight_of_msb_false {x : BitVec w} {n : Nat} (h : x.msb = false) :
-    (x.sshiftRight n).toFin = Fin.ofNat (2^w) (x.toNat >>> n) := by
+    (x.sshiftRight n).toFin = Fin.ofNat' (2^w) (x.toNat >>> n) := by
   apply Fin.eq_of_val_eq
-  simp only [val_toFin, toNat_sshiftRight, h, Bool.false_eq_true, ↓reduceIte, Fin.val_ofNat]
+  simp only [val_toFin, toNat_sshiftRight, h, Bool.false_eq_true, ↓reduceIte, Fin.val_ofNat']
   have := Nat.shiftRight_le x.toNat n
   rw [Nat.mod_eq_of_lt (by omega)]
 
 theorem toFin_sshiftRight {x : BitVec w} {n : Nat} :
     (x.sshiftRight n).toFin =
       if x.msb
-      then Fin.ofNat (2^w) (2 ^ w - 1 - (2 ^ w - 1 - x.toNat) >>> n)
-      else Fin.ofNat (2^w) (x.toNat >>> n) := by
+      then Fin.ofNat' (2^w) (2 ^ w - 1 - (2 ^ w - 1 - x.toNat) >>> n)
+      else Fin.ofNat' (2^w) (x.toNat >>> n) := by
   by_cases h : x.msb
   · simp [toFin_sshiftRight_of_msb_true, h]
   · simp [toFin_sshiftRight_of_msb_false, h]
@@ -2397,18 +2397,18 @@ theorem toNat_sshiftRight' {x y : BitVec w} :
   rw [sshiftRight_eq', toNat_sshiftRight]
 
 theorem toFin_sshiftRight'_of_msb_true {x y : BitVec w} (h : x.msb = true) :
-    (x.sshiftRight' y).toFin = Fin.ofNat (2^w) (2 ^ w - 1 - (2 ^ w - 1 - x.toNat) >>> y.toNat) := by
+    (x.sshiftRight' y).toFin = Fin.ofNat' (2^w) (2 ^ w - 1 - (2 ^ w - 1 - x.toNat) >>> y.toNat) := by
   rw [sshiftRight_eq', toFin_sshiftRight_of_msb_true h]
 
 theorem toFin_sshiftRight'_of_msb_false {x y : BitVec w} (h : x.msb = false) :
-    (x.sshiftRight' y).toFin = Fin.ofNat (2^w) (x.toNat >>> y.toNat) := by
+    (x.sshiftRight' y).toFin = Fin.ofNat' (2^w) (x.toNat >>> y.toNat) := by
   rw [sshiftRight_eq', toFin_sshiftRight_of_msb_false h]
 
 theorem toFin_sshiftRight' {x y : BitVec w} :
     (x.sshiftRight' y).toFin =
       if x.msb
-      then Fin.ofNat (2^w) (2 ^ w - 1 - (2 ^ w - 1 - x.toNat) >>> y.toNat)
-      else Fin.ofNat (2^w) (x.toNat >>> y.toNat) := by
+      then Fin.ofNat' (2^w) (2 ^ w - 1 - (2 ^ w - 1 - x.toNat) >>> y.toNat)
+      else Fin.ofNat' (2^w) (x.toNat >>> y.toNat) := by
   rw [sshiftRight_eq', toFin_sshiftRight]
 
 theorem toInt_sshiftRight' {x y : BitVec w} :
@@ -2614,16 +2614,16 @@ theorem toInt_signExtend_eq_toInt_bmod_of_le (x : BitVec w) (h : v ≤ w) :
   rw [BitVec.toInt_signExtend, Nat.min_eq_left h]
 
 theorem toFin_signExtend_of_le {x : BitVec w} (hv : v ≤ w):
-    (x.signExtend v).toFin = Fin.ofNat (2 ^ v) x.toNat := by
+    (x.signExtend v).toFin = Fin.ofNat' (2 ^ v) x.toNat := by
   simp [signExtend_eq_setWidth_of_le _ hv]
 
 theorem toFin_signExtend (x : BitVec w) :
-    (x.signExtend v).toFin = Fin.ofNat (2 ^ v) (x.toNat + if x.msb = true then 2 ^ v - 2 ^ w else 0):= by
+    (x.signExtend v).toFin = Fin.ofNat' (2 ^ v) (x.toNat + if x.msb = true then 2 ^ v - 2 ^ w else 0):= by
   by_cases hv : v ≤ w
   · simp [toFin_signExtend_of_le hv, show 2 ^ v - 2 ^ w = 0 by rw [@Nat.sub_eq_zero_iff_le]; apply Nat.pow_le_pow_of_le (by decide) (by omega)]
   · simp only [Nat.not_le] at hv
     apply Fin.eq_of_val_eq
-    simp only [val_toFin, Fin.val_ofNat]
+    simp only [val_toFin, Fin.val_ofNat']
     rw [toNat_signExtend_of_le _ (by omega)]
     have : 2 ^ w < 2 ^ v := by apply Nat.pow_lt_pow_of_lt <;> omega
     rw [Nat.mod_eq_of_lt]
@@ -2974,7 +2974,7 @@ theorem extractLsb'_append_eq_ite {v w} {xhi : BitVec v} {xlo : BitVec w} {start
     extractLsb' start len (xhi ++ xlo) =
     if hstart : start < w
     then
-      if hlen : start + len ≤ w
+      if hlen : start + len < w
       then extractLsb' start len xlo
       else
         (((extractLsb' (start - w) (len - (w - start)) xhi) ++
@@ -2983,7 +2983,7 @@ theorem extractLsb'_append_eq_ite {v w} {xhi : BitVec v} {xlo : BitVec w} {start
       extractLsb' (start - w) len xhi := by
   by_cases hstart : start < w
   · simp only [hstart, ↓reduceDIte]
-    by_cases hlen : start + len ≤ w
+    by_cases hlen : start + len < w
     · simp only [hlen, ↓reduceDIte]
       ext i hi
       simp only [getElem_extractLsb', getLsbD_append, ite_eq_left_iff, Nat.not_lt]
@@ -3006,14 +3006,11 @@ theorem extractLsb'_append_eq_ite {v w} {xhi : BitVec v} {xlo : BitVec w} {start
 /-- Extracting bits `[start..start+len)` from `(xhi ++ xlo)` equals extracting
 the bits from `xlo` when `start + len` is within `xlo`.
 -/
-theorem extractLsb'_append_eq_of_add_le {v w} {xhi : BitVec v} {xlo : BitVec w}
-    {start len : Nat} (h : start + len ≤ w) :
+theorem extractLsb'_append_eq_of_lt {v w} {xhi : BitVec v} {xlo : BitVec w}
+    {start len : Nat} (h : start + len < w) :
     extractLsb' start len (xhi ++ xlo) = extractLsb' start len xlo := by
-  simp only [extractLsb'_append_eq_ite, h, ↓reduceDIte, dite_eq_ite, ite_eq_left_iff, Nat.not_lt]
-  intro h'
-  have : len = 0 := by omega
-  subst this
-  simp
+  simp [extractLsb'_append_eq_ite, h]
+  omega
 
 /-- Extracting bits `[start..start+len)` from `(xhi ++ xlo)` equals extracting
 the bits from `xhi` when `start` is outside `xlo`.
@@ -3182,11 +3179,11 @@ theorem getElem_concat (x : BitVec w) (b : Bool) (i : Nat) (h : i < w + 1) :
   · simp [Nat.mod_eq_of_lt b.toNat_lt]
   · simp [Nat.div_eq_of_lt b.toNat_lt, Nat.testBit_add_one]
 
-@[simp] theorem getElem_concat_zero {x : BitVec w} : (concat x b)[0] = b := by
+@[simp] theorem getLsbD_concat_zero : (concat x b).getLsbD 0 = b := by
   simp [getElem_concat]
 
-theorem getLsbD_concat_zero : (concat x b).getLsbD 0 = b := by
-  simp
+@[simp] theorem getElem_concat_zero : (concat x b)[0] = b := by
+  simp [getElem_concat]
 
 @[simp] theorem getLsbD_concat_succ : (concat x b).getLsbD (i + 1) = x.getLsbD i := by
   simp [getLsbD_concat]
@@ -3326,19 +3323,11 @@ Definition of bitvector addition as a nat.
 
 theorem ofNat_add {n} (x y : Nat) : BitVec.ofNat n (x + y) = BitVec.ofNat n x + BitVec.ofNat n y := by
   apply eq_of_toNat_eq
-  simp [BitVec.ofNat, Fin.ofNat_add]
+  simp [BitVec.ofNat, Fin.ofNat'_add]
 
 theorem ofNat_add_ofNat {n} (x y : Nat) : BitVec.ofNat n x + BitVec.ofNat n y = BitVec.ofNat n (x + y) :=
   (ofNat_add x y).symm
 
-@[simp]
-theorem toNat_add_of_not_uaddOverflow {x y : BitVec w} (h : ¬ uaddOverflow x y) :
-    (x + y).toNat = x.toNat + y.toNat := by
-  rcases w with _|w
-  · simp [of_length_zero]
-  · simp only [uaddOverflow, ge_iff_le, decide_eq_true_eq, Nat.not_le] at h
-    rw [toNat_add, Nat.mod_eq_of_lt h]
-
 protected theorem add_assoc (x y z : BitVec n) : x + y + z = x + (y + z) := by
   apply eq_of_toNat_eq ; simp [Nat.add_assoc]
 instance : Std.Associative (α := BitVec n) (· + ·) := ⟨BitVec.add_assoc⟩
@@ -3368,15 +3357,6 @@ theorem ofInt_add {n} (x y : Int) : BitVec.ofInt n (x + y) =
   apply eq_of_toInt_eq
   simp
 
-@[simp]
-theorem toInt_add_of_not_saddOverflow {x y : BitVec w} (h : ¬ saddOverflow x y) :
-    (x + y).toInt = x.toInt + y.toInt := by
-  rcases w with _|w
-  · simp [of_length_zero]
-  · simp only [saddOverflow, Nat.add_one_sub_one, ge_iff_le, Bool.or_eq_true, decide_eq_true_eq,
-      _root_.not_or, Int.not_le, Int.not_lt] at h
-    rw [toInt_add, Int.bmod_eq_of_le (by push_cast; omega) (by push_cast; omega)]
-
 @[simp]
 theorem shiftLeft_add_distrib {x y : BitVec w} {n : Nat} :
     (x + y) <<< n = x <<< n + y <<< n := by
@@ -3402,24 +3382,6 @@ theorem sub_def {n} (x y : BitVec n) : x - y = .ofNat n ((2^n - y.toNat) + x.toN
     (x - y).toInt = (x.toInt - y.toInt).bmod (2 ^ w) := by
   simp [toInt_eq_toNat_bmod, @Int.ofNat_sub y.toNat (2 ^ w) (by omega), -Int.natCast_pow]
 
-@[simp]
-theorem toNat_sub_of_not_usubOverflow {x y : BitVec w} (h : ¬ usubOverflow x y) :
-    (x - y).toNat = x.toNat - y.toNat := by
-  rcases w with _|w
-  · simp [of_length_zero]
-  · simp only [usubOverflow, decide_eq_true_eq, Nat.not_lt] at h
-    rw [toNat_sub, ← Nat.sub_add_comm (by omega), Nat.add_sub_assoc h, Nat.add_mod_left,
-      Nat.mod_eq_of_lt (by omega)]
-
-@[simp]
-theorem toInt_sub_of_not_ssubOverflow {x y : BitVec w} (h : ¬ ssubOverflow x y) :
-    (x - y).toInt = x.toInt - y.toInt := by
-  rcases w with _|w
-  · simp [of_length_zero]
-  · simp only [ssubOverflow, Nat.add_one_sub_one, ge_iff_le, Bool.or_eq_true, decide_eq_true_eq,
-      _root_.not_or, Int.not_le, Int.not_lt] at h
-    rw [toInt_sub, Int.bmod_eq_of_le (by push_cast; omega) (by push_cast; omega)]
-
 theorem toInt_sub_toInt_lt_twoPow_iff {x y : BitVec w} :
     (x.toInt - y.toInt < - 2 ^ (w - 1))
     ↔ (x.toInt < 0 ∧ 0 ≤ y.toInt ∧ 0 ≤ (x.toInt - y.toInt).bmod (2 ^ w)) := by
@@ -3471,7 +3433,7 @@ theorem sub_ofFin (x : BitVec n) (y : Fin (2^n)) : x - .ofFin y = .ofFin (x.toFi
 -- If `x` and `n` are not literals, applying this theorem eagerly may not be a good idea.
 theorem ofNat_sub_ofNat {n} (x y : Nat) : BitVec.ofNat n x - BitVec.ofNat n y = .ofNat n ((2^n - y % 2^n) + x) := by
   apply eq_of_toNat_eq
-  simp [BitVec.ofNat, Fin.ofNat_sub]
+  simp [BitVec.ofNat, Fin.ofNat'_sub]
 
 @[simp] protected theorem sub_zero (x : BitVec n) : x - 0#n = x := by apply eq_of_toNat_eq ; simp
 
@@ -3498,21 +3460,11 @@ theorem toInt_neg {x : BitVec w} :
   rw [← BitVec.zero_sub, toInt_sub]
   simp [BitVec.toInt_ofNat]
 
-@[simp]
-theorem toInt_neg_of_not_negOverflow {x : BitVec w} (h : ¬ negOverflow x):
-    (-x).toInt = -x.toInt := by
-  rcases w with _|w
-  · simp [of_length_zero]
-  · have := toInt_lt (x := x); simp only [Nat.add_one_sub_one] at this
-    have := le_toInt (x := x); simp only [Nat.add_one_sub_one] at this
-    simp only [negOverflow, Nat.add_one_sub_one, beq_iff_eq] at h
-    rw [toInt_neg, Int.bmod_eq_of_le (by push_cast; omega) (by push_cast; omega)]
-
 theorem ofInt_neg {w : Nat} {n : Int} : BitVec.ofInt w (-n) = -BitVec.ofInt w n :=
   eq_of_toInt_eq (by simp [toInt_neg])
 
 @[simp] theorem toFin_neg (x : BitVec n) :
-    (-x).toFin = Fin.ofNat (2^n) (2^n - x.toNat) :=
+    (-x).toFin = Fin.ofNat' (2^n) (2^n - x.toNat) :=
   rfl
 
 theorem sub_eq_add_neg {n} (x y : BitVec n) : x - y = x + - y := by
@@ -3727,7 +3679,7 @@ theorem fill_false {w : Nat} : fill w false = 0#w := 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
+    (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 -/
@@ -3739,7 +3691,7 @@ theorem mul_def {n} {x y : BitVec n} : x * y = (ofFin <| x.toFin * y.toFin) := r
 
 theorem ofNat_mul {n} (x y : Nat) : BitVec.ofNat n (x * y) = BitVec.ofNat n x * BitVec.ofNat n y := by
   apply eq_of_toNat_eq
-  simp [BitVec.ofNat, Fin.ofNat_mul]
+  simp [BitVec.ofNat, Fin.ofNat'_mul]
 
 theorem ofNat_mul_ofNat {n} (x y : Nat) : BitVec.ofNat n x * BitVec.ofNat n y = BitVec.ofNat n (x * y) :=
   (ofNat_mul x y).symm
@@ -3797,23 +3749,6 @@ theorem two_mul {x : BitVec w} : 2#w * x = x + x := by rw [BitVec.mul_comm, mul_
   (x * y).toInt = (x.toInt * y.toInt).bmod (2^w) := by
   simp [toInt_eq_toNat_bmod, -Int.natCast_pow]
 
-@[simp]
-theorem toNat_mul_of_not_umulOverflow {x y : BitVec w} (h : ¬ umulOverflow x y) :
-    (x * y).toNat = x.toNat * y.toNat := by
-  rcases w with _|w
-  · simp [of_length_zero]
-  · simp only [umulOverflow, ge_iff_le, decide_eq_true_eq, Nat.not_le] at h
-    rw [toNat_mul, Nat.mod_eq_of_lt h]
-
-@[simp]
-theorem toInt_mul_of_not_smulOverflow {x y : BitVec w} (h : ¬ smulOverflow x y) :
-    (x * y).toInt = x.toInt * y.toInt := by
-  rcases w with _|w
-  · simp [of_length_zero]
-  · simp only [smulOverflow, Nat.add_one_sub_one, ge_iff_le, Bool.or_eq_true, decide_eq_true_eq,
-      _root_.not_or, Int.not_le, Int.not_lt] at h
-    rw [toInt_mul, Int.bmod_eq_of_le (by push_cast; omega) (by push_cast; omega)]
-
 theorem ofInt_mul {n} (x y : Int) : BitVec.ofInt n (x * y) =
     BitVec.ofInt n x * BitVec.ofInt n y := by
   apply eq_of_toInt_eq
@@ -3998,15 +3933,6 @@ theorem pos_of_msb {x : BitVec w} (hx : x.msb = true) : 0#w < x := by
   rw [BitVec.not_lt, le_zero_iff] at h
   simp [h] at hx
 
-@[simp]
-theorem lt_of_msb_false_of_msb_true {x y : BitVec w} (hx : x.msb = false) (hy : y.msb = true) :
-    x < y := by
-  simp only [LT.lt]
-  have := toNat_ge_of_msb_true hy
-  have := toNat_lt_of_msb_false hx
-  simp
-  omega
-
 /-! ### udiv -/
 
 theorem udiv_def {x y : BitVec n} : x / y = BitVec.ofNat n (x.toNat / y.toNat) := by
@@ -4188,14 +4114,6 @@ 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]
 
-@[simp]
-theorem msb_umod_of_msb_false_of_ne_zero {x y : BitVec w} (hmsb : y.msb = false) (h_ne_zero : y ≠ 0#w) :
-    (x % y).msb = false := by
-  simp only [msb_umod, Bool.and_eq_false_imp, Bool.or_eq_false_iff, beq_eq_false_iff_ne,
-    ne_eq, h_ne_zero]
-  intro h
-  simp [BitVec.le_of_lt, lt_of_msb_false_of_msb_true hmsb h]
-
 /-! ### smtUDiv -/
 
 theorem smtUDiv_eq (x y : BitVec w) : smtUDiv x y = if y = 0#w then allOnes w else x / y := by
@@ -4644,7 +4562,7 @@ theorem toInt_rotateLeft {x : BitVec w} {r : Nat} :
 
 theorem toFin_rotateLeft {x : BitVec w} {r : Nat} :
   (x.rotateLeft r).toFin =
-    Fin.ofNat (2 ^ w) (x.toNat <<< (r % w)) ||| x.toFin / Fin.ofNat (2 ^ w) (2 ^ (w - r % w)) := by
+    Fin.ofNat' (2 ^ w) (x.toNat <<< (r % w)) ||| x.toFin / Fin.ofNat' (2 ^ w) (2 ^ (w - r % w)) := by
   simp [rotateLeft_def, toFin_shiftLeft, toFin_ushiftRight, toFin_or]
 
 /-! ## Rotate Right -/
@@ -4806,7 +4724,7 @@ theorem toInt_rotateRight {x : BitVec w} {r : Nat} :
   simp [rotateRight_def, toInt_shiftLeft, toInt_ushiftRight, toInt_or]
 
 theorem toFin_rotateRight {x : BitVec w} {r : Nat} :
-    (x.rotateRight r).toFin = x.toFin / Fin.ofNat (2 ^ w) (2 ^ (r % w)) ||| Fin.ofNat (2 ^ w) (x.toNat <<< (w - r % w)) := by
+    (x.rotateRight r).toFin = x.toFin / Fin.ofNat' (2 ^ w) (2 ^ (r % w)) ||| Fin.ofNat' (2 ^ w) (x.toNat <<< (w - r % w)) := by
   simp [rotateRight_def, toFin_shiftLeft, toFin_ushiftRight, toFin_or]
 
 /- ## twoPow -/
@@ -4878,7 +4796,7 @@ theorem toInt_twoPow {w i : Nat} :
       · simp [h, h', show i < w + 1 by omega, Int.natCast_pow]
 
 theorem toFin_twoPow {w i : Nat} :
-    (BitVec.twoPow w i).toFin = Fin.ofNat (2^w) (2^i) := by
+    (BitVec.twoPow w i).toFin = Fin.ofNat' (2^w) (2^i) := by
   rcases w with rfl | w
   · simp [BitVec.twoPow, BitVec.toFin, toFin_shiftLeft, Fin.fin_one_eq_zero]
   · simp [BitVec.twoPow, BitVec.toFin, toFin_shiftLeft, Nat.shiftLeft_eq]
@@ -5430,27 +5348,6 @@ theorem neg_ofNat_eq_ofInt_neg {w : Nat} {x : Nat} :
   apply BitVec.eq_of_toInt_eq
   simp [BitVec.toInt_neg, BitVec.toInt_ofNat]
 
-@[simp]
-theorem neg_toInt_neg {x : BitVec w} (h : x.msb = false) :
-    -(-x).toInt = x.toNat := by
-  simp [toInt_neg_eq_of_msb h, toInt_eq_toNat_of_msb, h]
-
-theorem toNat_pos_of_ne_zero {x : BitVec w} (hx : x ≠ 0#w) :
-    0 < x.toNat := by
-  simp [toNat_eq] at hx; omega
-
-theorem toNat_neg_lt_of_msb (x : BitVec w) (hmsb : x.msb = true) :
-    (-x).toNat ≤ 2^(w-1) := by
-  rcases w with _|w
-  · simp [BitVec.eq_nil x]
-  · by_cases hx : x = 0#(w + 1)
-    · simp [hx]
-    · have := BitVec.le_toNat_of_msb_true hmsb
-      have := toNat_pos_of_ne_zero hx
-      rw [toNat_neg, Nat.mod_eq_of_lt (by omega), ← Nat.two_pow_pred_add_two_pow_pred (by omega),
-        ← Nat.two_mul]
-      omega
-
 /-! ### abs -/
 
 theorem abs_eq (x : BitVec w) : x.abs = if x.msb then -x else x := rfl
@@ -5543,7 +5440,7 @@ theorem toInt_abs_eq_natAbs_of_ne_intMin {x : BitVec w} (hx : x ≠ intMin w) :
   simp [toInt_abs_eq_natAbs, hx]
 
 theorem toFin_abs {x : BitVec w} :
-    x.abs.toFin = if x.msb then Fin.ofNat (2 ^ w) (2 ^ w - x.toNat) else x.toFin := by
+    x.abs.toFin = if x.msb then Fin.ofNat' (2 ^ w) (2 ^ w - x.toNat) else x.toFin := by
   by_cases h : x.msb <;> simp [BitVec.abs, h]
 
 /-! ### Reverse -/

src/Init/Data/Bool.lean

@@ -455,7 +455,7 @@ theorem toNat_lt (b : Bool) : b.toNat < 2 :=
 /--
 Converts `true` to `1` and `false` to `0`.
 -/
-@[expose] def toInt (b : Bool) : Int := cond b 1 0
+def toInt (b : Bool) : Int := cond b 1 0
 
 @[simp] theorem toInt_false : false.toInt = 0 := rfl
 

src/Init/Data/ByteArray/Basic.lean

@@ -205,7 +205,7 @@ def foldlM {β : Type v} {m : Type v → Type w} [Monad m] (f : β → UInt8 →
 
 @[inline]
 def foldl {β : Type v} (f : β → UInt8 → β) (init : β) (as : ByteArray) (start := 0) (stop := as.size) : β :=
-  Id.run <| as.foldlM (pure <| f · ·) init start stop
+  Id.run <| as.foldlM f init start stop
 
 /-- Iterator over the bytes (`UInt8`) of a `ByteArray`.
 

src/Init/Data/Fin/Basic.lean

@@ -46,12 +46,15 @@ Returns `a` modulo `n` as a `Fin n`.
 
 The assumption `NeZero n` ensures that `Fin n` is nonempty.
 -/
-@[expose] protected def ofNat (n : Nat) [NeZero n] (a : Nat) : Fin n :=
+@[expose] protected def ofNat' (n : Nat) [NeZero n] (a : Nat) : Fin n :=
   ⟨a % n, Nat.mod_lt _ (pos_of_neZero n)⟩
 
-@[deprecated Fin.ofNat (since := "2025-05-28")]
-protected def ofNat' (n : Nat) [NeZero n] (a : Nat) : Fin n :=
-  Fin.ofNat n a
+/--
+Returns `a` modulo `n + 1` as a `Fin n.succ`.
+-/
+@[deprecated Fin.ofNat' (since := "2024-11-27")]
+protected def ofNat {n : Nat} (a : Nat) : Fin (n + 1) :=
+  ⟨a % (n+1), Nat.mod_lt _ (Nat.zero_lt_succ _)⟩
 
 -- We provide this because other similar types have a `toNat` function, but `simp` rewrites
 -- `i.toNat` to `i.val`.
@@ -81,7 +84,7 @@ Examples:
  * `(2 : Fin 3) + (2 : Fin 3) = (1 : Fin 3)`
 -/
 protected def add : Fin n → Fin n → Fin n
-  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(a + b) % n, by exact mlt h⟩
+  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(a + b) % n, mlt h⟩
 
 /--
 Multiplication modulo `n`, usually invoked via the `*` operator.
@@ -92,7 +95,7 @@ Examples:
  * `(3 : Fin 10) * (7 : Fin 10) = (1 : Fin 10)`
 -/
 protected def mul : Fin n → Fin n → Fin n
-  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(a * b) % n, by exact mlt h⟩
+  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(a * b) % n, mlt h⟩
 
 /--
 Subtraction modulo `n`, usually invoked via the `-` operator.
@@ -119,7 +122,7 @@ protected def sub : Fin n → Fin n → Fin n
   using recursion on the second argument.
   See issue #4413.
   -/
-  | ⟨a, h⟩, ⟨b, _⟩ => ⟨((n - b) + a) % n, by exact mlt h⟩
+  | ⟨a, h⟩, ⟨b, _⟩ => ⟨((n - b) + a) % n, mlt h⟩
 
 /-!
 Remark: land/lor can be defined without using (% n), but
@@ -161,19 +164,19 @@ def modn : Fin n → Nat → Fin n
 Bitwise and.
 -/
 def land : Fin n → Fin n → Fin n
-  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(Nat.land a b) % n, by exact mlt h⟩
+  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(Nat.land a b) % n, mlt h⟩
 
 /--
 Bitwise or.
 -/
 def lor : Fin n → Fin n → Fin n
-  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(Nat.lor a b) % n, by exact mlt h⟩
+  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(Nat.lor a b) % n, mlt h⟩
 
 /--
 Bitwise xor (“exclusive or”).
 -/
 def xor : Fin n → Fin n → Fin n
-  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(Nat.xor a b) % n, by exact mlt h⟩
+  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(Nat.xor a b) % n, mlt h⟩
 
 /--
 Bitwise left shift of bounded numbers, with wraparound on overflow.
@@ -184,7 +187,7 @@ Examples:
  * `(1 : Fin 10) <<< (4 : Fin 10) = (6 : Fin 10)`
 -/
 def shiftLeft : Fin n → Fin n → Fin n
-  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(a <<< b) % n, by exact mlt h⟩
+  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(a <<< b) % n, mlt h⟩
 
 /--
 Bitwise right shift of bounded numbers.
@@ -198,7 +201,7 @@ Examples:
  * `(15 : Fin 17) >>> (2 : Fin 17) = (3 : Fin 17)`
 -/
 def shiftRight : Fin n → Fin n → Fin n
-  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(a >>> b) % n, by exact mlt h⟩
+  | ⟨a, h⟩, ⟨b, _⟩ => ⟨(a >>> b) % n, mlt h⟩
 
 instance : Add (Fin n) where
   add := Fin.add
@@ -227,7 +230,7 @@ instance : ShiftRight (Fin n) where
   shiftRight := Fin.shiftRight
 
 instance instOfNat {n : Nat} [NeZero n] {i : Nat} : OfNat (Fin n) i where
-  ofNat := Fin.ofNat n i
+  ofNat := Fin.ofNat' n i
 
 /-- If you actually have an element of `Fin n`, then the `n` is always positive -/
 protected theorem pos (i : Fin n) : 0 < n :=

src/Init/Data/Fin/Fold.lean

@@ -100,11 +100,6 @@ Fin.foldrM n f xₙ = do
 
 /-! ### foldlM -/
 
-@[congr] theorem foldlM_congr [Monad m] {n k : Nat} (w : n = k) (f : α → Fin n → m α) :
-    foldlM n f = foldlM k (fun x i => f x (i.cast w.symm)) := by
-  subst w
-  rfl
-
 theorem foldlM_loop_lt [Monad m] (f : α → Fin n → m α) (x) (h : i < n) :
     foldlM.loop n f x i = f x ⟨i, h⟩ >>= (foldlM.loop n f . (i+1)) := by
   rw [foldlM.loop, dif_pos h]
@@ -125,49 +120,14 @@ theorem foldlM_loop [Monad m] (f : α → Fin (n+1) → m α) (x) (h : i < n+1)
     rw [foldlM_loop_eq, foldlM_loop_eq]
 termination_by n - i
 
-@[simp] theorem foldlM_zero [Monad m] (f : α → Fin 0 → m α) : foldlM 0 f = pure := by
-  funext x
-  exact foldlM_loop_eq ..
+@[simp] theorem foldlM_zero [Monad m] (f : α → Fin 0 → m α) (x) : foldlM 0 f x = pure x :=
+  foldlM_loop_eq ..
 
-theorem foldlM_succ [Monad m] (f : α → Fin (n+1) → m α) :
-    foldlM (n+1) f = fun x => f x 0 >>= foldlM n (fun x j => f x j.succ) := by
-  funext x
-  exact foldlM_loop ..
-
-/-- Variant of `foldlM_succ` that splits off `Fin.last n` rather than `0`. -/
-theorem foldlM_succ_last [Monad m] [LawfulMonad m] (f : α → Fin (n+1) → m α) :
-    foldlM (n+1) f = fun x => foldlM n (fun x j => f x j.castSucc) x >>= (f · (Fin.last n)) := by
-  funext x
-  induction n generalizing x with
-  | zero =>
-    simp [foldlM_succ]
-  | succ n ih =>
-    rw [foldlM_succ]
-    conv => rhs; rw [foldlM_succ]
-    simp only [castSucc_zero, castSucc_succ, bind_assoc]
-    congr 1
-    funext x
-    rw [ih]
-    simp
-
-theorem foldlM_add [Monad m] [LawfulMonad m] (f : α → Fin (n + k) → m α) :
-    foldlM (n + k) f =
-      fun x => foldlM n (fun x i => f x (i.castLE (Nat.le_add_right n k))) x >>= foldlM k (fun x i => f x (i.natAdd n)) := by
-  induction k with
-  | zero =>
-    funext x
-    simp
-  | succ k ih =>
-    funext x
-    simp [foldlM_succ_last, ← Nat.add_assoc, ih]
+theorem foldlM_succ [Monad m] (f : α → Fin (n+1) → m α) (x) :
+    foldlM (n+1) f x = f x 0 >>= foldlM n (fun x j => f x j.succ) := foldlM_loop ..
 
 /-! ### foldrM -/
 
-@[congr] theorem foldrM_congr [Monad m] {n k : Nat} (w : n = k) (f : Fin n → α → m α) :
-    foldrM n f = foldrM k (fun i => f (i.cast w.symm)) := by
-  subst w
-  rfl
-
 theorem foldrM_loop_zero [Monad m] (f : Fin n → α → m α) (x) :
     foldrM.loop n f ⟨0, Nat.zero_le _⟩ x = pure x := by
   rw [foldrM.loop]
@@ -184,49 +144,20 @@ theorem foldrM_loop [Monad m] [LawfulMonad m] (f : Fin (n+1) → α → m α) (x
     rw [foldrM_loop_zero, foldrM_loop_succ, pure_bind]
     conv => rhs; rw [←bind_pure (f 0 x)]
     congr
-    try  -- TODO: block can be deleted after bootstrapping
-      funext
-      simp [foldrM_loop_zero]
+    funext
+    try simp only [foldrM.loop] -- the try makes this proof work with and without opaque wf rec
   | succ i ih =>
     rw [foldrM_loop_succ, foldrM_loop_succ, bind_assoc]
     congr; funext; exact ih ..
 
-@[simp] theorem foldrM_zero [Monad m] (f : Fin 0 → α → m α) : foldrM 0 f = pure := by
-  funext x
-  exact foldrM_loop_zero ..
+@[simp] theorem foldrM_zero [Monad m] (f : Fin 0 → α → m α) (x) : foldrM 0 f x = pure x :=
+  foldrM_loop_zero ..
 
-theorem foldrM_succ [Monad m] [LawfulMonad m] (f : Fin (n+1) → α → m α) :
-    foldrM (n+1) f = fun x => foldrM n (fun i => f i.succ) x >>= f 0 := by
-  funext x
-  exact foldrM_loop ..
-
-theorem foldrM_succ_last [Monad m] [LawfulMonad m] (f : Fin (n+1) → α → m α) :
-    foldrM (n+1) f = fun x => f (Fin.last n) x >>= foldrM n (fun i => f i.castSucc) := by
-  funext x
-  induction n generalizing x with
-  | zero => simp [foldrM_succ]
-  | succ n ih =>
-    rw [foldrM_succ]
-    conv => rhs; rw [foldrM_succ]
-    simp [ih]
-
-theorem foldrM_add [Monad m] [LawfulMonad m] (f : Fin (n + k) → α → m α) :
-    foldrM (n + k) f =
-      fun x => foldrM k (fun i => f (i.natAdd n)) x >>= foldrM n (fun i => f (i.castLE (Nat.le_add_right n k))) := by
-  induction k with
-  | zero =>
-    simp
-  | succ k ih =>
-    funext x
-    simp [foldrM_succ_last, ← Nat.add_assoc, ih]
+theorem foldrM_succ [Monad m] [LawfulMonad m] (f : Fin (n+1) → α → m α) (x) :
+    foldrM (n+1) f x = foldrM n (fun i => f i.succ) x >>= f 0 := foldrM_loop ..
 
 /-! ### foldl -/
 
-@[congr] theorem foldl_congr {n k : Nat} (w : n = k) (f : α → Fin n → α) :
-    foldl n f = foldl k (fun x i => f x (i.cast w.symm)) := by
-  subst w
-  rfl
-
 theorem foldl_loop_lt (f : α → Fin n → α) (x) (h : i < n) :
     foldl.loop n f x i = foldl.loop n f (f x ⟨i, h⟩) (i+1) := by
   rw [foldl.loop, dif_pos h]
@@ -256,34 +187,14 @@ theorem foldl_succ_last (f : α → Fin (n+1) → α) (x) :
   rw [foldl_succ]
   induction n generalizing x with
   | zero => simp [foldl_succ, Fin.last]
-  | succ n ih => rw [foldl_succ, ih (f · ·.succ), foldl_succ]; simp
-
-theorem foldl_add (f : α → Fin (n + m) → α) (x) :
-    foldl (n + m) f x =
-      foldl m (fun x i => f x (i.natAdd n))
-        (foldl n (fun x i => f x (i.castLE (Nat.le_add_right n m))) x):= by
-  induction m with
-  | zero => simp
-  | succ m ih => simp [foldl_succ_last, ih, ← Nat.add_assoc]
+  | succ n ih => rw [foldl_succ, ih (f · ·.succ), foldl_succ]; simp [succ_castSucc]
 
 theorem foldl_eq_foldlM (f : α → Fin n → α) (x) :
-    foldl n f x = (foldlM (m := Id) n (pure <| f · ·) x).run := by
+    foldl n f x = foldlM (m:=Id) n f x := by
   induction n generalizing x <;> simp [foldl_succ, foldlM_succ, *]
 
--- This is not marked `@[simp]` as it would match on every occurrence of `foldlM`.
-theorem foldlM_pure [Monad m] [LawfulMonad m] {n} {f : α → Fin n → α} :
-    foldlM n (fun x i => pure (f x i)) x = (pure (foldl n f x) : m α) := by
-  induction n generalizing x with
-  | zero => simp
-  | succ n ih => simp [foldlM_succ, foldl_succ, ih]
-
 /-! ### foldr -/
 
-@[congr] theorem foldr_congr {n k : Nat} (w : n = k) (f : Fin n → α → α) :
-    foldr n f = foldr k (fun i => f (i.cast w.symm)) := by
-  subst w
-  rfl
-
 theorem foldr_loop_zero (f : Fin n → α → α) (x) :
     foldr.loop n f 0 (Nat.zero_le _) x = x := by
   rw [foldr.loop]
@@ -309,18 +220,10 @@ theorem foldr_succ_last (f : Fin (n+1) → α → α) (x) :
     foldr (n+1) f x = foldr n (f ·.castSucc) (f (last n) x) := by
   induction n generalizing x with
   | zero => simp [foldr_succ, Fin.last]
-  | succ n ih => rw [foldr_succ, ih (f ·.succ), foldr_succ]; simp
-
-theorem foldr_add (f : Fin (n + m) → α → α) (x) :
-    foldr (n + m) f x =
-      foldr n (fun i => f (i.castLE (Nat.le_add_right n m)))
-        (foldr m (fun i => f (i.natAdd n)) x) := by
-  induction m generalizing x with
-  | zero => simp
-  | succ m ih => simp [foldr_succ_last, ih, ← Nat.add_assoc]
+  | succ n ih => rw [foldr_succ, ih (f ·.succ), foldr_succ]; simp [succ_castSucc]
 
 theorem foldr_eq_foldrM (f : Fin n → α → α) (x) :
-    foldr n f x = (foldrM (m := Id) n (pure <| f · ·) x).run := by
+    foldr n f x = foldrM (m:=Id) n f x := by
   induction n <;> simp [foldr_succ, foldrM_succ, *]
 
 theorem foldl_rev (f : Fin n → α → α) (x) :
@@ -335,11 +238,4 @@ theorem foldr_rev (f : α → Fin n → α) (x) :
   | zero => simp
   | succ n ih => rw [foldl_succ_last, foldr_succ, ← ih]; simp [rev_succ]
 
--- This is not marked `@[simp]` as it would match on every occurrence of `foldrM`.
-theorem foldrM_pure [Monad m] [LawfulMonad m] {n} {f : Fin n → α → α} :
-    foldrM n (fun i x => pure (f i x)) x = (pure (foldr n f x) : m α) := by
-  induction n generalizing x with
-  | zero => simp
-  | succ n ih => simp [foldrM_succ, foldr_succ, ih]
-
 end Fin

src/Init/Data/Fin/Lemmas.lean

@@ -15,9 +15,10 @@ import Init.Omega
 
 namespace Fin
 
-@[simp] theorem ofNat_zero (n : Nat) [NeZero n] : Fin.ofNat n 0 = 0 := rfl
+@[simp] theorem ofNat'_zero (n : Nat) [NeZero n] : Fin.ofNat' n 0 = 0 := rfl
 
-@[deprecated ofNat_zero (since := "2025-05-28")] abbrev ofNat'_zero := @ofNat_zero
+@[deprecated Fin.pos (since := "2024-11-11")]
+theorem size_pos (i : Fin n) : 0 < n := i.pos
 
 theorem mod_def (a m : Fin n) : a % m = Fin.mk (a % m) (Nat.lt_of_le_of_lt (Nat.mod_le _ _) a.2) :=
   rfl
@@ -28,6 +29,8 @@ theorem sub_def (a b : Fin n) : a - b = Fin.mk (((n - b) + a) % n) (Nat.mod_lt _
 
 theorem pos' : ∀ [Nonempty (Fin n)], 0 < n | ⟨i⟩ => i.pos
 
+@[deprecated pos' (since := "2024-11-11")] abbrev size_pos' := @pos'
+
 @[simp] theorem is_lt (a : Fin n) : (a : Nat) < n := a.2
 
 theorem pos_iff_nonempty {n : Nat} : 0 < n ↔ Nonempty (Fin n) :=
@@ -63,25 +66,19 @@ theorem mk_val (i : Fin n) : (⟨i, i.isLt⟩ : Fin n) = i := Fin.eta ..
     0 = (⟨a, ha⟩ : Fin n) ↔ a = 0 := by
   simp [eq_comm]
 
-@[simp] theorem val_ofNat (n : Nat) [NeZero n] (a : Nat) :
-  (Fin.ofNat n a).val = a % n := rfl
+@[simp] theorem val_ofNat' (n : Nat) [NeZero n] (a : Nat) :
+  (Fin.ofNat' n a).val = a % n := rfl
 
-@[deprecated val_ofNat (since := "2025-05-28")] abbrev val_ofNat' := @val_ofNat
-
-@[simp] theorem ofNat_self {n : Nat} [NeZero n] : Fin.ofNat n n = 0 := by
+@[simp] theorem ofNat'_self {n : Nat} [NeZero n] : Fin.ofNat' n n = 0 := by
   ext
   simp
   congr
 
-@[deprecated ofNat_self (since := "2025-05-28")] abbrev ofNat'_self := @ofNat_self
-
-@[simp] theorem ofNat_val_eq_self [NeZero n] (x : Fin n) : (Fin.ofNat n x) = x := by
+@[simp] theorem ofNat'_val_eq_self [NeZero n] (x : Fin n) : (Fin.ofNat' n x) = x := by
   ext
-  rw [val_ofNat, Nat.mod_eq_of_lt]
+  rw [val_ofNat', Nat.mod_eq_of_lt]
   exact x.2
 
-@[deprecated ofNat_val_eq_self (since := "2025-05-28")] abbrev ofNat'_val_eq_self := @ofNat_val_eq_self
-
 @[simp] theorem mod_val (a b : Fin n) : (a % b).val = a.val % b.val :=
   rfl
 
@@ -103,20 +100,19 @@ theorem dite_val {n : Nat} {c : Prop} [Decidable c] {x y : Fin n} :
   by_cases c <;> simp [*]
 
 instance (n : Nat) [NeZero n] : NatCast (Fin n) where
-  natCast a := Fin.ofNat n a
+  natCast a := Fin.ofNat' n a
 
-@[expose]
 def intCast [NeZero n] (a : Int) : Fin n :=
   if 0 ≤ a then
-    Fin.ofNat n a.natAbs
+    Fin.ofNat' n a.natAbs
   else
-    - Fin.ofNat n a.natAbs
+    - Fin.ofNat' n a.natAbs
 
 instance (n : Nat) [NeZero n] : IntCast (Fin n) where
   intCast := Fin.intCast
 
 theorem intCast_def {n : Nat} [NeZero n] (x : Int) :
-    (x : Fin n) = if 0 ≤ x then Fin.ofNat n x.natAbs else -Fin.ofNat n x.natAbs := rfl
+    (x : Fin n) = if 0 ≤ x then Fin.ofNat' n x.natAbs else -Fin.ofNat' n x.natAbs := rfl
 
 /-! ### order -/
 
@@ -650,20 +646,6 @@ theorem rev_castSucc (k : Fin n) : rev (castSucc k) = succ (rev k) := k.rev_cast
 
 theorem rev_succ (k : Fin n) : rev (succ k) = castSucc (rev k) := k.rev_addNat 1
 
-@[simp, grind _=_]
-theorem castSucc_succ (i : Fin n) : i.succ.castSucc = i.castSucc.succ := rfl
-
-@[simp, grind =]
-theorem castLE_refl (h : n ≤ n) (i : Fin n) : i.castLE h = i := rfl
-
-@[simp, grind =]
-theorem castSucc_castLE (h : n ≤ m) (i : Fin n) :
-    (i.castLE h).castSucc = i.castLE (by omega) := rfl
-
-@[simp, grind =]
-theorem castSucc_natAdd (n : Nat) (i : Fin k) :
-    (i.natAdd n).castSucc = (i.castSucc).natAdd n := rfl
-
 /-! ### pred -/
 
 @[simp] theorem coe_pred (j : Fin (n + 1)) (h : j ≠ 0) : (j.pred h : Nat) = j - 1 := rfl
@@ -801,7 +783,7 @@ parameter, `Fin.cases` is the corresponding case analysis operator, and `Fin.rev
 version that starts at the greatest value instead of `0`.
 -/
 -- FIXME: Performance review
-@[elab_as_elim, expose] def induction {motive : Fin (n + 1) → Sort _} (zero : motive 0)
+@[elab_as_elim] def induction {motive : Fin (n + 1) → Sort _} (zero : motive 0)
     (succ : ∀ i : Fin n, motive (castSucc i) → motive i.succ) :
     ∀ i : Fin (n + 1), motive i
   | ⟨i, hi⟩ => go i hi
@@ -843,7 +825,7 @@ The two cases are:
 
 The corresponding induction principle is `Fin.induction`.
 -/
-@[elab_as_elim, expose] def cases {motive : Fin (n + 1) → Sort _}
+@[elab_as_elim] def cases {motive : Fin (n + 1) → Sort _}
     (zero : motive 0) (succ : ∀ i : Fin n, motive i.succ) :
     ∀ i : Fin (n + 1), motive i := induction zero fun i _ => succ i
 
@@ -969,38 +951,30 @@ theorem val_ne_zero_iff [NeZero n] {a : Fin n} : a.val ≠ 0 ↔ a ≠ 0 :=
 
 /-! ### add -/
 
-theorem ofNat_add [NeZero n] (x : Nat) (y : Fin n) :
-    Fin.ofNat n x + y = Fin.ofNat n (x + y.val) := by
+theorem ofNat'_add [NeZero n] (x : Nat) (y : Fin n) :
+    Fin.ofNat' n x + y = Fin.ofNat' n (x + y.val) := by
   apply Fin.eq_of_val_eq
-  simp [Fin.ofNat, Fin.add_def]
+  simp [Fin.ofNat', Fin.add_def]
 
-@[deprecated ofNat_add (since := "2025-05-28")] abbrev ofNat_add' := @ofNat_add
-
-theorem add_ofNat [NeZero n] (x : Fin n) (y : Nat) :
-    x + Fin.ofNat n y = Fin.ofNat n (x.val + y) := by
+theorem add_ofNat' [NeZero n] (x : Fin n) (y : Nat) :
+    x + Fin.ofNat' n y = Fin.ofNat' n (x.val + y) := by
   apply Fin.eq_of_val_eq
-  simp [Fin.ofNat, Fin.add_def]
-
-@[deprecated add_ofNat (since := "2025-05-28")] abbrev add_ofNat' := @add_ofNat
+  simp [Fin.ofNat', Fin.add_def]
 
 /-! ### sub -/
 
 protected theorem coe_sub (a b : Fin n) : ((a - b : Fin n) : Nat) = ((n - b) + a) % n := by
   cases a; cases b; rfl
 
-theorem ofNat_sub [NeZero n] (x : Nat) (y : Fin n) :
-    Fin.ofNat n x - y = Fin.ofNat n ((n - y.val) + x) := by
+theorem ofNat'_sub [NeZero n] (x : Nat) (y : Fin n) :
+    Fin.ofNat' n x - y = Fin.ofNat' n ((n - y.val) + x) := by
   apply Fin.eq_of_val_eq
-  simp [Fin.ofNat, Fin.sub_def]
+  simp [Fin.ofNat', Fin.sub_def]
 
-@[deprecated ofNat_sub (since := "2025-05-28")] abbrev ofNat_sub' := @ofNat_sub
-
-theorem sub_ofNat [NeZero n] (x : Fin n) (y : Nat) :
-    x - Fin.ofNat n y = Fin.ofNat n ((n - y % n) + x.val) := by
+theorem sub_ofNat' [NeZero n] (x : Fin n) (y : Nat) :
+    x - Fin.ofNat' n y = Fin.ofNat' n ((n - y % n) + x.val) := by
   apply Fin.eq_of_val_eq
-  simp [Fin.ofNat, Fin.sub_def]
-
-@[deprecated sub_ofNat (since := "2025-05-28")] abbrev sub_ofNat' := @sub_ofNat
+  simp [Fin.ofNat', Fin.sub_def]
 
 @[simp] protected theorem sub_self [NeZero n] {x : Fin n} : x - x = 0 := by
   ext
@@ -1047,19 +1021,15 @@ theorem val_neg {n : Nat} [NeZero n] (x : Fin n) :
 
 /-! ### mul -/
 
-theorem ofNat_mul [NeZero n] (x : Nat) (y : Fin n) :
-    Fin.ofNat n x * y = Fin.ofNat n (x * y.val) := by
+theorem ofNat'_mul [NeZero n] (x : Nat) (y : Fin n) :
+    Fin.ofNat' n x * y = Fin.ofNat' n (x * y.val) := by
   apply Fin.eq_of_val_eq
-  simp [Fin.ofNat, Fin.mul_def]
+  simp [Fin.ofNat', Fin.mul_def]
 
-@[deprecated ofNat_mul (since := "2025-05-28")] abbrev ofNat_mul' := @ofNat_mul
-
-theorem mul_ofNat [NeZero n] (x : Fin n) (y : Nat) :
-    x * Fin.ofNat n y = Fin.ofNat n (x.val * y) := by
+theorem mul_ofNat' [NeZero n] (x : Fin n) (y : Nat) :
+    x * Fin.ofNat' n y = Fin.ofNat' n (x.val * y) := by
   apply Fin.eq_of_val_eq
-  simp [Fin.ofNat, Fin.mul_def]
-
-@[deprecated mul_ofNat (since := "2025-05-28")] abbrev mul_ofNat' := @mul_ofNat
+  simp [Fin.ofNat', Fin.mul_def]
 
 theorem val_mul {n : Nat} : ∀ a b : Fin n, (a * b).val = a.val * b.val % n
   | ⟨_, _⟩, ⟨_, _⟩ => rfl

src/Init/Data/Float.lean

@@ -161,7 +161,8 @@ This function does not reduce in the kernel. It is compiled to the C inequality
   match a, b with
   | ⟨a⟩, ⟨b⟩ => floatSpec.decLe a b
 
-attribute [instance] Float.decLt Float.decLe
+instance floatDecLt (a b : Float) : Decidable (a < b) := Float.decLt a b
+instance floatDecLe (a b : Float) : Decidable (a ≤ b) := Float.decLe a b
 
 /--
 Converts a floating-point number to a string.

src/Init/Data/Float32.lean

@@ -145,7 +145,7 @@ Compares two floating point numbers for strict inequality.
 
 This function does not reduce in the kernel. It is compiled to the C inequality operator.
 -/
-@[extern "lean_float32_decLt", instance] opaque Float32.decLt (a b : Float32) : Decidable (a < b) :=
+@[extern "lean_float32_decLt"] opaque Float32.decLt (a b : Float32) : Decidable (a < b) :=
   match a, b with
   | ⟨a⟩, ⟨b⟩ => float32Spec.decLt a b
 
@@ -154,10 +154,13 @@ Compares two floating point numbers for non-strict inequality.
 
 This function does not reduce in the kernel. It is compiled to the C inequality operator.
 -/
-@[extern "lean_float32_decLe", instance] opaque Float32.decLe (a b : Float32) : Decidable (a ≤ b) :=
+@[extern "lean_float32_decLe"] opaque Float32.decLe (a b : Float32) : Decidable (a ≤ b) :=
   match a, b with
   | ⟨a⟩, ⟨b⟩ => float32Spec.decLe a b
 
+instance float32DecLt (a b : Float32) : Decidable (a < b) := Float32.decLt a b
+instance float32DecLe (a b : Float32) : Decidable (a ≤ b) := Float32.decLe a b
+
 /--
 Converts a floating-point number to a string.
 

src/Init/Data/FloatArray/Basic.lean

@@ -165,7 +165,7 @@ def foldlM {β : Type v} {m : Type v → Type w} [Monad m] (f : β → Float →
 
 @[inline]
 def foldl {β : Type v} (f : β → Float → β) (init : β) (as : FloatArray) (start := 0) (stop := as.size) : β :=
-  Id.run <| as.foldlM (pure <| f · ·) init start stop
+  Id.run <| as.foldlM f init start stop
 
 end FloatArray
 

src/Init/Data/Format/Basic.lean

@@ -142,36 +142,17 @@ private structure WorkItem where
   indent : Int
   activeTags : Nat
 
-/--
-A directive indicating whether a given work group is able to be flattened.
-
-- `allow` indicates that the group is allowed to be flattened; its argument is `true` if
-  there is sufficient space for it to be flattened (and so it should be), or `false` if not.
-- `disallow` means that this group should not be flattened irrespective of space concerns.
-  This is used at levels of a `Format` outside of any flattening groups. It is necessary to track
-  this so that, after a hard line break, we know whether to try to flatten the next line.
--/
-inductive FlattenAllowability where
-  | allow (fits : Bool)
-  | disallow
-  deriving BEq
-
-/-- Whether the given directive indicates that flattening should occur. -/
-def FlattenAllowability.shouldFlatten : FlattenAllowability → Bool
-  | allow true => true
-  | _ => false
-
 private structure WorkGroup where
-  fla   : FlattenAllowability
-  flb   : FlattenBehavior
-  items : List WorkItem
+  flatten : Bool
+  flb     : FlattenBehavior
+  items   : List WorkItem
 
 private partial def spaceUptoLine' : List WorkGroup → Nat → Nat → SpaceResult
   |   [],                         _,   _ => {}
   |   { items := [],    .. }::gs, col, w => spaceUptoLine' gs col w
   | g@{ items := i::is, .. }::gs, col, w =>
     merge w
-      (spaceUptoLine i.f g.fla.shouldFlatten (w + col - i.indent) w)
+      (spaceUptoLine i.f g.flatten (w + col - i.indent) w)
       (spaceUptoLine' ({ g with items := is }::gs) col)
 
 /-- A monad in which we can pretty-print `Format` objects. -/
@@ -188,11 +169,11 @@ open MonadPrettyFormat
 private def pushGroup (flb : FlattenBehavior) (items : List WorkItem) (gs : List WorkGroup) (w : Nat) [Monad m] [MonadPrettyFormat m] : m (List WorkGroup) := do
   let k  ← currColumn
   -- Flatten group if it + the remainder (gs) fits in the remaining space. For `fill`, measure only up to the next (ungrouped) line break.
-  let g  := { fla := .allow (flb == FlattenBehavior.allOrNone), flb := flb, items := items : WorkGroup }
+  let g  := { flatten := flb == FlattenBehavior.allOrNone, flb := flb, items := items : WorkGroup }
   let r  := spaceUptoLine' [g] k (w-k)
   let r' := merge (w-k) r (spaceUptoLine' gs k)
   -- Prevent flattening if any item contains a hard line break, except within `fill` if it is ungrouped (=> unflattened)
-  return { g with fla := .allow (!r.foundFlattenedHardLine && r'.space <= w-k) }::gs
+  return { g with flatten := !r.foundFlattenedHardLine && r'.space <= w-k }::gs
 
 private partial def be (w : Nat) [Monad m] [MonadPrettyFormat m] : List WorkGroup → m Unit
   | []                           => pure ()
@@ -219,15 +200,11 @@ private partial def be (w : Nat) [Monad m] [MonadPrettyFormat m] : List WorkGrou
         pushNewline i.indent.toNat
         let is := { i with f := text (s.extract (s.next p) s.endPos) }::is
         -- after a hard line break, re-evaluate whether to flatten the remaining group
-        -- note that we shouldn't start flattening after a hard break outside a group
-        if g.fla == .disallow then
-          be w (gs' is)
-        else
-          pushGroup g.flb is gs w >>= be w
+        pushGroup g.flb is gs w >>= be w
     | line =>
       match g.flb with
       | FlattenBehavior.allOrNone =>
-        if g.fla.shouldFlatten then
+        if g.flatten then
           -- flatten line = text " "
           pushOutput " "
           endTags i.activeTags
@@ -243,10 +220,10 @@ private partial def be (w : Nat) [Monad m] [MonadPrettyFormat m] : List WorkGrou
           endTags i.activeTags
           pushGroup FlattenBehavior.fill is gs w >>= be w
         -- if preceding fill item fit in a single line, try to fit next one too
-        if g.fla.shouldFlatten then
+        if g.flatten then
           let gs'@(g'::_) ← pushGroup FlattenBehavior.fill is gs (w - " ".length)
             | panic "unreachable"
-          if g'.fla.shouldFlatten then
+          if g'.flatten then
             pushOutput " "
             endTags i.activeTags
             be w gs'  -- TODO: use `return`
@@ -255,7 +232,7 @@ private partial def be (w : Nat) [Monad m] [MonadPrettyFormat m] : List WorkGrou
         else
           breakHere
     | align force =>
-      if g.fla.shouldFlatten && !force then
+      if g.flatten && !force then
         -- flatten (align false) = nil
         endTags i.activeTags
         be w (gs' is)
@@ -270,7 +247,7 @@ private partial def be (w : Nat) [Monad m] [MonadPrettyFormat m] : List WorkGrou
           endTags i.activeTags
           be w (gs' is)
     | group f flb =>
-      if g.fla.shouldFlatten then
+      if g.flatten then
         -- flatten (group f) = flatten f
         be w (gs' ({ i with f }::is))
       else
@@ -279,7 +256,7 @@ private partial def be (w : Nat) [Monad m] [MonadPrettyFormat m] : List WorkGrou
 /-- Render the given `f : Format` with a line width of `w`.
 `indent` is the starting amount to indent each line by. -/
 def prettyM (f : Format) (w : Nat) (indent : Nat := 0) [Monad m] [MonadPrettyFormat m] : m Unit :=
-  be w [{ flb := FlattenBehavior.allOrNone, fla := .disallow, items := [{ f := f, indent, activeTags := 0 }]}]
+  be w [{ flb := FlattenBehavior.allOrNone, flatten := false, items := [{ f := f, indent, activeTags := 0 }]}]
 
 /-- Create a format `l ++ f ++ r` with a flatten group.
 FlattenBehaviour is `allOrNone`; for `fill` use `bracketFill`. -/
@@ -317,7 +294,7 @@ private structure State where
   out    : String := ""
   column : Nat    := 0
 
-private instance : MonadPrettyFormat (StateM State) where
+instance : MonadPrettyFormat (StateM State) where
   -- We avoid a structure instance update, and write these functions using pattern matching because of issue #316
   pushOutput s       := modify fun ⟨out, col⟩ => ⟨out ++ s, col + s.length⟩
   pushNewline indent := modify fun ⟨out, _⟩ => ⟨out ++ "\n".pushn ' ' indent, indent⟩

src/Init/Data/Hashable.lean

@@ -57,6 +57,9 @@ instance : Hashable UInt64 where
 instance : Hashable USize where
   hash n := n.toUInt64
 
+instance : Hashable ByteArray where
+  hash as := as.foldl (fun r a => mixHash r (hash a)) 7
+
 instance : Hashable (Fin n) where
   hash v := v.val.toUInt64
 

src/Init/Data/Int/Basic.lean

@@ -269,7 +269,7 @@ set_option bootstrap.genMatcherCode false in
 
   Implemented by efficient native code. -/
 @[extern "lean_int_dec_nonneg"]
-def decNonneg (m : @& Int) : Decidable (NonNeg m) :=
+private def decNonneg (m : @& Int) : Decidable (NonNeg m) :=
   match m with
   | ofNat m => isTrue <| NonNeg.mk m
   | -[_ +1] => isFalse <| fun h => nomatch h

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

@@ -41,7 +41,6 @@ Examples:
 * `(-0b1000 : Int) >>> 1 = -0b0100`
 * `(-0b0111 : Int) >>> 1 = -0b0100`
 -/
-@[expose]
 protected def shiftRight : Int → Nat → Int
   | Int.ofNat n, s => Int.ofNat (n >>> s)
   | Int.negSucc n, s => Int.negSucc (n >>> s)

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

@@ -264,8 +264,8 @@ theorem mul_emod (a b n : Int) : (a * b) % n = (a % n) * (b % n) % n := by
   match k, h with
   | _, ⟨t, rfl⟩ => rw [Int.mul_assoc, add_mul_emod_self_left]
 
-theorem emod_emod (a b : Int) : (a % b) % b = a % b := by
-  simp
+@[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]
 
 theorem sub_emod (a b n : Int) : (a - b) % n = (a % n - b % n) % n := by
   apply (emod_add_cancel_right b).mp

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

@@ -1410,7 +1410,8 @@ theorem mul_tmod (a b n : Int) : (a * b).tmod n = (a.tmod n * b.tmod n).tmod n :
   norm_cast at h
   rw [Nat.mod_mod_of_dvd _ h]
 
-theorem tmod_tmod (a b : Int) : (a.tmod b).tmod b = a.tmod b := by simp
+@[simp] theorem tmod_tmod (a b : Int) : (a.tmod b).tmod b = a.tmod b :=
+  tmod_tmod_of_dvd a (Int.dvd_refl b)
 
 theorem tmod_eq_zero_of_dvd : ∀ {a b : Int}, a ∣ b → tmod b a = 0
   | _, _, ⟨_, rfl⟩ => mul_tmod_right ..
@@ -1468,8 +1469,9 @@ protected theorem tdiv_mul_cancel {a b : Int} (H : b ∣ a) : a.tdiv b * b = a :
 protected theorem mul_tdiv_cancel' {a b : Int} (H : a ∣ b) : a * b.tdiv a = b := by
   rw [Int.mul_comm, Int.tdiv_mul_cancel H]
 
-theorem neg_tmod_self (a : Int) : (-a).tmod a = 0 := by
-  simp
+@[simp] theorem neg_tmod_self (a : Int) : (-a).tmod a = 0 := by
+  rw [← dvd_iff_tmod_eq_zero, Int.dvd_neg]
+  exact Int.dvd_refl a
 
 theorem lt_tdiv_add_one_mul_self (a : Int) {b : Int} (H : 0 < b) : a < (a.tdiv b + 1) * b := by
   rw [Int.add_mul, Int.one_mul, Int.mul_comm]
@@ -1566,11 +1568,13 @@ theorem dvd_tmod_sub_self {x m : Int} : m ∣ x.tmod m - x := by
 theorem dvd_self_sub_tmod {x m : Int} : m ∣ x - x.tmod m :=
   Int.dvd_neg.1 (by simpa only [Int.neg_sub] using dvd_tmod_sub_self)
 
-theorem neg_mul_tmod_right (a b : Int) : (-(a * b)).tmod a = 0 := by
-  simp
+@[simp] theorem neg_mul_tmod_right (a b : Int) : (-(a * b)).tmod a = 0 := by
+  rw [← dvd_iff_tmod_eq_zero, Int.dvd_neg]
+  exact Int.dvd_mul_right a b
 
-theorem neg_mul_tmod_left (a b : Int) : (-(a * b)).tmod b = 0 := by
-  simp
+@[simp] theorem neg_mul_tmod_left (a b : Int) : (-(a * b)).tmod b = 0 := by
+  rw [← dvd_iff_tmod_eq_zero, Int.dvd_neg]
+  exact Int.dvd_mul_left a b
 
 @[simp] protected theorem tdiv_one : ∀ a : Int, a.tdiv 1 = a
   | (n:Nat) => congrArg ofNat (Nat.div_one _)
@@ -2189,8 +2193,8 @@ theorem mul_fmod (a b n : Int) : (a * b).fmod n = (a.fmod n * b.fmod n).fmod n :
   match k, h with
   | _, ⟨t, rfl⟩ => rw [Int.mul_assoc, add_mul_fmod_self_left]
 
-theorem fmod_fmod (a b : Int) : (a.fmod b).fmod b = a.fmod b := by
-  simp
+@[simp] theorem fmod_fmod (a b : Int) : (a.fmod b).fmod b = a.fmod b :=
+  fmod_fmod_of_dvd _ (Int.dvd_refl b)
 
 theorem sub_fmod (a b n : Int) : (a - b).fmod n = (a.fmod n - b.fmod n).fmod n := by
   apply (fmod_add_cancel_right b).mp

src/Init/Data/Int/Gcd.lean

@@ -35,7 +35,6 @@ Examples:
 * `Int.gcd 0 5 = 5`
 * `Int.gcd (-7) 0 = 7`
 -/
-@[expose]
 def gcd (m n : Int) : Nat := m.natAbs.gcd n.natAbs
 
 theorem gcd_eq_natAbs_gcd_natAbs (m n : Int) : gcd m n = Nat.gcd m.natAbs n.natAbs := rfl
@@ -429,7 +428,6 @@ Examples:
  * `Int.lcm 0 3 = 0`
  * `Int.lcm (-3) 0 = 0`
 -/
-@[expose]
 def lcm (m n : Int) : Nat := m.natAbs.lcm n.natAbs
 
 theorem lcm_eq_natAbs_lcm_natAbs (m n : Int) : lcm m n = Nat.lcm m.natAbs n.natAbs := rfl

src/Init/Data/Int/LemmasAux.lean

@@ -121,7 +121,7 @@ theorem toNat_lt_toNat {n m : Int} (hn : 0 < m) : n.toNat < m.toNat ↔ n < m :=
 /-! ### min and max -/
 
 @[simp] protected theorem min_assoc : ∀ (a b c : Int), min (min a b) c = min a (min b c) := by omega
-instance : Std.Associative (α := Int) min := ⟨Int.min_assoc⟩
+instance : Std.Associative (α := Nat) min := ⟨Nat.min_assoc⟩
 
 @[simp] protected theorem min_self_assoc {m n : Int} : min m (min m n) = min m n := by
   rw [← Int.min_assoc, Int.min_self]
@@ -130,7 +130,7 @@ instance : Std.Associative (α := Int) min := ⟨Int.min_assoc⟩
   rw [Int.min_comm m n, ← Int.min_assoc, Int.min_self]
 
 @[simp] protected theorem max_assoc (a b c : Int) : max (max a b) c = max a (max b c) := by omega
-instance : Std.Associative (α := Int) max := ⟨Int.max_assoc⟩
+instance : Std.Associative (α := Nat) max := ⟨Nat.max_assoc⟩
 
 @[simp] protected theorem max_self_assoc {m n : Int} : max m (max m n) = max m n := by
   rw [← Int.max_assoc, Int.max_self]

src/Init/Data/Int/Order.lean

@@ -638,7 +638,7 @@ theorem toNat_of_nonneg {a : Int} (h : 0 ≤ a) : (toNat a : Int) = a := by
 @[simp] theorem toNat_natCast (n : Nat) : toNat ↑n = n := rfl
 
 @[deprecated toNat_natCast (since := "2025-04-16")]
-theorem toNat_ofNat (n : Nat) : toNat ↑n = n := rfl
+theorem toNat_ofNat (n : Nat) : toNat ↑n = n := toNat_natCast n
 
 @[simp] theorem toNat_negSucc (n : Nat) : (Int.negSucc n).toNat = 0 := by
   simp [toNat]

src/Init/Data/List/Attach.lean

@@ -23,7 +23,6 @@ a list `l : List α`, given a proof that every element of `l` in fact satisfies
 `O(|l|)`. `List.pmap`, named for “partial map,” is the equivalent of `List.map` for such partial
 functions.
 -/
-@[expose]
 def pmap {P : α → Prop} (f : ∀ a, P a → β) : ∀ l : List α, (H : ∀ a ∈ l, P a) → List β
   | [], _ => []
   | a :: l, H => f a (forall_mem_cons.1 H).1 :: pmap f l (forall_mem_cons.1 H).2
@@ -41,7 +40,7 @@ elements in the corresponding subtype `{ x // P x }`.
 
 `O(1)`.
 -/
-@[implemented_by attachWithImpl, expose] def attachWith
+@[implemented_by attachWithImpl] def attachWith
     (l : List α) (P : α → Prop) (H : ∀ x ∈ l, P x) : List {x // P x} := pmap Subtype.mk l H
 
 /--
@@ -55,7 +54,7 @@ recursion](lean-manual://section/well-founded-recursion) that use higher-order f
 `List.map`) to prove that an value taken from a list is smaller than the list. This allows the
 well-founded recursion mechanism to prove that the function terminates.
 -/
-@[inline, expose] def attach (l : List α) : List {x // x ∈ l} := attachWith l _ fun _ => id
+@[inline] def attach (l : List α) : List {x // x ∈ l} := attachWith l _ fun _ => id
 
 /-- Implementation of `pmap` using the zero-copy version of `attach`. -/
 @[inline] private def pmapImpl {P : α → Prop} (f : ∀ a, P a → β) (l : List α) (H : ∀ a ∈ l, P a) :
@@ -676,7 +675,6 @@ the elaboration of definitions by [well-founded
 recursion](lean-manual://section/well-founded-recursion). If this function is encountered in a proof
 state, the right approach is usually the tactic `simp [List.unattach, -List.map_subtype]`.
 -/
-@[expose]
 def unattach {α : Type _} {p : α → Prop} (l : List { x // p x }) : List α := l.map (·.val)
 
 @[simp] theorem unattach_nil {p : α → Prop} : ([] : List { x // p x }).unattach = [] := rfl

src/Init/Data/List/Basic.lean

@@ -586,7 +586,7 @@ Examples:
 * `[1, 2, 3, 4].reverse = [4, 3, 2, 1]`
 * `[].reverse = []`
 -/
-@[expose] def reverse (as : List α) : List α :=
+def reverse (as : List α) : List α :=
   reverseAux as []
 
 @[simp, grind] theorem reverse_nil : reverse ([] : List α) = [] := rfl
@@ -715,7 +715,7 @@ Examples:
  * `List.singleton "green" = ["green"]`.
  * `List.singleton [1, 2, 3] = [[1, 2, 3]]`
 -/
-@[inline, expose] protected def singleton {α : Type u} (a : α) : List α := [a]
+@[inline] protected def singleton {α : Type u} (a : α) : List α := [a]
 
 /-! ### flatMap -/
 
@@ -1190,10 +1190,10 @@ def isPrefixOf [BEq α] : List α → List α → Bool
   | _,     []    => false
   | a::as, b::bs => a == b && isPrefixOf as bs
 
-@[simp, grind =] theorem isPrefixOf_nil_left [BEq α] : isPrefixOf ([] : List α) l = true := by
+@[simp] theorem isPrefixOf_nil_left [BEq α] : isPrefixOf ([] : List α) l = true := by
   simp [isPrefixOf]
-@[simp, grind =] theorem isPrefixOf_cons_nil [BEq α] : isPrefixOf (a::as) ([] : List α) = false := rfl
-@[grind =] theorem isPrefixOf_cons₂ [BEq α] {a : α} :
+@[simp] theorem isPrefixOf_cons_nil [BEq α] : isPrefixOf (a::as) ([] : List α) = false := rfl
+theorem isPrefixOf_cons₂ [BEq α] {a : α} :
     isPrefixOf (a::as) (b::bs) = (a == b && isPrefixOf as bs) := rfl
 
 /--
@@ -1229,7 +1229,7 @@ Examples:
 def isSuffixOf [BEq α] (l₁ l₂ : List α) : Bool :=
   isPrefixOf l₁.reverse l₂.reverse
 
-@[simp, grind =] theorem isSuffixOf_nil_left [BEq α] : isSuffixOf ([] : List α) l = true := by
+@[simp] theorem isSuffixOf_nil_left [BEq α] : isSuffixOf ([] : List α) l = true := by
   simp [isSuffixOf]
 
 /--
@@ -1564,8 +1564,8 @@ protected def erase {α} [BEq α] : List α → α → List α
     | true  => as
     | false => a :: List.erase as b
 
-@[simp, grind =] theorem erase_nil [BEq α] (a : α) : [].erase a = [] := rfl
-@[grind =] theorem erase_cons [BEq α] {a b : α} {l : List α} :
+@[simp] theorem erase_nil [BEq α] (a : α) : [].erase a = [] := rfl
+theorem erase_cons [BEq α] {a b : α} {l : List α} :
     (b :: l).erase a = if b == a then l else b :: l.erase a := by
   simp only [List.erase]; split <;> simp_all
 
@@ -2096,7 +2096,7 @@ where
   | 0,   acc => acc
   | n+1, acc => loop n (n::acc)
 
-@[simp, grind =] theorem range_zero : range 0 = [] := rfl
+@[simp] theorem range_zero : range 0 = [] := rfl
 
 /-! ### range' -/
 

src/Init/Data/List/BasicAux.lean

@@ -27,7 +27,7 @@ Returns the `i`-th element in the list (zero-based).
 If the index is out of bounds (`i ≥ as.length`), this function returns `none`.
 Also see `get`, `getD` and `get!`.
 -/
-@[deprecated "Use `a[i]?` instead." (since := "2025-02-12"), expose]
+@[deprecated "Use `a[i]?` instead." (since := "2025-02-12")]
 def get? : (as : List α) → (i : Nat) → Option α
   | a::_,  0   => some a
   | _::as, n+1 => get? as n
@@ -61,7 +61,7 @@ Returns the `i`-th element in the list (zero-based).
 If the index is out of bounds (`i ≥ as.length`), this function panics when executed, and returns
 `default`. See `get?` and `getD` for safer alternatives.
 -/
-@[deprecated "Use `a[i]!` instead." (since := "2025-02-12"), expose]
+@[deprecated "Use `a[i]!` instead." (since := "2025-02-12")]
 def get! [Inhabited α] : (as : List α) → (i : Nat) → α
   | a::_,  0   => a
   | _::as, n+1 => get! as n
@@ -92,7 +92,7 @@ Examples:
  * `["spring", "summer", "fall", "winter"].getD 0 "never" = "spring"`
  * `["spring", "summer", "fall", "winter"].getD 4 "never" = "never"`
 -/
-@[expose] def getD (as : List α) (i : Nat) (fallback : α) : α :=
+def getD (as : List α) (i : Nat) (fallback : α) : α :=
   as[i]?.getD fallback
 
 @[simp] theorem getD_nil : getD [] n d = d := rfl
@@ -111,7 +111,6 @@ Examples:
  * `["circle", "rectangle"].getLast! = "rectangle"`
  * `["circle"].getLast! = "circle"`
 -/
-@[expose]
 def getLast! [Inhabited α] : List α → α
   | []    => panic! "empty list"
   | a::as => getLast (a::as) (fun h => List.noConfusion h)
@@ -147,7 +146,7 @@ Examples:
  * `["apple", "banana", "grape"].tail! = ["banana", "grape"]`
  * `["banana", "grape"].tail! = ["grape"]`
 -/
-@[expose] def tail! : List α → List α
+def tail! : List α → List α
   | []    => panic! "empty list"
   | _::as => as
 
@@ -255,7 +254,7 @@ pointer-equal to its argument.
 For verification purposes, `List.mapMono = List.map`.
 -/
 def mapMono (as : List α) (f : α → α) : List α :=
-  Id.run <| as.mapMonoM (pure <| f ·)
+  Id.run <| as.mapMonoM f
 
 /-! ## Additional lemmas required for bootstrapping `Array`. -/
 

src/Init/Data/List/Control.lean

@@ -54,7 +54,7 @@ This implementation is tail recursive. `List.mapM'` is a a non-tail-recursive va
 more convenient to reason about. `List.forM` is the variant that discards the results and
 `List.mapA` is the variant that works with `Applicative`.
 -/
-@[inline, expose]
+@[inline]
 def mapM {m : Type u → Type v} [Monad m] {α : Type w} {β : Type u} (f : α → m β) (as : List α) : m (List β) :=
   let rec @[specialize] loop
     | [],      bs => pure bs.reverse
@@ -83,7 +83,7 @@ Applies the monadic action `f` to every element in the list, in order.
 `List.mapM` is a variant that collects results. `List.forA` is a variant that works on any
 `Applicative`.
 -/
-@[specialize, expose]
+@[specialize]
 protected def forM {m : Type u → Type v} [Monad m] {α : Type w} (as : List α) (f : α → m PUnit) : m PUnit :=
   match as with
   | []      => pure ⟨⟩
@@ -191,7 +191,7 @@ Examining 7
 [10, 14, 14]
 ```
 -/
-@[inline, expose]
+@[inline]
 def filterMapM {m : Type u → Type v} [Monad m] {α : Type w} {β : Type u} (f : α → m (Option β)) (as : List α) : m (List β) :=
   let rec @[specialize] loop
     | [],     bs => pure bs.reverse
@@ -205,7 +205,7 @@ def filterMapM {m : Type u → Type v} [Monad m] {α : Type w} {β : Type u} (f
 Applies a monadic function that returns a list to each element of a list, from left to right, and
 concatenates the resulting lists.
 -/
-@[inline, expose]
+@[inline]
 def flatMapM {m : Type u → Type v} [Monad m] {α : Type w} {β : Type u} (f : α → m (List β)) (as : List α) : m (List β) :=
   let rec @[specialize] loop
     | [],     bs => pure bs.reverse.flatten
@@ -230,7 +230,7 @@ example [Monad m] (f : α → β → m α) :
   := by rfl
 ```
 -/
-@[specialize, expose]
+@[specialize]
 def foldlM {m : Type u → Type v} [Monad m] {s : Type u} {α : Type w} : (f : s → α → m s) → (init : s) → List α → m s
   | _, s, []      => pure s
   | f, s, a :: as => do
@@ -257,7 +257,7 @@ example [Monad m] (f : α → β → m β) :
   := by rfl
 ```
 -/
-@[inline, expose]
+@[inline]
 def foldrM {m : Type u → Type v} [Monad m] {s : Type u} {α : Type w} (f : α → s → m s) (init : s) (l : List α) : m s :=
   l.reverse.foldlM (fun s a => f a s) init
 
@@ -348,16 +348,9 @@ theorem findM?_pure {m} [Monad m] [LawfulMonad m] (p : α → Bool) (as : List
     | false => simp [ih]
 
 @[simp]
-theorem idRun_findM? (p : α → Id Bool) (as : List α) :
-    (findM? p as).run = as.find? (p · |>.run) :=
+theorem findM?_id (p : α → Bool) (as : List α) : findM? (m := Id) p as = as.find? p :=
   findM?_pure _ _
 
-@[deprecated idRun_findM? (since := "2025-05-21")]
-theorem findM?_id (p : α → Id Bool) (as : List α) :
-    findM? (m := Id) p as = as.find? p :=
-  findM?_pure _ _
-
-
 /--
 Returns the first non-`none` result of applying the monadic function `f` to each element of the
 list, in order. Returns `none` if `f` returns `none` for all elements.
@@ -401,13 +394,7 @@ theorem findSomeM?_pure [Monad m] [LawfulMonad m] {f : α → Option β} {as : L
     | none   => simp [ih]
 
 @[simp]
-theorem idRun_findSomeM? (f : α → Id (Option β)) (as : List α) :
-    (findSomeM? f as).run = as.findSome? (f · |>.run) :=
-  findSomeM?_pure
-
-@[deprecated idRun_findSomeM? (since := "2025-05-21")]
-theorem findSomeM?_id (f : α → Id (Option β)) (as : List α) :
-    findSomeM? (m := Id) f as = as.findSome? f :=
+theorem findSomeM?_id {f : α → Option β} {as : List α} : findSomeM? (m := Id) f as = as.findSome? f :=
   findSomeM?_pure
 
 theorem findM?_eq_findSomeM? [Monad m] [LawfulMonad m] {p : α → m Bool} {as : List α} :
@@ -422,7 +409,7 @@ theorem findM?_eq_findSomeM? [Monad m] [LawfulMonad m] {p : α → m Bool} {as :
     intro b
     cases b <;> simp
 
-@[inline, expose] protected def forIn' {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : List α) (init : β) (f : (a : α) → a ∈ as → β → m (ForInStep β)) : m β :=
+@[inline] protected def forIn' {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : List α) (init : β) (f : (a : α) → a ∈ as → β → m (ForInStep β)) : m β :=
   let rec @[specialize] loop : (as' : List α) → (b : β) → Exists (fun bs => bs ++ as' = as) → m β
     | [], b, _    => pure b
     | a::as', b, h => do

src/Init/Data/List/Count.lean

@@ -10,9 +10,6 @@ import Init.Data.List.Sublist
 
 /-!
 # Lemmas about `List.countP` and `List.count`.
-
-Because we mark `countP_eq_length_filter` and `count_eq_countP` with `@[grind _=_]`,
-we don't need many other `@[grind]` annotations here.
 -/
 
 set_option linter.listVariables true -- Enforce naming conventions for `List`/`Array`/`Vector` variables.
@@ -64,7 +61,6 @@ theorem length_eq_countP_add_countP (p : α → Bool) {l : List α} : length l =
       · rfl
       · simp [h]
 
-@[grind =]
 theorem countP_eq_length_filter {l : List α} : countP p l = length (filter p l) := by
   induction l with
   | nil => rfl
@@ -73,7 +69,6 @@ theorem countP_eq_length_filter {l : List α} : countP p l = length (filter p l)
     then rw [countP_cons_of_pos h, ih, filter_cons_of_pos h, length]
     else rw [countP_cons_of_neg h, ih, filter_cons_of_neg h]
 
-@[grind =]
 theorem countP_eq_length_filter' : countP p = length ∘ filter p := by
   funext l
   apply countP_eq_length_filter
@@ -102,7 +97,6 @@ theorem countP_replicate {p : α → Bool} {a : α} {n : Nat} :
   simp only [countP_eq_length_filter, filter_replicate]
   split <;> simp
 
-@[grind]
 theorem boole_getElem_le_countP {p : α → Bool} {l : List α} {i : Nat} (h : i < l.length) :
     (if p l[i] then 1 else 0) ≤ l.countP p := by
   induction l generalizing i with
@@ -126,7 +120,6 @@ theorem IsInfix.countP_le (s : l₁ <:+: l₂) : countP p l₁ ≤ countP p l₂
 
 -- See `Init.Data.List.Nat.Count` for `Sublist.le_countP : countP p l₂ - (l₂.length - l₁.length) ≤ countP p l₁`.
 
-@[grind]
 theorem countP_tail_le (l) : countP p l.tail ≤ countP p l :=
   (tail_sublist l).countP_le
 
@@ -205,21 +198,18 @@ variable [BEq α]
 
 @[simp] theorem count_nil {a : α} : count a [] = 0 := rfl
 
-@[grind]
 theorem count_cons {a b : α} {l : List α} :
     count a (b :: l) = count a l + if b == a then 1 else 0 := by
   simp [count, countP_cons]
 
-@[grind =] theorem count_eq_countP {a : α} {l : List α} : count a l = countP (· == a) l := rfl
+theorem count_eq_countP {a : α} {l : List α} : count a l = countP (· == a) l := rfl
 theorem count_eq_countP' {a : α} : count a = countP (· == a) := by
   funext l
   apply count_eq_countP
 
-@[grind]
-theorem count_tail : ∀ {l : List α} {a : α},
-      l.tail.count a = l.count a - if l.head? == some a then 1 else 0
-  | [], a => by simp
-  | _ :: _, a => by simp [count_cons]
+theorem count_tail : ∀ {l : List α} (h : l ≠ []) (a : α),
+      l.tail.count a = l.count a - if l.head h == a then 1 else 0
+  | _ :: _, a, _ => by simp [count_cons]
 
 theorem count_le_length {a : α} {l : List α} : count a l ≤ l.length := countP_le_length
 
@@ -242,7 +232,7 @@ theorem count_le_count_cons {a b : α} {l : List α} : count a l ≤ count a (b
 theorem count_singleton {a b : α} : count a [b] = if b == a then 1 else 0 := by
   simp [count_cons]
 
-@[simp, grind =] theorem count_append {a : α} {l₁ l₂ : List α} : count a (l₁ ++ l₂) = count a l₁ + count a l₂ :=
+@[simp] theorem count_append {a : α} {l₁ l₂ : List α} : count a (l₁ ++ l₂) = count a l₁ + count a l₂ :=
   countP_append
 
 theorem count_flatten {a : α} {l : List (List α)} : count a l.flatten = (l.map (count a)).sum := by
@@ -251,7 +241,6 @@ theorem count_flatten {a : α} {l : List (List α)} : count a l.flatten = (l.map
 @[simp] theorem count_reverse {a : α} {l : List α} : count a l.reverse = count a l := by
   simp only [count_eq_countP, countP_eq_length_filter, filter_reverse, length_reverse]
 
-@[grind]
 theorem boole_getElem_le_count {a : α} {l : List α} {i : Nat} (h : i < l.length) :
     (if l[i] == a then 1 else 0) ≤ l.count a := by
   rw [count_eq_countP]
@@ -294,7 +283,7 @@ theorem count_eq_length {l : List α} : count a l = l.length ↔ ∀ b ∈ l, a
 @[simp] theorem count_replicate_self {a : α} {n : Nat} : count a (replicate n a) = n :=
   (count_eq_length.2 <| fun _ h => (eq_of_mem_replicate h).symm).trans (length_replicate ..)
 
-@[grind =] theorem count_replicate {a b : α} {n : Nat} : count a (replicate n b) = if b == a then n else 0 := by
+theorem count_replicate {a b : α} {n : Nat} : count a (replicate n b) = if b == a then n else 0 := by
   split <;> (rename_i h; simp only [beq_iff_eq] at h)
   · exact ‹b = a› ▸ count_replicate_self ..
   · exact count_eq_zero.2 <| mt eq_of_mem_replicate (Ne.symm h)
@@ -306,18 +295,14 @@ theorem filter_beq {l : List α} (a : α) : l.filter (· == a) = replicate (coun
 theorem filter_eq [DecidableEq α] {l : List α} (a : α) : l.filter (· = a) = replicate (count a l) a :=
   funext (Bool.beq_eq_decide_eq · a) ▸ filter_beq a
 
-@[grind =] theorem replicate_sublist_iff {l : List α} : replicate n a <+ l ↔ n ≤ count a l := by
+theorem le_count_iff_replicate_sublist {l : List α} : n ≤ count a l ↔ replicate n a <+ l := by
   refine ⟨fun h => ?_, fun h => ?_⟩
-  · simpa only [count_replicate_self] using h.count_le a
   · exact ((replicate_sublist_replicate a).2 h).trans <| filter_beq a ▸ filter_sublist
-
-@[deprecated replicate_sublist_iff (since := "2025-05-26")]
-theorem le_count_iff_replicate_sublist {l : List α} : n ≤ count a l ↔ replicate n a <+ l :=
-  replicate_sublist_iff.symm
+  · simpa only [count_replicate_self] using h.count_le a
 
 theorem replicate_count_eq_of_count_eq_length {l : List α} (h : count a l = length l) :
     replicate (count a l) a = l :=
-  (replicate_sublist_iff.mpr (Nat.le_refl _)).eq_of_length <| length_replicate.trans h
+  (le_count_iff_replicate_sublist.mp (Nat.le_refl _)).eq_of_length <| length_replicate.trans h
 
 @[simp] theorem count_filter {l : List α} (h : p a) : count a (filter p l) = count a l := by
   rw [count, countP_filter]; congr; funext b
@@ -340,7 +325,6 @@ theorem count_filterMap {α} [BEq β] {b : β} {f : α → Option β} {l : List
 theorem count_flatMap {α} [BEq β] {l : List α} {f : α → List β} {x : β} :
     count x (l.flatMap f) = sum (map (count x ∘ f) l) := countP_flatMap
 
-@[grind]
 theorem count_erase {a b : α} :
     ∀ {l : List α}, count a (l.erase b) = count a l - if b == a then 1 else 0
   | [] => by simp

src/Init/Data/List/Erase.lean

@@ -126,10 +126,9 @@ theorem le_length_eraseP {l : List α} : l.length - 1 ≤ (l.eraseP p).length :=
   rw [length_eraseP]
   split <;> simp
 
-@[grind →]
 theorem mem_of_mem_eraseP {l : List α} : a ∈ l.eraseP p → a ∈ l := (eraseP_subset ·)
 
-@[simp, grind] theorem mem_eraseP_of_neg {l : List α} (pa : ¬p a) : a ∈ l.eraseP p ↔ a ∈ l := by
+@[simp] theorem mem_eraseP_of_neg {l : List α} (pa : ¬p a) : a ∈ l.eraseP p ↔ a ∈ l := by
   refine ⟨mem_of_mem_eraseP, fun al => ?_⟩
   match exists_or_eq_self_of_eraseP p l with
   | .inl h => rw [h]; assumption
@@ -261,7 +260,6 @@ theorem eraseP_eq_iff {p} {l : List α} :
 theorem Pairwise.eraseP (q) : Pairwise p l → Pairwise p (l.eraseP q) :=
   Pairwise.sublist <| eraseP_sublist
 
-@[grind]
 theorem Nodup.eraseP (p) : Nodup l → Nodup (l.eraseP p) :=
   Pairwise.eraseP p
 
@@ -380,10 +378,9 @@ theorem le_length_erase [LawfulBEq α] {a : α} {l : List α} : l.length - 1 ≤
   rw [length_erase]
   split <;> simp
 
-@[grind →]
 theorem mem_of_mem_erase {a b : α} {l : List α} (h : a ∈ l.erase b) : a ∈ l := erase_subset h
 
-@[simp, grind] theorem mem_erase_of_ne [LawfulBEq α] {a b : α} {l : List α} (ab : a ≠ b) :
+@[simp] theorem mem_erase_of_ne [LawfulBEq α] {a b : α} {l : List α} (ab : a ≠ b) :
     a ∈ l.erase b ↔ a ∈ l :=
   erase_eq_eraseP b l ▸ mem_eraseP_of_neg (mt eq_of_beq ab.symm)
 
@@ -490,10 +487,6 @@ theorem Nodup.mem_erase_iff [LawfulBEq α] {a : α} (d : Nodup l) : a ∈ l.eras
 theorem Nodup.not_mem_erase [LawfulBEq α] {a : α} (h : Nodup l) : a ∉ l.erase a := fun H => by
   simpa using ((Nodup.mem_erase_iff h).mp H).left
 
--- Only activate `not_mem_erase` when `l.Nodup` is already available.
-grind_pattern List.Nodup.not_mem_erase => a ∈ l.erase a, l.Nodup
-
-@[grind]
 theorem Nodup.erase [LawfulBEq α] (a : α) : Nodup l → Nodup (l.erase a) :=
   Pairwise.erase a
 

src/Init/Data/List/FinRange.lean

@@ -6,8 +6,7 @@ Authors: François G. Dorais
 module
 
 prelude
-import all Init.Data.List.OfFn
-import Init.Data.List.Monadic
+import Init.Data.List.OfFn
 
 set_option linter.listVariables true -- Enforce naming conventions for `List`/`Array`/`Vector` variables.
 set_option linter.indexVariables true -- Enforce naming conventions for index variables.
@@ -58,50 +57,3 @@ theorem finRange_reverse {n} : (finRange n).reverse = (finRange n).map Fin.rev :
     simp [Fin.rev_succ]
 
 end List
-
-namespace Fin
-
-theorem foldlM_eq_foldlM_finRange [Monad m] (f : α → Fin n → m α) (x : α) :
-    foldlM n f x = (List.finRange n).foldlM f x := by
-  induction n generalizing x with
-  | zero => simp
-  | succ n ih =>
-    simp [foldlM_succ, List.finRange_succ, List.foldlM_cons]
-    congr 1
-    funext y
-    simp [ih, List.foldlM_map]
-
-theorem foldrM_eq_foldrM_finRange [Monad m] [LawfulMonad m] (f : Fin n → α → m α) (x : α) :
-    foldrM n f x = (List.finRange n).foldrM f x := by
-  induction n generalizing x with
-  | zero => simp
-  | succ n ih =>
-    simp [foldrM_succ, List.finRange_succ, ih, List.foldrM_map]
-
-theorem foldl_eq_finRange_foldl (f : α → Fin n → α) (x : α) :
-    foldl n f x = (List.finRange n).foldl f x := by
-  induction n generalizing x with
-  | zero => simp
-  | succ n ih =>
-    simp [foldl_succ, List.finRange_succ, ih, List.foldl_map]
-
-theorem foldr_eq_finRange_foldr (f : Fin n → α → α) (x : α) :
-    foldr n f x = (List.finRange n).foldr f x := by
-  induction n generalizing x with
-  | zero => simp
-  | succ n ih =>
-    simp [foldr_succ, List.finRange_succ, ih, List.foldr_map]
-
-end Fin
-
-namespace List
-
-theorem ofFnM_succ {n} [Monad m] [LawfulMonad m] {f : Fin (n + 1) → m α} :
-    ofFnM f = (do
-      let a ← f 0
-      let as ← ofFnM fun i => f i.succ
-      pure (a :: as)) := by
-  simp [ofFnM, Fin.foldlM_eq_foldlM_finRange, List.finRange_succ, List.foldlM_cons_eq_append,
-    List.foldlM_map]
-
-end List

src/Init/Data/List/Find.lean

@@ -243,6 +243,9 @@ theorem find?_eq_some_iff_append :
           cases h₁
           simp
 
+@[deprecated find?_eq_some_iff_append (since := "2024-11-06")]
+abbrev find?_eq_some := @find?_eq_some_iff_append
+
 @[simp]
 theorem find?_cons_eq_some : (a :: xs).find? p = some b ↔ (p a ∧ a = b) ∨ (!p a ∧ xs.find? p = some b) := by
   rw [find?_cons]
@@ -1105,9 +1108,14 @@ theorem isSome_finIdxOf? [BEq α] [LawfulBEq α] {l : List α} {a : α} :
     simp only [finIdxOf?_cons]
     split <;> simp_all [@eq_comm _ x a]
 
+@[simp]
 theorem isNone_finIdxOf? [BEq α] [LawfulBEq α] {l : List α} {a : α} :
     (l.finIdxOf? a).isNone = ¬ a ∈ l := by
-  simp
+  induction l with
+  | nil => simp
+  | cons x xs ih =>
+    simp only [finIdxOf?_cons]
+    split <;> simp_all [@eq_comm _ x a]
 
 /-! ### idxOf?
 
@@ -1146,9 +1154,15 @@ theorem isSome_idxOf? [BEq α] [LawfulBEq α] {l : List α} {a : α} :
     simp only [idxOf?_cons]
     split <;> simp_all [@eq_comm _ x a]
 
+@[simp]
 theorem isNone_idxOf? [BEq α] [LawfulBEq α] {l : List α} {a : α} :
     (l.idxOf? a).isNone = ¬ a ∈ l := by
-  simp
+  induction l with
+  | nil => simp
+  | cons x xs ih =>
+    simp only [idxOf?_cons]
+    split <;> simp_all [@eq_comm _ x a]
+
 
 /-! ### lookup -/
 

src/Init/Data/List/Impl.lean

@@ -109,7 +109,7 @@ Example:
   let rec go : ∀ as acc, filterMapTR.go f as acc = acc.toList ++ as.filterMap f
     | [], acc => by simp [filterMapTR.go, filterMap]
     | a::as, acc => by
-      simp only [filterMapTR.go, go as, Array.toList_push, append_assoc, singleton_append,
+      simp only [filterMapTR.go, go as, Array.push_toList, append_assoc, singleton_append,
         filterMap]
       split <;> simp [*]
   exact (go l #[]).symm
@@ -550,7 +550,7 @@ def zipIdxTR (l : List α) (n : Nat := 0) : List (α × Nat) :=
   (as.foldr (fun a (n, acc) => (n-1, (a, n-1) :: acc)) (n + as.size, [])).2
 
 @[csimp] theorem zipIdx_eq_zipIdxTR : @zipIdx = @zipIdxTR := by
-  funext α l n; simp only [zipIdxTR]
+  funext α l n; simp only [zipIdxTR, size_toArray]
   let f := fun (a : α) (n, acc) => (n-1, (a, n-1) :: acc)
   let rec go : ∀ l i, l.foldr f (i + l.length, []) = (i, zipIdx l i)
     | [], n => rfl
@@ -571,7 +571,7 @@ def enumFromTR (n : Nat) (l : List α) : List (Nat × α) :=
 set_option linter.deprecated false in
 @[deprecated zipIdx_eq_zipIdxTR (since := "2025-01-21"), csimp]
 theorem enumFrom_eq_enumFromTR : @enumFrom = @enumFromTR := by
-  funext α n l; simp only [enumFromTR]
+  funext α n l; simp only [enumFromTR, size_toArray]
   let f := fun (a : α) (n, acc) => (n-1, (n-1, a) :: acc)
   let rec go : ∀ l n, l.foldr f (n + l.length, []) = (n, enumFrom n l)
     | [], n => rfl

src/Init/Data/List/Lemmas.lean

@@ -272,13 +272,13 @@ theorem getElem_of_getElem? {l : List α} : l[i]? = some a → ∃ h : i < l.len
 theorem some_eq_getElem?_iff {l : List α} : some a = l[i]? ↔ ∃ h : i < l.length, l[i] = a := by
   rw [eq_comm, getElem?_eq_some_iff]
 
-theorem some_getElem_eq_getElem?_iff {xs : List α} {i : Nat} (h : i < xs.length) :
+@[simp] theorem some_getElem_eq_getElem?_iff {xs : List α} {i : Nat} (h : i < xs.length) :
     (some xs[i] = xs[i]?) ↔ True := by
-  simp
+  simp [h]
 
-theorem getElem?_eq_some_getElem_iff {xs : List α} {i : Nat} (h : i < xs.length) :
+@[simp] theorem getElem?_eq_some_getElem_iff {xs : List α} {i : Nat} (h : i < xs.length) :
     (xs[i]? = some xs[i]) ↔ True := by
-  simp
+  simp [h]
 
 theorem getElem_eq_iff {l : List α} {i : Nat} (h : i < l.length) : l[i] = x ↔ l[i]? = some x := by
   simp only [getElem?_eq_some_iff]
@@ -296,7 +296,7 @@ theorem getD_getElem? {l : List α} {i : Nat} {d : α} :
     have p : i ≥ l.length := Nat.le_of_not_gt h
     simp [getElem?_eq_none p, h]
 
-@[simp] theorem getElem_singleton {a : α} {i : Nat} (h : i < 1) : [a][i] = a := by
+@[simp] theorem getElem_singleton {a : α} {i : Nat} (h : i < 1) : [a][i] = a :=
   match i, h with
   | 0, _ => rfl
 
@@ -434,8 +434,8 @@ theorem eq_nil_iff_forall_not_mem {l : List α} : l = [] ↔ ∀ a, a ∉ l := b
 theorem eq_of_mem_singleton : a ∈ [b] → a = b
   | .head .. => rfl
 
-theorem mem_singleton {a b : α} : a ∈ [b] ↔ a = b := by
-  simp
+@[simp] theorem mem_singleton {a b : α} : a ∈ [b] ↔ a = b :=
+  ⟨eq_of_mem_singleton, (by simp [·])⟩
 
 theorem forall_mem_cons {p : α → Prop} {a : α} {l : List α} :
     (∀ x, x ∈ a :: l → p x) ↔ p a ∧ ∀ x, x ∈ l → p x :=
@@ -575,9 +575,9 @@ theorem isEmpty_iff_length_eq_zero {l : List α} : l.isEmpty ↔ l.length = 0 :=
 
 /-! ### any / all -/
 
-@[grind =] theorem any_eq {l : List α} : l.any p = decide (∃ x, x ∈ l ∧ p x) := by induction l <;> simp [*]
+theorem any_eq {l : List α} : l.any p = decide (∃ x, x ∈ l ∧ p x) := by induction l <;> simp [*]
 
-@[grind =] theorem all_eq {l : List α} : l.all p = decide (∀ x, x ∈ l → p x) := by induction l <;> simp [*]
+theorem all_eq {l : List α} : l.all p = decide (∀ x, x ∈ l → p x) := by induction l <;> simp [*]
 
 theorem decide_exists_mem {l : List α} {p : α → Prop} [DecidablePred p] :
     decide (∃ x, x ∈ l ∧ p x) = l.any p := by
@@ -834,7 +834,7 @@ theorem getElem_length_sub_one_eq_getLast {l : List α} (h : l.length - 1 < l.le
   rw [← getLast_eq_getElem]
 
 @[simp, grind] theorem getLast_cons_cons {a : α} {l : List α} :
-    getLast (a :: b :: l) (by simp) = getLast (b :: l) (by simp) :=
+    getLast (a :: b :: l) (by simp) = getLast (b :: l) (by simp) := by
   rfl
 
 theorem getLast_cons {a : α} {l : List α} : ∀ (h : l ≠ nil),
@@ -1128,8 +1128,7 @@ theorem map_singleton {f : α → β} {a : α} : map f [a] = [f a] := rfl
 
 -- We use a lower priority here as there are more specific lemmas in downstream libraries
 -- which should be able to fire first.
-@[simp 500, grind =] theorem mem_map {f : α → β} :
-    ∀ {l : List α}, b ∈ l.map f ↔ ∃ a, a ∈ l ∧ f a = b
+@[simp 500] theorem mem_map {f : α → β} : ∀ {l : List α}, b ∈ l.map f ↔ ∃ a, a ∈ l ∧ f a = b
   | [] => by simp
   | _ :: l => by simp [mem_map (l := l), eq_comm (a := b)]
 
@@ -1253,7 +1252,7 @@ theorem tailD_map {f : α → β} {l l' : List α} :
 theorem getLastD_map {f : α → β} {l : List α} {a : α} : (map f l).getLastD (f a) = f (l.getLastD a) := by
   simp
 
-@[simp, grind _=_] theorem map_map {g : β → γ} {f : α → β} {l : List α} :
+@[simp] theorem map_map {g : β → γ} {f : α → β} {l : List α} :
     map g (map f l) = map (g ∘ f) l := by induction l <;> simp_all
 
 /-! ### filter -/
@@ -1338,7 +1337,7 @@ theorem foldr_filter {p : α → Bool} {f : α → β → β} {l : List α} {ini
     simp only [filter_cons, foldr_cons]
     split <;> simp [ih]
 
-@[grind _=_] theorem filter_map {f : β → α} {p : α → Bool} {l : List β} :
+theorem filter_map {f : β → α} {p : α → Bool} {l : List β} :
     filter p (map f l) = map f (filter (p ∘ f) l) := by
   induction l with
   | nil => rfl
@@ -1573,6 +1572,9 @@ theorem not_mem_append {a : α} {s t : List α} (h₁ : a ∉ s) (h₂ : a ∉ t
 theorem mem_append_eq {a : α} {s t : List α} : (a ∈ s ++ t) = (a ∈ s ∨ a ∈ t) :=
   propext mem_append
 
+@[deprecated mem_append_left (since := "2024-11-20")] abbrev mem_append_of_mem_left := @mem_append_left
+@[deprecated mem_append_right (since := "2024-11-20")] abbrev mem_append_of_mem_right := @mem_append_right
+
 /--
 See also `eq_append_cons_of_mem`, which proves a stronger version
 in which the initial list must not contain the element.
@@ -1683,8 +1685,8 @@ theorem getLast_concat {a : α} : ∀ {l : List α}, getLast (l ++ [a]) (by simp
 
 @[deprecated append_eq_nil_iff (since := "2025-01-13")] abbrev append_eq_nil := @append_eq_nil_iff
 
-theorem nil_eq_append_iff : [] = a ++ b ↔ a = [] ∧ b = [] := by
-  simp
+@[simp] theorem nil_eq_append_iff : [] = a ++ b ↔ a = [] ∧ b = [] := by
+  rw [eq_comm, append_eq_nil_iff]
 
 @[grind →]
 theorem eq_nil_of_append_eq_nil {l₁ l₂ : List α} (h : l₁ ++ l₂ = []) : l₁ = [] ∧ l₂ = [] :=
@@ -1880,7 +1882,7 @@ theorem eq_nil_or_concat : ∀ l : List α, l = [] ∨ ∃ l' b, l = concat l' b
 
 /-! ### flatten -/
 
-@[simp, grind _=_] theorem length_flatten {L : List (List α)} : L.flatten.length = (L.map length).sum := by
+@[simp] theorem length_flatten {L : List (List α)} : L.flatten.length = (L.map length).sum := by
   induction L with
   | nil => rfl
   | cons =>
@@ -1895,8 +1897,8 @@ theorem eq_nil_or_concat : ∀ l : List α, l = [] ∨ ∃ l' b, l = concat l' b
 @[simp] theorem flatten_eq_nil_iff {L : List (List α)} : L.flatten = [] ↔ ∀ l ∈ L, l = [] := by
   induction L <;> simp_all
 
-theorem nil_eq_flatten_iff {L : List (List α)} : [] = L.flatten ↔ ∀ l ∈ L, l = [] := by
-  simp
+@[simp] theorem nil_eq_flatten_iff {L : List (List α)} : [] = L.flatten ↔ ∀ l ∈ L, l = [] := by
+  rw [eq_comm, flatten_eq_nil_iff]
 
 theorem flatten_ne_nil_iff {xss : List (List α)} : xss.flatten ≠ [] ↔ ∃ xs, xs ∈ xss ∧ xs ≠ [] := by
   simp
@@ -2050,7 +2052,7 @@ theorem eq_iff_flatten_eq : ∀ {L L' : List (List α)},
 
 /-! ### flatMap -/
 
-@[grind _=_] theorem flatMap_def {l : List α} {f : α → List β} : l.flatMap f = flatten (map f l) := rfl
+theorem flatMap_def {l : List α} {f : α → List β} : l.flatMap f = flatten (map f l) := rfl
 
 @[simp] theorem flatMap_id {L : List (List α)} : L.flatMap id = L.flatten := by simp [flatMap_def]
 
@@ -2539,25 +2541,17 @@ theorem flatten_reverse {L : List (List α)} :
   induction l generalizing b <;> simp [*]
 
 theorem foldl_eq_foldlM {f : β → α → β} {b : β} {l : List α} :
-    l.foldl f b = (l.foldlM (m := Id) (pure <| f · ·) b).run := by
-  simp
+    l.foldl f b = l.foldlM (m := Id) f b := by
+  induction l generalizing b <;> simp [*, foldl]
 
 theorem foldr_eq_foldrM {f : α → β → β} {b : β} {l : List α} :
-    l.foldr f b = (l.foldrM (m := Id) (pure <| f · ·) b).run := by
-  simp
+    l.foldr f b = l.foldrM (m := Id) f b := by
+  induction l <;> simp [*, foldr]
 
-theorem idRun_foldlM {f : β → α → Id β} {b : β} {l : List α} :
-    Id.run (l.foldlM f b) = l.foldl (f · · |>.run) b := foldl_eq_foldlM.symm
-
-@[deprecated idRun_foldlM (since := "2025-05-21")]
-theorem id_run_foldlM {f : β → α → Id β} {b : β} {l : List α} :
+@[simp] theorem id_run_foldlM {f : β → α → Id β} {b : β} {l : List α} :
     Id.run (l.foldlM f b) = l.foldl f b := foldl_eq_foldlM.symm
 
-theorem idRun_foldrM {f : α → β → Id β} {b : β} {l : List α} :
-    Id.run (l.foldrM f b) = l.foldr (f · · |>.run) b := foldr_eq_foldrM.symm
-
-@[deprecated idRun_foldrM (since := "2025-05-21")]
-theorem id_run_foldrM {f : α → β → Id β} {b : β} {l : List α} :
+@[simp] theorem id_run_foldrM {f : α → β → Id β} {b : β} {l : List α} :
     Id.run (l.foldrM f b) = l.foldr f b := foldr_eq_foldrM.symm
 
 @[simp] theorem foldlM_reverse [Monad m] {l : List α} {f : β → α → m β} {b : β} :
@@ -2582,11 +2576,6 @@ theorem id_run_foldrM {f : α → β → Id β} {b : β} {l : List α} :
     l.foldl (fun xs y => f y :: xs) l' = (l.map f).reverse ++ l' := by
   induction l generalizing l' <;> simp [*]
 
-/-- Variant of `foldl_flip_cons_eq_append` specalized to `f = id`. -/
-@[grind] theorem foldl_flip_cons_eq_append' {l l' : List α} :
-    l.foldl (fun xs y => y :: xs) l' = l.reverse ++ l' := by
-  simp
-
 @[simp, grind] theorem foldr_append_eq_append {l : List α} {f : α → List β} {l' : List β} :
     l.foldr (f · ++ ·) l' = (l.map f).flatten ++ l' := by
   induction l <;> simp [*]
@@ -2652,10 +2641,10 @@ theorem foldr_map_hom {g : α → β} {f : α → α → α} {f' : β → β →
   induction l <;> simp [*]
 
 @[simp, grind _=_] theorem foldl_append {β : Type _} {f : β → α → β} {b : β} {l l' : List α} :
-    (l ++ l').foldl f b = l'.foldl f (l.foldl f b) := by simp [foldl_eq_foldlM, -foldlM_pure]
+    (l ++ l').foldl f b = l'.foldl f (l.foldl f b) := by simp [foldl_eq_foldlM]
 
 @[simp, grind _=_] theorem foldr_append {f : α → β → β} {b : β} {l l' : List α} :
-    (l ++ l').foldr f b = l.foldr f (l'.foldr f b) := by simp [foldr_eq_foldrM, -foldrM_pure]
+    (l ++ l').foldr f b = l.foldr f (l'.foldr f b) := by simp [foldr_eq_foldrM]
 
 @[grind] theorem foldl_flatten {f : β → α → β} {b : β} {L : List (List α)} :
     (flatten L).foldl f b = L.foldl (fun b l => l.foldl f b) b := by
@@ -2666,8 +2655,7 @@ theorem foldr_map_hom {g : α → β} {f : α → α → α} {f' : β → β →
   induction L <;> simp_all
 
 @[simp, grind] theorem foldl_reverse {l : List α} {f : β → α → β} {b : β} :
-    l.reverse.foldl f b = l.foldr (fun x y => f y x) b := by
-  simp [foldl_eq_foldlM, foldr_eq_foldrM, -foldrM_pure]
+    l.reverse.foldl f b = l.foldr (fun x y => f y x) b := by simp [foldl_eq_foldlM, foldr_eq_foldrM]
 
 @[simp, grind] theorem foldr_reverse {l : List α} {f : α → β → β} {b : β} :
     l.reverse.foldr f b = l.foldl (fun x y => f y x) b :=
@@ -2719,7 +2707,6 @@ example {xs : List Nat} : xs.foldl (· + ·) 1 > 0 := by
     intros; omega
 ```
 -/
-@[expose]
 def foldlRecOn {motive : β → Sort _} : ∀ (l : List α) (op : β → α → β) {b : β} (_ : motive b)
     (_ : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ l), motive (op b a)), motive (List.foldl op b l)
   | [], _, _, hb, _ => hb
@@ -2754,7 +2741,6 @@ example {xs : List Nat} : xs.foldr (· + ·) 1 > 0 := by
     intros; omega
 ```
 -/
-@[expose]
 def foldrRecOn {motive : β → Sort _} : ∀ (l : List α) (op : α → β → β) {b : β} (_ : motive b)
     (_ : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ l), motive (op a b)), motive (List.foldr op b l)
   | nil, _, _, hb, _ => hb
@@ -2952,7 +2938,7 @@ theorem contains_iff_exists_mem_beq [BEq α] {l : List α} {a : α} :
     l.contains a ↔ ∃ a' ∈ l, a == a' := by
   induction l <;> simp_all
 
-@[grind _=_]
+@[grind]
 theorem contains_iff_mem [BEq α] [LawfulBEq α] {l : List α} {a : α} :
     l.contains a ↔ a ∈ l := by
   simp
@@ -3427,8 +3413,8 @@ variable [LawfulBEq α]
     | Or.inr h' => exact h'
   else rw [insert_of_not_mem h, mem_cons]
 
-theorem mem_insert_self {a : α} {l : List α} : a ∈ l.insert a := by
-  simp
+@[simp] theorem mem_insert_self {a : α} {l : List α} : a ∈ l.insert a :=
+  mem_insert_iff.2 (Or.inl rfl)
 
 theorem mem_insert_of_mem {l : List α} (h : a ∈ l) : a ∈ l.insert b :=
   mem_insert_iff.2 (Or.inr h)
@@ -3704,6 +3690,17 @@ theorem mem_iff_get? {a} {l : List α} : a ∈ l ↔ ∃ n, l.get? n = some a :=
 
 /-! ### Deprecations -/
 
+@[deprecated get?_eq_none (since := "2024-11-29")] abbrev get?_len_le := @getElem?_eq_none
+@[deprecated getElem?_eq_some_iff (since := "2024-11-29")]
+abbrev getElem?_eq_some := @getElem?_eq_some_iff
+@[deprecated get?_eq_some_iff (since := "2024-11-29")]
+abbrev get?_eq_some := @getElem?_eq_some_iff
+@[deprecated LawfulGetElem.getElem?_def (since := "2024-11-29")]
+theorem getElem?_eq (l : List α) (i : Nat) :
+    l[i]? = if h : i < l.length then some l[i] else none :=
+  getElem?_def _ _
+@[deprecated getElem?_eq_none (since := "2024-11-29")] abbrev getElem?_len_le := @getElem?_eq_none
+
 @[deprecated _root_.isSome_getElem? (since := "2024-12-09")]
 theorem isSome_getElem? {l : List α} {i : Nat} : l[i]?.isSome ↔ i < l.length := by
   simp

src/Init/Data/List/MapIdx.lean

@@ -27,7 +27,7 @@ that the index is valid.
 
 `List.mapIdx` is a variant that does not provide the function with evidence that the index is valid.
 -/
-@[inline, expose] def mapFinIdx (as : List α) (f : (i : Nat) → α → (h : i < as.length) → β) : List β :=
+@[inline] def mapFinIdx (as : List α) (f : (i : Nat) → α → (h : i < as.length) → β) : List β :=
   go as #[] (by simp)
 where
   /-- Auxiliary for `mapFinIdx`:
@@ -44,7 +44,7 @@ returning the list of results.
 `List.mapFinIdx` is a variant that additionally provides the function with a proof that the index
 is valid.
 -/
-@[inline, expose] def mapIdx (f : Nat → α → β) (as : List α) : List β := go as #[] where
+@[inline] def mapIdx (f : Nat → α → β) (as : List α) : List β := go as #[] where
   /-- Auxiliary for `mapIdx`:
   `mapIdx.go [a₀, a₁, ...] acc = acc.toList ++ [f acc.size a₀, f (acc.size + 1) a₁, ...]` -/
   @[specialize] go : List α → Array β → List β
@@ -320,7 +320,7 @@ theorem mapIdx_nil {f : Nat → α → β} : mapIdx f [] = [] :=
 theorem mapIdx_go_length {acc : Array β} :
     length (mapIdx.go f l acc) = length l + acc.size := by
   induction l generalizing acc with
-  | nil => simp [mapIdx.go]
+  | nil => simp only [mapIdx.go, length_nil, Nat.zero_add]
   | cons _ _ ih =>
     simp only [mapIdx.go, ih, Array.size_push, Nat.add_succ, length_cons, Nat.add_comm]
 
@@ -348,7 +348,7 @@ theorem getElem?_mapIdx_go : ∀ {l : List α} {acc : Array β} {i : Nat},
     split <;> split
     · simp only [Option.some.injEq]
       rw [← Array.getElem_toList]
-      simp only [Array.toList_push]
+      simp only [Array.push_toList]
       rw [getElem_append_left, ← Array.getElem_toList]
     · have : i = acc.size := by omega
       simp_all

src/Init/Data/List/Monadic.lean

@@ -8,8 +8,6 @@ module
 prelude
 import Init.Data.List.TakeDrop
 import Init.Data.List.Attach
-import Init.Data.List.OfFn
-import Init.Data.Array.Bootstrap
 import all Init.Data.List.Control
 
 /-!
@@ -44,7 +42,6 @@ This is a non-tail-recursive variant of `List.mapM` that's easier to reason abou
 as the main definition and replaced by the tail-recursive version because they can only be proved
 equal when `m` is a `LawfulMonad`.
 -/
-@[expose]
 def mapM' [Monad m] (f : α → m β) : List α → m (List β)
   | [] => pure []
   | a :: l => return (← f a) :: (← l.mapM' f)
@@ -69,24 +66,16 @@ theorem mapM'_eq_mapM [Monad m] [LawfulMonad m] {f : α → m β} {l : List α}
     l.mapM (m := m) (pure <| f ·) = pure (l.map f) := by
   induction l <;> simp_all
 
-@[simp] theorem idRun_mapM {l : List α} {f : α → Id β} : (l.mapM f).run = l.map (f · |>.run) :=
+@[simp] theorem mapM_id {l : List α} {f : α → Id β} : l.mapM f = l.map f :=
   mapM_pure
 
-@[deprecated idRun_mapM (since := "2025-05-21")]
-theorem mapM_id {l : List α} {f : α → Id β} : (l.mapM f).run = l.map (f · |>.run) :=
-  mapM_pure
-
-@[simp] theorem mapM_map [Monad m] [LawfulMonad m] {f : α → β} {g : β → m γ} {l : List α} :
-    (l.map f).mapM g = l.mapM (g ∘ f) := by
-  induction l <;> simp_all
-
 @[simp] theorem mapM_append [Monad m] [LawfulMonad m] {f : α → m β} {l₁ l₂ : List α} :
     (l₁ ++ l₂).mapM f = (return (← l₁.mapM f) ++ (← l₂.mapM f)) := by induction l₁ <;> simp [*]
 
 /-- Auxiliary lemma for `mapM_eq_reverse_foldlM_cons`. -/
 theorem foldlM_cons_eq_append [Monad m] [LawfulMonad m] {f : α → m β} {as : List α} {b : β} {bs : List β} :
-    (as.foldlM (init := b :: bs) fun acc a => (· :: acc) <$> f a) =
-      (· ++ b :: bs) <$> as.foldlM (init := []) fun acc a => (· :: acc) <$> f a := by
+    (as.foldlM (init := b :: bs) fun acc a => return ((← f a) :: acc)) =
+      (· ++ b :: bs) <$> as.foldlM (init := []) fun acc a => return ((← f a) :: acc) := by
   induction as generalizing b bs with
   | nil => simp
   | cons a as ih =>
@@ -94,7 +83,7 @@ theorem foldlM_cons_eq_append [Monad m] [LawfulMonad m] {f : α → m β} {as :
     simp [ih, _root_.map_bind, Functor.map_map, Function.comp_def]
 
 theorem mapM_eq_reverse_foldlM_cons [Monad m] [LawfulMonad m] {f : α → m β} {l : List α} :
-    mapM f l = reverse <$> (l.foldlM (fun acc a => (· :: acc) <$> f a) []) := by
+    mapM f l = reverse <$> (l.foldlM (fun acc a => return ((← f a) :: acc)) []) := by
   rw [← mapM'_eq_mapM]
   induction l with
   | nil => simp
@@ -350,18 +339,12 @@ theorem forIn'_eq_foldlM [Monad m] [LawfulMonad m]
   simp only [forIn'_eq_foldlM]
   induction l.attach generalizing init <;> simp_all
 
-@[simp] theorem idRun_forIn'_yield_eq_foldl
-    (l : List α) (f : (a : α) → a ∈ l → β → Id β) (init : β) :
-    (forIn' l init (fun a m b => .yield <$> f a m b)).run =
-      l.attach.foldl (fun b ⟨a, h⟩ => f a h b |>.run) init :=
-  forIn'_pure_yield_eq_foldl _ _
-
-@[deprecated idRun_forIn'_yield_eq_foldl (since := "2025-05-21")]
-theorem forIn'_yield_eq_foldl
+@[simp] theorem forIn'_yield_eq_foldl
     {l : List α} (f : (a : α) → a ∈ l → β → β) (init : β) :
     forIn' (m := Id) l init (fun a m b => .yield (f a m b)) =
-      l.attach.foldl (fun b ⟨a, h⟩ => f a h b) init :=
-  forIn'_pure_yield_eq_foldl _ _
+      l.attach.foldl (fun b ⟨a, h⟩ => f a h b) init := by
+  simp only [forIn'_eq_foldlM]
+  induction l.attach generalizing init <;> simp_all
 
 @[simp] theorem forIn'_map [Monad m] [LawfulMonad m]
     {l : List α} (g : α → β) (f : (b : β) → b ∈ l.map g → γ → m (ForInStep γ)) :
@@ -409,18 +392,12 @@ theorem forIn_eq_foldlM [Monad m] [LawfulMonad m]
   simp only [forIn_eq_foldlM]
   induction l generalizing init <;> simp_all
 
-@[simp] theorem idRun_forIn_yield_eq_foldl
-    (l : List α) (f : α → β → Id β) (init : β) :
-    (forIn l init (fun a b => .yield <$> f a b)).run =
-      l.foldl (fun b a => f a b |>.run) init :=
-  forIn_pure_yield_eq_foldl _ _
-
-@[deprecated idRun_forIn_yield_eq_foldl (since := "2025-05-21")]
-theorem forIn_yield_eq_foldl
+@[simp] theorem forIn_yield_eq_foldl
     {l : List α} (f : α → β → β) (init : β) :
     forIn (m := Id) l init (fun a b => .yield (f a b)) =
-      l.foldl (fun b a => f a b) init :=
-  forIn_pure_yield_eq_foldl _ _
+      l.foldl (fun b a => f a b) init := by
+  simp only [forIn_eq_foldlM]
+  induction l generalizing init <;> simp_all
 
 @[simp] theorem forIn_map [Monad m] [LawfulMonad m]
     {l : List α} {g : α → β} {f : β → γ → m (ForInStep γ)} :

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

@@ -156,7 +156,7 @@ theorem modifyHead_eq_modify_zero (f : α → α) (l : List α) :
 @[simp] theorem modify_eq_nil_iff {f : α → α} {i} {l : List α} :
     l.modify i f = [] ↔ l = [] := by cases l <;> cases i <;> simp
 
-@[grind =] theorem getElem?_modify (f : α → α) :
+theorem getElem?_modify (f : α → α) :
     ∀ i (l : List α) j, (l.modify i f)[j]? = (fun a => if i = j then f a else a) <$> l[j]?
   | n, l, 0 => by cases l <;> cases n <;> simp
   | n, [], _+1 => by cases n <;> rfl
@@ -167,7 +167,7 @@ theorem modifyHead_eq_modify_zero (f : α → α) (l : List α) :
     cases h' : l[j]? <;> by_cases h : i = j <;>
       simp [h, if_pos, if_neg, Option.map, mt Nat.succ.inj, not_false_iff, h']
 
-@[simp, grind =] theorem length_modify (f : α → α) : ∀ (l : List α) i, (l.modify i f).length = l.length :=
+@[simp] theorem length_modify (f : α → α) : ∀ (l : List α) i, (l.modify i f).length = l.length :=
   length_modifyTailIdx _ fun l => by cases l <;> rfl
 
 @[simp] theorem getElem?_modify_eq (f : α → α) (i) (l : List α) :
@@ -178,7 +178,7 @@ theorem modifyHead_eq_modify_zero (f : α → α) (l : List α) :
     (l.modify i f)[j]? = l[j]? := by
   simp only [getElem?_modify, if_neg h, id_map']
 
-@[grind =] theorem getElem_modify (f : α → α) (i) (l : List α) (j) (h : j < (l.modify i f).length) :
+theorem getElem_modify (f : α → α) (i) (l : List α) (j) (h : j < (l.modify i f).length) :
     (l.modify i f)[j] =
       if i = j then f (l[j]'(by simp at h; omega)) else l[j]'(by simp at h; omega) := by
   rw [getElem_eq_iff, getElem?_modify]
@@ -245,7 +245,6 @@ theorem exists_of_modify (f : α → α) {i} {l : List α} (h : i < l.length) :
 @[simp] theorem modify_id (i) (l : List α) : l.modify i id = l := by
   simp [modify]
 
-@[grind =]
 theorem take_modify (f : α → α) (i j) (l : List α) :
     (l.modify i f).take j = (l.take j).modify i f := by
   induction j generalizing l i with
@@ -258,7 +257,6 @@ theorem take_modify (f : α → α) (i j) (l : List α) :
       | zero => simp
       | succ i => simp [ih]
 
-@[grind =]
 theorem drop_modify_of_lt (f : α → α) (i j) (l : List α) (h : i < j) :
     (l.modify i f).drop j = l.drop j := by
   apply ext_getElem
@@ -268,7 +266,6 @@ theorem drop_modify_of_lt (f : α → α) (i j) (l : List α) (h : i < j) :
     intro h'
     omega
 
-@[grind =]
 theorem drop_modify_of_ge (f : α → α) (i j) (l : List α) (h : i ≥ j) :
     (l.modify i f).drop j = (l.drop j).modify (i - j) f  := by
   apply ext_getElem

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

@@ -55,7 +55,7 @@ theorem sublist_eq_map_getElem {l l' : List α} (h : l' <+ l) : ∃ is : List (F
     simp [Function.comp_def, pairwise_map, IH, ← get_eq_getElem, get_cons_zero, get_cons_succ']
 
 set_option linter.listVariables false in
-theorem pairwise_iff_getElem {l : List α} : Pairwise R l ↔
+theorem pairwise_iff_getElem : Pairwise R l ↔
     ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length) (_hij : i < j), R l[i] l[j] := by
   rw [pairwise_iff_forall_sublist]
   constructor <;> intro h

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

@@ -617,6 +617,9 @@ set_option linter.deprecated false
 @[deprecated zipIdx_eq_nil_iff (since := "2025-01-21"), simp]
 theorem enum_eq_nil_iff {l : List α} : List.enum l = [] ↔ l = [] := enumFrom_eq_nil
 
+@[deprecated zipIdx_eq_nil_iff (since := "2024-11-04")]
+theorem enum_eq_nil {l : List α} : List.enum l = [] ↔ l = [] := enum_eq_nil_iff
+
 @[deprecated zipIdx_singleton (since := "2025-01-21"), simp]
 theorem enum_singleton (x : α) : enum [x] = [(0, x)] := rfl
 

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

@@ -30,7 +30,7 @@ theorem IsSuffix.getElem {xs ys : List α} (h : xs <:+ ys) {i} (hn : i < xs.leng
   have := h.length_le
   omega
 
-theorem suffix_iff_getElem? {l₁ l₂ : List α} : l₁ <:+ l₂ ↔
+theorem isSuffix_iff : l₁ <:+ l₂ ↔
     l₁.length ≤ l₂.length ∧ ∀ i (h : i < l₁.length), l₂[i + l₂.length - l₁.length]? = some l₁[i] := by
   suffices l₁.length ≤ l₂.length ∧ l₁ <:+ l₂ ↔
       l₁.length ≤ l₂.length ∧ ∀ i (h : i < l₁.length), l₂[i + l₂.length - l₁.length]? = some l₁[i] by
@@ -41,7 +41,7 @@ theorem suffix_iff_getElem? {l₁ l₂ : List α} : l₁ <:+ l₂ ↔
       exact (this.mpr h).2
   simp only [and_congr_right_iff]
   intro le
-  rw [← reverse_prefix, prefix_iff_getElem?]
+  rw [← reverse_prefix, isPrefix_iff]
   simp only [length_reverse]
   constructor
   · intro w i h
@@ -60,33 +60,15 @@ theorem suffix_iff_getElem? {l₁ l₂ : List α} : l₁ <:+ l₂ ↔
     rw [w, getElem_reverse]
     exact Nat.lt_of_lt_of_le h le
 
-@[deprecated suffix_iff_getElem? (since := "2025-05-27")]
-abbrev isSuffix_iff := @suffix_iff_getElem?
-
-theorem suffix_iff_getElem {l₁ l₂ : List α} :
-    l₁ <:+ l₂ ↔ ∃ (_ : l₁.length ≤ l₂.length), ∀ i (_ : i < l₁.length), l₂[i + l₂.length - l₁.length] = l₁[i] := by
-  rw [suffix_iff_getElem?]
-  constructor
-  · rintro ⟨h, w⟩
-    refine ⟨h, fun i h => ?_⟩
-    specialize w i h
-    rw [getElem?_eq_getElem] at w
-    simpa using w
-  · rintro ⟨h, w⟩
-    refine ⟨h, fun i h => ?_⟩
-    specialize w i h
-    rw [getElem?_eq_getElem]
-    simpa using w
-
-theorem infix_iff_getElem? {l₁ l₂ : List α} : l₁ <:+: l₂ ↔
+theorem isInfix_iff : l₁ <:+: l₂ ↔
     ∃ k, l₁.length + k ≤ l₂.length ∧ ∀ i (h : i < l₁.length), l₂[i + k]? = some l₁[i] := by
   constructor
   · intro h
     obtain ⟨t, p, s⟩ := infix_iff_suffix_prefix.mp h
     refine ⟨t.length - l₁.length, by have := p.length_le; have := s.length_le; omega, ?_⟩
-    rw [suffix_iff_getElem?] at p
+    rw [isSuffix_iff] at p
     obtain ⟨p', p⟩ := p
-    rw [prefix_iff_getElem?] at s
+    rw [isPrefix_iff] at s
     intro i h
     rw [s _ (by omega)]
     specialize p i (by omega)
@@ -111,9 +93,6 @@ theorem infix_iff_getElem? {l₁ l₂ : List α} : l₁ <:+: l₂ ↔
       simp_all
       omega
 
-@[deprecated infix_iff_getElem? (since := "2025-05-27")]
-abbrev isInfix_iff := @infix_iff_getElem?
-
 theorem suffix_iff_eq_append : l₁ <:+ l₂ ↔ take (length l₂ - length l₁) l₂ ++ l₁ = l₂ :=
   ⟨by rintro ⟨r, rfl⟩; simp only [length_append, Nat.add_sub_cancel_right, take_left], fun e =>
     ⟨_, e⟩⟩
@@ -136,7 +115,7 @@ theorem suffix_iff_eq_drop : l₁ <:+ l₂ ↔ l₁ = drop (length l₂ - length
   ⟨fun h => append_cancel_left <| (suffix_iff_eq_append.1 h).trans (take_append_drop _ _).symm,
     fun e => e.symm ▸ drop_suffix _ _⟩
 
-@[grind =] theorem prefix_take_le_iff {xs : List α} (hm : i < xs.length) :
+theorem prefix_take_le_iff {xs : List α} (hm : i < xs.length) :
     xs.take i <+: xs.take j ↔ i ≤ j := by
   simp only [prefix_iff_eq_take, length_take]
   induction i generalizing xs j with

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

@@ -56,7 +56,7 @@ theorem getElem?_take_eq_none {l : List α} {i j : Nat} (h : i ≤ j) :
     (l.take i)[j]? = none :=
   getElem?_eq_none <| Nat.le_trans (length_take_le _ _) h
 
-@[grind =] theorem getElem?_take {l : List α} {i j : Nat} :
+@[grind =]theorem getElem?_take {l : List α} {i j : Nat} :
     (l.take i)[j]? = if j < i then l[j]? else none := by
   split
   · next h => exact getElem?_take_of_lt h
@@ -199,7 +199,7 @@ theorem take_eq_dropLast {l : List α} {i : Nat} (h : i + 1 = l.length) :
         simpa using h
 
 theorem take_prefix_take_left {l : List α} {i j : Nat} (h : i ≤ j) : take i l <+: take j l := by
-  rw [prefix_iff_getElem?]
+  rw [isPrefix_iff]
   intro i w
   rw [getElem?_take_of_lt, getElem_take, getElem?_eq_getElem]
   simp only [length_take] at w

src/Init/Data/List/OfFn.lean

@@ -27,13 +27,6 @@ Examples:
 -/
 def ofFn {n} (f : Fin n → α) : List α := Fin.foldr n (f · :: ·) []
 
-/--
-Creates a list wrapped in a monad by applying the monadic function `f : Fin n → m α`
-to each potential index in order, starting at `0`.
--/
-def ofFnM {n} [Monad m] (f : Fin n → m α) : m (List α) :=
-  List.reverse <$> Fin.foldlM n (fun xs i => (· :: xs) <$> f i) []
-
 @[simp]
 theorem length_ofFn {f : Fin n → α} : (ofFn f).length = n := by
   simp only [ofFn]
@@ -56,8 +49,7 @@ protected theorem getElem_ofFn {f : Fin n → α} (h : i < (ofFn f).length) :
       simp_all
 
 @[simp]
-protected theorem getElem?_ofFn {f : Fin n → α} :
-    (ofFn f)[i]? = if h : i < n then some (f ⟨i, h⟩) else none :=
+protected theorem getElem?_ofFn {f : Fin n → α} : (ofFn f)[i]? = if h : i < n then some (f ⟨i, h⟩) else none :=
   if h : i < (ofFn f).length
   then by
     rw [getElem?_eq_getElem h, List.getElem_ofFn]
@@ -68,8 +60,8 @@ protected theorem getElem?_ofFn {f : Fin n → α} :
 
 /-- `ofFn` on an empty domain is the empty list. -/
 @[simp]
-theorem ofFn_zero {f : Fin 0 → α} : ofFn f = [] := by
-  rw [ofFn, Fin.foldr_zero]
+theorem ofFn_zero {f : Fin 0 → α} : ofFn f = [] :=
+  ext_get (by simp) (fun i hi₁ hi₂ => by contradiction)
 
 @[simp]
 theorem ofFn_succ {n} {f : Fin (n + 1) → α} : ofFn f = f 0 :: ofFn fun i => f i.succ :=
@@ -78,22 +70,6 @@ theorem ofFn_succ {n} {f : Fin (n + 1) → α} : ofFn f = f 0 :: ofFn fun i => f
     · simp
     · simp)
 
-theorem ofFn_succ_last {n} {f : Fin (n + 1) → α} :
-    ofFn f = (ofFn fun i => f i.castSucc) ++ [f (Fin.last n)] := by
-  induction n with
-  | zero => simp [ofFn_succ]
-  | succ n ih =>
-    rw [ofFn_succ]
-    conv => rhs; rw [ofFn_succ]
-    rw [ih]
-    simp
-
-theorem ofFn_add {n m} {f : Fin (n + m) → α} :
-    ofFn f = (ofFn fun i => f (i.castLE (Nat.le_add_right n m))) ++ (ofFn fun i => f (i.natAdd n)) := by
-  induction m with
-  | zero => simp
-  | succ m ih => simp [-ofFn_succ, ofFn_succ_last, ih]
-
 @[simp]
 theorem ofFn_eq_nil_iff {f : Fin n → α} : ofFn f = [] ↔ n = 0 := by
   cases n <;> simp only [ofFn_zero, ofFn_succ, eq_self_iff_true, Nat.succ_ne_zero, reduceCtorEq]
@@ -116,65 +92,4 @@ theorem getLast_ofFn {n} {f : Fin n → α} (h : ofFn f ≠ []) :
     (ofFn f).getLast h = f ⟨n - 1, Nat.sub_one_lt (mt ofFn_eq_nil_iff.2 h)⟩ := by
   simp [getLast_eq_getElem, length_ofFn, List.getElem_ofFn]
 
-/-- `ofFnM` on an empty domain is the empty list. -/
-@[simp]
-theorem ofFnM_zero [Monad m] [LawfulMonad m] {f : Fin 0 → m α} : ofFnM f = pure [] := by
-  simp [ofFnM]
-
-/-! See `Init.Data.List.FinRange` for the `ofFnM_succ` variant. -/
-
-theorem ofFnM_succ_last {n} [Monad m] [LawfulMonad m] {f : Fin (n + 1) → m α} :
-    ofFnM f = (do
-      let as ← ofFnM fun i => f i.castSucc
-      let a  ← f (Fin.last n)
-      pure (as ++ [a])) := by
-  simp [ofFnM, Fin.foldlM_succ_last]
-
-theorem ofFnM_add {n m} [Monad m] [LawfulMonad m] {f : Fin (n + k) → m α} :
-    ofFnM f = (do
-      let as ← ofFnM fun i : Fin n => f (i.castLE (Nat.le_add_right n k))
-      let bs ← ofFnM fun i : Fin k => f (i.natAdd n)
-      pure (as ++ bs)) := by
-  induction k with
-  | zero => simp
-  | succ k ih => simp [ofFnM_succ_last, ih]
-
-
-end List
-
-namespace Fin
-
-theorem foldl_cons_eq_append {f : Fin n → α} {xs : List α} :
-    Fin.foldl n (fun xs i => f i :: xs) xs = (List.ofFn f).reverse ++ xs := by
-  induction n generalizing xs with
-  | zero => simp
-  | succ n ih => simp [Fin.foldl_succ, List.ofFn_succ, ih]
-
-theorem foldr_cons_eq_append {f : Fin n → α} {xs : List α} :
-    Fin.foldr n (fun i xs => f i :: xs) xs = List.ofFn f ++ xs:= by
-  induction n generalizing xs with
-  | zero => simp
-  | succ n ih => simp [Fin.foldr_succ, List.ofFn_succ, ih]
-
-end Fin
-
-namespace List
-
-@[simp]
-theorem ofFnM_pure_comp [Monad m] [LawfulMonad m] {n} {f : Fin n → α} :
-    ofFnM (pure ∘ f) = (pure (ofFn f) : m (List α)) := by
-  simp [ofFnM, Fin.foldlM_pure, Fin.foldl_cons_eq_append]
-
--- Variant of `ofFnM_pure_comp` using a lambda.
--- This is not marked a `@[simp]` as it would match on every occurrence of `ofFnM`.
-theorem ofFnM_pure [Monad m] [LawfulMonad m] {n} {f : Fin n → α} :
-    ofFnM (fun i => pure (f i)) = (pure (ofFn f) : m (List α)) :=
-  ofFnM_pure_comp
-
-@[simp, grind =] theorem idRun_ofFnM {f : Fin n → Id α} :
-    Id.run (ofFnM f) = ofFn (fun i => Id.run (f i)) := by
-  induction n with
-  | zero => simp
-  | succ n ih => simp [-ofFn_succ, ofFnM_succ_last, ofFn_succ_last, ih]
-
 end List

src/Init/Data/List/Pairwise.lean

@@ -24,7 +24,7 @@ open Nat
 
 /-! ### Pairwise -/
 
-@[grind →] theorem Pairwise.sublist : l₁ <+ l₂ → l₂.Pairwise R → l₁.Pairwise R
+theorem Pairwise.sublist : l₁ <+ l₂ → l₂.Pairwise R → l₁.Pairwise R
   | .slnil, h => h
   | .cons _ s, .cons _ h₂ => h₂.sublist s
   | .cons₂ _ s, .cons h₁ h₂ => (h₂.sublist s).cons fun _ h => h₁ _ (s.subset h)
@@ -37,11 +37,11 @@ theorem Pairwise.imp {α R S} (H : ∀ {a b}, R a b → S a b) :
 theorem rel_of_pairwise_cons (p : (a :: l).Pairwise R) : ∀ {a'}, a' ∈ l → R a a' :=
   (pairwise_cons.1 p).1 _
 
-@[grind →] theorem Pairwise.of_cons (p : (a :: l).Pairwise R) : Pairwise R l :=
+theorem Pairwise.of_cons (p : (a :: l).Pairwise R) : Pairwise R l :=
   (pairwise_cons.1 p).2
 
 set_option linter.unusedVariables false in
-@[grind] theorem Pairwise.tail : ∀ {l : List α} (h : Pairwise R l), Pairwise R l.tail
+theorem Pairwise.tail : ∀ {l : List α} (h : Pairwise R l), Pairwise R l.tail
   | [], h => h
   | _ :: _, h => h.of_cons
 
@@ -101,11 +101,11 @@ theorem Pairwise.forall_of_forall_of_flip (h₁ : ∀ x ∈ l, R x x) (h₂ : Pa
     · exact h₃.1 _ hx
     · exact ih (fun x hx => h₁ _ <| mem_cons_of_mem _ hx) h₂.2 h₃.2 hx hy
 
-@[grind] theorem pairwise_singleton (R) (a : α) : Pairwise R [a] := by simp
+theorem pairwise_singleton (R) (a : α) : Pairwise R [a] := by simp
 
-@[grind =] theorem pairwise_pair {a b : α} : Pairwise R [a, b] ↔ R a b := by simp
+theorem pairwise_pair {a b : α} : Pairwise R [a, b] ↔ R a b := by simp
 
-@[grind =] theorem pairwise_map {l : List α} :
+theorem pairwise_map {l : List α} :
     (l.map f).Pairwise R ↔ l.Pairwise fun a b => R (f a) (f b) := by
   induction l
   · simp
@@ -115,11 +115,11 @@ theorem Pairwise.of_map {S : β → β → Prop} (f : α → β) (H : ∀ a b :
     (p : Pairwise S (map f l)) : Pairwise R l :=
   (pairwise_map.1 p).imp (H _ _)
 
-@[grind] theorem Pairwise.map {S : β → β → Prop} (f : α → β) (H : ∀ a b : α, R a b → S (f a) (f b))
+theorem Pairwise.map {S : β → β → Prop} (f : α → β) (H : ∀ a b : α, R a b → S (f a) (f b))
     (p : Pairwise R l) : Pairwise S (map f l) :=
   pairwise_map.2 <| p.imp (H _ _)
 
-@[grind =] theorem pairwise_filterMap {f : β → Option α} {l : List β} :
+theorem pairwise_filterMap {f : β → Option α} {l : List β} :
     Pairwise R (filterMap f l) ↔ Pairwise (fun a a' : β => ∀ b, f a = some b → ∀ b', f a' = some b' → R b b') l := by
   let _S (a a' : β) := ∀ b, f a = some b → ∀ b', f a' = some b' → R b b'
   induction l with
@@ -134,20 +134,20 @@ theorem Pairwise.of_map {S : β → β → Prop} (f : α → β) (H : ∀ a b :
     simpa [IH, e] using fun _ =>
       ⟨fun h a ha b hab => h _ _ ha hab, fun h a b ha hab => h _ ha _ hab⟩
 
-@[grind] theorem Pairwise.filterMap {S : β → β → Prop} (f : α → Option β)
+theorem Pairwise.filterMap {S : β → β → Prop} (f : α → Option β)
     (H : ∀ a a' : α, R a a' → ∀ b, f a = some b → ∀ b', f a' = some b' → S b b') {l : List α} (p : Pairwise R l) :
     Pairwise S (filterMap f l) :=
   pairwise_filterMap.2 <| p.imp (H _ _)
 
-@[grind =] theorem pairwise_filter {p : α → Bool} {l : List α} :
+theorem pairwise_filter {p : α → Prop} [DecidablePred p] {l : List α} :
     Pairwise R (filter p l) ↔ Pairwise (fun x y => p x → p y → R x y) l := by
   rw [← filterMap_eq_filter, pairwise_filterMap]
   simp
 
-@[grind] theorem Pairwise.filter (p : α → Bool) : Pairwise R l → Pairwise R (filter p l) :=
+theorem Pairwise.filter (p : α → Bool) : Pairwise R l → Pairwise R (filter p l) :=
   Pairwise.sublist filter_sublist
 
-@[grind =] theorem pairwise_append {l₁ l₂ : List α} :
+theorem pairwise_append {l₁ l₂ : List α} :
     (l₁ ++ l₂).Pairwise R ↔ l₁.Pairwise R ∧ l₂.Pairwise R ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b := by
   induction l₁ <;> simp [*, or_imp, forall_and, and_assoc, and_left_comm]
 
@@ -157,13 +157,13 @@ theorem pairwise_append_comm {R : α → α → Prop} (s : ∀ {x y}, R x y →
     (x : α) (xm : x ∈ l₂) (y : α) (ym : y ∈ l₁) : R x y := s (H y ym x xm)
   simp only [pairwise_append, and_left_comm]; rw [Iff.intro (this l₁ l₂) (this l₂ l₁)]
 
-@[grind =] theorem pairwise_middle {R : α → α → Prop} (s : ∀ {x y}, R x y → R y x) {a : α} {l₁ l₂ : List α} :
+theorem pairwise_middle {R : α → α → Prop} (s : ∀ {x y}, R x y → R y x) {a : α} {l₁ l₂ : List α} :
     Pairwise R (l₁ ++ a :: l₂) ↔ Pairwise R (a :: (l₁ ++ l₂)) := by
   show Pairwise R (l₁ ++ ([a] ++ l₂)) ↔ Pairwise R ([a] ++ l₁ ++ l₂)
   rw [← append_assoc, pairwise_append, @pairwise_append _ _ ([a] ++ l₁), pairwise_append_comm s]
   simp only [mem_append, or_comm]
 
-@[grind =] theorem pairwise_flatten {L : List (List α)} :
+theorem pairwise_flatten {L : List (List α)} :
     Pairwise R (flatten L) ↔
       (∀ l ∈ L, Pairwise R l) ∧ Pairwise (fun l₁ l₂ => ∀ x ∈ l₁, ∀ y ∈ l₂, R x y) L := by
   induction L with
@@ -174,16 +174,16 @@ theorem pairwise_append_comm {R : α → α → Prop} (s : ∀ {x y}, R x y →
     rw [and_comm, and_congr_left_iff]
     intros; exact ⟨fun h l' b c d e => h c d e l' b, fun h c d e l' b => h l' b c d e⟩
 
-@[grind =] theorem pairwise_flatMap {R : β → β → Prop} {l : List α} {f : α → List β} :
+theorem pairwise_flatMap {R : β → β → Prop} {l : List α} {f : α → List β} :
     List.Pairwise R (l.flatMap f) ↔
       (∀ a ∈ l, Pairwise R (f a)) ∧ Pairwise (fun a₁ a₂ => ∀ x ∈ f a₁, ∀ y ∈ f a₂, R x y) l := by
   simp [List.flatMap, pairwise_flatten, pairwise_map]
 
-@[grind =] theorem pairwise_reverse {l : List α} :
+theorem pairwise_reverse {l : List α} :
     l.reverse.Pairwise R ↔ l.Pairwise (fun a b => R b a) := by
   induction l <;> simp [*, pairwise_append, and_comm]
 
-@[simp, grind =] theorem pairwise_replicate {n : Nat} {a : α} :
+@[simp] theorem pairwise_replicate {n : Nat} {a : α} :
     (replicate n a).Pairwise R ↔ n ≤ 1 ∨ R a a := by
   induction n with
   | zero => simp
@@ -205,13 +205,12 @@ theorem pairwise_append_comm {R : α → α → Prop} (s : ∀ {x y}, R x y →
         simp
       · exact ⟨fun _ => h, Or.inr h⟩
 
-@[grind] theorem Pairwise.drop {l : List α} {i : Nat} (h : List.Pairwise R l) : List.Pairwise R (l.drop i) :=
+theorem Pairwise.drop {l : List α} {i : Nat} (h : List.Pairwise R l) : List.Pairwise R (l.drop i) :=
   h.sublist (drop_sublist _ _)
 
-@[grind] theorem Pairwise.take {l : List α} {i : Nat} (h : List.Pairwise R l) : List.Pairwise R (l.take i) :=
+theorem Pairwise.take {l : List α} {i : Nat} (h : List.Pairwise R l) : List.Pairwise R (l.take i) :=
   h.sublist (take_sublist _ _)
 
-@[grind =]
 theorem pairwise_iff_forall_sublist : l.Pairwise R ↔ (∀ {a b}, [a,b] <+ l → R a b) := by
   induction l with
   | nil => simp
@@ -248,7 +247,7 @@ theorem pairwise_of_forall_mem_list {l : List α} {r : α → α → Prop} (h :
   intro a b hab
   apply h <;> (apply hab.subset; simp)
 
-@[grind =] theorem pairwise_pmap {p : β → Prop} {f : ∀ b, p b → α} {l : List β} (h : ∀ x ∈ l, p x) :
+theorem pairwise_pmap {p : β → Prop} {f : ∀ b, p b → α} {l : List β} (h : ∀ x ∈ l, p x) :
     Pairwise R (l.pmap f h) ↔
       Pairwise (fun b₁ b₂ => ∀ (h₁ : p b₁) (h₂ : p b₂), R (f b₁ h₁) (f b₂ h₂)) l := by
   induction l with
@@ -260,7 +259,7 @@ theorem pairwise_of_forall_mem_list {l : List α} {r : α → α → Prop} (h :
     rintro H _ b hb rfl
     exact H b hb _ _
 
-@[grind] theorem Pairwise.pmap {l : List α} (hl : Pairwise R l) {p : α → Prop} {f : ∀ a, p a → β}
+theorem Pairwise.pmap {l : List α} (hl : Pairwise R l) {p : α → Prop} {f : ∀ a, p a → β}
     (h : ∀ x ∈ l, p x) {S : β → β → Prop}
     (hS : ∀ ⦃x⦄ (hx : p x) ⦃y⦄ (hy : p y), R x y → S (f x hx) (f y hy)) :
     Pairwise S (l.pmap f h) := by
@@ -269,22 +268,17 @@ theorem pairwise_of_forall_mem_list {l : List α} {r : α → α → Prop} (h :
 
 /-! ### Nodup -/
 
-@[grind =] theorem nodup_iff_pairwise_ne : List.Nodup l ↔ List.Pairwise (· ≠ ·) l := Iff.rfl
-
-@[simp, grind]
+@[simp]
 theorem nodup_nil : @Nodup α [] :=
   Pairwise.nil
 
-@[simp, grind =]
+@[simp]
 theorem nodup_cons {a : α} {l : List α} : Nodup (a :: l) ↔ a ∉ l ∧ Nodup l := by
   simp only [Nodup, pairwise_cons, forall_mem_ne]
 
 theorem Nodup.sublist : l₁ <+ l₂ → Nodup l₂ → Nodup l₁ :=
   Pairwise.sublist
 
-grind_pattern Nodup.sublist => l₁ <+ l₂, Nodup l₁
-grind_pattern Nodup.sublist => l₁ <+ l₂, Nodup l₂
-
 theorem Sublist.nodup : l₁ <+ l₂ → Nodup l₂ → Nodup l₁ :=
   Nodup.sublist
 
@@ -309,7 +303,7 @@ theorem getElem?_inj {xs : List α}
       rw [mem_iff_getElem?]
     exact ⟨_, h₂⟩; exact ⟨_ , h₂.symm⟩
 
-@[simp, grind =] theorem nodup_replicate {n : Nat} {a : α} :
+@[simp] theorem nodup_replicate {n : Nat} {a : α} :
     (replicate n a).Nodup ↔ n ≤ 1 := by simp [Nodup]
 
 end List

src/Init/Data/List/Range.lean

@@ -142,8 +142,6 @@ theorem range'_eq_cons_iff : range' s n = a :: xs ↔ s = a ∧ 0 < n ∧ xs = r
 
 /-! ### range -/
 
-@[simp, grind =] theorem range_one : range 1 = [0] := rfl
-
 theorem range_loop_range' : ∀ s n, range.loop s (range' s n) = range' 0 (n + s)
   | 0, _ => rfl
   | s + 1, n => by rw [← Nat.add_assoc, Nat.add_right_comm n s 1]; exact range_loop_range' s (n + 1)

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

@@ -153,12 +153,12 @@ where
     mergeTR (run' r) (run l) le
 
 theorem splitRevInTwo'_fst (l : { l : List α // l.length = n }) :
-    (splitRevInTwo' l).1 = ⟨(splitInTwo (n := n) ⟨l.1.reverse, by simpa using l.2⟩).2.1, by simp; omega⟩ := by
+    (splitRevInTwo' l).1 = ⟨(splitInTwo ⟨l.1.reverse, by simpa using l.2⟩).2.1, by simp; omega⟩ := by
   simp only [splitRevInTwo', splitRevAt_eq, reverse_take, splitInTwo_snd]
   congr
   omega
 theorem splitRevInTwo'_snd (l : { l : List α // l.length = n }) :
-    (splitRevInTwo' l).2 = ⟨(splitInTwo (n := n) ⟨l.1.reverse, by simpa using l.2⟩).1.1.reverse, by simp; omega⟩ := by
+    (splitRevInTwo' l).2 = ⟨(splitInTwo ⟨l.1.reverse, by simpa using l.2⟩).1.1.reverse, by simp; omega⟩ := by
   simp only [splitRevInTwo', splitRevAt_eq, reverse_take, splitInTwo_fst, reverse_reverse]
   congr 2
   simp

src/Init/Data/List/Sublist.lean

@@ -24,14 +24,14 @@ open Nat
 section isPrefixOf
 variable [BEq α]
 
-@[simp, grind =] theorem isPrefixOf_cons₂_self [LawfulBEq α] {a : α} :
+@[simp] theorem isPrefixOf_cons₂_self [LawfulBEq α] {a : α} :
     isPrefixOf (a::as) (a::bs) = isPrefixOf as bs := by simp [isPrefixOf_cons₂]
 
 @[simp] theorem isPrefixOf_length_pos_nil {l : List α} (h : 0 < l.length) : isPrefixOf l [] = false := by
   cases l <;> simp_all [isPrefixOf]
 
-@[simp, grind =] theorem isPrefixOf_replicate {a : α} :
-    isPrefixOf l (replicate n a) = ((l.length ≤ n) && l.all (· == a)) := by
+@[simp] theorem isPrefixOf_replicate {a : α} :
+    isPrefixOf l (replicate n a) = (decide (l.length ≤ n) && l.all (· == a)) := by
   induction l generalizing n with
   | nil => simp
   | cons _ _ ih =>
@@ -45,10 +45,10 @@ end isPrefixOf
 section isSuffixOf
 variable [BEq α]
 
-@[simp, grind =] theorem isSuffixOf_cons_nil : isSuffixOf (a::as) ([] : List α) = false := by
+@[simp] theorem isSuffixOf_cons_nil : isSuffixOf (a::as) ([] : List α) = false := by
   simp [isSuffixOf]
 
-@[simp, grind =] theorem isSuffixOf_replicate {a : α} :
+@[simp] theorem isSuffixOf_replicate {a : α} :
     isSuffixOf l (replicate n a) = (decide (l.length ≤ n) && l.all (· == a)) := by
   simp [isSuffixOf, all_eq]
 
@@ -58,8 +58,7 @@ end isSuffixOf
 
 /-! ### List subset -/
 
--- For now we don't annotate lemmas about `Subset` for `grind`, but instead just unfold the definition.
-@[grind =] theorem subset_def {l₁ l₂ : List α} : l₁ ⊆ l₂ ↔ ∀ {a : α}, a ∈ l₁ → a ∈ l₂ := .rfl
+theorem subset_def {l₁ l₂ : List α} : l₁ ⊆ l₂ ↔ ∀ {a : α}, a ∈ l₁ → a ∈ l₂ := .rfl
 
 @[simp] theorem nil_subset (l : List α) : [] ⊆ l := nofun
 
@@ -96,15 +95,9 @@ theorem eq_nil_of_subset_nil {l : List α} : l ⊆ [] → l = [] := subset_nil.m
 theorem map_subset {l₁ l₂ : List α} (f : α → β) (h : l₁ ⊆ l₂) : map f l₁ ⊆ map f l₂ :=
   fun x => by simp only [mem_map]; exact .imp fun a => .imp_left (@h _)
 
-grind_pattern map_subset => l₁ ⊆ l₂, map f l₁
-grind_pattern map_subset => l₁ ⊆ l₂, map f l₂
-
 theorem filter_subset {l₁ l₂ : List α} (p : α → Bool) (H : l₁ ⊆ l₂) : filter p l₁ ⊆ filter p l₂ :=
   fun x => by simp_all [mem_filter, subset_def.1 H]
 
-grind_pattern filter_subset => l₁ ⊆ l₂, filter p l₁
-grind_pattern filter_subset => l₁ ⊆ l₂, filter p l₂
-
 theorem filterMap_subset {l₁ l₂ : List α} (f : α → Option β) (H : l₁ ⊆ l₂) :
     filterMap f l₁ ⊆ filterMap f l₂ := by
   intro x
@@ -112,9 +105,6 @@ theorem filterMap_subset {l₁ l₂ : List α} (f : α → Option β) (H : l₁
   rintro ⟨a, h, w⟩
   exact ⟨a, H h, w⟩
 
-grind_pattern filterMap_subset => l₁ ⊆ l₂, filterMap f l₁
-grind_pattern filterMap_subset => l₁ ⊆ l₂, filterMap f l₂
-
 theorem subset_append_left (l₁ l₂ : List α) : l₁ ⊆ l₁ ++ l₂ := fun _ => mem_append_left _
 
 theorem subset_append_right (l₁ l₂ : List α) : l₂ ⊆ l₁ ++ l₂ := fun _ => mem_append_right _
@@ -149,11 +139,11 @@ theorem subset_replicate {n : Nat} {a : α} {l : List α} (h : n ≠ 0) : l ⊆
 
 /-! ### Sublist and isSublist -/
 
-@[simp, grind] theorem nil_sublist : ∀ l : List α, [] <+ l
+@[simp] theorem nil_sublist : ∀ l : List α, [] <+ l
   | [] => .slnil
   | a :: l => (nil_sublist l).cons a
 
-@[simp, grind] theorem Sublist.refl : ∀ l : List α, l <+ l
+@[simp] theorem Sublist.refl : ∀ l : List α, l <+ l
   | [] => .slnil
   | a :: l => (Sublist.refl l).cons₂ a
 
@@ -170,14 +160,14 @@ theorem Sublist.trans {l₁ l₂ l₃ : List α} (h₁ : l₁ <+ l₂) (h₂ : l
 
 instance : Trans (@Sublist α) Sublist Sublist := ⟨Sublist.trans⟩
 
-attribute [simp, grind] Sublist.cons
+attribute [simp] Sublist.cons
 
 theorem sublist_cons_self (a : α) (l : List α) : l <+ a :: l := (Sublist.refl l).cons _
 
 theorem sublist_of_cons_sublist : a :: l₁ <+ l₂ → l₁ <+ l₂ :=
   (sublist_cons_self a l₁).trans
 
-@[simp, grind =]
+@[simp]
 theorem cons_sublist_cons : a :: l₁ <+ a :: l₂ ↔ l₁ <+ l₂ :=
   ⟨fun | .cons _ s => sublist_of_cons_sublist s | .cons₂ _ s => s, .cons₂ _⟩
 
@@ -191,7 +181,7 @@ theorem sublist_or_mem_of_sublist (h : l <+ l₁ ++ a :: l₂) : l <+ l₁ ++ l
     | .cons _ h => exact (IH h).imp_left (Sublist.cons _)
     | .cons₂ _ h => exact (IH h).imp (Sublist.cons₂ _) (.tail _)
 
-@[grind →] theorem Sublist.subset : l₁ <+ l₂ → l₁ ⊆ l₂
+theorem Sublist.subset : l₁ <+ l₂ → l₁ ⊆ l₂
   | .slnil, _, h => h
   | .cons _ s, _, h => .tail _ (s.subset h)
   | .cons₂ .., _, .head .. => .head ..
@@ -200,10 +190,10 @@ theorem sublist_or_mem_of_sublist (h : l <+ l₁ ++ a :: l₂) : l <+ l₁ ++ l
 protected theorem Sublist.mem (hx : a ∈ l₁) (hl : l₁ <+ l₂) : a ∈ l₂ :=
   hl.subset hx
 
-@[grind] theorem Sublist.head_mem (s : ys <+ xs) (h) : ys.head h ∈ xs :=
+theorem Sublist.head_mem (s : ys <+ xs) (h) : ys.head h ∈ xs :=
   s.mem (List.head_mem h)
 
-@[grind] theorem Sublist.getLast_mem (s : ys <+ xs) (h) : ys.getLast h ∈ xs :=
+theorem Sublist.getLast_mem (s : ys <+ xs) (h) : ys.getLast h ∈ xs :=
   s.mem (List.getLast_mem h)
 
 instance : Trans (@Sublist α) Subset Subset :=
@@ -218,7 +208,7 @@ instance : Trans (fun l₁ l₂ => Sublist l₂ l₁) (Membership.mem : List α
 theorem mem_of_cons_sublist {a : α} {l₁ l₂ : List α} (s : a :: l₁ <+ l₂) : a ∈ l₂ :=
   (cons_subset.1 s.subset).1
 
-@[simp, grind =] theorem sublist_nil {l : List α} : l <+ [] ↔ l = [] :=
+@[simp] theorem sublist_nil {l : List α} : l <+ [] ↔ l = [] :=
   ⟨fun s => subset_nil.1 s.subset, fun H => H ▸ Sublist.refl _⟩
 
 theorem eq_nil_of_sublist_nil {l : List α} (s : l <+ []) : l = [] :=
@@ -229,39 +219,29 @@ theorem Sublist.length_le : l₁ <+ l₂ → length l₁ ≤ length l₂
   | .cons _l s => le_succ_of_le (length_le s)
   | .cons₂ _ s => succ_le_succ (length_le s)
 
-grind_pattern Sublist.length_le => l₁ <+ l₂, length l₁
-grind_pattern Sublist.length_le => l₁ <+ l₂, length l₂
-
 theorem Sublist.eq_of_length : l₁ <+ l₂ → length l₁ = length l₂ → l₁ = l₂
   | .slnil, _ => rfl
   | .cons a s, h => nomatch Nat.not_lt.2 s.length_le (h ▸ lt_succ_self _)
   | .cons₂ a s, h => by rw [s.eq_of_length (succ.inj h)]
 
--- Only activative `eq_of_length` if we're already thinking about lengths.
-grind_pattern Sublist.eq_of_length => l₁ <+ l₂, length l₁, length l₂
-
 theorem Sublist.eq_of_length_le (s : l₁ <+ l₂) (h : length l₂ ≤ length l₁) : l₁ = l₂ :=
   s.eq_of_length <| Nat.le_antisymm s.length_le h
 
 theorem Sublist.length_eq (s : l₁ <+ l₂) : length l₁ = length l₂ ↔ l₁ = l₂ :=
   ⟨s.eq_of_length, congrArg _⟩
 
-@[grind]
 theorem tail_sublist : ∀ l : List α, tail l <+ l
   | [] => .slnil
   | a::l => sublist_cons_self a l
 
-@[grind]
 protected theorem Sublist.tail : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → tail l₁ <+ tail l₂
   | _, _, slnil => .slnil
   | _, _, Sublist.cons _ h => (tail_sublist _).trans h
   | _, _, Sublist.cons₂ _ h => h
 
-@[grind →]
 theorem Sublist.of_cons_cons {l₁ l₂ : List α} {a b : α} (h : a :: l₁ <+ b :: l₂) : l₁ <+ l₂ :=
   h.tail
 
-@[grind]
 protected theorem Sublist.map (f : α → β) {l₁ l₂} (s : l₁ <+ l₂) : map f l₁ <+ map f l₂ := by
   induction s with
   | slnil => simp
@@ -270,31 +250,19 @@ protected theorem Sublist.map (f : α → β) {l₁ l₂} (s : l₁ <+ l₂) : m
   | cons₂ a s ih =>
     simpa using cons₂ (f a) ih
 
-grind_pattern Sublist.map => l₁ <+ l₂, map f l₁
-grind_pattern Sublist.map => l₁ <+ l₂, map f l₂
-
-@[grind]
 protected theorem Sublist.filterMap (f : α → Option β) (s : l₁ <+ l₂) :
     filterMap f l₁ <+ filterMap f l₂ := by
   induction s <;> simp [filterMap_cons] <;> split <;> simp [*, cons, cons₂]
 
-grind_pattern Sublist.filterMap => l₁ <+ l₂, filterMap f l₁
-grind_pattern Sublist.filterMap => l₁ <+ l₂, filterMap f l₂
-
-@[grind]
 protected theorem Sublist.filter (p : α → Bool) {l₁ l₂} (s : l₁ <+ l₂) : filter p l₁ <+ filter p l₂ := by
   rw [← filterMap_eq_filter]; apply s.filterMap
 
-grind_pattern Sublist.filter => l₁ <+ l₂, l₁.filter p
-grind_pattern Sublist.filter => l₁ <+ l₂, l₂.filter p
-
 theorem head_filter_mem (xs : List α) (p : α → Bool) (h) : (xs.filter p).head h ∈ xs :=
   filter_sublist.head_mem h
 
 theorem getLast_filter_mem (xs : List α) (p : α → Bool) (h) : (xs.filter p).getLast h ∈ xs :=
   filter_sublist.getLast_mem h
 
-@[grind =]
 theorem sublist_filterMap_iff {l₁ : List β} {f : α → Option β} :
     l₁ <+ l₂.filterMap f ↔ ∃ l', l' <+ l₂ ∧ l₁ = l'.filterMap f := by
   induction l₂ generalizing l₁ with
@@ -329,12 +297,10 @@ theorem sublist_filterMap_iff {l₁ : List β} {f : α → Option β} :
         rwa [filterMap_cons_some] at h
         assumption
 
-@[grind =]
 theorem sublist_map_iff {l₁ : List β} {f : α → β} :
     l₁ <+ l₂.map f ↔ ∃ l', l' <+ l₂ ∧ l₁ = l'.map f := by
   simp only [← filterMap_eq_map, sublist_filterMap_iff]
 
-@[grind =]
 theorem sublist_filter_iff {l₁ : List α} {p : α → Bool} :
     l₁ <+ l₂.filter p ↔ ∃ l', l' <+ l₂ ∧ l₁ = l'.filter p := by
   simp only [← filterMap_eq_filter, sublist_filterMap_iff]
@@ -343,15 +309,11 @@ theorem sublist_append_left : ∀ l₁ l₂ : List α, l₁ <+ l₁ ++ l₂
   | [], _ => nil_sublist _
   | _ :: l₁, l₂ => (sublist_append_left l₁ l₂).cons₂ _
 
-grind_pattern sublist_append_left => Sublist, l₁ ++ l₂
-
 theorem sublist_append_right : ∀ l₁ l₂ : List α, l₂ <+ l₁ ++ l₂
   | [], _ => Sublist.refl _
   | _ :: l₁, l₂ => (sublist_append_right l₁ l₂).cons _
 
-grind_pattern sublist_append_right => Sublist, l₁ ++ l₂
-
-@[simp, grind =] theorem singleton_sublist {a : α} {l} : [a] <+ l ↔ a ∈ l := by
+@[simp] theorem singleton_sublist {a : α} {l} : [a] <+ l ↔ a ∈ l := by
   refine ⟨fun h => h.subset (mem_singleton_self _), fun h => ?_⟩
   obtain ⟨_, _, rfl⟩ := append_of_mem h
   exact ((nil_sublist _).cons₂ _).trans (sublist_append_right ..)
@@ -359,14 +321,10 @@ grind_pattern sublist_append_right => Sublist, l₁ ++ l₂
 @[simp] theorem sublist_append_of_sublist_left (s : l <+ l₁) : l <+ l₁ ++ l₂ :=
   s.trans <| sublist_append_left ..
 
-grind_pattern sublist_append_of_sublist_left => l <+ l₁, l₁ ++ l₂
-
 @[simp] theorem sublist_append_of_sublist_right (s : l <+ l₂) : l <+ l₁ ++ l₂ :=
   s.trans <| sublist_append_right ..
 
-grind_pattern sublist_append_of_sublist_right => l <+ l₂, l₁ ++ l₂
-
-@[simp, grind =] theorem append_sublist_append_left : ∀ l, l ++ l₁ <+ l ++ l₂ ↔ l₁ <+ l₂
+@[simp] theorem append_sublist_append_left : ∀ l, l ++ l₁ <+ l ++ l₂ ↔ l₁ <+ l₂
   | [] => Iff.rfl
   | _ :: l => cons_sublist_cons.trans (append_sublist_append_left l)
 
@@ -381,9 +339,6 @@ theorem Sublist.append_right : l₁ <+ l₂ → ∀ l, l₁ ++ l <+ l₂ ++ l
 theorem Sublist.append (hl : l₁ <+ l₂) (hr : r₁ <+ r₂) : l₁ ++ r₁ <+ l₂ ++ r₂ :=
   (hl.append_right _).trans ((append_sublist_append_left _).2 hr)
 
-grind_pattern Sublist.append => l₁ <+ l₂, r₁ <+ r₂, l₁ ++ r₁, l₂ ++ r₂
-
-@[grind =]
 theorem sublist_cons_iff {a : α} {l l'} :
     l <+ a :: l' ↔ l <+ l' ∨ ∃ r, l = a :: r ∧ r <+ l' := by
   constructor
@@ -395,7 +350,6 @@ theorem sublist_cons_iff {a : α} {l l'} :
     · exact h.cons _
     · exact h.cons₂ _
 
-@[grind =]
 theorem cons_sublist_iff {a : α} {l l'} :
     a :: l <+ l' ↔ ∃ r₁ r₂, l' = r₁ ++ r₂ ∧ a ∈ r₁ ∧ l <+ r₂ := by
   induction l' with
@@ -479,7 +433,6 @@ theorem Sublist.of_sublist_append_right (w : ∀ a, a ∈ l → a ∉ l₁) (h :
     exact fun x m => w x (mem_append_left l₂' m) (h₁.mem m)
   simp_all
 
-@[grind]
 theorem Sublist.middle {l : List α} (h : l <+ l₁ ++ l₂) (a : α) : l <+ l₁ ++ a :: l₂ := by
   rw [sublist_append_iff] at h
   obtain ⟨l₁', l₂', rfl, h₁, h₂⟩ := h
@@ -490,14 +443,13 @@ theorem Sublist.reverse : l₁ <+ l₂ → l₁.reverse <+ l₂.reverse
   | .cons _ h => by rw [reverse_cons]; exact sublist_append_of_sublist_left h.reverse
   | .cons₂ _ h => by rw [reverse_cons, reverse_cons]; exact h.reverse.append_right _
 
-@[simp, grind =] theorem reverse_sublist : l₁.reverse <+ l₂.reverse ↔ l₁ <+ l₂ :=
+@[simp] theorem reverse_sublist : l₁.reverse <+ l₂.reverse ↔ l₁ <+ l₂ :=
   ⟨fun h => l₁.reverse_reverse ▸ l₂.reverse_reverse ▸ h.reverse, Sublist.reverse⟩
 
-@[grind _=_]
 theorem sublist_reverse_iff : l₁ <+ l₂.reverse ↔ l₁.reverse <+ l₂ :=
   by rw [← reverse_sublist, reverse_reverse]
 
-@[simp, grind =] theorem append_sublist_append_right (l) : l₁ ++ l <+ l₂ ++ l ↔ l₁ <+ l₂ :=
+@[simp] theorem append_sublist_append_right (l) : l₁ ++ l <+ l₂ ++ l ↔ l₁ <+ l₂ :=
   ⟨fun h => by
     have := h.reverse
     simp only [reverse_append, append_sublist_append_left, reverse_sublist] at this
@@ -512,7 +464,6 @@ theorem sublist_reverse_iff : l₁ <+ l₂.reverse ↔ l₁.reverse <+ l₂ :=
     | refl => apply Sublist.refl
     | step => simp [*, replicate, Sublist.cons]
 
-@[grind =]
 theorem sublist_replicate_iff : l <+ replicate m a ↔ ∃ n, n ≤ m ∧ l = replicate n a := by
   induction l generalizing m with
   | nil =>
@@ -600,7 +551,7 @@ theorem flatten_sublist_iff {L : List (List α)} {l} :
         exact ⟨l₁, L'.flatten, by simp, by simpa using h 0 (by simp), L', rfl,
           fun i lt => by simpa using h (i+1) (Nat.add_lt_add_right lt 1)⟩
 
-@[simp, grind =] theorem isSublist_iff_sublist [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
+@[simp] theorem isSublist_iff_sublist [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
     l₁.isSublist l₂ ↔ l₁ <+ l₂ := by
   cases l₁ <;> cases l₂ <;> simp [isSublist]
   case cons.cons hd₁ tl₁ hd₂ tl₂ =>
@@ -622,49 +573,41 @@ theorem flatten_sublist_iff {L : List (List α)} {l} :
 instance [DecidableEq α] (l₁ l₂ : List α) : Decidable (l₁ <+ l₂) :=
   decidable_of_iff (l₁.isSublist l₂) isSublist_iff_sublist
 
-@[grind]
 protected theorem Sublist.drop : ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → ∀ i, l₁.drop i <+ l₂.drop i
   | _, _, h, 0 => h
   | _, _, h, i + 1 => by rw [← drop_tail, ← drop_tail]; exact h.tail.drop i
 
 /-! ### IsPrefix / IsSuffix / IsInfix -/
 
-@[simp, grind] theorem prefix_append (l₁ l₂ : List α) : l₁ <+: l₁ ++ l₂ := ⟨l₂, rfl⟩
+@[simp] theorem prefix_append (l₁ l₂ : List α) : l₁ <+: l₁ ++ l₂ := ⟨l₂, rfl⟩
 
-@[simp, grind] theorem suffix_append (l₁ l₂ : List α) : l₂ <:+ l₁ ++ l₂ := ⟨l₁, rfl⟩
+@[simp] theorem suffix_append (l₁ l₂ : List α) : l₂ <:+ l₁ ++ l₂ := ⟨l₁, rfl⟩
 
 theorem infix_append (l₁ l₂ l₃ : List α) : l₂ <:+: l₁ ++ l₂ ++ l₃ := ⟨l₁, l₃, rfl⟩
 
-@[simp, grind] theorem infix_append' (l₁ l₂ l₃ : List α) : l₂ <:+: l₁ ++ (l₂ ++ l₃) := by
+@[simp] theorem infix_append' (l₁ l₂ l₃ : List α) : l₂ <:+: l₁ ++ (l₂ ++ l₃) := by
   rw [← List.append_assoc]; apply infix_append
 
-theorem infix_append_left : l₁ <:+: l₁ ++ l₂ := ⟨[], l₂, rfl⟩
-theorem infix_append_right : l₂ <:+: l₁ ++ l₂ := ⟨l₁, [], by simp⟩
-
 theorem IsPrefix.isInfix : l₁ <+: l₂ → l₁ <:+: l₂ := fun ⟨t, h⟩ => ⟨[], t, h⟩
 
-grind_pattern IsPrefix.isInfix => l₁ <+: l₂, IsInfix
-
 theorem IsSuffix.isInfix : l₁ <:+ l₂ → l₁ <:+: l₂ := fun ⟨t, h⟩ => ⟨t, [], by rw [h, append_nil]⟩
 
-grind_pattern IsSuffix.isInfix => l₁ <:+ l₂, IsInfix
+@[simp] theorem nil_prefix {l : List α} : [] <+: l := ⟨l, rfl⟩
 
-@[simp, grind] theorem nil_prefix {l : List α} : [] <+: l := ⟨l, rfl⟩
+@[simp] theorem nil_suffix {l : List α} : [] <:+ l := ⟨l, append_nil _⟩
 
-@[simp, grind] theorem nil_suffix {l : List α} : [] <:+ l := ⟨l, append_nil _⟩
-
-@[simp, grind] theorem nil_infix {l : List α} : [] <:+: l := nil_prefix.isInfix
+@[simp] theorem nil_infix {l : List α} : [] <:+: l := nil_prefix.isInfix
 
 theorem prefix_refl (l : List α) : l <+: l := ⟨[], append_nil _⟩
-@[simp, grind] theorem prefix_rfl {l : List α} : l <+: l := prefix_refl l
+@[simp] theorem prefix_rfl {l : List α} : l <+: l := prefix_refl l
 
 theorem suffix_refl (l : List α) : l <:+ l := ⟨[], rfl⟩
-@[simp, grind] theorem suffix_rfl {l : List α} : l <:+ l := suffix_refl l
+@[simp] theorem suffix_rfl {l : List α} : l <:+ l := suffix_refl l
 
 theorem infix_refl (l : List α) : l <:+: l := prefix_rfl.isInfix
-@[simp, grind] theorem infix_rfl {l : List α} : l <:+: l := infix_refl l
+@[simp] theorem infix_rfl {l : List α} : l <:+: l := infix_refl l
 
-@[simp, grind] theorem suffix_cons (a : α) : ∀ l, l <:+ a :: l := suffix_append [a]
+@[simp] theorem suffix_cons (a : α) : ∀ l, l <:+ a :: l := suffix_append [a]
 
 theorem infix_cons : l₁ <:+: l₂ → l₁ <:+: a :: l₂ := fun ⟨l₁', l₂', h⟩ => ⟨a :: l₁', l₂', h ▸ rfl⟩
 
@@ -674,38 +617,12 @@ theorem infix_concat : l₁ <:+: l₂ → l₁ <:+: concat l₂ a := fun ⟨l₁
 theorem IsPrefix.trans : ∀ {l₁ l₂ l₃ : List α}, l₁ <+: l₂ → l₂ <+: l₃ → l₁ <+: l₃
   | _, _, _, ⟨r₁, rfl⟩, ⟨r₂, rfl⟩ => ⟨r₁ ++ r₂, (append_assoc _ _ _).symm⟩
 
-grind_pattern IsPrefix.trans => l₁ <+: l₂, l₂ <+: l₃
-
 theorem IsSuffix.trans : ∀ {l₁ l₂ l₃ : List α}, l₁ <:+ l₂ → l₂ <:+ l₃ → l₁ <:+ l₃
   | _, _, _, ⟨l₁, rfl⟩, ⟨l₂, rfl⟩ => ⟨l₂ ++ l₁, append_assoc _ _ _⟩
 
-grind_pattern IsSuffix.trans => l₁ <:+ l₂, l₂ <:+ l₃
-
 theorem IsInfix.trans : ∀ {l₁ l₂ l₃ : List α}, l₁ <:+: l₂ → l₂ <:+: l₃ → l₁ <:+: l₃
   | l, _, _, ⟨l₁, r₁, rfl⟩, ⟨l₂, r₂, rfl⟩ => ⟨l₂ ++ l₁, r₁ ++ r₂, by simp only [append_assoc]⟩
 
-grind_pattern IsInfix.trans => l₁ <:+: l₂, l₂ <:+: l₃
-
-theorem prefix_append_of_prefix (h : l₁ <+: l₂) : l₁ <+: l₂ ++ l₃ :=
-  h.trans (prefix_append l₂ l₃)
-
-grind_pattern prefix_append_of_prefix => l₁ <+: l₂, l₂ ++ l₃
-
-theorem suffix_append_of_suffix (h : l₁ <:+ l₃) : l₁ <:+ l₂ ++ l₃ :=
-  h.trans (suffix_append l₂ l₃)
-
-grind_pattern suffix_append_of_suffix => l₁ <:+ l₃, l₂ ++ l₃
-
-theorem infix_append_of_infix_left (h : l₁ <:+: l₂) : l₁ <:+: l₂ ++ l₃ :=
-  h.trans infix_append_left
-
-grind_pattern infix_append_of_infix_left => l₁ <:+: l₂, l₂ ++ l₃
-
-theorem infix_append_of_infix_right (h : l₁ <:+: l₃) : l₁ <:+: l₂ ++ l₃ :=
-  h.trans infix_append_right
-
-grind_pattern infix_append_of_infix_right => l₁ <:+: l₃, l₂ ++ l₃
-
 protected theorem IsInfix.sublist : l₁ <:+: l₂ → l₁ <+ l₂
   | ⟨_, _, h⟩ => h ▸ (sublist_append_right ..).trans (sublist_append_left ..)
 
@@ -724,11 +641,11 @@ protected theorem IsSuffix.sublist (h : l₁ <:+ l₂) : l₁ <+ l₂ :=
 protected theorem IsSuffix.subset (hl : l₁ <:+ l₂) : l₁ ⊆ l₂ :=
   hl.sublist.subset
 
-@[simp, grind =] theorem infix_nil : l <:+: [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ infix_rfl)⟩
+@[simp] theorem infix_nil : l <:+: [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ infix_rfl)⟩
 
-@[simp, grind =] theorem prefix_nil : l <+: [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ prefix_rfl)⟩
+@[simp] theorem prefix_nil : l <+: [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ prefix_rfl)⟩
 
-@[simp, grind =] theorem suffix_nil : l <:+ [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ suffix_rfl)⟩
+@[simp] theorem suffix_nil : l <:+ [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ suffix_rfl)⟩
 
 theorem eq_nil_of_infix_nil (h : l <:+: []) : l = [] := infix_nil.mp h
 theorem eq_nil_of_prefix_nil (h : l <+: []) : l = [] := prefix_nil.mp h
@@ -746,21 +663,12 @@ theorem IsInfix.ne_nil {xs ys : List α} (h : xs <:+: ys) (hx : xs ≠ []) : ys
 theorem IsInfix.length_le (h : l₁ <:+: l₂) : l₁.length ≤ l₂.length :=
   h.sublist.length_le
 
-grind_pattern IsInfix.length_le => l₁ <:+: l₂, l₁.length
-grind_pattern IsInfix.length_le => l₁ <:+: l₂, l₂.length
-
 theorem IsPrefix.length_le (h : l₁ <+: l₂) : l₁.length ≤ l₂.length :=
   h.sublist.length_le
 
-grind_pattern IsPrefix.length_le => l₁ <+: l₂, l₁.length
-grind_pattern IsPrefix.length_le => l₁ <+: l₂, l₂.length
-
 theorem IsSuffix.length_le (h : l₁ <:+ l₂) : l₁.length ≤ l₂.length :=
   h.sublist.length_le
 
-grind_pattern IsSuffix.length_le => l₁ <:+ l₂, l₁.length
-grind_pattern IsSuffix.length_le => l₁ <:+ l₂, l₂.length
-
 theorem IsPrefix.getElem {xs ys : List α} (h : xs <+: ys) {i} (hi : i < xs.length) :
     xs[i] = ys[i]'(Nat.le_trans hi h.length_le) := by
   obtain ⟨_, rfl⟩ := h
@@ -768,23 +676,23 @@ theorem IsPrefix.getElem {xs ys : List α} (h : xs <+: ys) {i} (hi : i < xs.leng
 
 -- See `Init.Data.List.Nat.Sublist` for `IsSuffix.getElem`.
 
-@[grind →] theorem IsPrefix.mem (hx : a ∈ l₁) (hl : l₁ <+: l₂) : a ∈ l₂ :=
+theorem IsPrefix.mem (hx : a ∈ l₁) (hl : l₁ <+: l₂) : a ∈ l₂ :=
   hl.subset hx
 
-@[grind →] theorem IsSuffix.mem (hx : a ∈ l₁) (hl : l₁ <:+ l₂) : a ∈ l₂ :=
+theorem IsSuffix.mem (hx : a ∈ l₁) (hl : l₁ <:+ l₂) : a ∈ l₂ :=
   hl.subset hx
 
-@[grind →] theorem IsInfix.mem (hx : a ∈ l₁) (hl : l₁ <:+: l₂) : a ∈ l₂ :=
+theorem IsInfix.mem (hx : a ∈ l₁) (hl : l₁ <:+: l₂) : a ∈ l₂ :=
   hl.subset hx
 
-@[simp, grind =] theorem reverse_suffix : reverse l₁ <:+ reverse l₂ ↔ l₁ <+: l₂ :=
+@[simp] theorem reverse_suffix : reverse l₁ <:+ reverse l₂ ↔ l₁ <+: l₂ :=
   ⟨fun ⟨r, e⟩ => ⟨reverse r, by rw [← reverse_reverse l₁, ← reverse_append, e, reverse_reverse]⟩,
    fun ⟨r, e⟩ => ⟨reverse r, by rw [← reverse_append, e]⟩⟩
 
-@[simp, grind =] theorem reverse_prefix : reverse l₁ <+: reverse l₂ ↔ l₁ <:+ l₂ := by
+@[simp] theorem reverse_prefix : reverse l₁ <+: reverse l₂ ↔ l₁ <:+ l₂ := by
   rw [← reverse_suffix]; simp only [reverse_reverse]
 
-@[simp, grind =] theorem reverse_infix : reverse l₁ <:+: reverse l₂ ↔ l₁ <:+: l₂ := by
+@[simp] theorem reverse_infix : reverse l₁ <:+: reverse l₂ ↔ l₁ <:+: l₂ := by
   refine ⟨fun ⟨s, t, e⟩ => ⟨reverse t, reverse s, ?_⟩, fun ⟨s, t, e⟩ => ⟨reverse t, reverse s, ?_⟩⟩
   · rw [← reverse_reverse l₁, append_assoc, ← reverse_append, ← reverse_append, e,
       reverse_reverse]
@@ -793,21 +701,12 @@ theorem IsPrefix.getElem {xs ys : List α} (h : xs <+: ys) {i} (hi : i < xs.leng
 theorem IsInfix.reverse : l₁ <:+: l₂ → reverse l₁ <:+: reverse l₂ :=
   reverse_infix.2
 
-grind_pattern IsInfix.reverse => l₁ <:+: l₂, l₁.reverse
-grind_pattern IsInfix.reverse => l₁ <:+: l₂, l₂.reverse
-
 theorem IsSuffix.reverse : l₁ <:+ l₂ → reverse l₁ <+: reverse l₂ :=
   reverse_prefix.2
 
-grind_pattern IsSuffix.reverse => l₁ <:+ l₂, l₁.reverse
-grind_pattern IsSuffix.reverse => l₁ <:+ l₂, l₂.reverse
-
 theorem IsPrefix.reverse : l₁ <+: l₂ → reverse l₁ <:+ reverse l₂ :=
   reverse_suffix.2
 
-grind_pattern IsPrefix.reverse => l₁ <+: l₂, l₁.reverse
-grind_pattern IsPrefix.reverse => l₁ <+: l₂, l₂.reverse
-
 theorem IsPrefix.head {l₁ l₂ : List α} (h : l₁ <+: l₂) (hx : l₁ ≠ []) :
     l₁.head hx = l₂.head (h.ne_nil hx) := by
   cases l₁ <;> cases l₂ <;> simp only [head_cons, ne_eq, not_true_eq_false] at hx ⊢
@@ -881,7 +780,7 @@ theorem prefix_cons_iff : l₁ <+: a :: l₂ ↔ l₁ = [] ∨ ∃ t, l₁ = a :
       · simp only [w]
         refine ⟨s, by simp [h']⟩
 
-@[simp, grind =] theorem cons_prefix_cons : a :: l₁ <+: b :: l₂ ↔ a = b ∧ l₁ <+: l₂ := by
+@[simp] theorem cons_prefix_cons : a :: l₁ <+: b :: l₂ ↔ a = b ∧ l₁ <+: l₂ := by
   simp only [prefix_cons_iff, cons.injEq, false_or, List.cons_ne_nil]
   constructor
   · rintro ⟨t, ⟨rfl, rfl⟩, h⟩
@@ -932,8 +831,7 @@ theorem infix_concat_iff {l₁ l₂ : List α} {a : α} :
   rw [← reverse_infix, reverse_concat, infix_cons_iff, reverse_infix,
     ← reverse_prefix, reverse_concat]
 
-theorem prefix_iff_getElem? {l₁ l₂ : List α} :
-    l₁ <+: l₂ ↔ ∀ i (h : i < l₁.length), l₂[i]? = some l₁[i] := by
+theorem isPrefix_iff : l₁ <+: l₂ ↔ ∀ i (h : i < l₁.length), l₂[i]? = some l₁[i] := by
   induction l₁ generalizing l₂ with
   | nil => simp
   | cons a l₁ ih =>
@@ -945,12 +843,7 @@ theorem prefix_iff_getElem? {l₁ l₂ : List α} :
       rw (occs := [2]) [← Nat.and_forall_add_one]
       simp [Nat.succ_lt_succ_iff, eq_comm]
 
--- See `Init.Data.List.Nat.Sublist` for `isSuffix_iff` and `ifInfix_iff`.
-
-@[deprecated prefix_iff_getElem? (since := "2025-05-27")]
-abbrev isPrefix_iff := @prefix_iff_getElem?
-
-theorem prefix_iff_getElem {l₁ l₂ : List α} :
+theorem isPrefix_iff_getElem {l₁ l₂ : List α} :
     l₁ <+: l₂ ↔ ∃ (h : l₁.length ≤ l₂.length), ∀ i (hx : i < l₁.length),
       l₁[i] = l₂[i]'(Nat.lt_of_lt_of_le hx h) where
   mp h := ⟨h.length_le, fun _ h' ↦ h.getElem h'⟩
@@ -968,16 +861,9 @@ theorem prefix_iff_getElem {l₁ l₂ : List α} :
         simp only [cons_prefix_cons]
         exact ⟨h 0 (zero_lt_succ _), tail_ih hl fun a ha ↦ h a.succ (succ_lt_succ ha)⟩
 
-@[deprecated prefix_iff_getElem (since := "2025-05-27")]
-abbrev isPrefix_iff_getElem := @prefix_iff_getElem
+-- See `Init.Data.List.Nat.Sublist` for `isSuffix_iff` and `ifInfix_iff`.
 
-theorem cons_prefix_iff {a : α} {l₁ l₂ : List α} :
-    a :: l₁ <+: l₂ ↔ ∃ l', l₂ = a :: l' ∧ l₁ <+: l' := by
-  match l₂ with
-  | nil => simp
-  | cons b l₂ => simp [and_assoc, eq_comm]
-
-theorem prefix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂ : List β} :
+theorem isPrefix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂ : List β} :
     l₂ <+: filterMap f l₁ ↔ ∃ l, l <+: l₁ ∧ l₂ = filterMap f l := by
   simp only [IsPrefix, append_eq_filterMap_iff]
   constructor
@@ -986,10 +872,7 @@ theorem prefix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂
   · rintro ⟨l₁, ⟨l₂, rfl⟩, rfl⟩
     exact ⟨_, l₁, l₂, rfl, rfl, rfl⟩
 
-@[deprecated prefix_filterMap_iff (since := "2025-05-27")]
-abbrev isPrefix_filterMap_iff := @prefix_filterMap_iff
-
-theorem suffix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂ : List β} :
+theorem isSuffix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂ : List β} :
     l₂ <:+ filterMap f l₁ ↔ ∃ l, l <:+ l₁ ∧ l₂ = filterMap f l := by
   simp only [IsSuffix, append_eq_filterMap_iff]
   constructor
@@ -998,10 +881,7 @@ theorem suffix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂
   · rintro ⟨l₁, ⟨l₂, rfl⟩, rfl⟩
     exact ⟨_, l₂, l₁, rfl, rfl, rfl⟩
 
-@[deprecated suffix_filterMap_iff (since := "2025-05-27")]
-abbrev isSuffix_filterMap_iff := @suffix_filterMap_iff
-
-theorem infix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂ : List β} :
+theorem isInfix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂ : List β} :
     l₂ <:+: filterMap f l₁ ↔ ∃ l, l <:+: l₁ ∧ l₂ = filterMap f l := by
   simp only [IsInfix, append_eq_filterMap_iff, filterMap_eq_append_iff]
   constructor
@@ -1010,52 +890,31 @@ theorem infix_filterMap_iff {β} {f : α → Option β} {l₁ : List α} {l₂ :
   · rintro ⟨l₃, ⟨l₂, l₁, rfl⟩, rfl⟩
     exact ⟨_, _, _, l₁, rfl, ⟨⟨l₂, l₃, rfl, rfl, rfl⟩, rfl⟩⟩
 
-@[deprecated infix_filterMap_iff (since := "2025-05-27")]
-abbrev isInfix_filterMap_iff := @infix_filterMap_iff
-
-theorem prefix_filter_iff {p : α → Bool} {l₁ l₂ : List α} :
+theorem isPrefix_filter_iff {p : α → Bool} {l₁ l₂ : List α} :
     l₂ <+: l₁.filter p ↔ ∃ l, l <+: l₁ ∧ l₂ = l.filter p := by
-  rw [← filterMap_eq_filter, prefix_filterMap_iff]
+  rw [← filterMap_eq_filter, isPrefix_filterMap_iff]
 
-@[deprecated prefix_filter_iff (since := "2025-05-27")]
-abbrev isPrefix_filter_iff := @prefix_filter_iff
-
-theorem suffix_filter_iff {p : α → Bool} {l₁ l₂ : List α} :
+theorem isSuffix_filter_iff {p : α → Bool} {l₁ l₂ : List α} :
     l₂ <:+ l₁.filter p ↔ ∃ l, l <:+ l₁ ∧ l₂ = l.filter p := by
-  rw [← filterMap_eq_filter, suffix_filterMap_iff]
+  rw [← filterMap_eq_filter, isSuffix_filterMap_iff]
 
-@[deprecated suffix_filter_iff (since := "2025-05-27")]
-abbrev isSuffix_filter_iff := @suffix_filter_iff
-
-theorem infix_filter_iff {p : α → Bool} {l₁ l₂ : List α} :
+theorem isInfix_filter_iff {p : α → Bool} {l₁ l₂ : List α} :
     l₂ <:+: l₁.filter p ↔ ∃ l, l <:+: l₁ ∧ l₂ = l.filter p := by
-  rw [← filterMap_eq_filter, infix_filterMap_iff]
+  rw [← filterMap_eq_filter, isInfix_filterMap_iff]
 
-@[deprecated infix_filter_iff (since := "2025-05-27")]
-abbrev isInfix_filter_iff := @infix_filter_iff
-
-theorem prefix_map_iff {β} {f : α → β} {l₁ : List α} {l₂ : List β} :
+theorem isPrefix_map_iff {β} {f : α → β} {l₁ : List α} {l₂ : List β} :
     l₂ <+: l₁.map f ↔ ∃ l, l <+: l₁ ∧ l₂ = l.map f := by
-  rw [← filterMap_eq_map, prefix_filterMap_iff]
+  rw [← filterMap_eq_map, isPrefix_filterMap_iff]
 
-@[deprecated prefix_map_iff (since := "2025-05-27")]
-abbrev isPrefix_map_iff := @prefix_map_iff
-
-theorem suffix_map_iff {β} {f : α → β} {l₁ : List α} {l₂ : List β} :
+theorem isSuffix_map_iff {β} {f : α → β} {l₁ : List α} {l₂ : List β} :
     l₂ <:+ l₁.map f ↔ ∃ l, l <:+ l₁ ∧ l₂ = l.map f := by
-  rw [← filterMap_eq_map, suffix_filterMap_iff]
+  rw [← filterMap_eq_map, isSuffix_filterMap_iff]
 
-@[deprecated suffix_map_iff (since := "2025-05-27")]
-abbrev isSuffix_map_iff := @suffix_map_iff
-
-theorem infix_map_iff {β} {f : α → β} {l₁ : List α} {l₂ : List β} :
+theorem isInfix_map_iff {β} {f : α → β} {l₁ : List α} {l₂ : List β} :
     l₂ <:+: l₁.map f ↔ ∃ l, l <:+: l₁ ∧ l₂ = l.map f := by
-  rw [← filterMap_eq_map, infix_filterMap_iff]
+  rw [← filterMap_eq_map, isInfix_filterMap_iff]
 
-@[deprecated infix_map_iff (since := "2025-05-27")]
-abbrev isInfix_map_iff := @infix_map_iff
-
-@[grind =] theorem prefix_replicate_iff {n} {a : α} {l : List α} :
+theorem isPrefix_replicate_iff {n} {a : α} {l : List α} :
     l <+: List.replicate n a ↔ l.length ≤ n ∧ l = List.replicate l.length a := by
   rw [IsPrefix]
   simp only [append_eq_replicate_iff]
@@ -1067,18 +926,12 @@ abbrev isInfix_map_iff := @infix_map_iff
     · simpa using add_sub_of_le h
     · simpa using w
 
-@[deprecated prefix_replicate_iff (since := "2025-05-27")]
-abbrev isPrefix_replicate_iff := @prefix_replicate_iff
-
-@[grind =] theorem suffix_replicate_iff {n} {a : α} {l : List α} :
+theorem isSuffix_replicate_iff {n} {a : α} {l : List α} :
     l <:+ List.replicate n a ↔ l.length ≤ n ∧ l = List.replicate l.length a := by
-  rw [← reverse_prefix, reverse_replicate, prefix_replicate_iff]
+  rw [← reverse_prefix, reverse_replicate, isPrefix_replicate_iff]
   simp [reverse_eq_iff]
 
-@[deprecated suffix_replicate_iff (since := "2025-05-27")]
-abbrev isSuffix_replicate_iff := @suffix_replicate_iff
-
-@[grind =] theorem infix_replicate_iff {n} {a : α} {l : List α} :
+theorem isInfix_replicate_iff {n} {a : α} {l : List α} :
     l <:+: List.replicate n a ↔ l.length ≤ n ∧ l = List.replicate l.length a := by
   rw [IsInfix]
   simp only [append_eq_replicate_iff, length_append]
@@ -1090,9 +943,6 @@ abbrev isSuffix_replicate_iff := @suffix_replicate_iff
     · simpa using Nat.sub_add_cancel h
     · simpa using w
 
-@[deprecated infix_replicate_iff (since := "2025-05-27")]
-abbrev isInfix_replicate_iff := @infix_replicate_iff
-
 theorem infix_of_mem_flatten : ∀ {L : List (List α)}, l ∈ L → l <:+: flatten L
   | l' :: _, h =>
     match h with
@@ -1106,16 +956,16 @@ theorem infix_of_mem_flatten : ∀ {L : List (List α)}, l ∈ L → l <:+: flat
 theorem prefix_cons_inj (a) : a :: l₁ <+: a :: l₂ ↔ l₁ <+: l₂ :=
   prefix_append_right_inj [a]
 
-@[grind] theorem take_prefix (i) (l : List α) : take i l <+: l :=
+theorem take_prefix (i) (l : List α) : take i l <+: l :=
   ⟨_, take_append_drop _ _⟩
 
-@[grind] theorem drop_suffix (i) (l : List α) : drop i l <:+ l :=
+theorem drop_suffix (i) (l : List α) : drop i l <:+ l :=
   ⟨_, take_append_drop _ _⟩
 
-@[grind] theorem take_sublist (i) (l : List α) : take i l <+ l :=
+theorem take_sublist (i) (l : List α) : take i l <+ l :=
   (take_prefix i l).sublist
 
-@[grind] theorem drop_sublist (i) (l : List α) : drop i l <+ l :=
+theorem drop_sublist (i) (l : List α) : drop i l <+ l :=
   (drop_suffix i l).sublist
 
 theorem take_subset (i) (l : List α) : take i l ⊆ l :=
@@ -1136,22 +986,22 @@ theorem drop_suffix_drop_left (l : List α) {i j : Nat} (h : i ≤ j) : drop j l
 
 -- See `Init.Data.List.Nat.TakeDrop` for `take_prefix_take_left`.
 
-@[grind] theorem drop_sublist_drop_left (l : List α) {i j : Nat} (h : i ≤ j) : drop j l <+ drop i l :=
+theorem drop_sublist_drop_left (l : List α) {i j : Nat} (h : i ≤ j) : drop j l <+ drop i l :=
   (drop_suffix_drop_left l h).sublist
 
-@[grind] theorem drop_subset_drop_left (l : List α) {i j : Nat} (h : i ≤ j) : drop j l ⊆ drop i l :=
+theorem drop_subset_drop_left (l : List α) {i j : Nat} (h : i ≤ j) : drop j l ⊆ drop i l :=
   (drop_sublist_drop_left l h).subset
 
-@[grind] theorem takeWhile_prefix (p : α → Bool) : l.takeWhile p <+: l :=
+theorem takeWhile_prefix (p : α → Bool) : l.takeWhile p <+: l :=
   ⟨l.dropWhile p, takeWhile_append_dropWhile⟩
 
-@[grind] theorem dropWhile_suffix (p : α → Bool) : l.dropWhile p <:+ l :=
+theorem dropWhile_suffix (p : α → Bool) : l.dropWhile p <:+ l :=
   ⟨l.takeWhile p, takeWhile_append_dropWhile⟩
 
-@[grind] theorem takeWhile_sublist (p : α → Bool) : l.takeWhile p <+ l :=
+theorem takeWhile_sublist (p : α → Bool) : l.takeWhile p <+ l :=
   (takeWhile_prefix p).sublist
 
-@[grind] theorem dropWhile_sublist (p : α → Bool) : l.dropWhile p <+ l :=
+theorem dropWhile_sublist (p : α → Bool) : l.dropWhile p <+ l :=
   (dropWhile_suffix p).sublist
 
 theorem takeWhile_subset {l : List α} (p : α → Bool) : l.takeWhile p ⊆ l :=
@@ -1160,88 +1010,61 @@ theorem takeWhile_subset {l : List α} (p : α → Bool) : l.takeWhile p ⊆ l :
 theorem dropWhile_subset {l : List α} (p : α → Bool) : l.dropWhile p ⊆ l :=
   (dropWhile_sublist p).subset
 
-@[grind] theorem dropLast_prefix : ∀ l : List α, l.dropLast <+: l
+theorem dropLast_prefix : ∀ l : List α, l.dropLast <+: l
   | [] => ⟨nil, by rw [dropLast, List.append_nil]⟩
   | a :: l => ⟨_, dropLast_concat_getLast (cons_ne_nil a l)⟩
 
-@[grind] theorem dropLast_sublist (l : List α) : l.dropLast <+ l :=
+theorem dropLast_sublist (l : List α) : l.dropLast <+ l :=
   (dropLast_prefix l).sublist
 
 theorem dropLast_subset (l : List α) : l.dropLast ⊆ l :=
   (dropLast_sublist l).subset
 
-@[grind] theorem tail_suffix (l : List α) : tail l <:+ l := by rw [← drop_one]; apply drop_suffix
+theorem tail_suffix (l : List α) : tail l <:+ l := by rw [← drop_one]; apply drop_suffix
 
-@[grind] theorem IsPrefix.map {β} (f : α → β) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) : l₁.map f <+: l₂.map f := by
+theorem IsPrefix.map {β} (f : α → β) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) : l₁.map f <+: l₂.map f := by
   obtain ⟨r, rfl⟩ := h
   rw [map_append]; apply prefix_append
 
-grind_pattern IsPrefix.map => l₁ <+: l₂, l₁.map f
-grind_pattern IsPrefix.map => l₁ <+: l₂, l₂.map f
-
-@[grind] theorem IsSuffix.map {β} (f : α → β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) : l₁.map f <:+ l₂.map f := by
+theorem IsSuffix.map {β} (f : α → β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) : l₁.map f <:+ l₂.map f := by
   obtain ⟨r, rfl⟩ := h
   rw [map_append]; apply suffix_append
 
-grind_pattern IsSuffix.map => l₁ <:+ l₂, l₁.map f
-grind_pattern IsSuffix.map => l₁ <:+ l₂, l₂.map f
-
-@[grind] theorem IsInfix.map {β} (f : α → β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) : l₁.map f <:+: l₂.map f := by
+theorem IsInfix.map {β} (f : α → β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) : l₁.map f <:+: l₂.map f := by
   obtain ⟨r₁, r₂, rfl⟩ := h
   rw [map_append, map_append]; apply infix_append
 
-grind_pattern IsInfix.map => l₁ <:+: l₂, l₁.map f
-grind_pattern IsInfix.map => l₁ <:+: l₂, l₂.map f
-
-@[grind] theorem IsPrefix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) :
+theorem IsPrefix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) :
     l₁.filter p <+: l₂.filter p := by
   obtain ⟨xs, rfl⟩ := h
   rw [filter_append]; apply prefix_append
 
-grind_pattern IsPrefix.filter => l₁ <+: l₂, l₁.filter p
-grind_pattern IsPrefix.filter => l₁ <+: l₂, l₂.filter p
-
-@[grind] theorem IsSuffix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) :
+theorem IsSuffix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) :
     l₁.filter p <:+ l₂.filter p := by
   obtain ⟨xs, rfl⟩ := h
   rw [filter_append]; apply suffix_append
 
-grind_pattern IsSuffix.filter => l₁ <:+ l₂, l₁.filter p
-grind_pattern IsSuffix.filter => l₁ <:+ l₂, l₂.filter p
-
-@[grind] theorem IsInfix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) :
+theorem IsInfix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) :
     l₁.filter p <:+: l₂.filter p := by
   obtain ⟨xs, ys, rfl⟩ := h
   rw [filter_append, filter_append]; apply infix_append _
 
-grind_pattern IsInfix.filter => l₁ <:+: l₂, l₁.filter p
-grind_pattern IsInfix.filter => l₁ <:+: l₂, l₂.filter p
-
-@[grind] theorem IsPrefix.filterMap {β} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) :
+theorem IsPrefix.filterMap {β} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) :
     filterMap f l₁ <+: filterMap f l₂ := by
   obtain ⟨xs, rfl⟩ := h
   rw [filterMap_append]; apply prefix_append
 
-grind_pattern IsPrefix.filterMap => l₁ <+: l₂, filterMap f l₁
-grind_pattern IsPrefix.filterMap => l₁ <+: l₂, filterMap f l₂
-
-@[grind] theorem IsSuffix.filterMap {β} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) :
+theorem IsSuffix.filterMap {β} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) :
     filterMap f l₁ <:+ filterMap f l₂ := by
   obtain ⟨xs, rfl⟩ := h
   rw [filterMap_append]; apply suffix_append
 
-grind_pattern IsSuffix.filterMap => l₁ <:+ l₂, filterMap f l₁
-grind_pattern IsSuffix.filterMap => l₁ <:+ l₂, filterMap f l₂
-
-@[grind] theorem IsInfix.filterMap {β} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) :
+theorem IsInfix.filterMap {β} (f : α → Option β) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) :
     filterMap f l₁ <:+: filterMap f l₂ := by
   obtain ⟨xs, ys, rfl⟩ := h
   rw [filterMap_append, filterMap_append]; apply infix_append
 
-grind_pattern IsInfix.filterMap => l₁ <:+: l₂, filterMap f l₁
-grind_pattern IsInfix.filterMap => l₁ <:+: l₂, filterMap f l₂
-
-@[simp, grind =] theorem isPrefixOf_iff_prefix [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
+@[simp] theorem isPrefixOf_iff_prefix [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
     l₁.isPrefixOf l₂ ↔ l₁ <+: l₂ := by
   induction l₁ generalizing l₂ with
   | nil => simp
@@ -1253,7 +1076,7 @@ grind_pattern IsInfix.filterMap => l₁ <:+: l₂, filterMap f l₂
 instance [DecidableEq α] (l₁ l₂ : List α) : Decidable (l₁ <+: l₂) :=
   decidable_of_iff (l₁.isPrefixOf l₂) isPrefixOf_iff_prefix
 
-@[simp, grind =] theorem isSuffixOf_iff_suffix [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
+@[simp] theorem isSuffixOf_iff_suffix [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
     l₁.isSuffixOf l₂ ↔ l₁ <:+ l₂ := by
   simp [isSuffixOf]
 

src/Init/Data/List/TakeDrop.lean

@@ -31,11 +31,6 @@ theorem take_cons {l : List α} (h : 0 < i) : (a :: l).take i = a :: l.take (i -
   | zero => exact absurd h (Nat.lt_irrefl _)
   | succ i => rfl
 
-theorem drop_cons {l : List α} (h : 0 < i) : (a :: l).drop i = l.drop (i - 1) := by
-  cases i with
-  | zero => exact absurd h (Nat.lt_irrefl _)
-  | succ i => rfl
-
 @[simp]
 theorem drop_one : ∀ {l : List α}, l.drop 1 = l.tail
   | [] | _ :: _ => rfl

src/Init/Data/List/ToArray.lean

@@ -210,6 +210,12 @@ theorem forM_toArray [Monad m] (l : List α) (f : α → m PUnit) :
   cases as
   simp
 
+@[simp] theorem foldl_push {l : List α} {as : Array α} : l.foldl Array.push as = as ++ l.toArray := by
+  induction l generalizing as <;> simp [*]
+
+@[simp] theorem foldr_push {l : List α} {as : Array α} : l.foldr (fun a bs => push bs a) as = as ++ l.reverse.toArray := by
+  rw [foldr_eq_foldl_reverse, foldl_push]
+
 @[simp, grind =] theorem findSomeM?_toArray [Monad m] [LawfulMonad m] (f : α → m (Option β)) (l : List α) :
     l.toArray.findSomeM? f = l.findSomeM? f := by
   rw [Array.findSomeM?]
@@ -256,16 +262,16 @@ theorem findRevM?_toArray [Monad m] [LawfulMonad m] (f : α → m Bool) (l : Lis
 
 @[simp, grind =] theorem findSome?_toArray (f : α → Option β) (l : List α) :
     l.toArray.findSome? f = l.findSome? f := by
-  rw [Array.findSome?, findSomeM?_toArray, findSomeM?_pure, Id.run_pure]
+  rw [Array.findSome?, ← findSomeM?_id, findSomeM?_toArray, Id.run]
 
 @[simp, grind =] theorem find?_toArray (f : α → Bool) (l : List α) :
     l.toArray.find? f = l.find? f := by
   rw [Array.find?]
-  simp only [forIn_toArray]
+  simp only [Id.run, Id, Id.pure_eq, Id.bind_eq, forIn_toArray]
   induction l with
   | nil => simp
   | cons a l ih =>
-    simp only [forIn_cons, find?]
+    simp only [forIn_cons, Id.pure_eq, Id.bind_eq, find?]
     by_cases f a <;> simp_all
 
 private theorem findFinIdx?_loop_toArray (w : l' = l.drop j) :
@@ -302,7 +308,7 @@ termination_by l.length - j
 @[simp, grind =] theorem findIdx?_toArray (p : α → Bool) (l : List α) :
     l.toArray.findIdx? p = l.findIdx? p := by
   rw [Array.findIdx?_eq_map_findFinIdx?_val, findIdx?_eq_map_findFinIdx?_val]
-  simp [Array.size]
+  simp
 
 private theorem idxAuxOf_toArray [BEq α] (a : α) (l : List α) (j : Nat) (w : l' = l.drop j) (h) :
     l.toArray.idxOfAux a j = findFinIdx?.go (fun x => x == a) l l' j h := by
@@ -339,11 +345,11 @@ termination_by l.length - j
 @[simp, grind =] theorem idxOf?_toArray [BEq α] (a : α) (l : List α) :
     l.toArray.idxOf? a = l.idxOf? a := by
   rw [Array.idxOf?, idxOf?]
-  simp [finIdxOf?, findIdx?_eq_map_findFinIdx?_val, Array.size]
+  simp [finIdxOf?, findIdx?_eq_map_findFinIdx?_val]
 
 @[simp, grind =] theorem findIdx_toArray {as : List α} {p : α → Bool} :
     as.toArray.findIdx p = as.findIdx p := by
-  rw [Array.findIdx, findIdx?_toArray, findIdx_eq_getD_findIdx?, Array.size]
+  rw [Array.findIdx, findIdx?_toArray, findIdx_eq_getD_findIdx?]
 
 @[simp, grind =] theorem idxOf_toArray [BEq α] {as : List α} {a : α} :
     as.toArray.idxOf a = as.idxOf a := by
@@ -670,9 +676,9 @@ theorem replace_toArray [BEq α] [LawfulBEq α] (l : List α) (a b : α) :
   split <;> rename_i i h
   · simp only [finIdxOf?_toArray, finIdxOf?_eq_none_iff] at h
     rw [replace_of_not_mem]
-    exact finIdxOf?_eq_none_iff.mp h
+    simpa
   · simp_all only [finIdxOf?_toArray, finIdxOf?_eq_some_iff, Fin.getElem_fin, set_toArray,
-      mk.injEq, Array.size]
+      mk.injEq]
     apply List.ext_getElem
     · simp
     · intro j h₁ h₂

src/Init/Data/Nat/Basic.lean

@@ -150,7 +150,7 @@ theorem add_one (n : Nat) : n + 1 = succ n :=
 @[simp] theorem succ_eq_add_one (n : Nat) : succ n = n + 1 :=
   rfl
 
-theorem add_one_ne_zero (n : Nat) : n + 1 ≠ 0 := nofun
+@[simp] theorem add_one_ne_zero (n : Nat) : n + 1 ≠ 0 := nofun
 theorem zero_ne_add_one (n : Nat) : 0 ≠ n + 1 := by simp
 
 protected theorem add_comm : ∀ (n m : Nat), n + m = m + n
@@ -731,12 +731,13 @@ theorem exists_eq_add_one_of_ne_zero : ∀ {n}, n ≠ 0 → Exists fun k => n =
 theorem ctor_eq_zero : Nat.zero = 0 :=
   rfl
 
-protected theorem one_ne_zero : 1 ≠ (0 : Nat) := by simp
+@[simp] protected theorem one_ne_zero : 1 ≠ (0 : Nat) :=
+  fun h => Nat.noConfusion h
 
 @[simp] protected theorem zero_ne_one : 0 ≠ (1 : Nat) :=
   fun h => Nat.noConfusion h
 
-theorem succ_ne_zero (n : Nat) : succ n ≠ 0 := by simp
+@[simp] theorem succ_ne_zero (n : Nat) : succ n ≠ 0 := by simp
 
 instance instNeZeroSucc {n : Nat} : NeZero (n + 1) := ⟨succ_ne_zero n⟩
 

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

@@ -72,7 +72,7 @@ Examples:
  * `0 <<< 3 = 0`
  * `0xf1 <<< 4 = 0xf10`
 -/
-@[extern "lean_nat_shiftl", expose]
+@[extern "lean_nat_shiftl"]
 def shiftLeft : @& Nat → @& Nat → Nat
   | n, 0 => n
   | n, succ m => shiftLeft (2*n) m
@@ -88,7 +88,7 @@ Examples:
  * `0 >>> 3 = 0`
  * `0xf13a >>> 8 = 0xf1`
 -/
-@[extern "lean_nat_shiftr", expose]
+@[extern "lean_nat_shiftr"]
 def shiftRight : @& Nat → @& Nat → Nat
   | n, 0 => n
   | n, succ m => shiftRight n m / 2

src/Init/Data/Nat/Fold.lean

@@ -197,8 +197,6 @@ theorem allTR_loop_congr {n m : Nat} (w : n = m) (f : (i : Nat) → i < n → Bo
       omega
   go n 0 f
 
-/-! ### `fold` -/
-
 @[simp] theorem fold_zero {α : Type u} (f : (i : Nat) → i < 0 → α → α) (init : α) :
     fold 0 f init = init := by simp [fold]
 
@@ -212,8 +210,6 @@ theorem fold_eq_finRange_foldl {α : Type u} (n : Nat) (f : (i : Nat) → i < n
   | succ n ih =>
     simp [ih, List.finRange_succ_last, List.foldl_map]
 
-/-! ### `foldRev` -/
-
 @[simp] theorem foldRev_zero {α : Type u} (f : (i : Nat) → i < 0 → α → α) (init : α) :
     foldRev 0 f init = init := by simp [foldRev]
 
@@ -227,12 +223,10 @@ theorem foldRev_eq_finRange_foldr {α : Type u} (n : Nat) (f : (i : Nat) → i <
   | zero => simp
   | succ n ih => simp [ih, List.finRange_succ_last, List.foldr_map]
 
-/-! ### `any` -/
-
 @[simp] theorem any_zero {f : (i : Nat) → i < 0 → Bool} : any 0 f = false := by simp [any]
 
 @[simp] theorem any_succ {n : Nat} (f : (i : Nat) → i < n + 1 → Bool) :
-    any (n + 1) f = (any n (fun i h => f i (by omega)) || f n (by omega)) := by simp [any]
+  any (n + 1) f = (any n (fun i h => f i (by omega)) || f n (by omega)) := by simp [any]
 
 theorem any_eq_finRange_any {n : Nat} (f : (i : Nat) → i < n → Bool) :
     any n f = (List.finRange n).any (fun ⟨i, h⟩ => f i h) := by
@@ -240,12 +234,10 @@ theorem any_eq_finRange_any {n : Nat} (f : (i : Nat) → i < n → Bool) :
   | zero => simp
   | succ n ih => simp [ih, List.finRange_succ_last, List.any_map, Function.comp_def]
 
-/-! ### `all` -/
-
 @[simp] theorem all_zero {f : (i : Nat) → i < 0 → Bool} : all 0 f = true := by simp [all]
 
 @[simp] theorem all_succ {n : Nat} (f : (i : Nat) → i < n + 1 → Bool) :
-    all (n + 1) f = (all n (fun i h => f i (by omega)) && f n (by omega)) := by simp [all]
+  all (n + 1) f = (all n (fun i h => f i (by omega)) && f n (by omega)) := by simp [all]
 
 theorem all_eq_finRange_all {n : Nat} (f : (i : Nat) → i < n → Bool) :
     all n f = (List.finRange n).all (fun ⟨i, h⟩ => f i h) := by
@@ -258,7 +250,7 @@ end Nat
 namespace Prod
 
 /--
-Combines an initial value with each natural number from a range, in increasing order.
+Combines an initial value with each natural number from in a range, in increasing order.
 
 In particular, `(start, stop).foldI f init` applies `f`on all the numbers
 from `start` (inclusive) to `stop` (exclusive) in increasing order:
@@ -268,7 +260,7 @@ Examples:
 * `(5, 8).foldI (fun j _ _ xs => xs.push j) #[] = #[5, 6, 7]`
 * `(5, 8).foldI (fun j _ _ xs => toString j :: xs) [] = ["7", "6", "5"]`
 -/
-@[inline, simp] def foldI {α : Type u} (i : Nat × Nat) (f : (j : Nat) → i.1 ≤ j → j < i.2 → α → α) (init : α) : α :=
+@[inline] def foldI {α : Type u} (i : Nat × Nat) (f : (j : Nat) → i.1 ≤ j → j < i.2 → α → α) (init : α) : α :=
   (i.2 - i.1).fold (fun j _ => f (i.1 + j) (by omega) (by omega)) init
 
 /--
@@ -282,7 +274,7 @@ Examples:
  * `(5, 8).anyI (fun j _ _ => j % 2 = 0) = true`
  * `(6, 6).anyI (fun j _ _ => j % 2 = 0) = false`
 -/
-@[inline, simp] def anyI (i : Nat × Nat) (f : (j : Nat) → i.1 ≤ j → j < i.2 → Bool) : Bool :=
+@[inline] def anyI (i : Nat × Nat) (f : (j : Nat) → i.1 ≤ j → j < i.2 → Bool) : Bool :=
   (i.2 - i.1).any (fun j _ => f (i.1 + j) (by omega) (by omega))
 
 /--
@@ -296,7 +288,7 @@ Examples:
  * `(5, 8).allI (fun j _ _ => j % 2 = 0) = false`
  * `(6, 7).allI (fun j _ _ => j % 2 = 0) = true`
 -/
-@[inline, simp] def allI (i : Nat × Nat) (f : (j : Nat) → i.1 ≤ j → j < i.2 → Bool) : Bool :=
+@[inline] def allI (i : Nat × Nat) (f : (j : Nat) → i.1 ≤ j → j < i.2 → Bool) : Bool :=
   (i.2 - i.1).all (fun j _ => f (i.1 + j) (by omega) (by omega))
 
 end Prod

src/Init/Data/Nat/Lcm.lean

@@ -26,7 +26,6 @@ Examples:
  * `Nat.lcm 0 3 = 0`
  * `Nat.lcm 3 0 = 0`
 -/
-@[expose]
 def lcm (m n : Nat) : Nat := m * n / gcd m n
 
 theorem lcm_eq_mul_div (m n : Nat) : lcm m n = m * n / gcd m n := rfl

src/Init/Data/Nat/Lemmas.lean

@@ -415,7 +415,7 @@ theorem succ_min_succ (x y) : min (succ x) (succ y) = succ (min x y) := by
   | inl h => rw [Nat.min_eq_left h, Nat.min_eq_left (Nat.succ_le_succ h)]
   | inr h => rw [Nat.min_eq_right h, Nat.min_eq_right (Nat.succ_le_succ h)]
 
-protected theorem min_self (a : Nat) : min a a = a := by simp
+@[simp] protected theorem min_self (a : Nat) : min a a = a := Nat.min_eq_left (Nat.le_refl _)
 instance : Std.IdempotentOp (α := Nat) min := ⟨Nat.min_self⟩
 
 @[simp] protected theorem min_assoc : ∀ (a b c : Nat), min (min a b) c = min a (min b c)
@@ -431,14 +431,16 @@ instance : Std.Associative (α := Nat) min := ⟨Nat.min_assoc⟩
 @[simp] protected theorem min_self_assoc' {m n : Nat} : min n (min m n) = min n m := by
   rw [Nat.min_comm m n, ← Nat.min_assoc, Nat.min_self]
 
-theorem min_add_left_self {a b : Nat} : min a (b + a) = a := by
+@[simp] theorem min_add_left_self {a b : Nat} : min a (b + a) = a := by
+  rw [Nat.min_def]
   simp
-theorem min_add_right_self {a b : Nat} : min a (a + b) = a := by
-  simp
-theorem add_left_min_self {a b : Nat} : min (b + a) a = a := by
-  simp
-theorem add_right_min_self {a b : Nat} : min (a + b) a = a := by
+@[simp] theorem min_add_right_self {a b : Nat} : min a (a + b) = a := by
+  rw [Nat.min_def]
   simp
+@[simp] theorem add_left_min_self {a b : Nat} : min (b + a) a = a := by
+  rw [Nat.min_comm, min_add_left_self]
+@[simp] theorem add_right_min_self {a b : Nat} : min (a + b) a = a := by
+  rw [Nat.min_comm, min_add_right_self]
 
 protected theorem sub_sub_eq_min : ∀ (a b : Nat), a - (a - b) = min a b
   | 0, _ => by rw [Nat.zero_sub, Nat.zero_min]
@@ -460,7 +462,7 @@ protected theorem succ_max_succ (x y) : max (succ x) (succ y) = succ (max x y) :
   | inl h => rw [Nat.max_eq_right h, Nat.max_eq_right (Nat.succ_le_succ h)]
   | inr h => rw [Nat.max_eq_left h, Nat.max_eq_left (Nat.succ_le_succ h)]
 
-protected theorem max_self (a : Nat) : max a a = a := by simp
+@[simp] protected theorem max_self (a : Nat) : max a a = a := Nat.max_eq_right (Nat.le_refl _)
 instance : Std.IdempotentOp (α := Nat) max := ⟨Nat.max_self⟩
 
 instance : Std.LawfulIdentity (α := Nat) max 0 where
@@ -474,14 +476,16 @@ instance : Std.LawfulIdentity (α := Nat) max 0 where
   | _+1, _+1, _+1 => by simp only [Nat.succ_max_succ]; exact congrArg succ <| Nat.max_assoc ..
 instance : Std.Associative (α := Nat) max := ⟨Nat.max_assoc⟩
 
-theorem max_add_left_self {a b : Nat} : max a (b + a) = b + a := by
+@[simp] theorem max_add_left_self {a b : Nat} : max a (b + a) = b + a := by
+  rw [Nat.max_def]
   simp
-theorem max_add_right_self {a b : Nat} : max a (a + b) = a + b := by
-  simp
-theorem add_left_max_self {a b : Nat} : max (b + a) a = b + a := by
-  simp
-theorem add_right_max_self {a b : Nat} : max (a + b) a = a + b := by
+@[simp] theorem max_add_right_self {a b : Nat} : max a (a + b) = a + b := by
+  rw [Nat.max_def]
   simp
+@[simp] theorem add_left_max_self {a b : Nat} : max (b + a) a = b + a := by
+  rw [Nat.max_comm, max_add_left_self]
+@[simp] theorem add_right_max_self {a b : Nat} : max (a + b) a = a + b := by
+  rw [Nat.max_comm, max_add_right_self]
 
 protected theorem sub_add_eq_max (a b : Nat) : a - b + b = max a b := by
   match Nat.le_total a b with
@@ -810,8 +814,10 @@ theorem sub_mul_mod {x k n : Nat} (h₁ : n*k ≤ x) : (x - n*k) % n = x % n :=
       simp [mul_succ, Nat.add_comm] at h₁; simp [h₁]
     rw [mul_succ, ← Nat.sub_sub, ← mod_eq_sub_mod h₄, sub_mul_mod h₂]
 
-theorem mod_mod (a n : Nat) : (a % n) % n = a % n := by
-  simp
+@[simp] theorem mod_mod (a n : Nat) : (a % n) % n = a % n :=
+  match eq_zero_or_pos n with
+  | .inl n0 => by simp [n0, mod_zero]
+  | .inr npos => Nat.mod_eq_of_lt (mod_lt _ npos)
 
 theorem mul_mod (a b n : Nat) : a * b % n = (a % n) * (b % n) % n := by
   rw (occs := [1]) [← mod_add_div a n]
@@ -1767,10 +1773,8 @@ instance decidableExistsLT' {p : (m : Nat) → m < k → Prop} [I : ∀ m h, Dec
 /-- Dependent version of `decidableExistsLE`. -/
 instance decidableExistsLE' {p : (m : Nat) → m ≤ k → Prop} [I : ∀ m h, Decidable (p m h)] :
     Decidable (∃ m : Nat, ∃ h : m ≤ k, p m h) :=
-  decidable_of_iff (∃ m, ∃ h : m < k + 1, p m (by omega)) <| by
-    apply exists_congr
-    intro
-    exact ⟨fun ⟨h, w⟩ => ⟨le_of_lt_succ h, w⟩, fun ⟨h, w⟩ => ⟨lt_add_one_of_le h, w⟩⟩
+  decidable_of_iff (∃ m, ∃ h : m < k + 1, p m (by omega)) (exists_congr fun _ =>
+    ⟨fun ⟨h, w⟩ => ⟨le_of_lt_succ h, w⟩, fun ⟨h, w⟩ => ⟨lt_add_one_of_le h, w⟩⟩)
 
 /-! ### Results about `List.sum` specialized to `Nat` -/
 

src/Init/Data/Option/Array.lean

@@ -8,42 +8,14 @@ module
 prelude
 import Init.Data.Array.Lemmas
 import Init.Data.Option.List
-import all Init.Data.Option.Instances
 
 namespace Option
 
-@[simp, grind] theorem mem_toArray {a : α} {o : Option α} : a ∈ o.toArray ↔ o = some a := by
-  cases o <;> simp [eq_comm]
-
-@[simp, grind] theorem forIn'_toArray [Monad m] (o : Option α) (b : β) (f : (a : α) → a ∈ o.toArray → β → m (ForInStep β)) :
-    forIn' o.toArray b f = forIn' o b fun a m b => f a (by simpa using m) b := by
-  cases o <;> simp <;> rfl
-
-@[simp, grind] theorem forIn_toArray [Monad m] (o : Option α) (b : β) (f : α → β → m (ForInStep β)) :
-    forIn o.toArray b f = forIn o b f := by
-  cases o <;> simp <;> rfl
-
-@[simp, grind] theorem foldlM_toArray [Monad m] [LawfulMonad m] (o : Option β) (a : α) (f : α → β → m α) :
-    o.toArray.foldlM f a = o.elim (pure a) (fun b => f a b) := by
-  cases o <;> simp
-
-@[simp, grind] theorem foldrM_toArray [Monad m] [LawfulMonad m] (o : Option β) (a : α) (f : β → α → m α) :
-    o.toArray.foldrM f a = o.elim (pure a) (fun b => f b a) := by
-  cases o <;> simp
-
-@[simp, grind] theorem foldl_toArray (o : Option β) (a : α) (f : α → β → α) :
-    o.toArray.foldl f a = o.elim a (fun b => f a b) := by
-  cases o <;> simp
-
-@[simp, grind] theorem foldr_toArray (o : Option β) (a : α) (f : β → α → α) :
-    o.toArray.foldr f a = o.elim a (fun b => f b a) := by
-  cases o <;> simp
-
-@[simp, grind =]
+@[simp]
 theorem toList_toArray {o : Option α} : o.toArray.toList = o.toList := by
   cases o <;> simp
 
-@[simp, grind =]
+@[simp]
 theorem toArray_toList {o : Option α} : o.toList.toArray = o.toArray := by
   cases o <;> simp
 
@@ -51,47 +23,4 @@ theorem toArray_filter {o : Option α} {p : α → Bool} :
     (o.filter p).toArray = o.toArray.filter p := by
   rw [← toArray_toList, toList_filter, ← List.filter_toArray, toArray_toList]
 
-theorem toArray_bind {o : Option α} {f : α → Option β} :
-    (o.bind f).toArray = o.toArray.flatMap (Option.toArray ∘ f) := by
-  cases o <;> simp
-
-theorem toArray_join {o : Option (Option α)} : o.join.toArray = o.toArray.flatMap Option.toArray := by
-  simp [toArray_bind, ← bind_id_eq_join]
-
-theorem toArray_map {o : Option α} {f : α → β} : (o.map f).toArray = o.toArray.map f := by
-  cases o <;> simp
-
-theorem toArray_min [Min α] {o o' : Option α} :
-    (min o o').toArray = o.toArray.zipWith min o'.toArray := by
-  cases o <;> cases o' <;> simp
-
-@[simp]
-theorem size_toArray_le {o : Option α} : o.toArray.size ≤ 1 := by
-  cases o <;> simp
-
-@[grind =]
-theorem size_toArray {o : Option α} :
-    o.toArray.size = if o.isSome then 1 else 0 := by
-  cases o <;> simp
-
-@[simp]
-theorem toArray_eq_empty_iff {o : Option α} : o.toArray = #[] ↔ o = none := by
-  cases o <;> simp
-
-@[simp]
-theorem toArray_eq_singleton_iff {o : Option α} : o.toArray = #[a] ↔ o = some a := by
-  cases o <;> simp
-
-theorem size_toArray_eq_zero_iff {o : Option α} :
-    o.toArray.size = 0 ↔ o = none := by
-  simp [Array.size]
-
-@[simp]
-theorem size_toArray_eq_one_iff {o : Option α} :
-    o.toArray.size = 1 ↔ o.isSome := by
-  cases o <;> simp
-
-theorem size_toArray_choice_eq_one [Nonempty α] : (choice α).toArray.size = 1 := by
-  simp
-
 end Option

src/Init/Data/Option/Attach.lean

@@ -8,16 +8,11 @@ module
 prelude
 import Init.Data.Option.Basic
 import Init.Data.Option.List
-import Init.Data.Option.Array
-import Init.Data.Array.Attach
 import Init.Data.List.Attach
 import Init.BinderPredicates
 
 namespace Option
 
-instance {o : Option α} : Subsingleton { x // o = some x } where
-  allEq a b := Subtype.ext (Option.some.inj (a.property.symm.trans b.property))
-
 /--
 Unsafe implementation of `attachWith`, taking advantage of the fact that the representation of
 `Option {x // P x}` is the same as the input `Option α`.
@@ -34,7 +29,7 @@ well-founded recursion that use iteration operators (such as `Option.map`) to pr
 value drawn from a parameter is smaller than the parameter. This allows the well-founded recursion
 mechanism to prove that the function terminates.
 -/
-@[implemented_by attachWithImpl, expose] def attachWith
+@[implemented_by attachWithImpl] def attachWith
     (xs : Option α) (P : α → Prop) (H : ∀ x, xs = some x → P x) : Option {x // P x} :=
   match xs with
   | none => none
@@ -49,14 +44,14 @@ operators (such as `Option.map`) to prove that an optional value drawn from a pa
 than the parameter. This allows the well-founded recursion mechanism to prove that the function
 terminates.
 -/
-@[inline, expose] def attach (xs : Option α) : Option {x // xs = some x} := xs.attachWith _ fun _ => id
+@[inline] def attach (xs : Option α) : Option {x // xs = some x} := xs.attachWith _ fun _ => id
 
-@[simp, grind =] theorem attach_none : (none : Option α).attach = none := rfl
-@[simp, grind =] theorem attachWith_none : (none : Option α).attachWith P H = none := rfl
+@[simp] theorem attach_none : (none : Option α).attach = none := rfl
+@[simp] theorem attachWith_none : (none : Option α).attachWith P H = none := rfl
 
-@[simp, grind =] theorem attach_some {x : α} :
+@[simp] theorem attach_some {x : α} :
     (some x).attach = some ⟨x, rfl⟩ := rfl
-@[simp, grind =] theorem attachWith_some {x : α} {P : α → Prop} (h : ∀ (b : α), some x = some b → P b) :
+@[simp] theorem attachWith_some {x : α} {P : α → Prop} (h : ∀ (b : α), some x = some b → P b) :
     (some x).attachWith P h = some ⟨x, by simpa using h⟩ := rfl
 
 theorem attach_congr {o₁ o₂ : Option α} (h : o₁ = o₂) :
@@ -76,7 +71,7 @@ theorem attach_map_val (o : Option α) (f : α → β) :
 @[deprecated attach_map_val (since := "2025-02-17")]
 abbrev attach_map_coe := @attach_map_val
 
-@[simp, grind =]theorem attach_map_subtype_val (o : Option α) :
+theorem attach_map_subtype_val (o : Option α) :
     o.attach.map Subtype.val = o :=
   (attach_map_val _ _).trans (congrFun Option.map_id _)
 
@@ -87,28 +82,28 @@ theorem attachWith_map_val {p : α → Prop} (f : α → β) (o : Option α) (H
 @[deprecated attachWith_map_val (since := "2025-02-17")]
 abbrev attachWith_map_coe := @attachWith_map_val
 
-@[simp, grind =] theorem attachWith_map_subtype_val {p : α → Prop} (o : Option α) (H : ∀ a, o = some a → p a) :
+theorem attachWith_map_subtype_val {p : α → Prop} (o : Option α) (H : ∀ a, o = some a → p a) :
     (o.attachWith p H).map Subtype.val = o :=
   (attachWith_map_val _ _ _).trans (congrFun Option.map_id _)
 
-theorem attach_eq_some : ∀ (o : Option α) (x : {x // o = some x}), o.attach = some x
+theorem attach_eq_some : ∀ (o : Option a) (x : {x // o = some x}), o.attach = some x
   | none, ⟨x, h⟩ => by simp at h
   | some a, ⟨x, h⟩ => by simpa using h
 
 theorem mem_attach : ∀ (o : Option α) (x : {x // o = some x}), x ∈ o.attach :=
   attach_eq_some
 
-@[simp, grind =] theorem isNone_attach (o : Option α) : o.attach.isNone = o.isNone := by
+@[simp] theorem isNone_attach (o : Option α) : o.attach.isNone = o.isNone := by
   cases o <;> simp
 
-@[simp, grind =] theorem isNone_attachWith {p : α → Prop} (o : Option α) (H : ∀ a, o = some a → p a) :
+@[simp] theorem isNone_attachWith {p : α → Prop} (o : Option α) (H : ∀ a, o = some a → p a) :
     (o.attachWith p H).isNone = o.isNone := by
   cases o <;> simp
 
-@[simp, grind =] theorem isSome_attach (o : Option α) : o.attach.isSome = o.isSome := by
+@[simp] theorem isSome_attach (o : Option α) : o.attach.isSome = o.isSome := by
   cases o <;> simp
 
-@[simp, grind =] theorem isSome_attachWith {p : α → Prop} (o : Option α) (H : ∀ a, o = some a → p a) :
+@[simp] theorem isSome_attachWith {p : α → Prop} (o : Option α) (H : ∀ a, o = some a → p a) :
     (o.attachWith p H).isSome = o.isSome := by
   cases o <;> simp
 
@@ -127,67 +122,43 @@ theorem mem_attach : ∀ (o : Option α) (x : {x // o = some x}), x ∈ o.attach
     o.attachWith p H = some x ↔ o = some x.val := by
   cases o <;> cases x <;> simp
 
-@[simp, grind =] theorem get_attach {o : Option α} (h : o.attach.isSome = true) :
-    o.attach.get h = ⟨o.get (by simpa using h), by simp⟩ :=
-  Subsingleton.elim _ _
+@[simp] theorem get_attach {o : Option α} (h : o.attach.isSome = true) :
+    o.attach.get h = ⟨o.get (by simpa using h), by simp⟩ := by
+  cases o
+  · simp at h
+  · simp [get_some]
 
-@[simp, grind =] theorem getD_attach {o : Option α} {fallback} :
-    o.attach.getD fallback = fallback :=
-  Subsingleton.elim _ _
-
-@[simp, grind =] theorem get!_attach {o : Option α} [Inhabited { x // o = some x }] :
-    o.attach.get! = default :=
-  Subsingleton.elim _ _
-
-@[simp, grind =] theorem get_attachWith {p : α → Prop} {o : Option α} (H : ∀ a, o = some a → p a) (h : (o.attachWith p H).isSome) :
+@[simp] theorem get_attachWith {p : α → Prop} {o : Option α} (H : ∀ a, o = some a → p a) (h : (o.attachWith p H).isSome) :
     (o.attachWith p H).get h = ⟨o.get (by simpa using h), H _ (by simp)⟩ := by
-  cases o <;> simp
-
-@[simp, grind =] theorem getD_attachWith {p : α → Prop} {o : Option α} {h} {fallback} :
-    (o.attachWith p h).getD fallback =
-      ⟨o.getD fallback.val, by
-        cases o
-        · exact fallback.property
-        · exact h _ (by simp)⟩ := by
-  cases o <;> simp
+  cases o
+  · simp at h
+  · simp [get_some]
 
 theorem toList_attach (o : Option α) :
-    o.attach.toList = o.toList.attach.map fun x => ⟨x.1, by simpa using x.2⟩ := by
-  cases o <;> simp
-
-theorem toList_attachWith {p : α → Prop} {o : Option α} {h} :
-    (o.attachWith p h).toList = o.toList.attach.map fun x => ⟨x.1, h _ (by simpa using x.2)⟩ := by
-  cases o <;> simp
-
-theorem toArray_attach (o : Option α) :
-    o.attach.toArray = o.toArray.attach.map fun x => ⟨x.1, by simpa using x.2⟩ := by
-  cases o <;> simp
-
-theorem toArray_attachWith {p : α → Prop} {o : Option α} {h} :
-    (o.attachWith p h).toArray = o.toArray.attach.map fun x => ⟨x.1, h _ (by simpa using x.2)⟩ := by
-  cases o <;> simp
+    o.attach.toList = o.toList.attach.map fun ⟨x, h⟩ => ⟨x, by simpa using h⟩ := by
+  cases o <;> simp [toList]
 
 @[simp, grind =] theorem attach_toList (o : Option α) :
     o.toList.attach = (o.attach.map fun ⟨a, h⟩ => ⟨a, by simpa using h⟩).toList := by
   cases o <;> simp [toList]
 
-@[grind =] theorem attach_map {o : Option α} (f : α → β) :
+theorem attach_map {o : Option α} (f : α → β) :
     (o.map f).attach = o.attach.map (fun ⟨x, h⟩ => ⟨f x, map_eq_some_iff.2 ⟨_, h, rfl⟩⟩) := by
   cases o <;> simp
 
-@[grind =] theorem attachWith_map {o : Option α} (f : α → β) {P : β → Prop} {H : ∀ (b : β), o.map f = some b → P b} :
+theorem attachWith_map {o : Option α} (f : α → β) {P : β → Prop} {H : ∀ (b : β), o.map f = some b → P b} :
     (o.map f).attachWith P H = (o.attachWith (P ∘ f) (fun _ h => H _ (map_eq_some_iff.2 ⟨_, h, rfl⟩))).map
       fun ⟨x, h⟩ => ⟨f x, h⟩ := by
   cases o <;> simp
 
-@[grind =] theorem map_attach_eq_pmap {o : Option α} (f : { x // o = some x } → β) :
+theorem map_attach_eq_pmap {o : Option α} (f : { x // o = some x } → β) :
     o.attach.map f = o.pmap (fun a (h : o = some a) => f ⟨a, h⟩) (fun _ h => h) := by
   cases o <;> simp
 
 @[deprecated map_attach_eq_pmap (since := "2025-02-09")]
 abbrev map_attach := @map_attach_eq_pmap
 
-@[simp, grind =] theorem map_attachWith {l : Option α} {P : α → Prop} {H : ∀ (a : α), l = some a → P a}
+@[simp] theorem map_attachWith {l : Option α} {P : α → Prop} {H : ∀ (a : α), l = some a → P a}
     (f : { x // P x } → β) :
     (l.attachWith P H).map f = l.attach.map fun ⟨x, h⟩ => f ⟨x, H _ h⟩ := by
   cases l <;> simp_all
@@ -203,12 +174,12 @@ theorem map_attach_eq_attachWith {o : Option α} {p : α → Prop} (f : ∀ a, o
     o.attach.map (fun x => ⟨x.1, f x.1 x.2⟩) = o.attachWith p f := by
   cases o <;> simp_all [Function.comp_def]
 
-@[grind =] theorem attach_bind {o : Option α} {f : α → Option β} :
+theorem attach_bind {o : Option α} {f : α → Option β} :
     (o.bind f).attach =
       o.attach.bind fun ⟨x, h⟩ => (f x).attach.map fun ⟨y, h'⟩ => ⟨y, bind_eq_some_iff.2 ⟨_, h, h'⟩⟩ := by
   cases o <;> simp
 
-@[grind =] theorem bind_attach {o : Option α} {f : {x // o = some x} → Option β} :
+theorem bind_attach {o : Option α} {f : {x // o = some x} → Option β} :
     o.attach.bind f = o.pbind fun a h => f ⟨a, h⟩ := by
   cases o <;> simp
 
@@ -216,7 +187,7 @@ theorem pbind_eq_bind_attach {o : Option α} {f : (a : α) → o = some a → Op
     o.pbind f = o.attach.bind fun ⟨x, h⟩ => f x h := by
   cases o <;> simp
 
-@[grind =] theorem attach_filter {o : Option α} {p : α → Bool} :
+theorem attach_filter {o : Option α} {p : α → Bool} :
     (o.filter p).attach =
       o.attach.bind fun ⟨x, h⟩ => if h' : p x then some ⟨x, by simp_all⟩ else none := by
   cases o with
@@ -232,12 +203,7 @@ theorem pbind_eq_bind_attach {o : Option α} {f : (a : α) → o = some a → Op
     · rintro ⟨h, rfl⟩
       simp [h]
 
-@[grind =] theorem filter_attachWith {P : α → Prop} {o : Option α} {h : ∀ x, o = some x → P x} {q : α → Bool} :
-    (o.attachWith P h).filter q =
-      (o.filter q).attachWith P (fun _ h' => h _ (eq_some_of_filter_eq_some h')) := by
-  cases o <;> simp [filter_some] <;> split <;> simp
-
-@[grind =] theorem filter_attach {o : Option α} {p : {x // o = some x} → Bool} :
+theorem filter_attach {o : Option α} {p : {x // o = some x} → Bool} :
     o.attach.filter p = o.pbind fun a h => if p ⟨a, h⟩ then some ⟨a, h⟩ else none := by
   cases o <;> simp [filter_some]
 
@@ -245,64 +211,6 @@ theorem toList_pbind {o : Option α} {f : (a : α) → o = some a → Option β}
     (o.pbind f).toList = o.attach.toList.flatMap (fun ⟨x, h⟩ => (f x h).toList) := by
   cases o <;> simp
 
-theorem toArray_pbind {o : Option α} {f : (a : α) → o = some a → Option β} :
-    (o.pbind f).toArray = o.attach.toArray.flatMap (fun ⟨x, h⟩ => (f x h).toArray) := by
-  cases o <;> simp
-
-theorem toList_pfilter {o : Option α} {p : (a : α) → o = some a → Bool} :
-    (o.pfilter p).toList = (o.toList.attach.filter (fun x => p x.1 (by simpa using x.2))).unattach := by
-  cases o with
-  | none => simp
-  | some a =>
-    simp only [pfilter_some, toList_some, List.attach_cons, List.attach_nil, List.map_nil]
-    split <;> rename_i h
-    · rw [List.filter_cons_of_pos h]; simp
-    · rw [List.filter_cons_of_neg h]; simp
-
-theorem toArray_pfilter {o : Option α} {p : (a : α) → o = some a → Bool} :
-    (o.pfilter p).toArray = (o.toArray.attach.filter (fun x => p x.1 (by simpa using x.2))).unattach := by
-  cases o with
-  | none => simp
-  | some a =>
-    simp only [pfilter_some, toArray_some, List.attach_toArray, List.attachWith_mem_toArray,
-      List.attach_cons, List.attach_nil, List.map_nil, List.map_cons, List.size_toArray,
-      List.length_cons, List.length_nil, Nat.zero_add, List.filter_toArray', List.unattach_toArray]
-    split <;> rename_i h
-    · rw [List.filter_cons_of_pos h]; simp
-    · rw [List.filter_cons_of_neg h]; simp
-
-theorem toList_pmap {p : α → Prop} {o : Option α} {f : (a : α) → p a → β}
-    (h : ∀ a, o = some a → p a) :
-    (o.pmap f h).toList = o.attach.toList.map (fun x => f x.1 (h _ x.2)) := by
-  cases o <;> simp
-
-theorem toArray_pmap {p : α → Prop} {o : Option α} {f : (a : α) → p a → β}
-    (h : ∀ a, o = some a → p a) :
-    (o.pmap f h).toArray = o.attach.toArray.map (fun x => f x.1 (h _ x.2)) := by
-  cases o <;> simp
-
-@[grind =] theorem attach_pfilter {o : Option α} {p : (a : α) → o = some a → Bool} :
-    (o.pfilter p).attach =
-      o.attach.pbind fun x h => if h' : p x (by simp_all) then
-        some ⟨x.1, by simpa [pfilter_eq_some_iff] using ⟨_, h'⟩⟩ else none := by
-  cases o with
-  | none => simp
-  | some a =>
-    simp only [attach_some, eq_mp_eq_cast, id_eq, pbind_some]
-    rw [attach_congr pfilter_some]
-    split <;> simp [*]
-
-theorem attach_guard {p : α → Bool} {x : α} :
-    (guard p x).attach = if h : p x then some ⟨x, by simp_all⟩ else none := by
-  simp only [guard_eq_ite]
-  split <;> simp [*]
-
-theorem attachWith_guard {q : α → Bool} {x : α} {P : α → Prop}
-    {h : ∀ a, guard q x = some a → P a} :
-    (guard q x).attachWith P h = if h' : q x then some ⟨x, h _ (by simp_all)⟩ else none := by
-  simp only [guard_eq_ite]
-  split <;> simp [*]
-
 /-! ## unattach
 
 `Option.unattach` is the (one-sided) inverse of `Option.attach`. It is a synonym for `Option.map Subtype.val`.
@@ -325,7 +233,6 @@ If this function is encountered in a proof state, the right approach is usually
 
 It is a synonym for `Option.map Subtype.val`.
 -/
-@[expose]
 def unattach {α : Type _} {p : α → Prop} (o : Option { x // p x }) := o.map (·.val)
 
 @[simp] theorem unattach_none {p : α → Prop} : (none : Option { x // p x }).unattach = none := rfl
@@ -348,29 +255,6 @@ def unattach {α : Type _} {p : α → Prop} (o : Option { x // p x }) := o.map
     (o.attachWith p H).unattach = o := by
   cases o <;> simp
 
-theorem unattach_eq_some_iff {p : α → Prop} {o : Option { x // p x }} {x : α} :
-    o.unattach = some x ↔ ∃ h, o = some ⟨x, h⟩ :=
-  match o with
-  | none => by simp
-  | some ⟨y, h⟩ => by simpa using fun h' => h' ▸ h
-
-@[simp]
-theorem unattach_eq_none_iff {p : α → Prop} {o : Option { x // p x }} :
-    o.unattach = none ↔ o = none := by
-  cases o <;> simp
-
-theorem get_unattach {p : α → Prop} {o : Option { x // p x }} {h} :
-    o.unattach.get h = (o.get (by simpa using h)).1 := by
-  cases o <;> simp
-
-theorem toList_unattach {p : α → Prop} {o : Option { x // p x }} :
-    o.unattach.toList = o.toList.unattach := by
-  cases o <;> simp
-
-theorem toArray_unattach {p : α → Prop} {o : Option { x // p x }} :
-    o.unattach.toArray = o.toArray.unattach := by
-  cases o <;> simp
-
 /-! ### Recognizing higher order functions on subtypes using a function that only depends on the value. -/
 
 /--
@@ -395,51 +279,4 @@ and simplifies these to the function directly taking the value.
   · simp only [filter_some, hf, unattach_some]
     split <;> simp
 
-@[simp] theorem unattach_guard {p : α → Prop} {q : { x // p x } → Bool} {r : α → Bool}
-    (hq : ∀ x h, q ⟨x, h⟩ = r x) {x : { x // p x }} :
-    (guard q x).unattach = guard r x.1 := by
-  simp only [guard]
-  split <;> simp_all
-
-@[simp] theorem unattach_pfilter {p : α → Prop} {o : Option { x // p x }}
-    {f : (a : { x // p x }) → o = some a → Bool}
-    {g : (a : α) → o.unattach = some a → Bool} (hf : ∀ x h h', f ⟨x, h⟩ h' = g x (by simp_all)) :
-    (o.pfilter f).unattach = o.unattach.pfilter g := by
-  cases o with
-  | none => simp
-  | some a =>
-    simp only [hf, pfilter_some, unattach_some]
-    split <;> simp
-
-@[simp] theorem unattach_merge {p : α → Prop} {f : { x // p x } → { x // p x } → { x // p x }}
-    {g : α → α → α} (hf : ∀ x h y h', (f ⟨x, h⟩ ⟨y, h'⟩).1 = g x y) {o o' : Option { x // p x }} :
-    (o.merge f o').unattach = o.unattach.merge g o'.unattach := by
-  cases o <;> cases o' <;> simp [*]
-
-theorem any_attach {p : α → Bool} {o : Option α} {q : { x // o = some x } → Bool}
-    (h : ∀ x h, q ⟨x, h⟩ = p x) : o.attach.any q = o.any p := by
-  cases o <;> simp [*]
-
-theorem any_attachWith {p : α → Bool} {o : Option α} {r : α → Prop} (hr : ∀ x, o = some x → r x)
-    {q : { x // r x } → Bool}
-    (h : ∀ x h, q ⟨x, h⟩ = p x) : (o.attachWith r hr).any q = o.any p := by
-  cases o <;> simp [*]
-
-theorem any_unattach {p : α → Prop} {o : Option { x // p x }} {q : α → Bool} :
-    o.unattach.any q = o.any (q ∘ Subtype.val) := by
-  cases o <;> simp
-
-theorem all_attach {p : α → Bool} {o : Option α} {q : { x // o = some x } → Bool}
-    (h : ∀ x h, q ⟨x, h⟩ = p x) : o.attach.all q = o.all p := by
-  cases o <;> simp [*]
-
-theorem all_attachWith {p : α → Bool} {o : Option α} {r : α → Prop} (hr : ∀ x, o = some x → r x)
-    {q : { x // r x } → Bool}
-    (h : ∀ x h, q ⟨x, h⟩ = p x) : (o.attachWith r hr).all q = o.all p := by
-  cases o <;> simp [*]
-
-theorem all_unattach {p : α → Prop} {o : Option { x // p x }} {q : α → Bool} :
-    o.unattach.all q = o.all (q ∘ Subtype.val) := by
-  cases o <;> simp
-
 end Option

src/Init/Data/Option/Basic.lean

@@ -102,9 +102,11 @@ From the perspective of `Option` as a collection with at most one element, the m
 is applied to the element if present, and the final result is empty if either the initial or the
 resulting collections are empty.
 -/
-@[inline] protected def bindM [Pure m] (f : α → m (Option β)) : Option α → m (Option β)
-  | none => pure none
-  | some a => f a
+@[inline] protected def bindM [Monad m] (f : α → m (Option β)) (o : Option α) : m (Option β) := do
+  if let some a := o then
+    return (← f a)
+  else
+    return none
 
 /--
 Applies a function in some applicative functor to an optional value, returning `none` with no
@@ -435,7 +437,7 @@ This is the monadic analogue of `Option.getD`.
 @[simp, grind] theorem getDM_some [Pure m] (a : α) (y : m α) : (some a).getDM y = pure a := rfl
 
 instance (α) [BEq α] [ReflBEq α] : ReflBEq (Option α) where
-  rfl {x} := private
+  rfl {x} :=
     match x with
     | some _ => BEq.rfl (α := α)
     | none => rfl

src/Init/Data/Option/BasicAux.lean

@@ -16,7 +16,7 @@ namespace Option
 /--
 Extracts the value from an `Option`, panicking on `none`.
 -/
-@[inline, expose] def get! {α : Type u} [Inhabited α] : Option α → α
+@[inline] def get! {α : Type u} [Inhabited α] : Option α → α
   | some x => x
   | none   => panic! "value is none"
 

src/Init/Data/Option/Instances.lean

@@ -87,7 +87,7 @@ some ⟨3, ⋯⟩
 none
 ```
 -/
-@[inline, expose]
+@[inline]
 def pbind : (o : Option α) → (f : (a : α) → o = some a → Option β) → Option β
   | none, _ => none
   | some a, f => f a rfl
@@ -114,7 +114,7 @@ some ⟨3, ⋯⟩
 none
 ```
 -/
-@[inline, expose] def pmap {p : α → Prop}
+@[inline] def pmap {p : α → Prop}
     (f : ∀ a : α, p a → β) :
     (o : Option α) → (∀ a, o = some a → p a) → Option β
   | none, _ => none
@@ -147,14 +147,14 @@ some ⟨3, ⋯⟩
 none
 ```
 -/
-@[inline, expose] def pelim (o : Option α) (b : β) (f : (a : α) → o = some a → β) : β :=
+@[inline] def pelim (o : Option α) (b : β) (f : (a : α) → o = some a → β) : β :=
   match o with
   | none => b
   | some a => f a rfl
 
 /-- Partial filter. If `o : Option α`, `p : (a : α) → o = some a → Bool`, then `o.pfilter p` is
 the same as `o.filter p` but `p` is passed the proof that `o = some a`. -/
-@[inline, expose] def pfilter (o : Option α) (p : (a : α) → o = some a → Bool) : Option α :=
+@[inline] def pfilter (o : Option α) (p : (a : α) → o = some a → Bool) : Option α :=
   match o with
   | none => none
   | some a => bif p a rfl then o else none
@@ -177,7 +177,7 @@ Examples:
 ((), 0)
 ```
 -/
-@[inline, expose] protected def forM [Pure m] : Option α → (α → m PUnit) → m PUnit
+@[inline] protected def forM [Pure m] : Option α → (α → m PUnit) → m PUnit
   | none  , _ => pure ⟨⟩
   | some a, f => f a