refactor: remove error message explanations from extension

.claude/CLAUDE.md

@@ -29,23 +29,6 @@ After rebuilding, LSP diagnostics may be stale until the user interacts with fil
 
 If the user expresses frustration with you, stop and ask them to help update this `.claude/CLAUDE.md` file with missing guidance.
 
-## Creating pull requests
+## Creating pull requests.
 
-Follow the commit convention in `doc/dev/commit_convention.md`.
-
-**Title format:** `<type>: <subject>` where type is one of: `feat`, `fix`, `doc`, `style`, `refactor`, `test`, `chore`, `perf`.
-Subject should use imperative present tense ("add" not "added"), no capitalization, no trailing period.
-
-**Body format:** The first paragraph must start with "This PR". This paragraph is automatically incorporated into release notes. Use imperative present tense. Include motivation and contrast with previous behavior when relevant.
-
-Example:
-```
-feat: add optional binder limit to `mkPatternFromTheorem`
-
-This PR adds a `num?` parameter to `mkPatternFromTheorem` to control how many
-leading quantifiers are stripped when creating a pattern.
-```
-
-## CI Log Retrieval
-
-When CI jobs fail, investigate immediately - don't wait for other jobs to complete. Individual job logs are often available even while other jobs are still running. Try `gh run view <run-id> --log` or `gh run view <run-id> --log-failed`, or use `gh run view <run-id> --job=<job-id>` to target the specific failed job. Sleeping is fine when asked to monitor CI and no failures exist yet, but once any job fails, investigate that failure immediately.
+All PRs must have a first paragraph starting with "This PR". This paragraph is automatically incorporated into release notes. Read `lean4/doc/dev/commit_convention.md` when making PRs.

.github/workflows/actionlint.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Checkout
-      uses: actions/checkout@v6
+      uses: actions/checkout@v5
     - name: actionlint
       uses: raven-actions/actionlint@v2
       with:

.github/workflows/build-template.yml

@@ -67,13 +67,13 @@ jobs:
         if: runner.os == 'macOS'
       - name: Checkout
         if: (!endsWith(matrix.os, '-with-cache'))
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           # the default is to use a virtual merge commit between the PR and master: just use the PR
           ref: ${{ github.event.pull_request.head.sha }}
       - name: Namespace Checkout
         if: endsWith(matrix.os, '-with-cache')
-        uses: namespacelabs/nscloud-checkout-action@v8
+        uses: namespacelabs/nscloud-checkout-action@v7
         with:
           ref: ${{ github.event.pull_request.head.sha }}
       - name: Open Nix shell once

.github/workflows/check-prelude.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           # the default is to use a virtual merge commit between the PR and master: just use the PR
           ref: ${{ github.event.pull_request.head.sha }}

.github/workflows/check-stage0.yml

@@ -8,7 +8,7 @@ jobs:
   check-stage0-on-queue:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v5
       with:
         ref: ${{ github.event.pull_request.head.sha }}
         fetch-depth: 0

.github/workflows/ci.yml

@@ -50,7 +50,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         # don't schedule nightlies on forks
         if: github.event_name == 'schedule' && github.repository == 'leanprover/lean4' || inputs.action == 'release nightly' || (startsWith(github.ref, 'refs/tags/') && github.repository == 'leanprover/lean4')
       - name: Set Nightly
@@ -267,17 +267,14 @@ jobs:
                 "test": true,
                 // turn off custom allocator & symbolic functions to make LSAN do its magic
                 "CMAKE_PRESET": "sanitize",
-                // * `StackOverflow*` correctly triggers ubsan.
-                // * `reverse-ffi` fails to link in sanitizers.
-                // * `interactive` and `async_select_channel` fail nondeterministically, would need
-                //   to be investigated..
-                // * 9366 is too close to timeout.
-                // * `bv_` sometimes times out calling into cadical even though we should be using
-                //   the standard compile flags for it.
-                // * `grind_guide` always times out.
-                // * `pkg/|lake/` tests sometimes time out (likely even hang), related to Lake CI
-                //   failures?
-                "CTEST_OPTIONS": "-E 'StackOverflow|reverse-ffi|interactive|async_select_channel|9366|run/bv_|grind_guide|pkg/|lake/'"
+                // `StackOverflow*` correctly triggers ubsan.
+                // `reverse-ffi` fails to link in sanitizers.
+                // `interactive` and `async_select_channel` fail nondeterministically, would need to
+                // be investigated..
+                // 9366 is too close to timeout.
+                // `bv_` sometimes times out calling into cadical even though we should be using the
+                // standard compile flags for it.
+                "CTEST_OPTIONS": "-E 'StackOverflow|reverse-ffi|interactive|async_select_channel|9366|run/bv_'"
               },
               {
                 "name": "macOS",
@@ -437,7 +434,7 @@ jobs:
         with:
           path: artifacts
       - name: Release
-        uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b
+        uses: softprops/action-gh-release@6da8fa9354ddfdc4aeace5fc48d7f679b5214090
         with:
           files: artifacts/*/*
           fail_on_unmatched_files: true
@@ -458,7 +455,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           # needed for tagging
           fetch-depth: 0
@@ -483,7 +480,7 @@ jobs:
           echo -e "\n*Full commit log*\n" >> diff.md
           git log --oneline "$last_tag"..HEAD | sed 's/^/* /' >> diff.md
       - name: Release Nightly
-        uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b
+        uses: softprops/action-gh-release@6da8fa9354ddfdc4aeace5fc48d7f679b5214090
         with:
           body_path: diff.md
           prerelease: true

.github/workflows/copyright-header.yml

@@ -6,7 +6,7 @@ jobs:
   check-lean-files:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v5
 
     - name: Verify .lean files start with a copyright header.
       run: |

.github/workflows/pr-release.yml

@@ -71,7 +71,7 @@ jobs:
           GH_TOKEN: ${{ secrets.PR_RELEASES_TOKEN }}
       - name: Release (short format)
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
-        uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b
+        uses: softprops/action-gh-release@6da8fa9354ddfdc4aeace5fc48d7f679b5214090
         with:
           name: Release for PR ${{ steps.workflow-info.outputs.pullRequestNumber }}
           # There are coredumps files here as well, but all in deeper subdirectories.
@@ -86,7 +86,7 @@ jobs:
 
       - name: Release (SHA-suffixed format)
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
-        uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b
+        uses: softprops/action-gh-release@6da8fa9354ddfdc4aeace5fc48d7f679b5214090
         with:
           name: Release for PR ${{ steps.workflow-info.outputs.pullRequestNumber }} (${{ steps.workflow-info.outputs.sourceHeadSha }})
           # There are coredumps files here as well, but all in deeper subdirectories.
@@ -166,14 +166,22 @@ jobs:
           if [ "$NIGHTLY_SHA" = "$MERGE_BASE_SHA" ]; then
             echo "The merge base of this PR coincides with the nightly release"
 
+            BATTERIES_REMOTE_TAGS="$(git ls-remote https://github.com/leanprover-community/batteries.git nightly-testing-"$MOST_RECENT_NIGHTLY")"
             MATHLIB_REMOTE_TAGS="$(git ls-remote https://github.com/leanprover-community/mathlib4-nightly-testing.git nightly-testing-"$MOST_RECENT_NIGHTLY")"
 
-            if [[ -n "$MATHLIB_REMOTE_TAGS" ]]; then
-              echo "... and Mathlib has a 'nightly-testing-$MOST_RECENT_NIGHTLY' tag."
+            if [[ -n "$BATTERIES_REMOTE_TAGS" ]]; then
+              echo "... and Batteries has a 'nightly-testing-$MOST_RECENT_NIGHTLY' tag."
               MESSAGE=""
+
+              if [[ -n "$MATHLIB_REMOTE_TAGS" ]]; then
+                echo "... and Mathlib has a 'nightly-testing-$MOST_RECENT_NIGHTLY' tag."
+              else
+                echo "... but Mathlib does not yet have a 'nightly-testing-$MOST_RECENT_NIGHTLY' tag."
+                MESSAGE="- ❗ Mathlib CI can not be attempted yet, as the \`nightly-testing-$MOST_RECENT_NIGHTLY\` tag does not exist there yet. We will retry when you push more commits. If you rebase your branch onto \`nightly-with-mathlib\`, Mathlib CI should run now."
+              fi
             else
-              echo "... but Mathlib does not yet have a 'nightly-testing-$MOST_RECENT_NIGHTLY' tag."
-              MESSAGE="- ❗ Mathlib CI can not be attempted yet, as the \`nightly-testing-$MOST_RECENT_NIGHTLY\` tag does not exist there yet. We will retry when you push more commits. If you rebase your branch onto \`nightly-with-mathlib\`, Mathlib CI should run now."
+              echo "... but Batteries does not yet have a 'nightly-testing-$MOST_RECENT_NIGHTLY' tag."
+              MESSAGE="- ❗ Batteries CI can not be attempted yet, as the \`nightly-testing-$MOST_RECENT_NIGHTLY\` tag does not exist there yet. We will retry when you push more commits. If you rebase your branch onto \`nightly-with-mathlib\`, Batteries CI should run now."
             fi
           else
             echo "The most recently nightly tag on this branch has SHA: $NIGHTLY_SHA"
@@ -387,7 +395,7 @@ jobs:
       # Checkout the Batteries repository with all branches
       - name: Checkout Batteries repository
         if: steps.workflow-info.outputs.pullRequestNumber != '' && steps.ready.outputs.mathlib_ready == 'true'
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           repository: leanprover-community/batteries
           token: ${{ secrets.MATHLIB4_BOT }}
@@ -447,7 +455,7 @@ jobs:
       # Checkout the mathlib4 repository with all branches
       - name: Checkout mathlib4 repository
         if: steps.workflow-info.outputs.pullRequestNumber != '' && steps.ready.outputs.mathlib_ready == 'true'
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           repository: leanprover-community/mathlib4-nightly-testing
           token: ${{ secrets.MATHLIB4_BOT }}
@@ -530,7 +538,7 @@ jobs:
       # Checkout the reference manual repository with all branches
       - name: Checkout mathlib4 repository
         if: steps.workflow-info.outputs.pullRequestNumber != '' && steps.reference-manual-ready.outputs.manual_ready == 'true'
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           repository: leanprover/reference-manual
           token: ${{ secrets.MANUAL_PR_BOT }}

.github/workflows/update-stage0.yml

@@ -27,7 +27,7 @@ jobs:
     # This action should push to an otherwise protected branch, so it
     # uses a deploy key with write permissions, as suggested at
     # https://stackoverflow.com/a/76135647/946226
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v5
       with:
         ssh-key: ${{secrets.STAGE0_SSH_KEY}}
     - run: echo "should_update_stage0=yes" >> "$GITHUB_ENV"

doc/dev/ffi.md

@@ -1,9 +1,189 @@
 # Foreign Function Interface
 
-The Lean FFI documentation is now part of the [Lean language reference](https://lean-lang.org/doc/reference/latest/).
+NOTE: The current interface was designed for internal use in Lean and should be considered **unstable**.
+It will be refined and extended in the future.
 
- * [General FFI](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=ffi)
- * [Representation of inductive types](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=inductive-types-ffi)
- * [String](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=string-ffi)
- * [Array](https://lean-lang.org/doc/reference/latest/find/?domain=Verso.Genre.Manual.section&name=array-ffi)
+As Lean is written partially in Lean itself and partially in C++, it offers efficient interoperability between the two languages (or rather, between Lean and any language supporting C interfaces).
+This support is however currently limited to transferring Lean data types; in particular, it is not possible yet to pass or return compound data structures such as C `struct`s by value from or to Lean.
 
+There are two primary attributes for interoperating with other languages:
+* `@[extern "sym"] constant leanSym : ...` binds a Lean declaration to the external symbol `sym`.
+  It can also be used with `def` to provide an internal definition, but ensuring consistency of both definitions is up to the user.
+* `@[export sym] def leanSym : ...` exports `leanSym` under the unmangled symbol name `sym`.
+
+For simple examples of how to call foreign code from Lean and vice versa, see <https://github.com/leanprover/lean4/blob/master/src/lake/examples/ffi> and <https://github.com/leanprover/lean4/blob/master/src/lake/examples/reverse-ffi>, respectively.
+
+## The Lean ABI
+
+The Lean Application Binary Interface (ABI) describes how the signature of a Lean declaration is encoded as a native calling convention.
+It is based on the standard C ABI and calling convention of the target platform.
+For a Lean declaration marked with either `@[extern "sym"]` or `@[export sym]` for some symbol name `sym`, let `α₁ → ... → αₙ → β` be the normalized declaration's type.
+If `n` is 0, the corresponding C declaration is
+```c
+extern s sym;
+```
+where `s` is the C translation of `β` as specified in the next section.
+In the case of an `@[extern]` definition, the symbol's value is guaranteed to be initialized only after calling the Lean module's initializer or that of an importing module; see [Initialization](#initialization).
+
+If `n` is greater than 0, the corresponding C declaration is
+```c
+s sym(t₁, ..., tₘ);
+```
+where the parameter types `tᵢ` are the C translation of the `αᵢ` as in the next section.
+In the case of `@[extern]` all *irrelevant* types are removed first; see next section.
+
+### Translating Types from Lean to C
+
+* The integer types `UInt8`, ..., `UInt64`, `USize` are represented by the C types `uint8_t`, ..., `uint64_t`, `size_t`, respectively
+* `Char` is represented by `uint32_t`
+* `Float` is represented by `double`
+* An *enum* inductive type of at least 2 and at most 2^32 constructors, each of which with no parameters, is represented by the first type of `uint8_t`, `uint16_t`, `uint32_t` that is sufficient to represent all constructor indices.
+
+  For example, the type `Bool` is represented as `uint8_t` with values `0` for `false` and `1` for `true`.
+* `Decidable α` is represented the same way as `Bool`
+* An inductive type with a *trivial structure*, that is,
+  * it is none of the types described above
+  * it is not marked `unsafe`
+  * it has a single constructor with a single parameter of *relevant* type
+
+  is represented by the representation of that parameter's type.
+
+  For example, `{ x : α // p }`, the `Subtype` structure of a value of type `α` and an irrelevant proof, is represented by the representation of `α`.
+  Similarly, the signed integer types `Int8`, ..., `Int64`, `ISize` are also represented by the unsigned C types `uint8_t`, ..., `uint64_t`, `size_t`, respectively, because they have a trivial structure.
+* `Nat` and `Int` are represented by `lean_object *`.
+  Their runtime values is either a pointer to an opaque bignum object or, if the lowest bit of the "pointer" is 1 (`lean_is_scalar`), an encoded unboxed natural number or integer (`lean_box`/`lean_unbox`).
+* A universe `Sort u`, type constructor `... → Sort u`, `Void α` or proposition `p : Prop` is *irrelevant* and is either statically erased (see above) or represented as a `lean_object *` with the runtime value `lean_box(0)`
+* Any other type is represented by `lean_object *`.
+  Its runtime value is a pointer to an object of a subtype of `lean_object` (see the "Inductive types" section below) or the unboxed value `lean_box(cidx)` for the `cidx`th constructor of an inductive type if this constructor does not have any relevant parameters.
+
+  Example: the runtime value of `u : Unit` is always `lean_box(0)`.
+
+#### Inductive types
+
+For inductive types which are in the fallback `lean_object *` case above and not trivial constructors, the type is stored as a `lean_ctor_object`, and `lean_is_ctor` will return true. A `lean_ctor_object` stores the constructor index in the header, and the fields are stored in the `m_objs` portion of the object.
+
+The memory order of the fields is derived from the types and order of the fields in the declaration. They are ordered as follows:
+
+* Non-scalar fields stored as `lean_object *`
+* Fields of type `USize`
+* Other scalar fields, in decreasing order by size
+
+Within each group the fields are ordered in declaration order. Trivial wrapper types count as their underlying wrapped type for this purpose.
+
+* To access fields of the first kind, use `lean_ctor_get(val, i)` to get the `i`th non-scalar field.
+* To access `USize` fields, use `lean_ctor_get_usize(val, n+i)` to get the `i`th usize field and `n` is the total number of fields of the first kind.
+* To access other scalar fields, use `lean_ctor_get_uintN(val, off)` or `lean_ctor_get_usize(val, off)` as appropriate. Here `off` is the byte offset of the field in the structure, starting at `n*sizeof(void*)` where `n` is the number of fields of the first two kinds.
+
+For example, a structure such as
+```lean
+structure S where
+  ptr_1 : Array Nat
+  usize_1 : USize
+  sc64_1 : UInt64
+  sc64_2 : { x : UInt64 // x > 0 } -- wrappers of scalars count as scalars
+  sc64_3 : Float -- `Float` is 64 bit
+  sc8_1 : Bool
+  sc16_1 : UInt16
+  sc8_2 : UInt8
+  sc64_4 : UInt64
+  usize_2 : USize
+  sc32_1 : Char -- trivial wrapper around `UInt32`
+  sc32_2 : UInt32
+  sc16_2 : UInt16
+```
+would get re-sorted into the following memory order:
+
+* `S.ptr_1` - `lean_ctor_get(val, 0)`
+* `S.usize_1` - `lean_ctor_get_usize(val, 1)`
+* `S.usize_2` - `lean_ctor_get_usize(val, 2)`
+* `S.sc64_1` - `lean_ctor_get_uint64(val, sizeof(void*)*3)`
+* `S.sc64_2` - `lean_ctor_get_uint64(val, sizeof(void*)*3 + 8)`
+* `S.sc64_3` - `lean_ctor_get_float(val, sizeof(void*)*3 + 16)`
+* `S.sc64_4` - `lean_ctor_get_uint64(val, sizeof(void*)*3 + 24)`
+* `S.sc32_1` - `lean_ctor_get_uint32(val, sizeof(void*)*3 + 32)`
+* `S.sc32_2` - `lean_ctor_get_uint32(val, sizeof(void*)*3 + 36)`
+* `S.sc16_1` - `lean_ctor_get_uint16(val, sizeof(void*)*3 + 40)`
+* `S.sc16_2` - `lean_ctor_get_uint16(val, sizeof(void*)*3 + 42)`
+* `S.sc8_1` - `lean_ctor_get_uint8(val, sizeof(void*)*3 + 44)`
+* `S.sc8_2` - `lean_ctor_get_uint8(val, sizeof(void*)*3 + 45)`
+
+### Borrowing
+
+By default, all `lean_object *` parameters of an `@[extern]` function are considered *owned*, i.e. the external code is passed a "virtual RC token" and is responsible for passing this token along to another consuming function (exactly once) or freeing it via `lean_dec`.
+To reduce reference counting overhead, parameters can be marked as *borrowed* by prefixing their type with `@&`.
+Borrowed objects must only be passed to other non-consuming functions (arbitrarily often) or converted to owned values using `lean_inc`.
+In `lean.h`, the `lean_object *` aliases `lean_obj_arg` and `b_lean_obj_arg` are used to mark this difference on the C side.
+
+Return values and `@[export]` parameters are always owned at the moment.
+
+## Initialization
+
+When including Lean code as part of a larger program, modules must be *initialized* before accessing any of their declarations.
+Module initialization entails
+* initialization of all "constants" (nullary functions), including closed terms lifted out of other functions
+* execution of all `[init]` functions
+* execution of all `[builtin_init]` functions, if the `builtin` parameter of the module initializer has been set
+
+The module initializer is automatically run with the `builtin` flag for executables compiled from Lean code and for "plugins" loaded with `lean --plugin`.
+For all other modules imported by `lean`, the initializer is run without `builtin`.
+Thus `[init]` functions are run iff their module is imported, regardless of whether they have native code available or not, while `[builtin_init]` functions are only run for native executable or plugins, regardless of whether their module is imported or not.
+`lean` uses built-in initializers for e.g. registering basic parsers that should be available even without importing their module (which is necessary for bootstrapping).
+
+The initializer for module `A.B` in a package `foo` is called `initialize_foo_A_B`. For modules in the Lean core (e.g., `Init.Prelude`), the initializer is called `initialize_Init_Prelude`. Module initializers will automatically initialize any imported modules. They are also idempotent (when run with the same `builtin` flag), but not thread-safe.
+
+**Important for process-related functionality**: If your application needs to use process-related functions from libuv, such as `Std.Internal.IO.Process.getProcessTitle` and `Std.Internal.IO.Process.setProcessTitle`, you must call `lean_setup_args(argc, argv)` (which returns a potentially modified `argv` that must be used in place of the original) **before** calling `lean_initialize()` or `lean_initialize_runtime_module()`. This sets up process handling capabilities correctly, which is essential for certain system-level operations that Lean's runtime may depend on.
+
+Together with initialization of the Lean runtime, you should execute code like the following exactly once before accessing any Lean declarations:
+
+```c
+void lean_initialize_runtime_module();
+void lean_initialize();
+char ** lean_setup_args(int argc, char ** argv);
+
+lean_object * initialize_A_B(uint8_t builtin);
+lean_object * initialize_C(uint8_t builtin);
+...
+
+argv = lean_setup_args(argc, argv); // if using process-related functionality
+lean_initialize_runtime_module();
+//lean_initialize();  // necessary (and replaces `lean_initialize_runtime_module`) if you (indirectly) access the `Lean` package
+
+lean_object * res;
+// use same default as for Lean executables
+uint8_t builtin = 1;
+res = initialize_A_B(builtin);
+if (lean_io_result_is_ok(res)) {
+    lean_dec_ref(res);
+} else {
+    lean_io_result_show_error(res);
+    lean_dec(res);
+    return ...;  // do not access Lean declarations if initialization failed
+}
+res = initialize_C(builtin);
+if (lean_io_result_is_ok(res)) {
+...
+
+//lean_init_task_manager();  // necessary if you (indirectly) use `Task`
+lean_io_mark_end_initialization();
+```
+
+In addition, any other thread not spawned by the Lean runtime itself must be initialized for Lean use by calling
+```c
+void lean_initialize_thread();
+```
+and should be finalized in order to free all thread-local resources by calling
+```c
+void lean_finalize_thread();
+```
+
+## `@[extern]` in the Interpreter
+
+The interpreter can run Lean declarations for which symbols are available in loaded shared libraries, which includes `@[extern]` declarations.
+Thus to e.g. run `#eval` on such a declaration, you need to
+1. compile (at least) the module containing the declaration and its dependencies into a shared library, and then
+1. pass this library to `lean --load-dynlib=` to run code `import`ing this module.
+
+Note that it is not sufficient to load the foreign library containing the external symbol because the interpreter depends on code that is emitted for each `@[extern]` declaration.
+Thus it is not possible to interpret an `@[extern]` declaration in the same file.
+
+See [`tests/compiler/foreign`](https://github.com/leanprover/lean4/tree/master/tests/compiler/foreign/) for an example.

doc/style.md

@@ -810,7 +810,7 @@ Docstrings for constants should have the following structure:
 
 The **short summary** should be 1–3 sentences (ideally 1) and provide
 enough information for most readers to quickly decide whether the
-constant is relevant to their task. The first (or only) sentence of
+docstring is relevant to their task. The first (or only) sentence of
 the short summary should be a *sentence fragment* in which the subject
 is implied to be the documented item, written in present tense
 indicative, or a *noun phrase* that characterizes the documented
@@ -1123,110 +1123,6 @@ infix:50 " ⇔ " => Bijection
 recommended_spelling "bij" for "⇔" in [Bijection, «term_⇔_»]
 ```
 
-#### Tactics
-
-Docstrings for tactics should have the following structure:
-
-* Short summary
-* Details
-* Variants
-* Examples
-
-Sometimes more than one declaration is needed to implement what the user
-sees as a single tactic. In that case, only one declaration should have
-the associated docstring, and the others should have the `tactic_alt`
-attribute to mark them as an implementation detail.
-
-The **short summary** should be 1–3 sentences (ideally 1) and provide
-enough information for most readers to quickly decide whether the
-tactic is relevant to their task. The first (or only) sentence of
-the short summary should be a full sentence in which the subject
-is an example invocation of the tactic, written in present tense
-indicative. If the example tactic invocation names parameters, then the
-short summary may refer to them. For the example invocation, prefer the
-simplest or most typical example. Explain more complicated forms in the
-variants section. If needed, abbreviate the invocation by naming part of
-the syntax and expanding it in the next sentence. The summary should be
-written as a single paragraph.
-
-**Details**, if needed, may be 1-3 paragraphs that describe further
-relevant information. They may insert links as needed. This section
-should fully explain the scope of the tactic: its syntax format,
-on which goals it works and what the resulting goal(s) look like. It
-should be clear whether the tactic fails if it does not close the main
-goal and whether it creates any side goals. The details may include
-explanatory examples that can’t necessarily be machine checked and
-don’t fit the format.
-
-If the tactic is extensible using `macro_rules`, mention this in the
-details, with a link to `lean-manual://section/tactic-macro-extension`
-and give a one-line example. If the tactic provides an attribute or a
-command that allows the user to extend its behavior, the documentation
-on how to extend the tactic belongs to that attribute or command. In the
-tactic docstring, use a single sentence to refer the reader to this
-further documentation.
-
-**Variants**, if needed, should be a bulleted list describing different
-options and forms of the same tactic. The reader should be able to parse
-and understand the parts of a tactic invocation they are hovering over,
-using this list. Each list item should describe an individual variant
-and take one of two formats: the **short summary** as above, or a
-**named list item**. A named list item consists of a title in bold
-followed by an indented short paragraph.
-
-Variants should be explained from the perspective of the tactic's users, not
-their implementers. A tactic that is implemented as a single Lean parser may
-have multiple variants from the perspective of users, while a tactic that is
-implemented as multiple parsers may have no variants, but merely an optional
-part of the syntax.
-
-**Examples** should start with the line `Examples:` (or `Example:` if
-there’s exactly one). The section should consist of a sequence of code
-blocks, each showing a Lean declaration (usually with the `example`
-keyword) that invokes the tactic. When the effect of the tactic is not
-clear from the code, you can use code comments to describe this. Do
-not include text between examples, because it can be unclear whether
-the text refers to the code before or after the example.
-
-##### Example
-
-````
-`rw [e]` uses the expression `e` as a rewrite rule on the main goal,
-then tries to close the goal by "cheap" (reducible) `rfl`.
-
-If `e` is a defined constant, then the equational theorems associated with `e`
-are used. This provides a convenient way to unfold `e`. If `e` has parameters,
-the tactic will try to fill these in by unification with the matching part of
-the target. Parameters are only filled in once per rule, restricting which
-later rewrites can be found. Parameters that are not filled in after
-unification will create side goals. If the `rfl` fails to close the main goal,
-no error is raised.
-
-`rw` may fail to rewrite terms "under binders", such as `∀ x, ...` or `∃ x,
-...`. `rw` can also fail with a "motive is type incorrect" error in the context
-of dependent types. In these cases, consider using `simp only`.
-
-* `rw [e₁, ... eₙ]` applies the given rules sequentially.
-* `rw [← e]` or `rw [<- e]` applies the rewrite in the reverse direction.
-* `rw [e] at l` rewrites with `e` at location(s) `l`.
-* `rw (occs := .pos L) [e]`, where `L` is a literal list of natural numbers,
-  only rewrites the given occurrences in the target. Occurrences count from 1.
-* `rw (occs := .neg L) [e]`, where `L` is a literal list of natural numbers,
-  skips rewriting the given occurrences in the target. Occurrences count from 1.
-
-Examples:
-
-```lean
-example {a b : Nat} (h : a + a = b) : (a + a) + (a + a) = b + b := by rw [h]
-```
-
-```lean
-example {f : Nat -> Nat} (h : ∀ x, f x = 1) (a b : Nat) : f a = f b := by
-  rw [h] -- `rw` instantiates `h` only once, so this is equivalent to: `rw [h a]`
-  -- goal: ⊢ 1 = f b
-  rw [h] -- equivalent to: `rw [h b]`
-```
-````
 
 
 ## Dictionary

script/Shake.lean

@@ -5,13 +5,12 @@ Authors: Mario Carneiro, Sebastian Ullrich
 -/
 module
 
-prelude
-public import Init.Prelude
-public import Init.System.IO
-public import Lean.Util.Path
 import Lean.Environment
 import Lean.ExtraModUses
+
+import Lake.CLI.Main
 import Lean.Parser.Module
+import Lake.Load.Workspace
 
 /-! # Shake: A Lean import minimizer
 
@@ -21,12 +20,84 @@ ensuring that every import is used to contribute some constant or other elaborat
 recorded by `recordExtraModUse` and friends.
 -/
 
+/-- help string for the command line interface -/
+def help : String := "Lean project tree shaking tool
+Usage: lake exe shake [OPTIONS] <MODULE>..
+
+Arguments:
+  <MODULE>
+    A module path like `Mathlib`. All files transitively reachable from the
+    provided module(s) will be checked.
+
+Options:
+  --force
+    Skips the `lake build --no-build` sanity check
+
+  --keep-implied
+    Preserves existing imports that are implied by other imports and thus not technically needed
+    anymore
+
+  --keep-prefix
+    If an import `X` would be replaced in favor of a more specific import `X.Y...` it implies,
+    preserves the original import instead. More generally, prefers inserting `import X` even if it
+    was not part of the original imports as long as it was in the original transitive import closure
+    of the current module.
+
+  --keep-public
+    Preserves all `public` imports to avoid breaking changes for external downstream modules
+
+  --add-public
+    Adds new imports as `public` if they have been in the original public closure of that module.
+    In other words, public imports will not be removed from a module unless they are unused even
+    in the private scope, and those that are removed will be re-added as `public` in downstream
+    modules even if only needed in the private scope there. Unlike `--keep-public`, this may
+    introduce breaking changes but will still limit the number of inserted imports.
+
+  --explain
+    Gives constants explaining why each module is needed
+
+  --fix
+    Apply the suggested fixes directly. Make sure you have a clean checkout
+    before running this, so you can review the changes.
+
+  --gh-style
+    Outputs messages that can be parsed by `gh-problem-matcher-wrap`
+
+Annotations:
+  The following annotations can be added to Lean files in order to configure the behavior of
+  `shake`. Only the substring `shake: ` directly followed by a directive is checked for, so multiple
+  directives can be mixed in one line such as `-- shake: keep-downstream, shake: keep-all`, and they
+  can be surrounded by arbitrary comments such as `-- shake: keep (metaprogram output dependency)`.
+
+  * `module -- shake: keep-downstream`:
+    Preserves this module in all (current) downstream modules, adding new imports of it if needed.
+
+  * `module -- shake: keep-all`:
+    Preserves all existing imports in this module as is. New imports now needed because of upstream
+    changes may still be added.
+
+  * `import X -- shake: keep`:
+    Preserves this specific import in the current module. The most common use case is to preserve a
+    public import that will be needed in downstream modules to make sense of the output of a
+    metaprogram defined in this module. For example, if a tactic is defined that may synthesize a
+    reference to a theorem when run, there is no way for `shake` to detect this by itself and the
+    module of that theorem should be publicly imported and annotated with `keep` in the tactic's
+    module.
+    ```
+    public import X  -- shake: keep (metaprogram output dependency)
+
+    ...
+
+    elab \"my_tactic\" : tactic => do
+      ... mkConst ``f -- `f`, defined in `X`, may appear in the output of this tactic
+    ```
+"
+
 open Lean
 
-namespace Lake.Shake
-
-/-- The parsed CLI arguments for shake. -/
-public structure Args where
+/-- The parsed CLI arguments. See `help` for more information -/
+structure Args where
+  help : Bool := false
   keepImplied : Bool := false
   keepPrefix : Bool := false
   keepPublic : Bool := false
@@ -214,9 +285,7 @@ def isDeclMeta' (env : Environment) (declName : Name) : Bool :=
   -- references from any other context as compatible with both phases.
   let inferFor :=
     if declName.isStr && (declName.getString!.startsWith "match_" || declName.getString! == "_unsafe_rec") then declName.getPrefix else declName
-  -- `isMarkedMeta` knows about non-defs such as `meta structure`, isDeclMeta knows about decls
-  -- implicitly marked meta
-  isMarkedMeta env inferFor || isDeclMeta env inferFor
+  isDeclMeta env inferFor
 
 /--
 Given an `Expr` reference, returns the declaration name that should be considered the reference, if
@@ -267,14 +336,12 @@ where
                 deps := deps.union k {indMod}
       return deps
 
-abbrev Explanations := Std.HashMap (ModuleIdx × NeedsKind) (Option (Name × Name))
-
 /--
 Calculates the same as `calcNeeds` but tracing each module to a use-def declaration pair or
 `none` if merely a recorded extra use.
 -/
-def getExplanations (s : State) (i : ModuleIdx) : Explanations := Id.run do
-  let env := s.env
+def getExplanations (env : Environment) (i : ModuleIdx) :
+    Std.HashMap (ModuleIdx × NeedsKind) (Option (Name × Name)) := Id.run do
   let mut deps := default
   for ci in env.header.moduleData[i]!.constants do
     -- Added guard for cases like `structure` that are still exported even if private
@@ -295,25 +362,18 @@ def getExplanations (s : State) (i : ModuleIdx) : Explanations := Id.run do
 where
   /-- Accumulate the results from expression `e` into `deps`. -/
   visitExpr (k : NeedsKind) name e deps :=
-    let env := s.env
     Lean.Expr.foldConsts e deps fun c deps => Id.run do
       let mut deps := deps
       if let some c := getDepConstName? env c then
         if let some j := env.getModuleIdxFor? c then
           let k := { k with isMeta := k.isMeta && !isDeclMeta' env c }
-          deps := addExplanation j k name c deps
-        for indMod in (indirectModUseExt.getState env)[c]?.getD #[] do
-          if s.transDeps[i]!.has k indMod then
-            deps := addExplanation indMod k name (`_indirect ++ c) deps
+          if
+            if let some (some (name', _)) := deps[(j, k)]? then
+              decide (name.toString.length < name'.toString.length)
+            else true
+          then
+            deps := deps.insert (j, k) (name, c)
       return deps
-  addExplanation (j : ModuleIdx) (k : NeedsKind) (use def_ : Name) (deps : Explanations) : Explanations :=
-    if
-      if let some (some (name', _)) := deps[(j, k)]? then
-        decide (use.toString.length < name'.toString.length)
-      else true
-    then
-      deps.insert (j, k) (use, def_)
-    else deps
 
 partial def initStateFromEnv (env : Environment) : State := Id.run do
   let mut s := { env }
@@ -480,7 +540,7 @@ def visitModule (pkg : Name) (srcSearchPath : SearchPath)
         let mut imp : Import := { k with module := s.modNames[j]! }
         let mut j := j
         if args.trace then
-          IO.eprintln s!"`{imp}` is needed{if needs.has k j then " (calculated)" else ""}"
+          IO.eprintln s!"`{imp}` is needed"
         if args.addPublic && !k.isExported &&
             -- also add as public if previously `public meta`, which could be from automatic porting
             (s.transDepsOrig[i]!.has { k with isExported := true } j || s.transDepsOrig[i]!.has { k with isExported := true, isMeta := true } j) then
@@ -569,7 +629,7 @@ def visitModule (pkg : Name) (srcSearchPath : SearchPath)
         if toRemove.any fun imp => imp == decodeImport stx then
           let pos := inputCtx.fileMap.toPosition stx.raw.getPos?.get!
           println! "{path}:{pos.line}:{pos.column+1}: warning: unused import \
-            (use `lake shake --fix` to fix this, or `lake shake --update` to ignore)"
+            (use `lake exe shake --fix` to fix this, or `lake exe shake --update` to ignore)"
       if !toAdd.isEmpty then
         -- we put the insert message on the beginning of the last import line
         let pos := inputCtx.fileMap.toPosition endHeader.offset
@@ -598,7 +658,7 @@ def visitModule (pkg : Name) (srcSearchPath : SearchPath)
   modify fun s => { s with transDeps := s.transDeps.set! i newTransDepsI }
 
   if args.explain then
-    let explanation := getExplanations s i
+    let explanation := getExplanations s.env i
     let sanitize n := if n.hasMacroScopes then (sanitizeName n).run' { options := {} } else n
     let run (imp : Import) := do
       let j := s.env.getModuleIdx? imp.module |>.get!
@@ -614,31 +674,76 @@ def visitModule (pkg : Name) (srcSearchPath : SearchPath)
         run j
     for i in toAdd do run i
 
+/-- Convert a list of module names to a bitset of module indexes -/
+def toBitset (s : State) (ns : List Name) : Bitset :=
+  ns.foldl (init := ∅) fun c name =>
+    match s.env.getModuleIdxFor? name with
+    | some i => c ∪ {i}
+    | none => c
+
 local instance : Ord Import where
   compare :=
     let _ := @lexOrd
     compareOn fun imp => (!imp.isExported, imp.module.toString)
 
-/--
-Run the shake analysis with the given arguments.
+/-- The main entry point. See `help` for more information on arguments. -/
+public def main (args : List String) : IO UInt32 := do
+  initSearchPath (← findSysroot)
+  -- Parse the arguments
+  let rec parseArgs (args : Args) : List String → Args
+    | [] => args
+    | "--help" :: rest => parseArgs { args with help := true } rest
+    | "--keep-implied" :: rest => parseArgs { args with keepImplied := true } rest
+    | "--keep-prefix" :: rest => parseArgs { args with keepPrefix := true } rest
+    | "--keep-public" :: rest => parseArgs { args with keepPublic := true } rest
+    | "--add-public" :: rest => parseArgs { args with addPublic := true } rest
+    | "--force" :: rest => parseArgs { args with force := true } rest
+    | "--fix" :: rest => parseArgs { args with fix := true } rest
+    | "--explain" :: rest => parseArgs { args with explain := true } rest
+    | "--trace" :: rest => parseArgs { args with trace := true } rest
+    | "--gh-style" :: rest => parseArgs { args with githubStyle := true } rest
+    | "--" :: rest => { args with mods := args.mods ++ rest.map (·.toName) }
+    | other :: rest => parseArgs { args with mods := args.mods.push other.toName } rest
+  let args := parseArgs {} args
 
-Assumes Lean's search path has already been properly configured.
--/
-public def run (args : Args) (h : 0 < args.mods.size)
-    (srcSearchPath : SearchPath := {}) : IO UInt32 := do
+  -- Bail if `--help` is passed
+  if args.help then
+    IO.println help
+    IO.Process.exit 0
 
+  if !args.force then
+    if (← IO.Process.output { cmd := "lake", args := #["build", "--no-build"] }).exitCode != 0 then
+      IO.println "There are out of date oleans. Run `lake build` or `lake exe cache get` first"
+      IO.Process.exit 1
+
+  -- Determine default module(s) to run shake on
+  let defaultTargetModules : Array Name ← try
+    let (elanInstall?, leanInstall?, lakeInstall?) ← Lake.findInstall?
+    let config ← Lake.MonadError.runEIO <| Lake.mkLoadConfig { elanInstall?, leanInstall?, lakeInstall? }
+    let some workspace ← Lake.loadWorkspace config |>.toBaseIO
+      | throw <| IO.userError "failed to load Lake workspace"
+    let defaultTargetModules := workspace.root.defaultTargets.flatMap fun target =>
+      if let some lib := workspace.root.findLeanLib? target then
+        lib.roots
+      else if let some exe := workspace.root.findLeanExe? target then
+        #[exe.config.root]
+      else
+        #[]
+    pure defaultTargetModules
+  catch _ =>
+    pure #[]
+
+  let srcSearchPath ← getSrcSearchPath
   -- the list of root modules
-  let mods := args.mods
+  let mods := if args.mods.isEmpty then defaultTargetModules else args.mods
   -- Only submodules of `pkg` will be edited or have info reported on them
-  let pkg := mods[0].getRoot
+  let pkg := mods[0]!.components.head!
 
   -- Load all the modules
   let imps := mods.map ({ module := · })
   let (_, s) ← importModulesCore imps (isExported := true) |>.run
   let s := s.markAllExported
   let mut env ← finalizeImport s (isModule := true) imps {} (leakEnv := false) (loadExts := false)
-  if env.header.moduleData.any (!·.isModule) then
-    throw <| .userError "`lake shake` only works with `module`s currently"
   -- the one env ext we want to initialize
   let is := indirectModUseExt.toEnvExtension.getState env
   let newState ← indirectModUseExt.addImportedFn is.importedEntries { env := env, opts := {} }

script/build_artifact.py

@@ -1,441 +0,0 @@
-#!/usr/bin/env python3
-"""
-build_artifact.py: Download pre-built CI artifacts for a Lean commit.
-
-Usage:
-    build_artifact.py                     # Download artifact for current HEAD
-    build_artifact.py --sha abc1234       # Download artifact for specific commit
-    build_artifact.py --clear-cache       # Clear artifact cache
-
-This script downloads pre-built binaries from GitHub Actions CI runs,
-which is much faster than building from source (~30s vs 2-5min).
-
-Artifacts are cached in ~/.cache/lean_build_artifact/ for reuse.
-"""
-
-import argparse
-import json
-import os
-import platform
-import shutil
-import subprocess
-import sys
-import urllib.request
-import urllib.error
-from pathlib import Path
-from typing import Optional
-
-# Constants
-GITHUB_API_BASE = "https://api.github.com"
-LEAN4_REPO = "leanprover/lean4"
-
-# CI artifact cache
-CACHE_DIR = Path.home() / '.cache' / 'lean_build_artifact'
-ARTIFACT_CACHE = CACHE_DIR
-
-# Sentinel value indicating CI failed (don't bother building locally)
-CI_FAILED = object()
-
-# ANSI colors for terminal output
-class Colors:
-    RED = '\033[91m'
-    GREEN = '\033[92m'
-    YELLOW = '\033[93m'
-    BLUE = '\033[94m'
-    BOLD = '\033[1m'
-    RESET = '\033[0m'
-
-def color(text: str, c: str) -> str:
-    """Apply color to text if stdout is a tty."""
-    if sys.stdout.isatty():
-        return f"{c}{text}{Colors.RESET}"
-    return text
-
-def error(msg: str) -> None:
-    """Print error message and exit."""
-    print(color(f"Error: {msg}", Colors.RED), file=sys.stderr)
-    sys.exit(1)
-
-def warn(msg: str) -> None:
-    """Print warning message."""
-    print(color(f"Warning: {msg}", Colors.YELLOW), file=sys.stderr)
-
-def info(msg: str) -> None:
-    """Print info message."""
-    print(color(msg, Colors.BLUE), file=sys.stderr)
-
-def success(msg: str) -> None:
-    """Print success message."""
-    print(color(msg, Colors.GREEN), file=sys.stderr)
-
-# -----------------------------------------------------------------------------
-# Platform detection
-# -----------------------------------------------------------------------------
-
-def get_artifact_name() -> Optional[str]:
-    """Get CI artifact name for current platform."""
-    system = platform.system()
-    machine = platform.machine()
-
-    if system == 'Darwin':
-        if machine == 'arm64':
-            return 'build-macOS aarch64'
-        return 'build-macOS'  # Intel
-    elif system == 'Linux':
-        if machine == 'aarch64':
-            return 'build-Linux aarch64'
-        return 'build-Linux release'
-    # Windows not supported for CI artifact download
-    return None
-
-# -----------------------------------------------------------------------------
-# GitHub API helpers
-# -----------------------------------------------------------------------------
-
-_github_token_warning_shown = False
-
-def get_github_token() -> Optional[str]:
-    """Get GitHub token from environment or gh CLI."""
-    global _github_token_warning_shown
-
-    # Check environment variable first
-    token = os.environ.get('GITHUB_TOKEN')
-    if token:
-        return token
-
-    # Try to get token from gh CLI
-    try:
-        result = subprocess.run(
-            ['gh', 'auth', 'token'],
-            capture_output=True,
-            text=True,
-            timeout=5
-        )
-        if result.returncode == 0 and result.stdout.strip():
-            return result.stdout.strip()
-    except (FileNotFoundError, subprocess.TimeoutExpired):
-        pass
-
-    # Warn once if no token available
-    if not _github_token_warning_shown:
-        _github_token_warning_shown = True
-        warn("No GitHub authentication found. API rate limits may apply.")
-        warn("Run 'gh auth login' or set GITHUB_TOKEN to avoid rate limiting.")
-
-    return None
-
-def github_api_request(url: str) -> dict:
-    """Make a GitHub API request and return JSON response."""
-    headers = {
-        'Accept': 'application/vnd.github.v3+json',
-        'User-Agent': 'build-artifact'
-    }
-
-    token = get_github_token()
-    if token:
-        headers['Authorization'] = f'token {token}'
-
-    req = urllib.request.Request(url, headers=headers)
-    try:
-        with urllib.request.urlopen(req, timeout=30) as response:
-            return json.loads(response.read().decode())
-    except urllib.error.HTTPError as e:
-        if e.code == 403:
-            error(f"GitHub API rate limit exceeded. Set GITHUB_TOKEN environment variable to increase limit.")
-        elif e.code == 404:
-            error(f"GitHub resource not found: {url}")
-        else:
-            error(f"GitHub API error: {e.code} {e.reason}")
-    except urllib.error.URLError as e:
-        error(f"Network error accessing GitHub API: {e.reason}")
-
-# -----------------------------------------------------------------------------
-# CI artifact cache functions
-# -----------------------------------------------------------------------------
-
-def get_cache_path(sha: str) -> Path:
-    """Get cache directory for a commit's artifact."""
-    return ARTIFACT_CACHE / sha[:12]
-
-def is_cached(sha: str) -> bool:
-    """Check if artifact for this commit is already cached and valid."""
-    cache_path = get_cache_path(sha)
-    return cache_path.exists() and (cache_path / 'bin' / 'lean').exists()
-
-def check_zstd_support() -> bool:
-    """Check if tar supports zstd compression."""
-    try:
-        result = subprocess.run(
-            ['tar', '--zstd', '--version'],
-            capture_output=True,
-            timeout=5
-        )
-        return result.returncode == 0
-    except (subprocess.TimeoutExpired, FileNotFoundError):
-        return False
-
-def check_gh_available() -> bool:
-    """Check if gh CLI is available and authenticated."""
-    try:
-        result = subprocess.run(
-            ['gh', 'auth', 'status'],
-            capture_output=True,
-            timeout=10
-        )
-        return result.returncode == 0
-    except (subprocess.TimeoutExpired, FileNotFoundError):
-        return False
-
-def download_ci_artifact(sha: str, quiet: bool = False):
-    """
-    Try to download CI artifact for a commit.
-    Returns:
-      - Path to extracted toolchain directory if available
-      - CI_FAILED sentinel if CI run failed (don't bother building locally)
-      - None if no artifact available but local build might work
-    """
-    # Check cache first
-    if is_cached(sha):
-        return get_cache_path(sha)
-
-    artifact_name = get_artifact_name()
-    if artifact_name is None:
-        return None  # Unsupported platform
-
-    cache_path = get_cache_path(sha)
-
-    try:
-        # Query for CI workflow run for this commit, including status
-        # Note: Query parameters must be in the URL for GET requests
-        result = subprocess.run(
-            ['gh', 'api', f'repos/{LEAN4_REPO}/actions/runs?head_sha={sha}&per_page=100',
-             '--jq', r'.workflow_runs[] | select(.name == "CI") | "\(.id) \(.conclusion // "null")"'],
-            capture_output=True,
-            text=True,
-            timeout=30
-        )
-        if result.returncode != 0 or not result.stdout.strip():
-            return None  # No CI run found (old commit?)
-
-        # Parse "run_id conclusion" format
-        line = result.stdout.strip().split('\n')[0]
-        parts = line.split(' ', 1)
-        run_id = parts[0]
-        conclusion = parts[1] if len(parts) > 1 else "null"
-
-        # Check if the desired artifact exists for this run
-        result = subprocess.run(
-            ['gh', 'api', f'repos/{LEAN4_REPO}/actions/runs/{run_id}/artifacts',
-             '--jq', f'.artifacts[] | select(.name == "{artifact_name}") | .id'],
-            capture_output=True,
-            text=True,
-            timeout=30
-        )
-        if result.returncode != 0 or not result.stdout.strip():
-            # No artifact available
-            # If CI failed and no artifact, the build itself likely failed - skip
-            if conclusion == "failure":
-                return CI_FAILED
-            # Otherwise (in progress, expired, etc.) - fall back to local build
-            return None
-
-        # Download artifact
-        cache_path.mkdir(parents=True, exist_ok=True)
-        if not quiet:
-            print("downloading CI artifact... ", end='', flush=True)
-
-        result = subprocess.run(
-            ['gh', 'run', 'download', run_id,
-             '-n', artifact_name,
-             '-R', LEAN4_REPO,
-             '-D', str(cache_path)],
-            capture_output=True,
-            text=True,
-            timeout=600  # 10 minutes for large downloads
-        )
-
-        if result.returncode != 0:
-            shutil.rmtree(cache_path, ignore_errors=True)
-            return None
-
-        # Extract tar.zst - find the file (name varies by platform/version)
-        tar_files = list(cache_path.glob('*.tar.zst'))
-        if not tar_files:
-            shutil.rmtree(cache_path, ignore_errors=True)
-            return None
-
-        tar_file = tar_files[0]
-        if not quiet:
-            print("extracting... ", end='', flush=True)
-
-        result = subprocess.run(
-            ['tar', '--zstd', '-xf', tar_file.name],
-            cwd=cache_path,
-            capture_output=True,
-            timeout=300
-        )
-
-        if result.returncode != 0:
-            shutil.rmtree(cache_path, ignore_errors=True)
-            return None
-
-        # Move contents up from lean-VERSION-PLATFORM/ to cache_path/
-        # The extracted directory name varies (e.g., lean-4.15.0-linux, lean-4.15.0-darwin_aarch64)
-        extracted_dirs = [d for d in cache_path.iterdir() if d.is_dir() and d.name.startswith('lean-')]
-        if extracted_dirs:
-            extracted = extracted_dirs[0]
-            for item in extracted.iterdir():
-                dest = cache_path / item.name
-                if dest.exists():
-                    if dest.is_dir():
-                        shutil.rmtree(dest)
-                    else:
-                        dest.unlink()
-                shutil.move(str(item), str(cache_path / item.name))
-            extracted.rmdir()
-
-        # Clean up tar file
-        tar_file.unlink()
-
-        # Verify the extraction worked
-        if not (cache_path / 'bin' / 'lean').exists():
-            shutil.rmtree(cache_path, ignore_errors=True)
-            return None
-
-        return cache_path
-
-    except (subprocess.TimeoutExpired, FileNotFoundError):
-        shutil.rmtree(cache_path, ignore_errors=True)
-        return None
-
-# -----------------------------------------------------------------------------
-# Git helpers
-# -----------------------------------------------------------------------------
-
-def get_current_commit() -> str:
-    """Get the current git HEAD commit SHA."""
-    try:
-        result = subprocess.run(
-            ['git', 'rev-parse', 'HEAD'],
-            capture_output=True,
-            text=True,
-            timeout=5
-        )
-        if result.returncode == 0:
-            return result.stdout.strip()
-        error(f"Failed to get current commit: {result.stderr.strip()}")
-    except subprocess.TimeoutExpired:
-        error("Timeout getting current commit")
-    except FileNotFoundError:
-        error("git not found")
-
-def resolve_sha(short_sha: str) -> str:
-    """Resolve a (possibly short) SHA to full 40-character SHA using git rev-parse."""
-    if len(short_sha) == 40:
-        return short_sha
-    try:
-        result = subprocess.run(
-            ['git', 'rev-parse', short_sha],
-            capture_output=True,
-            text=True,
-            timeout=5
-        )
-        if result.returncode == 0:
-            full_sha = result.stdout.strip()
-            if len(full_sha) == 40:
-                return full_sha
-        error(f"Cannot resolve SHA '{short_sha}': {result.stderr.strip() or 'not found in repository'}")
-    except subprocess.TimeoutExpired:
-        error(f"Timeout resolving SHA '{short_sha}'")
-    except FileNotFoundError:
-        error("git not found - required for SHA resolution")
-
-# -----------------------------------------------------------------------------
-# Main
-# -----------------------------------------------------------------------------
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='Download pre-built CI artifacts for a Lean commit.',
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-This script downloads pre-built binaries from GitHub Actions CI runs,
-which is much faster than building from source (~30s vs 2-5min).
-
-Artifacts are cached in ~/.cache/lean_build_artifact/ for reuse.
-
-Examples:
-  build_artifact.py                   # Download for current HEAD
-  build_artifact.py --sha abc1234     # Download for specific commit
-  build_artifact.py --clear-cache     # Clear cache to free disk space
-"""
-    )
-
-    parser.add_argument('--sha', metavar='SHA',
-                        help='Commit SHA to download artifact for (default: current HEAD)')
-    parser.add_argument('--clear-cache', action='store_true',
-                        help='Clear artifact cache and exit')
-    parser.add_argument('--quiet', '-q', action='store_true',
-                        help='Suppress progress messages (still prints result path)')
-
-    args = parser.parse_args()
-
-    # Handle cache clearing
-    if args.clear_cache:
-        if ARTIFACT_CACHE.exists():
-            size = sum(f.stat().st_size for f in ARTIFACT_CACHE.rglob('*') if f.is_file())
-            shutil.rmtree(ARTIFACT_CACHE)
-            info(f"Cleared cache at {ARTIFACT_CACHE} ({size / 1024 / 1024:.1f} MB)")
-        else:
-            info(f"Cache directory does not exist: {ARTIFACT_CACHE}")
-        return
-
-    # Get commit SHA
-    if args.sha:
-        sha = resolve_sha(args.sha)
-    else:
-        sha = get_current_commit()
-
-    if not args.quiet:
-        info(f"Commit: {sha[:12]}")
-
-    # Check prerequisites
-    if not check_gh_available():
-        error("gh CLI not available or not authenticated. Run 'gh auth login' first.")
-
-    if not check_zstd_support():
-        error("tar does not support zstd compression. Install zstd or a newer tar.")
-
-    artifact_name = get_artifact_name()
-    if artifact_name is None:
-        error(f"No CI artifacts available for this platform ({platform.system()} {platform.machine()})")
-
-    if not args.quiet:
-        info(f"Platform: {artifact_name}")
-
-    # Check cache
-    if is_cached(sha):
-        path = get_cache_path(sha)
-        if not args.quiet:
-            success("Using cached artifact")
-        print(path)
-        return
-
-    # Download artifact
-    result = download_ci_artifact(sha, quiet=args.quiet)
-
-    if result is CI_FAILED:
-        if not args.quiet:
-            print()  # End the "downloading..." line
-        error(f"CI build failed for commit {sha[:12]}")
-    elif result is None:
-        if not args.quiet:
-            print()  # End the "downloading..." line
-        error(f"No CI artifact available for commit {sha[:12]}")
-    else:
-        if not args.quiet:
-            print(color("done", Colors.GREEN))
-        print(result)
-
-if __name__ == '__main__':
-    main()

script/lakefile.toml

@@ -3,3 +3,9 @@ name = "scripts"
 [[lean_exe]]
 name = "modulize"
 root = "Modulize"
+
+[[lean_exe]]
+name = "shake"
+root = "Shake"
+# needed by `Lake.loadWorkspace`
+supportInterpreter = true

script/lean-bisect-test.lean

@@ -1,307 +0,0 @@
-/-
-  Copyright Strata Contributors
-
-  SPDX-License-Identifier: Apache-2.0 OR MIT
--/
-
-namespace Strata
-namespace Python
-
-/-
-Parser and translator for some basic regular expression patterns supported by
-Python's `re` library
-Ref.: https://docs.python.org/3/library/re.html
-
-Also see
-https://github.com/python/cpython/blob/759a048d4bea522fda2fe929be0fba1650c62b0e/Lib/re/_parser.py
-for a reference implementation.
--/
-
--------------------------------------------------------------------------------
-
-inductive ParseError where
-  /--
-    `patternError` is raised when Python's `re.patternError` exception is
-    raised.
-    [Reference: Python's re exceptions](https://docs.python.org/3/library/re.html#exceptions):
-
-    "Exception raised when a string passed to one of the functions here is not a
-    valid regular expression (for example, it might contain unmatched
-    parentheses) or when some other error occurs during compilation or matching.
-    It is never an error if a string contains no match for a pattern."
-  -/
-  | patternError  (message : String) (pattern : String) (pos : String.Pos.Raw)
-  /--
-  `unimplemented` is raised whenever we don't support some regex operations
-  (e.g., lookahead assertions).
-  -/
-  | unimplemented (message : String) (pattern : String) (pos : String.Pos.Raw)
-  deriving Repr
-
-def ParseError.toString : ParseError → String
-  | .patternError msg pat pos => s!"Pattern error at position {pos.byteIdx}: {msg} in pattern '{pat}'"
-  | .unimplemented msg pat pos => s!"Unimplemented at position {pos.byteIdx}: {msg} in pattern '{pat}'"
-
-instance : ToString ParseError where
-  toString := ParseError.toString
-
--------------------------------------------------------------------------------
-
-/--
-Regular Expression Nodes
--/
-inductive RegexAST where
-  /-- Single literal character: `a` -/
-  | char : Char → RegexAST
-  /-- Character range: `[a-z]` -/
-  | range : Char → Char → RegexAST
-  /-- Alternation: `a|b` -/
-  | union : RegexAST → RegexAST → RegexAST
-  /-- Concatenation: `ab` -/
-  | concat : RegexAST → RegexAST → RegexAST
-  /-- Any character: `.` -/
-  | anychar : RegexAST
-  /-- Zero or more: `a*` -/
-  | star : RegexAST → RegexAST
-  /-- One or more: `a+` -/
-  | plus : RegexAST → RegexAST
-  /-- Zero or one: `a?` -/
-  | optional : RegexAST → RegexAST
-  /-- Bounded repetition: `a{n,m}` -/
-  | loop : RegexAST → Nat → Nat → RegexAST
-  /-- Start of string: `^` -/
-  | anchor_start : RegexAST
-  /-- End of string: `$` -/
-  | anchor_end : RegexAST
-  /-- Grouping: `(abc)` -/
-  | group : RegexAST → RegexAST
-  /-- Empty string: `()` or `""` -/
-  | empty : RegexAST
-  /-- Complement: `[^a-z]` -/
-  | complement : RegexAST → RegexAST
-  deriving Inhabited, Repr
-
--------------------------------------------------------------------------------
-
-/-- Parse character class like [a-z], [0-9], etc. into union of ranges and
-  chars. Note that this parses `|` as a character. -/
-def parseCharClass (s : String) (pos : String.Pos.Raw) : Except ParseError (RegexAST × String.Pos.Raw) := do
-  if pos.get? s != some '[' then throw (.patternError "Expected '[' at start of character class" s pos)
-  let mut i := pos.next s
-
-  -- Check for complement (negation) with leading ^
-  let isComplement := !i.atEnd s && i.get? s == some '^'
-  if isComplement then
-    i := i.next s
-
-  let mut result : Option RegexAST := none
-
-  -- Process each element in the character class.
-  while !i.atEnd s && i.get? s != some ']' do
-    -- Uncommenting this makes the code stop
-    --dbg_trace "Working" (pure ())
-    let some c1 := i.get? s | throw (.patternError "Invalid character in class" s i)
-    let i1 := i.next s
-    -- Check for range pattern: c1-c2.
-    if !i1.atEnd s && i1.get? s == some '-' then
-      let i2 := i1.next s
-      if !i2.atEnd s && i2.get? s != some ']' then
-        let some c2 := i2.get? s | throw (.patternError "Invalid character in range" s i2)
-        if c1 > c2 then
-          throw (.patternError s!"Invalid character range [{c1}-{c2}]: \
-                                  start character '{c1}' is greater than end character '{c2}'" s i)
-        let r := RegexAST.range c1 c2
-        -- Union with previous elements.
-        result := some (match result with | none => r | some prev => RegexAST.union prev r)
-        i := i2.next s
-        continue
-    -- Single character.
-    let r := RegexAST.char c1
-    result := some (match result with | none => r | some prev => RegexAST.union prev r)
-    i := i.next s
-
-  let some ast := result | throw (.patternError "Unterminated character set" s pos)
-  let finalAst := if isComplement then RegexAST.complement ast else ast
-  pure (finalAst, i.next s)
-
--------------------------------------------------------------------------------
-
-/-- Parse numeric repeats like `{10}` or `{1,10}` into min and max bounds. -/
-def parseBounds (s : String) (pos : String.Pos.Raw) : Except ParseError (Nat × Nat × String.Pos.Raw) := do
-  if pos.get? s != some '{' then throw (.patternError "Expected '{' at start of bounds" s pos)
-  let mut i := pos.next s
-  let mut numStr := ""
-
-  -- Parse first number.
-  while !i.atEnd s && (i.get? s).any Char.isDigit do
-    numStr := numStr.push ((i.get? s).get!)
-    i := i.next s
-
-  let some n := numStr.toNat? | throw (.patternError "Invalid minimum bound" s pos)
-
-  -- Check for comma (range) or closing brace (exact count).
-  match i.get? s with
-  | some '}' => pure (n, n, i.next s)  -- {n} means exactly n times.
-  | some ',' =>
-    i := i.next s
-    -- Parse maximum bound
-    numStr := ""
-    while !i.atEnd s && (i.get? s).any Char.isDigit do
-      numStr := numStr.push ((i.get? s).get!)
-      i := i.next s
-    let some max := numStr.toNat? | throw (.patternError "Invalid maximum bound" s i)
-    if i.get? s != some '}' then throw (.patternError "Expected '}' at end of bounds" s i)
-    -- Validate bounds order
-    if max < n then
-      throw (.patternError s!"Invalid repeat bounds \{{n},{max}}: \
-                              maximum {max} is less than minimum {n}" s pos)
-    pure (n, max, i.next s)
-  | _ => throw (.patternError "Invalid bounds syntax" s i)
-
--------------------------------------------------------------------------------
-
-mutual
-/--
-Parse atom: single element (char, class, anchor, group) with optional
-quantifier. Stops at the first `|`.
--/
-partial def parseAtom (s : String) (pos : String.Pos.Raw) : Except ParseError (RegexAST × String.Pos.Raw) := do
-  if pos.atEnd s then throw (.patternError "Unexpected end of regex" s pos)
-
-  let some c := pos.get? s | throw (.patternError "Invalid position" s pos)
-
-  -- Detect invalid quantifier at start
-  if c == '*' || c == '+' || c == '{' || c == '?' then
-    throw (.patternError s!"Quantifier '{c}' at position {pos} has nothing to quantify" s pos)
-
-  -- Detect unbalanced closing parenthesis
-  if c == ')' then
-    throw (.patternError "Unbalanced parenthesis" s pos)
-
-  -- Parse base element (anchor, char class, group, anychar, escape, or single char).
-  let (base, nextPos) ← match c with
-    | '^' => pure (RegexAST.anchor_start, pos.next s)
-    | '$' => pure (RegexAST.anchor_end, pos.next s)
-    | '[' => parseCharClass s pos
-    | '(' => parseExplicitGroup s pos
-    | '.' => pure (RegexAST.anychar, pos.next s)
-    | '\\' =>
-      -- Handle escape sequence.
-      -- Note: Python uses a single backslash as an escape character, but Lean
-      -- strings need to escape that. After DDMification, we will see two
-      -- backslashes in Strata for every Python backslash.
-      let nextPos := pos.next s
-      if nextPos.atEnd s then throw (.patternError "Incomplete escape sequence at end of regex" s pos)
-      let some escapedChar := nextPos.get? s | throw (.patternError "Invalid escape position" s nextPos)
-      -- Check for special sequences (unsupported right now).
-      match escapedChar with
-      | 'A' | 'b' | 'B' | 'd' | 'D' | 's' | 'S' | 'w' | 'W' | 'z' | 'Z' =>
-        throw (.unimplemented s!"Special sequence \\{escapedChar} is not supported" s pos)
-      | 'a' | 'f' | 'n' | 'N' | 'r' | 't' | 'u' | 'U' | 'v' | 'x' =>
-        throw (.unimplemented s!"Escape sequence \\{escapedChar} is not supported" s pos)
-      | c =>
-        if c.isDigit then
-          throw (.unimplemented s!"Backreference \\{c} is not supported" s pos)
-        else
-          pure (RegexAST.char escapedChar, nextPos.next s)
-    | _ => pure (RegexAST.char c, pos.next s)
-
-  -- Check for numeric repeat suffix on base element (but not on anchors)
-  match base with
-  | .anchor_start | .anchor_end => pure (base, nextPos)
-  | _ =>
-    if !nextPos.atEnd s then
-      match nextPos.get? s with
-      | some '{' =>
-        let (min, max, finalPos) ← parseBounds s nextPos
-        pure (RegexAST.loop base min max, finalPos)
-      | some '*' =>
-        let afterStar := nextPos.next s
-        if !afterStar.atEnd s then
-          match afterStar.get? s with
-          | some '?' => throw (.unimplemented "Non-greedy quantifier *? is not supported" s nextPos)
-          | some '+' => throw (.unimplemented "Possessive quantifier *+ is not supported" s nextPos)
-          | _ => pure (RegexAST.star base, afterStar)
-        else pure (RegexAST.star base, afterStar)
-      | some '+' =>
-        let afterPlus := nextPos.next s
-        if !afterPlus.atEnd s then
-          match afterPlus.get? s with
-          | some '?' => throw (.unimplemented "Non-greedy quantifier +? is not supported" s nextPos)
-          | some '+' => throw (.unimplemented "Possessive quantifier ++ is not supported" s nextPos)
-          | _ => pure (RegexAST.plus base, afterPlus)
-        else pure (RegexAST.plus base, afterPlus)
-      | some '?' =>
-        let afterQuestion := nextPos.next s
-        if !afterQuestion.atEnd s then
-          match afterQuestion.get? s with
-          | some '?' => throw (.unimplemented "Non-greedy quantifier ?? is not supported" s nextPos)
-          | some '+' => throw (.unimplemented "Possessive quantifier ?+ is not supported" s nextPos)
-          | _ => pure (RegexAST.optional base, afterQuestion)
-        else pure (RegexAST.optional base, afterQuestion)
-      | _ => pure (base, nextPos)
-    else
-      pure (base, nextPos)
-
-/-- Parse explicit group with parentheses. -/
-partial def parseExplicitGroup (s : String) (pos : String.Pos.Raw) : Except ParseError (RegexAST × String.Pos.Raw) := do
-  if pos.get? s != some '(' then throw (.patternError "Expected '(' at start of group" s pos)
-  let mut i := pos.next s
-
-  -- Check for extension notation (?...
-  if !i.atEnd s && i.get? s == some '?' then
-    let i1 := i.next s
-    if !i1.atEnd s then
-      match i1.get? s with
-      | some '=' => throw (.unimplemented "Positive lookahead (?=...) is not supported" s pos)
-      | some '!' => throw (.unimplemented "Negative lookahead (?!...) is not supported" s pos)
-      | _ => throw (.unimplemented "Extension notation (?...) is not supported" s pos)
-
-  let (inner, finalPos) ← parseGroup s i (some ')')
-  pure (.group inner, finalPos)
-
-/-- Parse group: handles alternation and concatenation at current scope. -/
-partial def parseGroup (s : String) (pos : String.Pos.Raw) (endChar : Option Char) :
-    Except ParseError (RegexAST × String.Pos.Raw) := do
-  let mut alternatives : List (List RegexAST) := [[]]
-  let mut i := pos
-
-  -- Parse until end of string or `endChar`.
-  while !i.atEnd s && (endChar.isNone || i.get? s != endChar) do
-    if i.get? s == some '|' then
-      -- Push a new scope to `alternatives`.
-      alternatives := [] :: alternatives
-      i := i.next s
-    else
-      let (ast, nextPos) ← parseAtom s i
-      alternatives := match alternatives with
-        | [] => [[ast]]
-        | head :: tail => (ast :: head) :: tail
-      i := nextPos
-
-  -- Check for expected end character.
-  if let some ec := endChar then
-    if i.get? s != some ec then
-      throw (.patternError s!"Expected '{ec}'" s i)
-    i := i.next s
-
-  -- Build result: concatenate each alternative, then union them.
-  let concatAlts := alternatives.reverse.filterMap fun alt =>
-    match alt.reverse with
-    | [] => -- Empty regex.
-      some (.empty)
-    | [single] => some single
-    | head :: tail => some (tail.foldl RegexAST.concat head)
-
-  match concatAlts with
-  | [] => pure (.empty, i)
-  | [single] => pure (single, i)
-  | head :: tail => pure (tail.foldl RegexAST.union head, i)
-end
-
-/-- info: Except.ok (Strata.Python.RegexAST.range 'A' 'z', { byteIdx := 5 }) -/
-#guard_msgs in
-#eval parseCharClass "[A-z]" ⟨0⟩
-
--- Test code: Print done
-#print "Done!"

script/release_repos.yml

@@ -50,26 +50,12 @@ repositories:
     dependencies:
       - lean4-cli
 
-  - name: lean4-unicode-basic
-    url: https://github.com/fgdorais/lean4-unicode-basic
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies: []
-
-  - name: BibtexQuery
-    url: https://github.com/dupuisf/BibtexQuery
-    toolchain-tag: true
-    stable-branch: false
-    branch: master
-    dependencies: [lean4-unicode-basic]
-
   - name: doc-gen4
     url: https://github.com/leanprover/doc-gen4
     toolchain-tag: true
     stable-branch: false
     branch: main
-    dependencies: [lean4-cli, BibtexQuery]
+    dependencies: [lean4-cli]
 
   - name: reference-manual
     url: https://github.com/leanprover/reference-manual
@@ -127,30 +113,10 @@ repositories:
     dependencies:
       - mathlib4
 
-  - name: verso-web-components
-    url: https://github.com/leanprover/verso-web-components
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies:
-      - verso
-
   - name: lean-fro.org
     url: https://github.com/leanprover/lean-fro.org
     toolchain-tag: false
     stable-branch: false
     branch: master
     dependencies:
-      - verso-web-components
-
-  - name: comparator
-    url: https://github.com/leanprover/comparator
-    toolchain-tag: true
-    stable-branch: false
-    branch: master
-
-  - name: lean4export
-    url: https://github.com/leanprover/lean4export
-    toolchain-tag: true
-    stable-branch: false
-    branch: master
+      - verso

src/CMakeLists.txt

@@ -40,10 +40,6 @@ find_program(LLD_PATH lld)
 if(LLD_PATH)
   string(APPEND LEAN_EXTRA_LINKER_FLAGS_DEFAULT " -fuse-ld=lld")
 endif()
-if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-  # Create space in install names so they can be patched later in Nix.
-  string(APPEND LEAN_EXTRA_LINKER_FLAGS_DEFAULT " -headerpad_max_install_names")
-endif()
 
 set(LEAN_EXTRA_LINKER_FLAGS ${LEAN_EXTRA_LINKER_FLAGS_DEFAULT} CACHE STRING "Additional flags used by the linker")
 set(LEAN_EXTRA_CXX_FLAGS "" CACHE STRING "Additional flags used by the C++ compiler. Unlike `CMAKE_CXX_FLAGS`, these will not be used to build e.g. cadical.")
@@ -456,14 +452,11 @@ if(LLVM AND ${STAGE} GREATER 0)
     message(VERBOSE "leanshared linker flags: '${LEANSHARED_LINKER_FLAGS}' | lean extra cxx flags '${CMAKE_CXX_FLAGS}'")
 endif()
 
-# We always strip away unused declarations to reduce binary sizes as the time cost is small and the
-# potential benefit can be huge, especially when stripping `meta import`s.
+# get rid of unused parts of C++ stdlib
 if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-  string(APPEND LEANC_EXTRA_CC_FLAGS " -fdata-sections -ffunction-sections")
-  string(APPEND LEAN_EXTRA_LINKER_FLAGS " -Wl,-dead_strip")
+  string(APPEND TOOLCHAIN_SHARED_LINKER_FLAGS " -Wl,-dead_strip")
 elseif(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-  string(APPEND LEANC_EXTRA_CC_FLAGS " -fdata-sections -ffunction-sections")
-  string(APPEND LEAN_EXTRA_LINKER_FLAGS " -Wl,--gc-sections")
+  string(APPEND TOOLCHAIN_SHARED_LINKER_FLAGS " -Wl,--gc-sections")
 endif()
 
 if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
@@ -638,9 +631,6 @@ if(${STAGE} GREATER 1)
     COMMAND cmake -E copy_if_different "${PREV_STAGE}/lib/lean/libleanrt.a" "${CMAKE_BINARY_DIR}/lib/lean/libleanrt.a"
     COMMAND cmake -E copy_if_different "${PREV_STAGE}/lib/lean/libleancpp.a" "${CMAKE_BINARY_DIR}/lib/lean/libleancpp.a"
     COMMAND cmake -E copy_if_different "${PREV_STAGE}/lib/temp/libleancpp_1.a" "${CMAKE_BINARY_DIR}/lib/temp/libleancpp_1.a")
-  add_dependencies(leanrt_initial-exec copy-leancpp)
-  add_dependencies(leanrt copy-leancpp)
-  add_dependencies(leancpp_1 copy-leancpp)
   add_dependencies(leancpp copy-leancpp)
   if(LLVM)
       add_custom_target(copy-lean-h-bc
@@ -705,7 +695,7 @@ endif()
 
 set(STDLIBS Init Std Lean Leanc)
 if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-  list(APPEND STDLIBS Lake LeanChecker)
+  list(APPEND STDLIBS Lake)
 endif()
 
 add_custom_target(make_stdlib ALL
@@ -768,12 +758,6 @@ if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
     DEPENDS lake_shared
     COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make lake
     VERBATIM)
-
-  add_custom_target(leanchecker ALL
-    WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
-    DEPENDS lake_shared
-    COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make leanchecker
-    VERBATIM)
 endif()
 
 if(PREV_STAGE)

src/Init.lean

@@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
 module
+
 prelude
 public import Init.Prelude
 public import Init.Notation
@@ -37,7 +38,6 @@ public import Init.Omega
 public import Init.MacroTrace
 public import Init.Grind
 public import Init.GrindInstances
-public import Init.Sym
 public import Init.While
 public import Init.Syntax
 public import Init.Internal

src/Init/Classical.lean

@@ -102,7 +102,7 @@ noncomputable def strongIndefiniteDescription {α : Sort u} (p : α → Prop) (h
       ⟨xp.val, fun _ => xp.property⟩)
     (fun hp => ⟨choice h, fun h => absurd h hp⟩)
 
-/-- The Hilbert epsilon function. -/
+/-- the Hilbert epsilon Function -/
 noncomputable def epsilon {α : Sort u} [h : Nonempty α] (p : α → Prop) : α :=
   (strongIndefiniteDescription p h).val
 

src/Init/Control.lean

@@ -16,4 +16,3 @@ public import Init.Control.Option
 public import Init.Control.Lawful
 public import Init.Control.StateCps
 public import Init.Control.ExceptCps
-public import Init.Control.MonadAttach

src/Init/Control/Basic.lean

@@ -144,7 +144,7 @@ instance : ToBool Bool where
 Converts the result of the monadic action `x` to a `Bool`. If it is `true`, returns it and ignores
 `y`; otherwise, runs `y` and returns its result.
 
-This is a monadic counterpart to the short-circuiting `||` operator, usually accessed via the `<||>`
+This a monadic counterpart to the short-circuiting `||` operator, usually accessed via the `<||>`
 operator.
 -/
 @[macro_inline] def orM {m : Type u → Type v} {β : Type u} [Monad m] [ToBool β] (x y : m β) : m β := do
@@ -161,7 +161,7 @@ recommended_spelling "orM" for "<||>" in [orM, «term_<||>_»]
 Converts the result of the monadic action `x` to a `Bool`. If it is `true`, returns `y`; otherwise,
 returns the original result of `x`.
 
-This is a monadic counterpart to the short-circuiting `&&` operator, usually accessed via the `<&&>`
+This a monadic counterpart to the short-circuiting `&&` operator, usually accessed via the `<&&>`
 operator.
 -/
 @[macro_inline] def andM {m : Type u → Type v} {β : Type u} [Monad m] [ToBool β] (x y : m β) : m β := do

src/Init/Control/EState.lean

@@ -25,12 +25,6 @@ instance [Repr ε] [Repr α] : Repr (Result ε σ α) where
     | Result.error e _, prec => Repr.addAppParen ("EStateM.Result.error " ++ reprArg e) prec
     | Result.ok a _, prec    => Repr.addAppParen ("EStateM.Result.ok " ++ reprArg a) prec
 
-instance : MonadAttach (EStateM ε σ) where
-  CanReturn x a := Exists fun s => Exists fun s' => x.run s = .ok a s'
-  attach x s := match h : x s with
-    | .ok a s' => .ok ⟨a, s, s', h⟩ s'
-    | .error e s' => .error e s'
-
 end EStateM
 
 namespace EStateM

src/Init/Control/Except.lean

@@ -329,8 +329,3 @@ instance ExceptT.finally {m : Type u → Type v} {ε : Type u} [MonadFinally m]
     | (.ok a,    .ok b)    => pure (.ok (a, b))
     | (_,        .error e) => pure (.error e)  -- second error has precedence
     | (.error e, _)        => pure (.error e)
-
-instance [Monad m] [MonadAttach m] : MonadAttach (ExceptT ε m) where
-  CanReturn x a := MonadAttach.CanReturn (m := m) x (.ok a)
-  attach x := show m (Except ε _) from
-      (fun ⟨a, h⟩ => match a with | .ok a => .ok ⟨a, h⟩ | .error e => .error e) <$> MonadAttach.attach (m := m) x

src/Init/Control/ExceptCps.lean

@@ -75,13 +75,6 @@ instance [Monad m] : MonadLift m (ExceptCpsT σ m) where
 instance [Inhabited ε] : Inhabited (ExceptCpsT ε m α) where
   default := fun _ _ k₂ => k₂ default
 
-/--
-For continuation monads, it is not possible to provide a computable `MonadAttach` instance that
-actually adds information about the return value. Therefore, this instance always attaches a proof
-of `True`.
--/
-instance : MonadAttach (ExceptCpsT ε m) := .trivial
-
 @[simp] theorem run_pure [Monad m] : run (pure x : ExceptCpsT ε m α) = pure (Except.ok x) := rfl
 
 @[simp] theorem run_lift {α ε : Type u} [Monad m] (x : m α) : run (ExceptCpsT.lift x : ExceptCpsT ε m α) = (x >>= fun a => pure (Except.ok a) : m (Except ε α)) := rfl

src/Init/Control/Id.lean

@@ -9,7 +9,6 @@ module
 
 prelude
 public import Init.Core
-public import Init.Control.MonadAttach
 
 public section
 
@@ -68,15 +67,4 @@ instance [OfNat α n] : OfNat (Id α) n :=
 instance {m : Type u → Type v} [Pure m] : MonadLiftT Id m where
   monadLift x := pure x.run
 
-instance : MonadAttach Id where
-  CanReturn x a := x.run = a
-  attach x := pure ⟨x.run, rfl⟩
-
-instance : LawfulMonadAttach Id where
-  map_attach := rfl
-  canReturn_map_imp := by
-    intro _ _ x _ h
-    cases h
-    exact x.run.2
-
 end Id

src/Init/Control/Lawful.lean

@@ -10,4 +10,3 @@ public import Init.Control.Lawful.Basic
 public import Init.Control.Lawful.Instances
 public import Init.Control.Lawful.Lemmas
 public import Init.Control.Lawful.MonadLift
-public import Init.Control.Lawful.MonadAttach

src/Init/Control/Lawful/Basic.lean

@@ -248,10 +248,10 @@ namespace Id
 instance : LawfulMonad Id := by
   refine LawfulMonad.mk' _ ?_ ?_ ?_ <;> intros <;> rfl
 
-@[simp, grind =] theorem run_map (x : Id α) (f : α → β) : (f <$> x).run = f x.run := rfl
-@[simp, grind =] theorem run_bind (x : Id α) (f : α → Id β) : (x >>= f).run = (f x.run).run := rfl
-@[simp, grind =] theorem run_pure (a : α) : (pure a : Id α).run = a := rfl
-@[simp, grind =] theorem pure_run (a : Id α) : pure a.run = a := 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 pure_run (a : Id α) : pure a.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

src/Init/Control/Lawful/MonadAttach.lean

@@ -1,10 +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
-public import Init.Control.Lawful.MonadAttach.Lemmas
-public import Init.Control.Lawful.MonadAttach.Instances

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

@@ -1,86 +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
-public import Init.Control.Reader
-public import Init.Control.Lawful.Instances
-import Init.Control.Lawful.MonadAttach.Lemmas
-
-public instance [Monad m] [LawfulMonad m] [MonadAttach m] [WeaklyLawfulMonadAttach m] :
-    WeaklyLawfulMonadAttach (ReaderT ρ m) where
-  map_attach := by
-    simp only [Functor.map, MonadAttach.attach, Functor.map_map, WeaklyLawfulMonadAttach.map_attach]
-    intros; rfl
-
-public instance [Monad m] [LawfulMonad m] [MonadAttach m] [LawfulMonadAttach m] :
-    LawfulMonadAttach (ReaderT ρ m) where
-  canReturn_map_imp := by
-    simp only [Functor.map, MonadAttach.CanReturn, ReaderT.run]
-    rintro _ _ x a ⟨r, h⟩
-    apply LawfulMonadAttach.canReturn_map_imp h
-
-public instance [Monad m] [LawfulMonad m] [MonadAttach m] [WeaklyLawfulMonadAttach m] :
-    WeaklyLawfulMonadAttach (StateT σ m) where
-  map_attach := by
-    intro α x
-    simp only [Functor.map, StateT, funext_iff, StateT.map, bind_pure_comp, MonadAttach.attach,
-      Functor.map_map]
-    exact fun s => WeaklyLawfulMonadAttach.map_attach
-
-public instance [Monad m] [LawfulMonad m] [MonadAttach m] [LawfulMonadAttach m] :
-    LawfulMonadAttach (StateT σ m) where
-  canReturn_map_imp := by
-    simp only [Functor.map, MonadAttach.CanReturn, StateT.run, StateT.map, bind_pure_comp]
-    rintro _ _ x a ⟨s, s', h⟩
-    obtain ⟨a, h, h'⟩ := LawfulMonadAttach.canReturn_map_imp' h
-    cases h'
-    exact a.1.2
-
-public instance [Monad m] [LawfulMonad m] [MonadAttach m] [WeaklyLawfulMonadAttach m] :
-    WeaklyLawfulMonadAttach (ExceptT ε m) where
-  map_attach {α} x := by
-    simp only [Functor.map, MonadAttach.attach, ExceptT.map]
-    simp
-    conv => rhs; rw [← WeaklyLawfulMonadAttach.map_attach (m := m) (x := x)]
-    simp only [map_eq_pure_bind]
-    apply bind_congr; intro a
-    match a with
-    | ⟨.ok _, _⟩ => simp
-    | ⟨.error _, _⟩ => simp
-
-public instance [Monad m] [LawfulMonad m] [MonadAttach m] [LawfulMonadAttach m] :
-    LawfulMonadAttach (ExceptT ε m) where
-  canReturn_map_imp {α P x a} := by
-    simp only [Functor.map, MonadAttach.CanReturn, ExceptT.map, ExceptT.mk]
-    let x' := (fun a => show Subtype (fun a : Except _ _ => match a with | .ok a => P a | .error e => True) from ⟨match a with | .ok a => .ok a.1 | .error e => .error e, by cases a <;> simp [Subtype.property]⟩) <$> show m _ from x
-    have := LawfulMonadAttach.canReturn_map_imp (m := m) (x := x') (a := .ok a)
-    simp only at this
-    intro h
-    apply this
-    simp only [x', map_eq_pure_bind, bind_assoc]
-    refine cast ?_ h
-    congr 1
-    apply bind_congr; intro a
-    split <;> simp
-
-public instance [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m] :
-    WeaklyLawfulMonadAttach (StateRefT' ω σ m) :=
-  inferInstanceAs (WeaklyLawfulMonadAttach (ReaderT _ _))
-
-public instance [Monad m] [MonadAttach m] [LawfulMonad m] [LawfulMonadAttach m] :
-    LawfulMonadAttach (StateRefT' ω σ m) :=
-  inferInstanceAs (LawfulMonadAttach (ReaderT _ _))
-
-section
-
-attribute [local instance] MonadAttach.trivial
-
-public instance [Monad m] [LawfulMonad m] :
-    WeaklyLawfulMonadAttach m where
-  map_attach := by simp [MonadAttach.attach]
-
-end

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

@@ -1,90 +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
-public import Init.Control.MonadAttach
-import all Init.Control.MonadAttach
-public import Init.Control.Lawful.Lemmas
-public import Init.Control.Lawful.MonadLift.Lemmas
-
-public theorem LawfulMonadAttach.canReturn_bind_imp' [Monad m] [LawfulMonad m]
-    [MonadAttach m] [LawfulMonadAttach m]
-    {x : m α} {f : α → m β} :
-    MonadAttach.CanReturn (x >>= f) b → Exists fun a => MonadAttach.CanReturn x a ∧ MonadAttach.CanReturn (f a) b := by
-  intro h
-  let P (b : β) := Exists fun a => MonadAttach.CanReturn x a ∧ MonadAttach.CanReturn (f a) b
-  have h' : (x >>= f) = Subtype.val <$> (MonadAttach.attach x >>= (fun a => (do
-      let b ← MonadAttach.attach (f a)
-      return ⟨b.1, a.1, a.2, b.2⟩ : m (Subtype P)))) := by
-    simp only [map_bind, map_pure]
-    simp only [bind_pure_comp, WeaklyLawfulMonadAttach.map_attach]
-    rw (occs := [1]) [← WeaklyLawfulMonadAttach.map_attach (x := x)]
-    simp
-  rw [h'] at h
-  have := LawfulMonadAttach.canReturn_map_imp h
-  exact this
-
-public theorem LawfulMonadAttach.eq_of_canReturn_pure [Monad m] [MonadAttach m]
-    [LawfulMonad m] [LawfulMonadAttach m] {a b : α}
-    (h : MonadAttach.CanReturn (m := m) (pure a) b) :
-    a = b := by
-  let x : m (Subtype (a = ·)) := pure ⟨a, rfl⟩
-  have : pure a = Subtype.val <$> x := by simp [x]
-  rw [this] at h
-  exact LawfulMonadAttach.canReturn_map_imp h
-
-public theorem LawfulMonadAttach.canReturn_map_imp' [Monad m] [LawfulMonad m]
-    [MonadAttach m] [LawfulMonadAttach m]
-    {x : m α} {f : α → β} :
-    MonadAttach.CanReturn (f <$> x) b → Exists fun a => MonadAttach.CanReturn x a ∧ f a = b := by
-  rw [map_eq_pure_bind]
-  intro h
-  obtain ⟨a, h, h'⟩ := canReturn_bind_imp' h
-  exact ⟨a, h, eq_of_canReturn_pure h'⟩
-
-public theorem LawfulMonadAttach.canReturn_liftM_imp'
-    [Monad m] [MonadAttach m] [LawfulMonad m] [LawfulMonadAttach m]
-    [Monad n] [MonadAttach n] [LawfulMonad n] [LawfulMonadAttach n]
-    [MonadLiftT m n] [LawfulMonadLiftT m n] {x : m α} {a : α} :
-    MonadAttach.CanReturn (liftM (n := n) x) a → MonadAttach.CanReturn x a := by
-  intro h
-  simp only [← WeaklyLawfulMonadAttach.map_attach (x := x), liftM_map] at h
-  exact canReturn_map_imp h
-
-public theorem WeaklyLawfulMonadAttach.attach_bind_val
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    {x : m α} {f : α → m β} :
-    MonadAttach.attach x >>= (fun a => f a.val) = x >>= f := by
-  conv => rhs; simp only [← map_attach (x := x), bind_map_left]
-
-public theorem WeaklyLawfulMonadAttach.bind_attach_of_nonempty
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m] [Nonempty (m β)]
-    {x : m α} {f : Subtype (MonadAttach.CanReturn x) → m β} :
-    open scoped Classical in
-    MonadAttach.attach x >>= f = x >>= (fun a => if ha : MonadAttach.CanReturn x a then f ⟨a, ha⟩ else Classical.ofNonempty) := by
-  conv => rhs; simp +singlePass only [← map_attach (x := x)]
-  simp [Subtype.property]
-
-public theorem MonadAttach.attach_bind_eq_pbind
-    [Monad m] [MonadAttach m]
-    {x : m α} {f : Subtype (MonadAttach.CanReturn x) → m β} :
-    MonadAttach.attach x >>= f = MonadAttach.pbind x (fun a ha => f ⟨a, ha⟩) := by
-  simp [MonadAttach.pbind]
-
-public theorem WeaklyLawfulMonadAttach.pbind_eq_bind
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    {x : m α} {f : α → m β} :
-    MonadAttach.pbind x (fun a _ => f a) = x >>= f := by
-  conv => rhs; rw [← map_attach (x := x)]
-  simp [MonadAttach.pbind]
-
-public theorem WeaklyLawfulMonadAttach.pbind_eq_bind'
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    {x : m α} {f : α → m β} :
-    MonadAttach.pbind x (fun a _ => f a) = x >>= f := by
-  conv => rhs; rw [← map_attach (x := x)]
-  simp [MonadAttach.pbind]

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

@@ -6,7 +6,6 @@ Authors: Quang Dao
 module
 
 prelude
-public import Init.Control.Id
 public import Init.Control.Lawful.Basic
 public import Init.Control.Lawful.MonadLift.Basic
 
@@ -14,14 +13,6 @@ public section
 
 universe u v w
 
-theorem instMonadLiftTOfMonadLift_instMonadLiftTOfPure [Monad m] [Monad n] {_ : MonadLift m n}
-    [LawfulMonadLift m n] : instMonadLiftTOfMonadLift Id m n = Id.instMonadLiftTOfPure := by
-  have hext {a b : MonadLiftT Id n} (h : @a.monadLift = @b.monadLift) : a = b := by
-    cases a <;> cases b <;> simp_all
-  apply hext
-  ext α x
-  simp [monadLift, LawfulMonadLift.monadLift_pure]
-
 variable {m : Type u → Type v} {n : Type u → Type w} [Monad m] [Monad n] [MonadLiftT m n]
   [LawfulMonadLiftT m n] {α β : Type u}
 

src/Init/Control/MonadAttach.lean

@@ -1,126 +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
-public import Init.Control.Basic
-
-set_option linter.all true
-
-set_option doc.verso true
-
-/-!
-# {name (scope := "Init.Control.MonadAttach")}`MonadAttach`
-
-This module provides a mechanism for attaching proofs to the return values of monadic computations,
-producing a new monadic computation returning a {name}`Subtype`.
-
-This function is primarily used to allow definitions by [well-founded
-recursion](lean-manual://section/well-founded-recursion) that sequence computations using
-{name}`Bind.bind` (`>>=`) to prove properties about the return values of prior computations when
-a recursive call happens.
-This allows the well-founded recursion mechanism to prove that the function terminates.
--/
-
--- verso docstring is added below
-set_option linter.missingDocs false in
-public class MonadAttach (m : Type u → Type v) where
-  /--
-  A predicate that can be assumed to be true for all return values {name}`a` of actions {name}`x`
-  in {name}`m`, in all situations.
-  -/
-  CanReturn {α : Type u} : (x : m α) → (a : α) → Prop
-  /--
-  Attaches a proof of {name}`MonadAttach.CanReturn` to the return value of {name}`x`. This proof
-  can be used to prove the termination of well-founded recursive functions.
-  -/
-  attach {α : Type u} (x : m α) : m (Subtype (CanReturn x))
-
--- verso docstring is added below
-set_option linter.missingDocs false in
-public class WeaklyLawfulMonadAttach (m : Type u → Type v) [Monad m] [MonadAttach m] where
-  map_attach {α : Type u} {x : m α} : Subtype.val <$> MonadAttach.attach x = x
-
-/--
-This type class ensures that {name}`MonadAttach.CanReturn` is the unique strongest possible
-postcondition.
--/
-public class LawfulMonadAttach (m : Type u → Type v) [Monad m] [MonadAttach m] extends
-    WeaklyLawfulMonadAttach m where
-  canReturn_map_imp {α : Type u} {P : α → Prop} {x : m (Subtype P)} {a : α} :
-      MonadAttach.CanReturn (Subtype.val <$> x) a → P a
-
-/--
-Like {name}`Bind.bind`, {name}`pbind` sequences two computations {lean}`x : m α` and {lean}`f`,
-allowing the second to depend on the value computed by the first.
-But other than with {name}`Bind.bind`, the second computation can also depend on a proof that
-the return value {given}`a` of {name}`x` satisfies {lean}`MonadAttach.CanReturn x a`.
--/
-public def MonadAttach.pbind [Monad m] [MonadAttach m]
-    (x : m α) (f : (a : α) → MonadAttach.CanReturn x a → m β) : m β :=
-  MonadAttach.attach x >>= (fun ⟨a, ha⟩ => f a ha)
-
-/--
-A {lean}`MonadAttach` instance where all return values are possible and {name}`attach` adds no
-information to the return value, except a trivial proof of {name}`True`.
-
-This instance is used whenever no more useful {name}`MonadAttach` instance can be implemented.
-It always has a {name}`WeaklyLawfulMonadAttach`, but usually no {name}`LawfulMonadAttach` instance.
--/
-@[expose]
-public protected def MonadAttach.trivial {m : Type u → Type v} [Monad m] : MonadAttach m where
-  CanReturn _ _ := True
-  attach x := (⟨·, .intro⟩) <$> x
-
-section
-
-variable (α : Type u) [∀ m, Monad m] [∀ m, MonadAttach m]
-
-set_option doc.verso true
-
-/--
-For every {given}`x : m α`, this type class provides a predicate {lean}`MonadAttach.CanReturn x`
-and a way to attach a proof of this predicate to the return values of {name}`x` by providing
-an element {lean}`MonadAttach.attach x` of {lean}`m { a : α // MonadAttach.CanReturn x a }`.
-
-Instances should abide the law {lean}`Subtype.val <$> MonadAttach.attach x = x`, which is encoded by
-the {name}`WeaklyLawfulMonadAttach` type class. The stronger type class {name}`LawfulMonadAttach`
-ensures that {lean}`MonadAttach.CanReturn x` is the _unique_ strongest possible predicate.
-
-Similarly to {name (scope := "Init.Data.List.Attach")}`List.attach`, the purpose of
-{name}`MonadAttach` is to attach proof terms necessary for well-founded termination proofs.
-The iterator library relies on {name}`MonadAttach` for combinators such as
-{name (scope := "Init.Data.Iterators")}`Std.Iter.filterM` in order to automatically attach
-information about the monadic predicate's behavior that could be relevant for the termination
-behavior of the iterator.
-
-*Limitations*:
-
-For many monads, there is a strongly lawful {lean}`MonadAttach` instance, but there are exceptions.
-For example, there is no way to provide a computable {lean}`MonadAttach` instance for the CPS monad
-transformers
-{name (scope := "Init.Control.StateCps")}`StateCpsT` and
-{name (scope := "Init.Control.StateCps")}`ExceptCpsT` with a predicate that is not always
-{name}`True`. Therefore, such CPS monads only provide the trivial {lean}`MonadAttach` instance
-{lean}`MonadAttach.trivial` together with {name}`WeaklyLawfulMonadAttach`, but without
-{name}`LawfulMonadAttach`.
-
-For most monads with side effects, {lean}`MonadAttach` is too weak to fully capture the behavior of
-computations because the postcondition represented by {name}`MonadAttach.CanReturn` neither depends
-on the prior internal state of the monad, nor does it contain information about how the state of the
-monad changes with the computation.
--/
-add_decl_doc MonadAttach
-
-/--
-This type class ensures that every monadic action {given}`x : m α` can be recovered by stripping the
-proof component from the subtypes returned by
-{lean}`(MonadAttach.attach x) : m { a : α // MonadAttach.CanReturn x a }` . In other words,
-the type class ensures that {lean}`Subtype.val <$> MonadAttach.attach x = x`.
--/
-add_decl_doc WeaklyLawfulMonadAttach
-
-end

src/Init/Control/Option.lean

@@ -112,12 +112,6 @@ instance (ε : Type u) [MonadExceptOf ε m] : MonadExceptOf ε (OptionT m) where
   throw e           := OptionT.mk <| throwThe ε e
   tryCatch x handle := OptionT.mk <| tryCatchThe ε x handle
 
-instance [MonadAttach m] : MonadAttach (OptionT m) where
-  CanReturn x a := MonadAttach.CanReturn x.run (some a)
-  attach x := .mk ((fun
-      | ⟨some a, h⟩ => some ⟨a, h⟩
-      | ⟨none, _⟩ => none) <$> MonadAttach.attach x.run)
-
 end OptionT
 
 instance [Monad m] : MonadControl m (OptionT m) where

src/Init/Control/Reader.lean

@@ -51,7 +51,3 @@ A monad with access to a read-only value of type `ρ`. The value can be locally
 `withReader`, but it cannot be mutated.
 -/
 abbrev ReaderM (ρ : Type u) := ReaderT ρ Id
-
-instance [Monad m] [MonadAttach m] : MonadAttach (ReaderT ρ m) where
-  CanReturn x a := Exists (fun r => MonadAttach.CanReturn (x.run r) a)
-  attach x := fun r => (fun ⟨a, h⟩ => ⟨a, r, h⟩) <$> MonadAttach.attach (x.run r)

src/Init/Control/State.lean

@@ -204,7 +204,3 @@ instance StateT.tryFinally {m : Type u → Type v} {σ : Type u} [MonadFinally m
       | some (a, s') => h (some a) s'
       | none         => h none s
     pure ((a, b), s'')
-
-instance [Monad m] [MonadAttach m] : MonadAttach (StateT σ m) where
-  CanReturn x a := Exists fun s => Exists fun s' => MonadAttach.CanReturn (x.run s) (a, s')
-  attach x := fun s => (fun ⟨⟨a, s'⟩, h⟩ => ⟨⟨a, s, s', h⟩, s'⟩) <$> MonadAttach.attach (x.run s)

src/Init/Control/StateCps.lean

@@ -68,13 +68,6 @@ instance : MonadStateOf σ (StateCpsT σ m) where
   set s := fun _ _ k => k ⟨⟩ s
   modifyGet f := fun _ s k => let (a, s) := f s; k a s
 
-/--
-For continuation monads, it is not possible to provide a computable `MonadAttach` instance that
-actually adds information about the return value. Therefore, this instance always attaches a proof
-of `True`.
--/
-instance : MonadAttach (StateCpsT ε m) := .trivial
-
 /--
 Runs an action from the underlying monad in the monad with state. The state is not modified.
 

src/Init/Control/StateRef.lean

@@ -64,7 +64,6 @@ instance [Monad m] : Monad (StateRefT' ω σ m) := inferInstanceAs (Monad (Reade
 instance : MonadLift m (StateRefT' ω σ m) := ⟨StateRefT'.lift⟩
 instance (σ m) : MonadFunctor m (StateRefT' ω σ m) := inferInstanceAs (MonadFunctor m (ReaderT _ _))
 instance [Alternative m] [Monad m] : Alternative (StateRefT' ω σ m) := inferInstanceAs (Alternative (ReaderT _ _))
-instance [Monad m] [MonadAttach m] : MonadAttach (StateRefT' ω σ m) := inferInstanceAs (MonadAttach (ReaderT _ _))
 
 /--
 Retrieves the current value of the monad's mutable state.

src/Init/Core.lean

@@ -13,10 +13,6 @@ public import Init.SizeOf
 public section
 set_option linter.missingDocs true -- keep it documented
 
--- BEq instance for Option defined here so it's available early in the import chain
--- (before Init.Grind.Config and Init.MetaTypes which need BEq (Option Nat))
-deriving instance BEq for Option
-
 @[expose] section
 
 universe u v w
@@ -341,7 +337,7 @@ inductive Exists {α : Sort u} (p : α → Prop) : Prop where
 An indication of whether a loop's body terminated early that's used to compile the `for x in xs`
 notation.
 
-A collection's `ForIn` or `ForIn'` instance describes how to iterate over its elements. The monadic
+A collection's `ForIn` or `ForIn'` instance describe's how to iterate over its elements. The monadic
 action that represents the body of the loop returns a `ForInStep α`, where `α` is the local state
 used to implement features such as `let mut`.
 -/
@@ -514,12 +510,12 @@ abbrev SSuperset [HasSSubset α] (a b : α) := SSubset b a
 
 /-- Notation type class for the union operation `∪`. -/
 class Union (α : Type u) where
-  /-- `a ∪ b` is the union of `a` and `b`. -/
+  /-- `a ∪ b` is the union of`a` and `b`. -/
   union : α → α → α
 
 /-- Notation type class for the intersection operation `∩`. -/
 class Inter (α : Type u) where
-  /-- `a ∩ b` is the intersection of `a` and `b`. -/
+  /-- `a ∩ b` is the intersection of`a` and `b`. -/
   inter : α → α → α
 
 /-- Notation type class for the set difference `\`. -/
@@ -542,10 +538,10 @@ infix:50 " ⊇ " => Superset
 /-- Strict superset relation: `a ⊃ b`  -/
 infix:50 " ⊃ " => SSuperset
 
-/-- `a ∪ b` is the union of `a` and `b`. -/
+/-- `a ∪ b` is the union of`a` and `b`. -/
 infixl:65 " ∪ " => Union.union
 
-/-- `a ∩ b` is the intersection of `a` and `b`. -/
+/-- `a ∩ b` is the intersection of`a` and `b`. -/
 infixl:70 " ∩ " => Inter.inter
 
 /--
@@ -1565,10 +1561,6 @@ instance {p q : Prop} [d : Decidable (p ↔ q)] : Decidable (p = q) :=
   | isTrue h => isTrue (propext h)
   | isFalse h => isFalse fun heq => h (heq ▸ Iff.rfl)
 
-/-- Helper theorem for proving injectivity theorems -/
-theorem Lean.injEq_helper {P Q R : Prop} :
-  (P → Q → R) → (P ∧ Q → R) := by intro h ⟨h₁,h₂⟩; exact h h₁ h₂
-
 gen_injective_theorems% Array
 gen_injective_theorems% BitVec
 gen_injective_theorems% ByteArray

src/Init/Data/Array/Basic.lean

@@ -589,8 +589,6 @@ unsafe def foldlMUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Mon
   if start < stop then
     if stop ≤ as.size then
       fold (USize.ofNat start) (USize.ofNat stop) init
-    else if start < as.size then
-      fold (USize.ofNat start) (USize.ofNat as.size) init
     else
       pure init
   else

src/Init/Data/Array/DecidableEq.lean

@@ -125,22 +125,6 @@ instance instDecidableEmpEq (ys : Array α) : Decidable (#[] = ys) :=
   | ⟨[]⟩ => isTrue rfl
   | ⟨_ :: _⟩ => isFalse (fun h => Array.noConfusion rfl (heq_of_eq h) (fun h => List.noConfusion rfl h))
 
-@[inline]
-def instDecidableEqEmpImpl (xs : Array α) : Decidable (xs = #[]) :=
-  decidable_of_iff xs.isEmpty <| by rcases xs with ⟨⟨⟩⟩ <;> simp [Array.isEmpty]
-
-@[inline]
-def instDecidableEmpEqImpl (xs : Array α) : Decidable (#[] = xs) :=
-  decidable_of_iff xs.isEmpty <| by rcases xs with ⟨⟨⟩⟩ <;> simp [Array.isEmpty]
-
-@[csimp]
-theorem instDecidableEqEmp_csimp : @instDecidableEqEmp = @instDecidableEqEmpImpl :=
-  Subsingleton.allEq _ _
-
-@[csimp]
-theorem instDecidableEmpEq_csimp : @instDecidableEmpEq = @instDecidableEmpEqImpl :=
-  Subsingleton.allEq _ _
-
 theorem beq_eq_decide [BEq α] (xs ys : Array α) :
     (xs == ys) = if h : xs.size = ys.size then
       decide (∀ (i : Nat) (h' : i < xs.size), xs[i] == ys[i]'(h ▸ h')) else false := by

src/Init/Data/Array/Lemmas.lean

@@ -62,9 +62,6 @@ theorem eq_empty_of_size_eq_zero (h : xs.size = 0) : xs = #[] := by
   cases xs
   simp_all
 
-grind_pattern eq_empty_of_size_eq_zero => xs.size where
-  guard xs.size = 0
-
 theorem ne_empty_of_size_eq_add_one (h : xs.size = n + 1) : xs ≠ #[] := by
   cases xs
   simpa using List.ne_nil_of_length_eq_add_one h
@@ -115,8 +112,7 @@ theorem none_eq_getElem?_iff {xs : Array α} {i : Nat} : none = xs[i]? ↔ xs.si
 theorem getElem?_eq_none {xs : Array α} (h : xs.size ≤ i) : xs[i]? = none := by
   simp [h]
 
-grind_pattern Array.getElem?_eq_none => xs.size, xs[i]? where
-  guard xs.size ≤ i
+grind_pattern Array.getElem?_eq_none => xs.size, xs[i]?
 
 @[simp] theorem getElem?_eq_getElem {xs : Array α} {i : Nat} (h : i < xs.size) : xs[i]? = some xs[i] :=
   getElem?_pos ..

src/Init/Data/BitVec/Basic.lean

@@ -290,7 +290,7 @@ Lean convention that division by zero returns zero.
 
 Examples:
 * `(7#4).sdiv 2 = 3#4`
-* `(-8#4).sdiv 2 = -4#4`
+* `(-9#4).sdiv 2 = -4#4`
 * `(5#4).sdiv -2 = -2#4`
 * `(-7#4).sdiv (-2) = 3#4`
 -/
@@ -864,17 +864,4 @@ def clz (x : BitVec w) : BitVec w := clzAuxRec x (w - 1)
 /-- Count the number of trailing zeros. -/
 def ctz (x : BitVec w) : BitVec w := (x.reverse).clz
 
-/-- Count the number of bits with value `1` downward from the `pos`-th bit to the
-  `0`-th bit of `x`, storing the result in `acc`. -/
-def cpopNatRec (x : BitVec w) (pos acc : Nat) : Nat :=
-  match pos with
-  | 0 => acc
-  | n + 1 => x.cpopNatRec n (acc + (x.getLsbD n).toNat)
-
-/-- Population count operation, to count the number of bits with value `1` in `x`.
-  Also known as `popcount`, `popcnt`.
--/
-@[suggest_for BitVec.popcount BitVec.popcnt]
-def cpop (x : BitVec w) : BitVec w := BitVec.ofNat w (cpopNatRec x w 0)
-
 end BitVec

src/Init/Data/BitVec/Bootstrap.lean

@@ -159,17 +159,4 @@ theorem setWidth_neg_of_le {x : BitVec v} (h : w ≤ v) : BitVec.setWidth w (-x)
     omega
   omega
 
-@[induction_eliminator, elab_as_elim]
-theorem cons_induction {motive : (w : Nat) → BitVec w → Prop} (nil : motive 0 .nil)
-    (cons : ∀ {w : Nat} (b : Bool) (bv : BitVec w), motive w bv → motive (w + 1) (.cons b bv)) :
-    ∀ {w : Nat} (x : BitVec w), motive w x := by
-  intros w x
-  induction w
-  case zero =>
-    simp only [BitVec.eq_nil x, nil]
-  case succ wl ih =>
-    rw [← cons_msb_setWidth x]
-    apply cons
-    apply ih
-
 end BitVec

src/Init/Data/BitVec/Lemmas.lean

@@ -67,9 +67,6 @@ theorem none_eq_getElem?_iff {l : BitVec w} : none = l[n]? ↔ w ≤ n := by
 @[simp]
 theorem getElem?_eq_none {l : BitVec w} (h : w ≤ n) : l[n]? = none := getElem?_eq_none_iff.mpr h
 
-grind_pattern BitVec.getElem?_eq_none => l[n]? where
-  guard w ≤ n
-
 theorem getElem?_eq (l : BitVec w) (i : Nat) :
     l[i]? = if h : i < w then some l[i] else none := by
   split <;> simp_all
@@ -1022,14 +1019,6 @@ theorem setWidth_ofNat_one_eq_ofNat_one_of_lt {v w : Nat} (hv : 0 < v) :
   rw [Nat.mod_mod_of_dvd]
   exact Nat.pow_dvd_pow_iff_le_right'.mpr h
 
-@[simp]
-theorem setWidth_ofNat_of_le_of_lt {x : Nat} (h : w ≤ v) (h' : x < 2 ^ w) :
-    setWidth v (BitVec.ofNat w x) = BitVec.ofNat v x := by
-  apply BitVec.eq_of_toNat_eq
-  have := Nat.pow_le_pow_of_le (a := 2) (m := v) (n := w) (by omega) h
-  simp only [toNat_setWidth, toNat_ofNat]
-  rw [Nat.mod_eq_of_lt (by omega), Nat.mod_eq_of_lt (by omega), Nat.mod_eq_of_lt (by omega)]
-
 /--
 Iterated `setWidth` agrees with the second `setWidth`
 except in the case the first `setWidth` is a non-trivial truncation,
@@ -1263,31 +1252,11 @@ theorem extractLsb'_setWidth_of_le {b : BitVec w} {start len w' : Nat} (h : star
   simp
   omega
 
-@[simp]
-theorem extractLsb_setWidth_of_lt {x : BitVec w} {hi lo v : Nat} (h : lo + hi < v) :
-    (x.setWidth v).extractLsb hi lo = x.extractLsb hi lo := by
-  simp only [BitVec.extractLsb]
-  ext k hk
-  simp
-  omega
-
 theorem setWidth_extractLsb'_of_le {c : BitVec w} (h : len₁ ≤ len₂) :
     (c.extractLsb' start len₂).setWidth len₁ = c.extractLsb' start len₁ := by
   ext i hi
   simp [show i < len₂ by omega]
 
-theorem extractLsb'_cast {x : BitVec w} :
-    (x.cast hcast).extractLsb' start len = x.extractLsb' start len := by
-  ext k hk
-  simp
-
-@[simp]
-theorem extractLsb'_extractLsb'_of_le {x : BitVec w} (hlt : start + len ≤ len') :
-    (x.extractLsb' 0 len').extractLsb' start len  = x.extractLsb' start len := by
-  ext k hk
-  simp
-  omega
-
 /-! ### allOnes -/
 
 @[simp, grind =] theorem toNat_allOnes : (allOnes v).toNat = 2^v - 1 := by
@@ -2944,15 +2913,6 @@ theorem setWidth_eq_append {v : Nat} {x : BitVec v} {w : Nat} (h : v ≤ w) :
     omega
   · simp [hiv, getLsbD_of_ge x i (by omega)]
 
-@[simp]
-theorem extractLsb'_append_extractLsb' {x : BitVec (w + len)} :
-    (x.extractLsb' len w ++ x.extractLsb' 0 len) = x := by
-  ext i hi
-  simp only [getElem_append, getElem_extractLsb', Nat.zero_add, dite_eq_ite]
-  split
-  · rw [← getLsbD_eq_getElem]
-  · simp [show len + (i - len) = i by omega, ← getLsbD_eq_getElem]
-
 theorem setWidth_eq_extractLsb' {v : Nat} {x : BitVec v} {w : Nat} (h : w ≤ v) :
     x.setWidth w = x.extractLsb' 0 w := by
   rw [setWidth_eq_append_extractLsb']
@@ -3250,11 +3210,6 @@ theorem cons_append_append (x : BitVec w₁) (y : BitVec w₂) (z : BitVec w₃)
     · simp [h₂]; omega
     · simp [h₂];  omega
 
-@[simp]
-theorem extractLsb'_cons {x : BitVec w} :
-    (x.cons y).extractLsb' 0 w = x := by
-  simp [BitVec.toNat_eq, Nat.or_mod_two_pow, Nat.shiftLeft_eq]
-
 /-! ### concat -/
 
 @[simp, grind =] theorem toNat_concat (x : BitVec w) (b : Bool) :
@@ -3353,35 +3308,6 @@ theorem msb_concat {w : Nat} {b : Bool} {x : BitVec w} :
   ext
   simp [getElem_concat]
 
-theorem extractLsb'_concat {x : BitVec (w + 1)} {y : Bool} :
-    (x.concat y).extractLsb' 0 (t + 1) = (x.extractLsb' 0 t).concat y := by
-  ext i hi
-  simp only [← getLsbD_eq_getElem, getLsbD_extractLsb', hi, decide_true, Nat.zero_add,
-    getLsbD_concat, Bool.true_and]
-  split
-  · simp
-  · simp [show i - 1 < t by omega]
-
-theorem concat_extractLsb'_getLsb {x : BitVec (w + 1)} :
-    BitVec.concat (x.extractLsb' 1 w) (x.getLsb 0) = x := by
-  ext i hw
-  by_cases h : i = 0
-  · simp [h]
-  · simp [h, hw, show (1 + (i - 1)) = i by omega, getElem_concat]
-
-@[elab_as_elim]
-theorem concat_induction {motive : (w : Nat) → BitVec w → Prop} (nil : motive 0 .nil)
-    (concat : ∀ {w : Nat} (bv : BitVec w) (b : Bool), motive w bv → motive (w + 1) (bv.concat b)) :
-    ∀ {w : Nat} (x : BitVec w), motive w x := by
-  intros w x
-  induction w
-  case zero =>
-    simp only [BitVec.eq_nil x, nil]
-  case succ wl ih =>
-    rw [← concat_extractLsb'_getLsb (x := x)]
-    apply concat
-    apply ih
-
 /-! ### shiftConcat -/
 
 @[grind =]
@@ -5886,16 +5812,6 @@ theorem reverse_reverse_eq {x : BitVec w} :
   ext k hk
   rw [getElem_reverse, getMsbD_reverse, getLsbD_eq_getElem]
 
-@[simp]
-theorem concat_reverse_setWidth_msb_eq_reverse {x : BitVec (w + 1)} :
-    concat ((x.setWidth w).reverse) x.msb = x.reverse := by
-  ext i hi
-  simp only [getElem_reverse, BitVec.msb, getElem_concat, getMsbD_setWidth, Nat.le_add_right,
-    Nat.sub_eq_zero_of_le, Nat.zero_le, decide_true, Bool.true_and, dite_eq_ite]
-  by_cases hzero : i = 0
-  · simp [hzero]
-  · simp [hzero, show i - 1 + (w + 1) - w = i by omega]
-
 /-! ### Inequalities (le / lt) -/
 
 theorem ule_eq_not_ult (x y : BitVec w) : x.ule y = !y.ult x := by
@@ -6371,246 +6287,4 @@ theorem two_pow_ctz_le_toNat_of_ne_zero {x : BitVec w} (hx : x ≠ 0#w) :
   have hclz := getLsbD_true_ctz_of_ne_zero (x := x) hx
   exact Nat.ge_two_pow_of_testBit hclz
 
-/-! ### Population Count -/
-
-@[simp]
-theorem cpopNatRec_zero_self {x : BitVec w} :
-    x.cpopNatRec 0 acc = acc := rfl
-
-@[simp]
-theorem cpopNatRec_succ {n : Nat} {x : BitVec w} :
-    x.cpopNatRec (n + 1) acc = x.cpopNatRec n (acc + (x.getLsbD n).toNat) := rfl
-
-@[simp]
-theorem cpopNatRec_zero :
-    (0#w).cpopNatRec n acc = acc := by
-  induction n
-  · case zero =>
-    simp
-  · case succ n ihn =>
-    simp [ihn]
-
-theorem cpopNatRec_eq {x : BitVec w} {n : Nat} (acc : Nat):
-    x.cpopNatRec n acc = x.cpopNatRec n 0 + acc := by
-  induction n generalizing acc
-  · case zero =>
-    simp
-  · case succ n ihn =>
-    simp [ihn (acc := acc + (x.getLsbD n).toNat), ihn (acc := (x.getLsbD n).toNat)]
-    omega
-
-theorem cpopNatRec_add {x : BitVec w} {acc n : Nat} :
-    x.cpopNatRec n (acc + acc') = x.cpopNatRec n acc + acc' := by
-  rw [cpopNatRec_eq (acc := acc + acc'), cpopNatRec_eq (acc := acc), Nat.add_assoc]
-
-
-@[simp]
-theorem cpopNatRec_cons_of_le {x : BitVec w} {b : Bool} (hn : n ≤ w) :
-    (cons b x).cpopNatRec n acc = x.cpopNatRec n acc := by
-  induction n generalizing acc
-  · case zero =>
-    simp
-  · case succ n ihn =>
-    specialize ihn (acc := acc + ((cons b x).getLsbD n).toNat) (by omega)
-    rw [cpopNatRec_succ, ihn, getLsbD_cons]
-    simp [show ¬ n = w by omega]
-
-@[simp]
-theorem cpopNatRec_cons_of_lt {x : BitVec w} {b : Bool} (hn : w < n) :
-    (cons b x).cpopNatRec n acc = b.toNat + x.cpopNatRec n acc := by
-  induction n generalizing acc
-  · case zero =>
-    omega
-  · case succ n ihn =>
-    by_cases hlt : w < n
-    · rw [cpopNatRec_succ, ihn (acc := acc + ((cons b x).getLsbD n).toNat) (by omega)]
-      simp [getLsbD_cons, show ¬ n = w by omega]
-    · simp [show w = n by omega, getElem_cons,
-        cpopNatRec_add (acc := acc) (acc' := b.toNat), Nat.add_comm]
-
-theorem cpopNatRec_le {x : BitVec w} (n : Nat) :
-    x.cpopNatRec n acc ≤ acc + n := by
-  induction n generalizing acc
-  · case zero =>
-    simp
-  · case succ n ihn =>
-    have : (x.getLsbD n).toNat ≤ 1 := by cases x.getLsbD n <;> simp
-    specialize ihn (acc := acc + (x.getLsbD n).toNat)
-    simp
-    omega
-
-@[simp]
-theorem cpopNatRec_of_le {x : BitVec w} (k n : Nat) (hn : w ≤ n) :
-    x.cpopNatRec (n + k) acc = x.cpopNatRec n acc := by
-  induction k
-  · case zero =>
-    simp
-  · case succ k ihk =>
-    simp [show n + (k + 1) = (n + k) + 1 by omega, ihk, show w ≤ n + k by omega]
-
-@[simp]
-theorem cpopNatRec_allOnes (h : n ≤ w) :
-    (allOnes w).cpopNatRec n acc = acc + n := by
-  induction n
-  · case zero =>
-    simp
-  · case succ n ihn =>
-    specialize ihn (by omega)
-    simp [show n < w by omega, ihn,
-      cpopNatRec_add (acc := acc) (acc' := 1)]
-    omega
-
-@[simp]
-theorem cpop_allOnes :
-    (allOnes w).cpop = BitVec.ofNat w w := by
-  simp [cpop, cpopNatRec_allOnes]
-
-@[simp]
-theorem cpop_zero :
-    (0#w).cpop = 0#w := by
-  simp [cpop]
-
-theorem cpopNatRec_zero_le (x : BitVec w) (n : Nat) :
-    x.cpopNatRec n 0 ≤ w := by
-  induction x
-  · case nil => simp
-  · case cons w b bv ih =>
-    by_cases hle : n ≤ w
-    · have := cpopNatRec_cons_of_le (b := b) (x := bv) (n := n) (acc := 0) hle
-      omega
-    · rw [cpopNatRec_cons_of_lt (by omega)]
-      have : b.toNat ≤ 1 := by cases b <;> simp
-      omega
-
-theorem toNat_cpop_le (x : BitVec w) :
-    x.cpop.toNat ≤ w := by
-  have hlt := Nat.lt_two_pow_self (n := w)
-  have hle := cpopNatRec_zero_le (x := x) (n := w)
-  simp only [cpop, toNat_ofNat, ge_iff_le]
-  rw [Nat.mod_eq_of_lt (by omega)]
-  exact hle
-
-theorem cpopNatRec_concat_of_lt {x : BitVec w} {b : Bool} (hn : 0 < n) :
-    (concat x b).cpopNatRec n acc = b.toNat + x.cpopNatRec (n - 1) acc := by
-  induction n generalizing acc
-  · case zero =>
-    omega
-  · case succ n ihn =>
-    by_cases hn0 : 0 < n
-    · specialize ihn (acc := (acc + ((x.concat b).getLsbD n).toNat)) (by omega)
-      rw [cpopNatRec_succ, ihn, cpopNatRec_add (acc := acc)]
-      simp [getLsbD_concat, show ¬ n = 0 by omega, show n + 1 - 1 = n - 1 + 1 by omega, cpopNatRec_add]
-    · simp [show n = 0 by omega]
-      omega
-
-theorem toNat_cpop (x : BitVec w) :
-    x.cpop.toNat = x.cpopNatRec w 0 := by
-  have := cpopNatRec_zero_le x w
-  have := toNat_cpop_le x
-  have := Nat.lt_two_pow_self (n := w)
-  rw [cpop, toNat_ofNat, Nat.mod_eq_of_lt]
-  omega
-
-@[simp]
-theorem toNat_cpop_cons {x : BitVec w} {b : Bool} :
-    (x.cons b).cpop.toNat = b.toNat + x.cpop.toNat := by
-  simp [toNat_cpop, getElem_cons, cpopNatRec_eq (acc := b.toNat), Nat.add_comm]
-
-@[simp]
-theorem cpopNatRec_setWidth_of_le (x : BitVec w) (h : pos ≤ v) :
-    (setWidth v x).cpopNatRec pos acc = x.cpopNatRec pos acc := by
-  induction pos generalizing acc
-  · case zero =>
-    simp
-  · case succ pos ih =>
-    simp only [cpopNatRec_succ, getLsbD_setWidth]
-    rw [ih]
-    · congr
-      by_cases h : pos < v
-      <;> simp [h]
-      omega
-    · omega
-
-theorem cpop_cons {x : BitVec w} {b : Bool} :
-    (x.cons b).cpop = b.toNat + x.cpop.setWidth (w + 1) := by
-  have := toNat_cpop_le x
-  have := Bool.toNat_lt b
-  simp only [natCast_eq_ofNat, toNat_eq, toNat_add, toNat_ofNat, toNat_setWidth, Nat.lt_add_one,
-    toNat_mod_cancel_of_lt, Nat.mod_add_mod]
-  rw [toNat_cpop_cons, Nat.mod_eq_of_lt]
-  omega
-
-theorem cpop_concat {x : BitVec w} {b : Bool} :
-    (x.concat b).cpop = b.toNat + x.cpop.setWidth (w + 1) := by
-  have := cpopNatRec_zero_le (x := x) (n := w)
-  have := Nat.lt_two_pow_self (n := w)
-  rw [cpop, cpop, cpopNatRec_concat_of_lt,
-    Nat.add_one_sub_one, natCast_eq_ofNat, ofNat_add]
-  congr
-  rw [setWidth_ofNat_of_le_of_lt (x := x.cpopNatRec w 0) (by omega) (by omega)]
-  omega
-
-@[simp]
-theorem toNat_cpop_concat {x : BitVec w} {b : Bool} :
-    (x.concat b).cpop.toNat = b.toNat + x.cpop.toNat := by
-  have := toNat_cpop_le (x := x)
-  have := Nat.lt_two_pow_self (n := w + 1)
-  simp only [cpop_concat, natCast_eq_ofNat, toNat_add, toNat_ofNat, toNat_setWidth, Nat.lt_add_one,
-    toNat_mod_cancel_of_lt, Nat.mod_add_mod]
-  rw [Nat.mod_eq_of_lt]
-  cases b <;> (simp; omega)
-
-theorem cpop_cons_eq_cpop_concat (x : BitVec w) :
-    (x.cons y).cpop = (x.concat y).cpop := by
-  rw [cpop_cons, cpop_concat]
-
-@[simp]
-theorem cpop_reverse (x : BitVec w) :
-    x.reverse.cpop = x.cpop := by
-  induction w
-  · case zero =>
-    simp [cpop, reverse]
-  · case succ w ihw =>
-    rw [← concat_reverse_setWidth_msb_eq_reverse, cpop_concat, ihw, ← cpop_cons]
-    simp
-
-@[simp]
-theorem cpopNatRec_cast_eq_of_eq {x : BitVec w} (p : w = v) :
-    (x.cast p).cpopNatRec n = x.cpopNatRec n := by
-  subst p; simp
-
-@[simp]
-theorem cpop_cast (x : BitVec w) (h : w = v) :
-    (x.cast h).cpop = x.cpop.cast h := by
-  simp [cpop, cpopNatRec_cast_eq_of_eq, h]
-
-@[simp]
-theorem toNat_cpop_append {x : BitVec w} {y : BitVec u} :
-    (x ++ y).cpop.toNat = x.cpop.toNat + y.cpop.toNat := by
-  induction x generalizing y
-  · case nil =>
-    simp
-  · case cons w b bv ih =>
-    simp [cons_append, ih]
-    omega
-
-theorem cpop_append {x : BitVec w} {y : BitVec u} :
-    (x ++ y).cpop = x.cpop.setWidth (w + u) + y.cpop.setWidth (w + u) := by
-  apply eq_of_toNat_eq
-  have := toNat_cpop_le x
-  have := toNat_cpop_le y
-  have := Nat.lt_two_pow_self (n := w + u)
-  simp only [toNat_cpop_append, toNat_add, toNat_setWidth, Nat.add_mod_mod, Nat.mod_add_mod]
-  rw [Nat.mod_eq_of_lt (by omega)]
-
-theorem toNat_cpop_not {x : BitVec w} :
-    (~~~x).cpop.toNat = w - x.cpop.toNat := by
-  induction x
-  · case nil =>
-    simp
-  · case cons b x ih =>
-    have := toNat_cpop_le x
-    cases b
-    <;> (simp [ih]; omega)
-
 end BitVec

src/Init/Data/ByteArray/Basic.lean

@@ -269,8 +269,6 @@ unsafe def foldlMUnsafe {β : Type v} {m : Type v → Type w} [Monad m] (f : β
   if start < stop then
     if stop ≤ as.size then
       fold (USize.ofNat start) (USize.ofNat stop) init
-    else if start < as.size then
-      fold (USize.ofNat start) (USize.ofNat as.size) init
     else
       pure init
   else

src/Init/Data/Char/Basic.lean

@@ -102,7 +102,7 @@ Returns `true` if the character is a uppercase ASCII letter.
 The uppercase ASCII letters are the following: `ABCDEFGHIJKLMNOPQRSTUVWXYZ`.
 -/
 @[inline] def isUpper (c : Char) : Bool :=
-  c.val ≥ 'A'.val ∧ c.val ≤ 'Z'.val
+  c.val ≥ 65 && c.val ≤ 90
 
 /--
 Returns `true` if the character is a lowercase ASCII letter.
@@ -110,7 +110,7 @@ Returns `true` if the character is a lowercase ASCII letter.
 The lowercase ASCII letters are the following: `abcdefghijklmnopqrstuvwxyz`.
 -/
 @[inline] def isLower (c : Char) : Bool :=
-  c.val ≥ 'a'.val && c.val ≤ 'z'.val
+  c.val ≥ 97 && c.val ≤ 122
 
 /--
 Returns `true` if the character is an ASCII letter.
@@ -126,7 +126,7 @@ Returns `true` if the character is an ASCII digit.
 The ASCII digits are the following: `0123456789`.
 -/
 @[inline] def isDigit (c : Char) : Bool :=
-  c.val ≥ '0'.val && c.val ≤ '9'.val
+  c.val ≥ 48 && c.val ≤ 57
 
 /--
 Returns `true` if the character is an ASCII letter or digit.
@@ -143,16 +143,9 @@ alphabet are returned unchanged.
 
 The uppercase ASCII letters are the following: `ABCDEFGHIJKLMNOPQRSTUVWXYZ`.
 -/
-@[inline]
 def toLower (c : Char) : Char :=
-  if h : c.val ≥ 'A'.val ∧ c.val ≤ 'Z'.val then
-    ⟨c.val + ('a'.val - 'A'.val), ?_⟩
-  else
-    c
-where finally
-  have h : c.val.toBitVec.toNat + ('a'.val - 'A'.val).toBitVec.toNat < 0xd800 :=
-    Nat.add_lt_add_right (Nat.lt_of_le_of_lt h.2 (by decide)) _
-  exact .inl (lt_of_eq_of_lt (Nat.mod_eq_of_lt (Nat.lt_trans h (by decide))) h)
+  let n := toNat c;
+  if n >= 65 ∧ n <= 90 then ofNat (n + 32) else c
 
 /--
 Converts a lowercase ASCII letter to the corresponding uppercase letter. Letters outside the ASCII
@@ -160,20 +153,8 @@ alphabet are returned unchanged.
 
 The lowercase ASCII letters are the following: `abcdefghijklmnopqrstuvwxyz`.
 -/
-@[inline]
 def toUpper (c : Char) : Char :=
-  if h : c.val ≥ 'a'.val ∧ c.val ≤ 'z'.val then
-    ⟨c.val + ('A'.val - 'a'.val), ?_⟩
-  else
-    c
-where finally
-  have h₁ : 2^32 ≤ c.val.toNat + ('A'.val - 'a'.val).toNat :=
-    @Nat.add_le_add 'a'.val.toNat _ (2^32 - 'a'.val.toNat) _ h.1 (by decide)
-  have h₂ : c.val.toBitVec.toNat + ('A'.val - 'a'.val).toNat < 2^32 + 0xd800 :=
-    Nat.add_lt_add_right (Nat.lt_of_le_of_lt h.2 (by decide)) _
-  have add_eq {x y : UInt32} : (x + y).toNat = (x.toNat + y.toNat) % 2^32 := rfl
-  replace h₂ := Nat.sub_lt_left_of_lt_add h₁ h₂
-  exact .inl <| lt_of_eq_of_lt (add_eq.trans (Nat.mod_eq_sub_mod h₁) |>.trans
-    (Nat.mod_eq_of_lt (Nat.lt_trans h₂ (by decide)))) h₂
+  let n := toNat c;
+  if n >= 97 ∧ n <= 122 then ofNat (n - 32) else c
 
 end Char

src/Init/Data/FloatArray/Basic.lean

@@ -144,8 +144,6 @@ unsafe def foldlMUnsafe {β : Type v} {m : Type v → Type w} [Monad m] (f : β
   if start < stop then
     if stop ≤ as.size then
       fold (USize.ofNat start) (USize.ofNat stop) init
-    else if start < as.size then
-      fold (USize.ofNat start) (USize.ofNat as.size) init
     else
       pure init
   else

src/Init/Data/Int/Gcd.lean

@@ -113,8 +113,6 @@ theorem gcd_eq_right_iff_dvd (hb : 0 ≤ b) : gcd a b = b ↔ b ∣ a := by
 
 theorem gcd_assoc (a b c : Int) : gcd (gcd a b) c = gcd a (gcd b c) := Nat.gcd_assoc ..
 
-theorem gcd_left_comm (a b c : Int) : gcd a (gcd b c) = gcd b (gcd a c) := Nat.gcd_left_comm ..
-
 theorem gcd_mul_left (m n k : Int) : gcd (m * n) (m * k) = m.natAbs * gcd n k := by
   simp [gcd_eq_natAbs_gcd_natAbs, Nat.gcd_mul_left, natAbs_mul]
 

src/Init/Data/Int/Lemmas.lean

@@ -333,12 +333,6 @@ protected theorem sub_sub_self (a b : Int) : a - (a - b) = b := by
 @[simp] protected theorem add_sub_cancel (a b : Int) : a + b - b = a :=
   Int.add_neg_cancel_right a b
 
-protected theorem add_sub_add_right (n k m : Int) : (n + k) - (m + k) = n - m := by
-  rw [Int.add_comm m, ← Int.sub_sub, Int.add_sub_cancel]
-
-protected theorem add_sub_add_left (k n m : Int) : (k + n) - (k + m) = n - m := by
-  rw [Int.add_comm k, Int.add_comm k, Int.add_sub_add_right]
-
 protected theorem add_sub_assoc (a b c : Int) : a + b - c = a + (b - c) := by
   rw [Int.sub_eq_add_neg, Int.add_assoc, Int.add_neg_eq_sub]
 
@@ -552,7 +546,6 @@ protected theorem mul_eq_zero {a b : Int} : a * b = 0 ↔ a = 0 ∨ b = 0 := by
   | .ofNat 0, _, _ => by simp
   | _, .ofNat 0, _ => by simp
   | .ofNat (_+1), .negSucc _, h => by cases h
-  | .negSucc _, .negSucc _, h => by cases h
 
 protected theorem mul_ne_zero {a b : Int} (a0 : a ≠ 0) (b0 : b ≠ 0) : a * b ≠ 0 :=
   Or.rec a0 b0 ∘ Int.mul_eq_zero.mp

src/Init/Data/Int/Order.lean

@@ -474,20 +474,6 @@ protected theorem max_lt {a b c : Int} : max a b < c ↔ a < c ∧ b < c := by
   simp only [Int.lt_iff_add_one_le]
   simpa using Int.max_le (a := a + 1) (b := b + 1) (c := c)
 
-protected theorem max_eq_right_iff {a b : Int} : max a b = b ↔ a ≤ b := by
-  apply Iff.intro
-  · intro h
-    rw [← h]
-    apply Int.le_max_left
-  · apply Int.max_eq_right
-
-protected theorem max_eq_left_iff {a b : Int} : max a b = a ↔ b ≤ a := by
-  apply Iff.intro
-  · intro h
-    rw [← h]
-    apply Int.le_max_right
-  · apply Int.max_eq_left
-
 @[simp] theorem ofNat_max_zero (n : Nat) : (max (n : Int) 0) = n := by
   rw [Int.max_eq_left (natCast_nonneg n)]
 
@@ -926,16 +912,6 @@ protected theorem sub_right_le_of_le_add {a b c : Int} (h : a ≤ b + c) : a - c
   have h := Int.add_le_add_right h (-c)
   rwa [Int.add_neg_cancel_right] at h
 
-protected theorem sub_right_le_iff_le_add {a b c : Int} : a - c ≤ b ↔ a ≤ b + c :=
-  ⟨Int.le_add_of_sub_right_le, Int.sub_right_le_of_le_add⟩
-
-theorem toNat_sub_eq_zero_iff (m n : Int) : toNat (m - n) = 0 ↔ m ≤ n := by
-  rw [← ofNat_inj, ofNat_toNat, cast_ofNat_Int, Int.max_eq_right_iff, Int.sub_right_le_iff_le_add,
-    Int.zero_add]
-
-theorem zero_eq_toNat_sub_iff (m n : Int) : 0 = toNat (m - n) ↔ m ≤ n := by
-  rw [eq_comm (a := 0), toNat_sub_eq_zero_iff]
-
 protected theorem le_add_of_neg_add_le_left {a b c : Int} (h : -b + a ≤ c) : a ≤ b + c := by
   rw [Int.add_comm] at h
   exact Int.le_add_of_sub_left_le h
@@ -1013,10 +989,6 @@ protected theorem lt_sub_right_of_add_lt {a b c : Int} (h : a + b < c) : a < c -
   have h := Int.add_lt_add_right h (-b)
   rwa [Int.add_neg_cancel_right] at h
 
-protected theorem lt_sub_right_iff_add_lt {a b c : Int} :
-    a < c - b ↔ a + b < c :=
-  ⟨Int.add_lt_of_lt_sub_right, Int.lt_sub_right_of_add_lt⟩
-
 protected theorem lt_add_of_neg_add_lt {a b c : Int} (h : -b + a < c) : a < b + c := by
   have h := Int.add_lt_add_left h b
   rwa [Int.add_neg_cancel_left] at h

src/Init/Data/Iterators/Basic.lean

@@ -10,7 +10,6 @@ public import Init.Classical
 public import Init.Ext
 
 set_option doc.verso true
-set_option linter.missingDocs true
 
 public section
 
@@ -293,11 +292,6 @@ theorem IterStep.mapIterator_id {step : IterStep α β} :
     step.mapIterator id = step := by
   cases step <;> rfl
 
-@[simp]
-theorem IterStep.mapIterator_id' {step : IterStep α β} :
-    step.mapIterator (fun x => x) = step := by
-  cases step <;> rfl
-
 /--
 A variant of `IterStep` that bundles the step together with a proof that it is "plausible".
 The plausibility predicate will later be chosen to assert that a state is a plausible successor
@@ -311,7 +305,7 @@ def PlausibleIterStep (IsPlausibleStep : IterStep α β → Prop) := Subtype IsP
 /--
 Match pattern for the `yield` case. See also `IterStep.yield`.
 -/
-@[match_pattern, simp, spec, expose]
+@[match_pattern, simp, expose]
 def PlausibleIterStep.yield {IsPlausibleStep : IterStep α β → Prop}
     (it' : α) (out : β) (h : IsPlausibleStep (.yield it' out)) :
     PlausibleIterStep IsPlausibleStep :=
@@ -320,7 +314,7 @@ def PlausibleIterStep.yield {IsPlausibleStep : IterStep α β → Prop}
 /--
 Match pattern for the `skip` case. See also `IterStep.skip`.
 -/
-@[match_pattern, simp, grind =, expose]
+@[match_pattern, simp, expose]
 def PlausibleIterStep.skip {IsPlausibleStep : IterStep α β → Prop}
     (it' : α) (h : IsPlausibleStep (.skip it')) : PlausibleIterStep IsPlausibleStep :=
   ⟨.skip it', h⟩
@@ -328,7 +322,7 @@ def PlausibleIterStep.skip {IsPlausibleStep : IterStep α β → Prop}
 /--
 Match pattern for the `done` case. See also `IterStep.done`.
 -/
-@[match_pattern, simp, grind =, expose]
+@[match_pattern, simp, expose]
 def PlausibleIterStep.done {IsPlausibleStep : IterStep α β → Prop}
     (h : IsPlausibleStep .done) : PlausibleIterStep IsPlausibleStep :=
   ⟨.done, h⟩
@@ -350,24 +344,14 @@ abbrev PlausibleIterStep.casesOn {IsPlausibleStep : IterStep α β → Prop}
 end IterStep
 
 /--
-The step function of an iterator in `Iter (α := α) β` or `IterM (α := α) m β`.
+The typeclass providing the step function of an iterator in `Iter (α := α) β` or
+`IterM (α := α) m β`.
 
 In order to allow intrinsic termination proofs when iterating with the `step` function, the
 step object is bundled with a proof that it is a "plausible" step for the given current iterator.
 -/
 class Iterator (α : Type w) (m : Type w → Type w') (β : outParam (Type w)) where
-  /--
-  A relation that governs the allowed steps from a given iterator.
-
-  The "plausible" steps are those which make sense for a given state; plausibility can ensure
-  properties such as the successor iterator being drawn from the same collection, that an iterator
-  resulting from a skip will return the same next value, or that the next item yielded is next one
-  in the original collection.
-  -/
   IsPlausibleStep : IterM (α := α) m β → IterStep (IterM (α := α) m β) β → Prop
-  /--
-  Carries out a step of iteration.
-  -/
   step : (it : IterM (α := α) m β) → m (Shrink <| PlausibleIterStep <| IsPlausibleStep it)
 
 section Monadic
@@ -380,7 +364,7 @@ def IterM.mk {α : Type w} (it : α) (m : Type w → Type w') (β : Type w) :
     IterM (α := α) m β :=
   ⟨it⟩
 
-@[deprecated IterM.mk (since := "2025-12-01"), inline, expose, inherit_doc IterM.mk]
+@[deprecated IterM.mk (since := "2025-12-01"), inline, expose]
 def Iterators.toIterM := @IterM.mk
 
 @[simp]
@@ -388,7 +372,6 @@ theorem IterM.mk_internalState {α m β} (it : IterM (α := α) m β) :
     .mk it.internalState m β = it :=
   rfl
 
-set_option linter.missingDocs false in
 @[deprecated IterM.mk_internalState (since := "2025-12-01")]
 def Iterators.toIterM_internalState := @IterM.mk_internalState
 
@@ -471,10 +454,8 @@ number of steps.
 -/
 inductive IterM.IsPlausibleIndirectOutput {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
     : IterM (α := α) m β → β → Prop where
-  /-- The output value could plausibly be emitted in the next step. -/
   | direct {it : IterM (α := α) m β} {out : β} : it.IsPlausibleOutput out →
       it.IsPlausibleIndirectOutput out
-  /-- The output value could plausibly be emitted in a step after the next step. -/
   | indirect {it it' : IterM (α := α) m β} {out : β} : it'.IsPlausibleSuccessorOf it →
       it'.IsPlausibleIndirectOutput out → it.IsPlausibleIndirectOutput out
 
@@ -484,9 +465,7 @@ finitely many steps. This relation is reflexive.
 -/
 inductive IterM.IsPlausibleIndirectSuccessorOf {α β : Type w} {m : Type w → Type w'}
     [Iterator α m β] : IterM (α := α) m β → IterM (α := α) m β → Prop where
-  /-- Every iterator is a plausible indirect successor of itself. -/
   | refl (it : IterM (α := α) m β) : it.IsPlausibleIndirectSuccessorOf it
-  /-- The iterator is a plausible successor of one of the current iterator's successors. -/
   | cons_right {it'' it' it : IterM (α := α) m β} (h' : it''.IsPlausibleIndirectSuccessorOf it')
       (h : it'.IsPlausibleSuccessorOf it) : it''.IsPlausibleIndirectSuccessorOf it
 
@@ -611,10 +590,8 @@ number of steps.
 -/
 inductive Iter.IsPlausibleIndirectOutput {α β : Type w} [Iterator α Id β] :
     Iter (α := α) β → β → Prop where
-  /-- The output value could plausibly be emitted in the next step. -/
   | direct {it : Iter (α := α) β} {out : β} : it.IsPlausibleOutput out →
       it.IsPlausibleIndirectOutput out
-  /-- The output value could plausibly be emitted in a step after the next step. -/
   | indirect {it it' : Iter (α := α) β} {out : β} : it'.IsPlausibleSuccessorOf it →
       it'.IsPlausibleIndirectOutput out → it.IsPlausibleIndirectOutput out
 
@@ -645,9 +622,7 @@ finitely many steps. This relation is reflexive.
 -/
 inductive Iter.IsPlausibleIndirectSuccessorOf {α : Type w} {β : Type w} [Iterator α Id β] :
     Iter (α := α) β → Iter (α := α) β → Prop where
-  /-- Every iterator is a plausible indirect successor of itself. -/
   | refl (it : Iter (α := α) β) : IsPlausibleIndirectSuccessorOf it it
-  /-- The iterator is a plausible indirect successor of one of the current iterator's successors. -/
   | cons_right {it'' it' it : Iter (α := α) β} (h' : it''.IsPlausibleIndirectSuccessorOf it')
       (h : it'.IsPlausibleSuccessorOf it) : it''.IsPlausibleIndirectSuccessorOf it
 
@@ -721,11 +696,6 @@ recursion over finite iterators. See also `IterM.finitelyManySteps` and `Iter.fi
 -/
 structure IterM.TerminationMeasures.Finite
     (α : Type w) (m : Type w → Type w') {β : Type w} [Iterator α m β] where
-  /--
-  The wrapped iterator.
-
-  In the wrapper, its finiteness is used as a termination measure.
-  -/
   it : IterM (α := α) m β
 
 /--
@@ -852,11 +822,6 @@ recursion over productive iterators. See also `IterM.finitelyManySkips` and `Ite
 -/
 structure IterM.TerminationMeasures.Productive
     (α : Type w) (m : Type w → Type w') {β : Type w} [Iterator α m β] where
-  /--
-  The wrapped iterator.
-
-  In the wrapper, its productivity is used as a termination measure.
-  -/
   it : IterM (α := α) m β
 
 /--
@@ -960,63 +925,6 @@ library.
 -/
 class LawfulDeterministicIterator (α : Type w) (m : Type w → Type w') [Iterator α m β]
     where
-  /--
-  Every iterator with state `α` in monad `m` has exactly one plausible step.
-  -/
   isPlausibleStep_eq_eq : ∀ it : IterM (α := α) m β, ∃ step, it.IsPlausibleStep = (· = step)
 
-namespace Iterators
-
-/--
-This structure provides a more convenient way to define `Finite α m` instances using
-`Finite.of_finitenessRelation : FinitenessRelation α m → Finite α m`.
--/
-structure FinitenessRelation (α : Type w) (m : Type w → Type w') {β : Type w}
-    [Iterator α m β] where
-  /--
-  A well-founded relation such that if `it'` is a successor iterator of `it`, then `Rel it' it`.
-  -/
-  Rel (it' it : IterM (α := α) m β) : Prop
-  /-- `Rel` is well-founded. -/
-  wf : WellFounded Rel
-  /-- If `it'` is a successor iterator of `it`, then `Rel it' it`. -/
-  subrelation : ∀ {it it'}, it'.IsPlausibleSuccessorOf it → Rel it' it
-
-theorem Finite.of_finitenessRelation
-    {α : Type w} {m : Type w → Type w'} {β : Type w}
-    [Iterator α m β] (r : FinitenessRelation α m) : Finite α m where
-  wf := by
-    refine Subrelation.wf (r := r.Rel) ?_ ?_
-    · intro x y h
-      apply FinitenessRelation.subrelation
-      exact h
-    · apply InvImage.wf
-      exact r.wf
-
-/--
-This structure provides a more convenient way to define `Productive α m` instances using
-`Productive.of_productivenessRelation : ProductivenessRelation α m → Productive α m`.
--/
-structure ProductivenessRelation (α : Type w) (m : Type w → Type w') {β : Type w}
-    [Iterator α m β] where
-  /--
-  A well-founded relation such that if `it'` is obtained from `it` by skipping, then `Rel it' it`.
-  -/
-  Rel : (IterM (α := α) m β) → (IterM (α := α) m β) → Prop
-  /-- `Rel` is well-founded. -/
-  wf : WellFounded Rel
-  /-- If `it'` is obtained from `it` by skipping, then `Rel it' it`. -/
-  subrelation : ∀ {it it'}, it'.IsPlausibleSkipSuccessorOf it → Rel it' it
-
-theorem Productive.of_productivenessRelation
-    {α : Type w} {m : Type w → Type w'} {β : Type w}
-    [Iterator α m β] (r : ProductivenessRelation α m) : Productive α m where
-  wf := by
-    refine Subrelation.wf (r := r.Rel) ?_ ?_
-    · intro x y h
-      apply ProductivenessRelation.subrelation
-      exact h
-    · apply InvImage.wf
-      exact r.wf
-
-end Std.Iterators
+end Std

src/Init/Data/Iterators/Combinators/FilterMap.lean

@@ -198,8 +198,12 @@ it.filterMapM     ---a'-----c'-------⊥
 For certain mapping functions `f`, the resulting iterator will be finite (or productive) even though
 no `Finite` (or `Productive`) instance is provided. For example, if `f` never returns `none`, then
 this combinator will preserve productiveness. If `f` is an `ExceptT` monad and will always fail,
-then `it.filterMapM` will be finite even if `it` isn't. In such cases, the termination proof needs
-to be done manually.
+then `it.filterMapM` will be finite even if `it` isn't. In the first case, consider
+using the `map`/`mapM`/`mapWithPostcondition` combinators instead, which provide more instances out
+of the box.
+
+If that does not help, the more general combinator `it.filterMapWithPostcondition f` makes it
+possible to manually prove `Finite` and `Productive` instances depending on the concrete choice of `f`.
 
 **Performance:**
 
@@ -208,7 +212,7 @@ returned `Option` value.
 -/
 @[always_inline, inline, expose]
 def Iter.filterMapM {α β γ : Type w} [Iterator α Id β] {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] (f : β → m (Option γ)) (it : Iter (α := α) β) :=
+    [Monad m] (f : β → m (Option γ)) (it : Iter (α := α) β) :=
   (letI : MonadLift Id m := ⟨pure⟩; it.toIterM.filterMapM f : IterM m γ)
 
 /--
@@ -234,7 +238,10 @@ it.filterM     ---a-----c-------⊥
 For certain mapping functions `f`, the resulting iterator will be finite (or productive) even though
 no `Finite` (or `Productive`) instance is provided. For example, if `f` is an `ExceptT` monad and
 will always fail, then `it.filterWithPostcondition` will be finite -- and productive -- even if `it`
-isn't. In such cases, the termination proof needs to be done manually.
+isn't.
+
+In such situations, the more general combinator `it.filterWithPostcondition f` makes it possible to
+manually prove `Finite` and `Productive` instances depending on the concrete choice of `f`.
 
 **Performance:**
 
@@ -242,7 +249,7 @@ For each value emitted by the base iterator `it`, this combinator calls `f`.
 -/
 @[always_inline, inline, expose]
 def Iter.filterM {α β : Type w} [Iterator α Id β] {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] (f : β → m (ULift Bool)) (it : Iter (α := α) β) :=
+    [Monad m] (f : β → m (ULift Bool)) (it : Iter (α := α) β) :=
   (letI : MonadLift Id m := ⟨pure⟩; it.toIterM.filterM f : IterM m β)
 
 /--
@@ -270,8 +277,10 @@ it.mapM     ---a'--b'--c'--d'-e'----⊥
 
 For certain mapping functions `f`, the resulting iterator will be finite (or productive) even though
 no `Finite` (or `Productive`) instance is provided. For example, if `f` is an `ExceptT` monad and
-will always fail, then `it.mapM` will be finite even if `it` isn't. In such cases, the termination
-proof needs to be done manually.
+will always fail, then `it.mapM` will be finite even if `it` isn't.
+
+If that does not help, the more general combinator `it.mapWithPostcondition f` makes it possible to
+manually prove `Finite` and `Productive` instances depending on the concrete choice of `f`.
 
 **Performance:**
 
@@ -279,7 +288,7 @@ For each value emitted by the base iterator `it`, this combinator calls `f`.
 -/
 @[always_inline, inline, expose]
 def Iter.mapM {α β γ : Type w} [Iterator α Id β] {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] (f : β → m γ) (it : Iter (α := α) β) :=
+    [Monad m] (f : β → m γ) (it : Iter (α := α) β) :=
   (letI : MonadLift Id m := ⟨pure⟩; it.toIterM.mapM f : IterM m γ)
 
 @[always_inline, inline, inherit_doc IterM.filterMap, expose]

src/Init/Data/Iterators/Combinators/FlatMap.lean

@@ -28,13 +28,13 @@ namespace Std
 
 @[always_inline, inherit_doc IterM.flatMapAfterM]
 public def Iter.flatMapAfterM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [Iterator α Id β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [Iterator α Id β] [Iterator α₂ m γ]
     (f : β → m (IterM (α := α₂) m γ)) (it₁ : Iter (α := α) β) (it₂ : Option (IterM (α := α₂) m γ)) :=
-  ((it₁.mapWithPostcondition pure).flatMapAfterM f it₂ : IterM m γ)
+  ((it₁.mapM pure).flatMapAfterM f it₂ : IterM m γ)
 
 @[always_inline, expose, inherit_doc IterM.flatMapM]
 public def Iter.flatMapM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [Iterator α Id β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [Iterator α Id β] [Iterator α₂ m γ]
     (f : β → m (IterM (α := α₂) m γ)) (it : Iter (α := α) β) :=
   (it.flatMapAfterM f none : IterM m γ)
 

src/Init/Data/Iterators/Combinators/Monadic/Attach.lean

@@ -6,6 +6,7 @@ Authors: Paul Reichert
 module
 
 prelude
+public import Init.Data.Iterators.Internal.Termination
 public import Init.Data.Iterators.Consumers.Loop
 
 public section
@@ -46,7 +47,7 @@ instance Attach.instIterator {α β : Type w} {m : Type w → Type w'} [Monad m]
 def Attach.instFinitenessRelation {α β : Type w} {m : Type w → Type w'} [Monad m]
     [Iterator α m β] [Finite α m] {P : β → Prop} :
     FinitenessRelation (Attach α m P) m where
-  Rel := InvImage WellFoundedRelation.rel fun it => it.internalState.inner.finitelyManySteps
+  rel := InvImage WellFoundedRelation.rel fun it => it.internalState.inner.finitelyManySteps
   wf := InvImage.wf _ WellFoundedRelation.wf
   subrelation {it it'} h := by
     apply Relation.TransGen.single
@@ -67,7 +68,7 @@ instance Attach.instFinite {α β : Type w} {m : Type w → Type w'} [Monad m]
 def Attach.instProductivenessRelation {α β : Type w} {m : Type w → Type w'} [Monad m]
     [Iterator α m β] [Productive α m] {P : β → Prop} :
     ProductivenessRelation (Attach α m P) m where
-  Rel := InvImage WellFoundedRelation.rel fun it => it.internalState.inner.finitelyManySkips
+  rel := InvImage WellFoundedRelation.rel fun it => it.internalState.inner.finitelyManySkips
   wf := InvImage.wf _ WellFoundedRelation.wf
   subrelation {it it'} h := by
     apply Relation.TransGen.single
@@ -85,6 +86,11 @@ instance Attach.instProductive {α β : Type w} {m : Type w → Type w'} [Monad
     Productive (Attach α m P) m :=
   .of_productivenessRelation instProductivenessRelation
 
+instance Attach.instIteratorCollect {α β : Type w} {m : Type w → Type w'} [Monad m] [Monad n]
+    {P : β → Prop} [Iterator α m β] :
+    IteratorCollect (Attach α m P) m n :=
+  .defaultImplementation
+
 instance Attach.instIteratorLoop {α β : Type w} {m : Type w → Type w'} [Monad m]
     {n : Type x → Type x'} [Monad n] {P : β → Prop} [Iterator α m β] :
     IteratorLoop (Attach α m P) m n :=

src/Init/Data/Iterators/Combinators/Monadic/FilterMap.lean

@@ -8,6 +8,7 @@ module
 prelude
 public import Init.Data.Iterators.Consumers.Loop
 public import Init.Data.Iterators.PostconditionMonad
+public import Init.Data.Iterators.Internal.Termination
 
 public section
 
@@ -122,7 +123,7 @@ returned `Option` value.
 def IterM.filterMapWithPostcondition {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''}
     [MonadLiftT m n] [Iterator α m β] (f : β → PostconditionT n (Option γ))
     (it : IterM (α := α) m β) : IterM (α := FilterMap α m n (fun ⦃_⦄ => monadLift) f) n γ :=
-  IterM.InternalCombinators.filterMap (n := n) (fun ⦃_⦄ => monadLift) f it
+  IterM.InternalCombinators.filterMap (fun ⦃_⦄ => monadLift) f it
 
 namespace Iterators.Types
 
@@ -171,7 +172,7 @@ private def FilterMap.instFinitenessRelation {α β γ : Type w} {m : Type w →
     {n : Type w → Type w''} [Monad n] [Iterator α m β] {lift : ⦃α : Type w⦄ → m α → n α}
     {f : β → PostconditionT n (Option γ)} [Finite α m] :
     FinitenessRelation (FilterMap α m n lift f) n where
-  Rel := InvImage IterM.IsPlausibleSuccessorOf (FilterMap.inner ∘ IterM.internalState)
+  rel := InvImage IterM.IsPlausibleSuccessorOf (FilterMap.inner ∘ IterM.internalState)
   wf := InvImage.wf _ Finite.wf
   subrelation {it it'} h := by
     obtain ⟨step, h, h'⟩ := h
@@ -204,7 +205,7 @@ private def Map.instProductivenessRelation {α β γ : Type w} {m : Type w → T
     {n : Type w → Type w''} [Monad n] [Iterator α m β] {lift : ⦃α : Type w⦄ → m α → n α}
     {f : β → PostconditionT n γ} [Productive α m] :
     ProductivenessRelation (Map α m n lift f) n where
-  Rel := InvImage IterM.IsPlausibleSkipSuccessorOf (FilterMap.inner ∘ IterM.internalState)
+  rel := InvImage IterM.IsPlausibleSkipSuccessorOf (FilterMap.inner ∘ IterM.internalState)
   wf := InvImage.wf _ Productive.wf
   subrelation {it it'} h := by
     cases h
@@ -220,6 +221,13 @@ instance Map.instProductive {α β γ : Type w} {m : Type w → Type w'}
     Productive (Map α m n lift f) n :=
   Productive.of_productivenessRelation Map.instProductivenessRelation
 
+instance FilterMap.instIteratorCollect {α β γ : Type w} {m : Type w → Type w'}
+    {n : Type w → Type w''} {o : Type w → Type x} [Monad n] [Monad o] [Iterator α m β]
+    {lift : ⦃α : Type w⦄ → m α → n α}
+    {f : β → PostconditionT n (Option γ)} :
+    IteratorCollect (FilterMap α m n lift f) n o :=
+  .defaultImplementation
+
 instance FilterMap.instIteratorLoop {α β γ : Type w} {m : Type w → Type w'}
     {n : Type w → Type w''} {o : Type x → Type x'}
     [Monad n] [Monad o] [Iterator α m β] {lift : ⦃α : Type w⦄ → m α → n α}
@@ -227,6 +235,23 @@ instance FilterMap.instIteratorLoop {α β γ : Type w} {m : Type w → Type w'}
     IteratorLoop (FilterMap α m n lift f) n o :=
   .defaultImplementation
 
+/--
+`map` operations allow for a more efficient implementation of `toArray`. For example,
+`array.iter.map f |>.toArray happens in-place if possible.
+-/
+instance Map.instIteratorCollect {α β γ : Type w} {m : Type w → Type w'}
+    {n : Type w → Type w''} {o : Type w → Type x} [Monad n] [Monad o] [Iterator α m β]
+    {lift₁ : ⦃α : Type w⦄ → m α → n α}
+    {f : β → PostconditionT n γ} [IteratorCollect α m o] :
+    IteratorCollect (Map α m n lift₁ f) n o where
+  toArrayMapped lift₂ _ g it :=
+    letI : MonadLift m n := ⟨lift₁ (α := _)⟩
+    letI : MonadLift n o := ⟨lift₂ (δ := _)⟩
+    IteratorCollect.toArrayMapped
+      (lift := fun ⦃_⦄ => monadLift)
+      (fun x => do g (← (f x).operation))
+      it.internalState.inner (m := m)
+
 instance Map.instIteratorLoop {α β γ : Type w} {m : Type w → Type w'}
     {n : Type w → Type w''} {o : Type x → Type x'} [Monad n] [Monad o] [Iterator α m β]
     {lift : ⦃α : Type w⦄ → m α → n α}
@@ -357,8 +382,12 @@ it.filterMapM     ---a'-----c'-------⊥
 For certain mapping functions `f`, the resulting iterator will be finite (or productive) even though
 no `Finite` (or `Productive`) instance is provided. For example, if `f` never returns `none`, then
 this combinator will preserve productiveness. If `f` is an `ExceptT` monad and will always fail,
-then `it.filterMapM` will be finite even if `it` isn't. In such cases, the termination proof needs
-to be done manually.
+then `it.filterMapM` will be finite even if `it` isn't. In the first case, consider
+using the `map`/`mapM`/`mapWithPostcondition` combinators instead, which provide more instances out of
+the box.
+
+If that does not help, the more general combinator `it.filterMapWithPostcondition f` makes it
+possible to manually prove `Finite` and `Productive` instances depending on the concrete choice of `f`.
 
 **Performance:**
 
@@ -367,9 +396,9 @@ returned `Option` value.
 -/
 @[inline, expose]
 def IterM.filterMapM {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''}
-    [Iterator α m β] [Monad n] [MonadAttach n] [MonadLiftT m n]
+    [Iterator α m β] [Monad n] [MonadLiftT m n]
     (f : β → n (Option γ)) (it : IterM (α := α) m β) :=
-  (it.filterMapWithPostcondition (fun b => PostconditionT.attachLift (f b)) : IterM n γ)
+  (it.filterMapWithPostcondition (fun b => PostconditionT.lift (f b)) : IterM n γ)
 
 /--
 If `it` is an iterator, then `it.mapM f` is another iterator that applies a monadic
@@ -396,8 +425,10 @@ it.mapM     ---a'--b'--c'--d'-e'----⊥
 
 For certain mapping functions `f`, the resulting iterator will be finite (or productive) even though
 no `Finite` (or `Productive`) instance is provided. For example, if `f` is an `ExceptT` monad and
-will always fail, then `it.mapM` will be finite even if `it` isn't. In such cases, the termination
-proof needs to be done manually.
+will always fail, then `it.mapM` will be finite even if `it` isn't.
+
+If that does not help, the more general combinator `it.mapWithPostcondition f` makes it possible to
+manually prove `Finite` and `Productive` instances depending on the concrete choice of `f`.
 
 **Performance:**
 
@@ -405,8 +436,8 @@ For each value emitted by the base iterator `it`, this combinator calls `f`.
 -/
 @[inline, expose]
 def IterM.mapM {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [Iterator α m β]
-    [Monad n] [MonadAttach n] [MonadLiftT m n] (f : β → n γ) (it : IterM (α := α) m β) :=
-  (it.mapWithPostcondition (fun b => PostconditionT.attachLift (f b)) : IterM n γ)
+    [Monad n] [MonadLiftT m n] (f : β → n γ) (it : IterM (α := α) m β) :=
+  (it.mapWithPostcondition (fun b => PostconditionT.lift (f b)) : IterM n γ)
 
 /--
 If `it` is an iterator, then `it.filterM f` is another iterator that applies a monadic
@@ -434,7 +465,10 @@ it.filterM     ---a-----c-------⊥
 For certain mapping functions `f`, the resulting iterator will be finite (or productive) even though
 no `Finite` (or `Productive`) instance is provided. For example, if `f` is an `ExceptT` monad and
 will always fail, then `it.filterWithPostcondition` will be finite -- and productive -- even if `it`
-isn't. In such cases, the termination proof needs to be done manually.
+isn't.
+
+In such situations, the more general combinator `it.filterWithPostcondition f` makes it possible to
+manually prove `Finite` and `Productive` instances depending on the concrete choice of `f`.
 
 **Performance:**
 
@@ -442,9 +476,9 @@ For each value emitted by the base iterator `it`, this combinator calls `f`.
 -/
 @[inline, expose]
 def IterM.filterM {α β : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [Iterator α m β]
-    [Monad n] [MonadAttach n] [MonadLiftT m n] (f : β → n (ULift Bool)) (it : IterM (α := α) m β) :=
+    [Monad n] [MonadLiftT m n] (f : β → n (ULift Bool)) (it : IterM (α := α) m β) :=
   (it.filterMapWithPostcondition
-    (fun b => (PostconditionT.attachLift (f b)).map (if ·.down = true then some b else none)) : IterM n β)
+    (fun b => (PostconditionT.lift (f b)).map (if ·.down = true then some b else none)) : IterM n β)
 
 /--
 If `it` is an iterator, then `it.filterMap f` is another iterator that applies a function `f` to all

src/Init/Data/Iterators/Combinators/Monadic/FlatMap.lean

@@ -78,7 +78,7 @@ For each value emitted by the outer iterator `it₁`, this combinator calls `f`.
 -/
 @[always_inline, inline]
 public def IterM.flatMapAfterM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [Iterator α m β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [Iterator α m β] [Iterator α₂ m γ]
     (f : β → m (IterM (α := α₂) m γ)) (it₁ : IterM (α := α) m β) (it₂ : Option (IterM (α := α₂) m γ)) :=
   ((it₁.mapM f).flattenAfter it₂ : IterM m γ)
 
@@ -117,7 +117,7 @@ For each value emitted by the outer iterator `it`, this combinator calls `f`.
 -/
 @[always_inline, inline, expose]
 public def IterM.flatMapM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [Iterator α m β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [Iterator α m β] [Iterator α₂ m γ]
     (f : β → m (IterM (α := α₂) m γ)) (it : IterM (α := α) m β) :=
   (it.flatMapAfterM f none : IterM m γ)
 
@@ -277,7 +277,7 @@ theorem Flatten.rel_of_right₂ [Monad m] [Iterator α m (IterM (α := α₂) m
 def Flatten.instFinitenessRelation [Monad m] [Iterator α m (IterM (α := α₂) m β)] [Iterator α₂ m β]
     [Finite α m] [Finite α₂ m] :
     FinitenessRelation (Flatten α α₂ β m) m where
-  Rel := Rel α β m
+  rel := Rel α β m
   wf := by
     apply InvImage.wf
     refine ⟨fun (a, b) => Prod.lexAccessible (WellFounded.apply ?_ a) (WellFounded.apply ?_) b⟩
@@ -342,7 +342,7 @@ theorem Flatten.productiveRel_of_right₂ [Monad m] [Iterator α m (IterM (α :=
 def Flatten.instProductivenessRelation [Monad m] [Iterator α m (IterM (α := α₂) m β)]
     [Iterator α₂ m β] [Finite α m] [Productive α₂ m] :
     ProductivenessRelation (Flatten α α₂ β m) m where
-  Rel := ProductiveRel α β m
+  rel := ProductiveRel α β m
   wf := by
     apply InvImage.wf
     refine ⟨fun (a, b) => Prod.lexAccessible (WellFounded.apply ?_ a) (WellFounded.apply ?_) b⟩
@@ -369,6 +369,10 @@ public def Flatten.instProductive [Monad m] [Iterator α m (IterM (α := α₂)
 
 end Productive
 
+public instance Flatten.instIteratorCollect [Monad m] [Monad n] [Iterator α m (IterM (α := α₂) m β)]
+    [Iterator α₂ m β] : IteratorCollect (Flatten α α₂ β m) m n :=
+  .defaultImplementation
+
 public instance Flatten.instIteratorLoop [Monad m] [Monad n] [Iterator α m (IterM (α := α₂) m β)]
     [Iterator α₂ m β] : IteratorLoop (Flatten α α₂ β m) m n :=
   .defaultImplementation

src/Init/Data/Iterators/Combinators/Monadic/Take.lean

@@ -9,6 +9,7 @@ prelude
 public import Init.Data.Nat.Lemmas
 public import Init.Data.Iterators.Consumers.Monadic.Collect
 public import Init.Data.Iterators.Consumers.Monadic.Loop
+public import Init.Data.Iterators.Internal.Termination
 
 @[expose] public section
 
@@ -164,7 +165,7 @@ theorem Take.rel_of_zero_of_inner [Monad m] [Iterator α m β]
 private def Take.instFinitenessRelation [Monad m] [Iterator α m β]
     [Productive α m] :
     FinitenessRelation (Take α m) m where
-  Rel := Take.Rel m
+  rel := Take.Rel m
   wf := by
     rw [Rel]
     split
@@ -207,6 +208,10 @@ instance Take.instFinite [Monad m] [Iterator α m β] [Productive α m] :
     Finite (Take α m) m :=
   by exact Finite.of_finitenessRelation instFinitenessRelation
 
+instance Take.instIteratorCollect {n : Type w → Type w'} [Monad m] [Monad n] [Iterator α m β] :
+    IteratorCollect (Take α m) m n :=
+  .defaultImplementation
+
 instance Take.instIteratorLoop {n : Type x → Type x'} [Monad m] [Monad n] [Iterator α m β] :
     IteratorLoop (Take α m) m n :=
   .defaultImplementation

src/Init/Data/Iterators/Combinators/Monadic/ULift.lean

@@ -6,6 +6,7 @@ Authors: Paul Reichert
 module
 
 prelude
+public import Init.Data.Iterators.Internal.Termination
 public import Init.Data.Iterators.Consumers.Monadic
 
 public section
@@ -98,7 +99,7 @@ instance ULiftIterator.instIterator [Iterator α m β] [Monad n] :
 
 private def ULiftIterator.instFinitenessRelation [Iterator α m β] [Finite α m] [Monad n] :
     FinitenessRelation (ULiftIterator α m n β lift) n where
-  Rel := InvImage WellFoundedRelation.rel (fun it => it.internalState.inner.finitelyManySteps)
+  rel := InvImage WellFoundedRelation.rel (fun it => it.internalState.inner.finitelyManySteps)
   wf := InvImage.wf _ WellFoundedRelation.wf
   subrelation h := by
     rcases h with ⟨_, hs, step, hp, rfl⟩
@@ -114,7 +115,7 @@ instance ULiftIterator.instFinite [Iterator α m β] [Finite α m] [Monad n] :
 
 private def ULiftIterator.instProductivenessRelation [Iterator α m β] [Productive α m] [Monad n] :
     ProductivenessRelation (ULiftIterator α m n β lift) n where
-  Rel := InvImage WellFoundedRelation.rel (fun it => it.internalState.inner.finitelyManySkips)
+  rel := InvImage WellFoundedRelation.rel (fun it => it.internalState.inner.finitelyManySkips)
   wf := InvImage.wf _ WellFoundedRelation.wf
   subrelation h := by
     rcases h with ⟨step, hp, hs⟩
@@ -131,6 +132,10 @@ instance ULiftIterator.instIteratorLoop {o : Type x → Type x'} [Monad n] [Mona
     IteratorLoop (ULiftIterator α m n β lift) n o :=
   .defaultImplementation
 
+instance ULiftIterator.instIteratorCollect [Monad n] [Monad o] [Iterator α m β] :
+    IteratorCollect (ULiftIterator α m n β lift) n o :=
+  .defaultImplementation
+
 end Iterators.Types
 
 open Std.Iterators Std.Iterators.Types

src/Init/Data/Iterators/Consumers/Access.lean

@@ -9,8 +9,6 @@ prelude
 public import Init.Data.Iterators.Consumers.Loop
 public import Init.Data.Iterators.Consumers.Monadic.Access
 
-set_option linter.missingDocs true
-
 @[expose] public section
 
 namespace Std

src/Init/Data/Iterators/Consumers/Collect.lean

@@ -21,6 +21,8 @@ Concretely, the following operations are provided:
 * `Iter.toList`, collecting the values in a list
 * `Iter.toListRev`, collecting the values in a list in reverse order but more efficiently
 * `Iter.toArray`, collecting the values in an array
+
+Some operations are implemented using the `IteratorCollect` type class.
 -/
 
 namespace Std
@@ -34,7 +36,7 @@ If the iterator is not finite, this function might run forever. The variant
 -/
 @[always_inline, inline]
 def Iter.toArray {α : Type w} {β : Type w}
-    [Iterator α Id β] (it : Iter (α := α) β) : Array β :=
+    [Iterator α Id β] [IteratorCollect α Id Id] (it : Iter (α := α) β) : Array β :=
   it.toIterM.toArray.run
 
 /--
@@ -44,7 +46,7 @@ This function is deprecated. Instead of `it.allowNontermination.toArray`, use `i
 -/
 @[always_inline, inline, deprecated Iter.toArray (since := "2025-12-04")]
 def Iter.Partial.toArray {α : Type w} {β : Type w}
-    [Iterator α Id β] (it : Iter.Partial (α := α) β) : Array β :=
+    [Iterator α Id β] [IteratorCollect α Id Id] (it : Iter.Partial (α := α) β) : Array β :=
   it.it.toArray
 
 /--
@@ -55,7 +57,7 @@ finite. If such a proof is not available, consider using `Iter.toArray`.
 -/
 @[always_inline, inline]
 def Iter.Total.toArray {α : Type w} {β : Type w}
-    [Iterator α Id β] [Finite α Id] (it : Iter.Total (α := α) β) :
+    [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id] (it : Iter.Total (α := α) β) :
     Array β :=
   it.it.toArray
 
@@ -103,7 +105,7 @@ If the iterator is not finite, this function might run forever. The variant
 -/
 @[always_inline, inline]
 def Iter.toList {α : Type w} {β : Type w}
-    [Iterator α Id β] (it : Iter (α := α) β) : List β :=
+    [Iterator α Id β] [IteratorCollect α Id Id] (it : Iter (α := α) β) : List β :=
   it.toIterM.toList.run
 
 /--
@@ -114,7 +116,7 @@ This function is deprecated. Instead of `it.allowNontermination.toList`, use `it
 -/
 @[always_inline, deprecated Iter.toList (since := "2025-12-04")]
 def Iter.Partial.toList {α : Type w} {β : Type w}
-    [Iterator α Id β] (it : Iter.Partial (α := α) β) : List β :=
+    [Iterator α Id β] [IteratorCollect α Id Id] (it : Iter.Partial (α := α) β) : List β :=
   it.it.toList
 
 /--
@@ -126,7 +128,7 @@ finite. If such a proof is not available, consider using `Iter.toList`.
 -/
 @[always_inline, inline]
 def Iter.Total.toList {α : Type w} {β : Type w}
-    [Iterator α Id β] [Finite α Id] (it : Iter.Total (α := α) β) :
+    [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id] (it : Iter.Total (α := α) β) :
     List β :=
   it.it.toList
 

src/Init/Data/Iterators/Consumers/Monadic/Access.lean

@@ -8,8 +8,6 @@ module
 prelude
 public import Init.Data.Iterators.Basic
 
-set_option linter.missingDocs true
-
 public section
 
 namespace Std
@@ -59,8 +57,8 @@ theorem IterM.not_isPlausibleNthOutputStep_yield {α β : Type w} {m : Type w
 
 /--
 `IteratorAccess α m` provides efficient implementations for random access or iterators that support
-it. `it.nextAtIdx? n` either returns the step in which the `n`th value of `it` is emitted
-(necessarily of the form `.yield _ _`) or `.done` if `it` terminates before emitting the `n`th
+it. `it.nextAtIdx? n` either returns the step in which the `n`-th value of `it` is emitted
+(necessarily of the form `.yield _ _`) or `.done` if `it` terminates before emitting the `n`-th
 value.
 
 For monadic iterators, the monadic effects of this operation may differ from manually iterating
@@ -70,11 +68,6 @@ is guaranteed to plausible in the sense of `IterM.IsPlausibleNthOutputStep`.
 This class is experimental and users of the iterator API should not explicitly depend on it.
 -/
 class IteratorAccess (α : Type w) (m : Type w → Type w') {β : Type w} [Iterator α m β] where
-  /--
-  `nextAtIdx? it n` either returns the step in which the `n`th value of `it` is emitted
-  (necessarily of the form `.yield _ _`) or `.done` if `it` terminates before emitting the `n`th
-  value.
-  -/
   nextAtIdx? (it : IterM (α := α) m β) (n : Nat) :
     m (PlausibleIterStep (it.IsPlausibleNthOutputStep n))
 

src/Init/Data/Iterators/Consumers/Monadic/Collect.lean

@@ -11,8 +11,6 @@ public import Init.Data.Iterators.Consumers.Monadic.Total
 public import Init.Data.Iterators.Internal.LawfulMonadLiftFunction
 public import Init.WFExtrinsicFix
 
-set_option linter.missingDocs true
-
 @[expose] public section
 
 /-!
@@ -24,23 +22,113 @@ Concretely, the following operations are provided:
 * `IterM.toList`, collecting the values in a list
 * `IterM.toListRev`, collecting the values in a list in reverse order but more efficiently
 * `IterM.toArray`, collecting the values in an array
+
+Some producers and combinators provide specialized implementations. These are captured by the
+`IteratorCollect` type class. They should be implemented by all types of iterators. A default
+implementation is provided. The typeclass `LawfulIteratorCollect` asserts that an `IteratorCollect`
+instance equals the default implementation.
 -/
 
 namespace Std
 open Std.Internal Std.Iterators
 
-section ToArray
+section Typeclasses
 
 /--
-If this relation is well-founded, then `IterM.toArray`, `IterM.toList` and `IterM.toListRev` are
-guaranteed to finish after finitely many steps. If all of the iterator's steps terminate
-individually, `IterM.toArray` is guaranteed to terminate.
+`IteratorCollect α m` provides efficient implementations of collectors for `α`-based
+iterators. Right now, it is limited to a potentially optimized `toArray` implementation.
+
+This class is experimental and users of the iterator API should not explicitly depend on it.
+They can, however, assume that consumers that require an instance will work for all iterators
+provided by the standard library.
+
+Note: For this to be compositional enough to be useful, `toArrayMapped` would need to accept a
+termination proof for the specific mapping function used instead of the blanket `Finite α m`
+instance. Otherwise, most combinators like `map` cannot implement their own instance relying on
+the instance of their base iterators. However, fixing this is currently low priority.
 -/
-def IterM.toArray.RecursionRel {α β : Type w} {m : Type w → Type w'}
+class IteratorCollect (α : Type w) (m : Type w → Type w') (n : Type w → Type w'')
+    {β : Type w} [Iterator α m β] where
+  /--
+  Maps the emitted values of an iterator using the given function and collects the results in an
+  `Array`. This is an internal implementation detail. Consider using `it.map f |>.toArray` instead.
+  -/
+  toArrayMapped :
+    (lift : ⦃δ : Type w⦄ → m δ → n δ) → {γ : Type w} → (β → n γ) → IterM (α := α) m β → n (Array γ)
+
+end Typeclasses
+
+section ToArray
+
+def IterM.DefaultConsumers.toArrayMapped.RecursionRel {α β : Type w} {m : Type w → Type w'}
     [Iterator α m β] {γ : Type w} (x' x : (_ : IterM (α := α) m β) ×' Array γ) : Prop :=
-  (∃ out, x.1.IsPlausibleStep (.yield x'.1 out) ∧ ∃ a, x'.2 = x.2.push a) ∨
+  (∃ out, x.1.IsPlausibleStep (.yield x'.1 out) ∧ ∃ fx, x'.2 = x.2.push fx) ∨
     (x.1.IsPlausibleStep (.skip x'.1) ∧ x'.2 = x.2)
 
+/--
+This is an internal function used in `IteratorCollect.defaultImplementation`.
+
+It iterates over an iterator and applies `f` whenever a value is emitted before inserting the result
+of `f` into an array.
+-/
+@[always_inline, no_expose]
+def IterM.DefaultConsumers.toArrayMapped {α β : Type w} {m : Type w → Type w'}
+    {n : Type w → Type w''} [Monad n] [Iterator α m β]
+    (lift : ⦃α : Type w⦄ → m α → n α) {γ : Type w} (f : β → n γ)
+    (it : IterM (α := α) m β) : n (Array γ) :=
+  letI : MonadLift m n := ⟨lift (α := _)⟩
+  go it #[]
+where
+  @[always_inline]
+  go it (acc : Array γ) : n (Array γ) :=
+    letI : MonadLift m n := ⟨lift (α := _)⟩
+    WellFounded.extrinsicFix₂ (C₂ := fun _ _ => n (Array γ)) (InvImage TerminationMeasures.Finite.Rel (·.1.finitelyManySteps!))
+    (fun (it : IterM (α := α) m β) acc recur => do
+      match (← it.step).inflate with
+      | .yield it' out h =>
+        recur it' (acc.push (← f out)) (by exact TerminationMeasures.Finite.rel_of_yield ‹_›)
+      | .skip it' h => recur it' acc (by exact TerminationMeasures.Finite.rel_of_skip ‹_›)
+      | .done _ => return acc) it acc
+
+/--
+This is the default implementation of the `IteratorCollect` class.
+It simply iterates through the iterator using `IterM.step`, incrementally building up the desired
+data structure. For certain iterators, more efficient implementations are possible and should be
+used instead.
+-/
+@[always_inline]
+def IteratorCollect.defaultImplementation {α β : Type w} {m : Type w → Type w'}
+    {n : Type w → Type w''} [Monad n] [Iterator α m β] :
+    IteratorCollect α m n where
+  toArrayMapped := IterM.DefaultConsumers.toArrayMapped
+
+/--
+Asserts that a given `IteratorCollect` instance is equal to `IteratorCollect.defaultImplementation`
+*if the underlying iterator is finite*.
+(Even though equal, the given instance might be vastly more efficient.)
+-/
+class LawfulIteratorCollect (α : Type w) (m : Type w → Type w') (n : Type w → Type w'')
+    {β : Type w} [Monad m] [Monad n] [Iterator α m β] [i : IteratorCollect α m n] where
+  lawful_toArrayMapped : ∀ lift [LawfulMonadLiftFunction lift] [Finite α m],
+    i.toArrayMapped lift (α := α) (γ := γ)
+      = IteratorCollect.defaultImplementation.toArrayMapped lift
+
+theorem LawfulIteratorCollect.toArrayMapped_eq {α β γ : Type w} {m : Type w → Type w'}
+    {n : Type w → Type w''} [Monad m] [Monad n] [Iterator α m β] [Finite α m] [IteratorCollect α m n]
+    [hl : LawfulIteratorCollect α m n] {lift : ⦃δ : Type w⦄ → m δ → n δ}
+    [LawfulMonadLiftFunction lift]
+    {f : β → n γ} {it : IterM (α := α) m β} :
+    IteratorCollect.toArrayMapped lift f it (m := m) =
+      IterM.DefaultConsumers.toArrayMapped lift f it (m := m) := by
+  rw [lawful_toArrayMapped]; rfl
+
+instance instLawfulIteratorCollectDefaultImplementation (α β : Type w) (m : Type w → Type w')
+    (n : Type w → Type w'') [Monad n] [Iterator α m β] [Monad m] [Iterator α m β] [Finite α m] :
+    haveI : IteratorCollect α m n := .defaultImplementation
+    LawfulIteratorCollect α m n :=
+  letI : IteratorCollect α m n := .defaultImplementation
+  ⟨fun _ => rfl⟩
+
 /--
 Traverses the given iterator and stores the emitted values in an array.
 
@@ -49,18 +137,8 @@ If the iterator is not finite, this function might run forever. The variant
 -/
 @[always_inline, inline]
 def IterM.toArray {α β : Type w} {m : Type w → Type w'} [Monad m] [Iterator α m β]
-    (it : IterM (α := α) m β) : m (Array β) :=
-  go it #[]
-where
-  @[always_inline]
-  go it (acc : Array β) : m (Array β) :=
-    WellFounded.extrinsicFix₂ (C₂ := fun _ _ => m (Array β)) (InvImage TerminationMeasures.Finite.Rel (·.1.finitelyManySteps!))
-    (fun (it : IterM (α := α) m β) acc recur => do
-      match (← it.step).inflate with
-      | .yield it' out h =>
-        recur it' (acc.push out) (by exact TerminationMeasures.Finite.rel_of_yield ‹_›)
-      | .skip it' h => recur it' acc (by exact TerminationMeasures.Finite.rel_of_skip ‹_›)
-      | .done _ => return acc) it acc
+    [IteratorCollect α m m] (it : IterM (α := α) m β) : m (Array β) :=
+  IteratorCollect.toArrayMapped (fun ⦃_⦄ => id) pure it
 
 /--
 Traverses the given iterator and stores the emitted values in an array.
@@ -69,7 +147,7 @@ This function is deprecated. Instead of `it.allowNontermination.toArray`, use `i
 -/
 @[always_inline, inline, deprecated IterM.toArray (since := "2025-10-23")]
 def IterM.Partial.toArray {α : Type w} {m : Type w → Type w'} {β : Type w} [Monad m]
-    [Iterator α m β] (it : IterM.Partial (α := α) m β) : m (Array β) :=
+    [Iterator α m β] (it : IterM.Partial (α := α) m β) [IteratorCollect α m m] : m (Array β) :=
   it.it.toArray
 
 /--
@@ -80,7 +158,7 @@ finite. If such a proof is not available, consider using `IterM.toArray`.
 -/
 @[always_inline, inline]
 def IterM.Total.toArray {α : Type w} {m : Type w → Type w'} {β : Type w} [Monad m]
-    [Iterator α m β] [Finite α m] (it : IterM.Total (α := α) m β) :
+    [Iterator α m β] [Finite α m] (it : IterM.Total (α := α) m β) [IteratorCollect α m m] :
     m (Array β) :=
   it.it.toArray
 
@@ -140,7 +218,7 @@ If the iterator is not finite, this function might run forever. The variant
 -/
 @[always_inline, inline]
 def IterM.toList {α : Type w} {m : Type w → Type w'} [Monad m] {β : Type w}
-    [Iterator α m β] (it : IterM (α := α) m β) : m (List β) :=
+    [Iterator α m β] [IteratorCollect α m m] (it : IterM (α := α) m β) : m (List β) :=
   Array.toList <$> IterM.toArray it
 
 /--
@@ -151,7 +229,7 @@ This function is deprecated. Instead of `it.allowNontermination.toList`, use `it
 -/
 @[always_inline, inline, deprecated IterM.toList (since := "2025-10-23")]
 def IterM.Partial.toList {α : Type w} {m : Type w → Type w'} [Monad m] {β : Type w}
-    [Iterator α m β] (it : IterM.Partial (α := α) m β) :
+    [Iterator α m β] (it : IterM.Partial (α := α) m β) [IteratorCollect α m m] :
     m (List β) :=
   Array.toList <$> it.it.toArray
 
@@ -164,7 +242,7 @@ finite. If such a proof is not available, consider using `IterM.toList`.
 -/
 @[always_inline, inline]
 def IterM.Total.toList {α : Type w} {m : Type w → Type w'} {β : Type w} [Monad m]
-    [Iterator α m β] [Finite α m] (it : IterM.Total (α := α) m β) :
+    [Iterator α m β] [Finite α m] (it : IterM.Total (α := α) m β) [IteratorCollect α m m] :
     m (List β) :=
   it.it.toList
 

src/Init/Data/Iterators/Consumers/Monadic/Loop.lean

@@ -11,8 +11,6 @@ public import Init.Data.Iterators.Internal.LawfulMonadLiftFunction
 public import Init.WFExtrinsicFix
 public import Init.Data.Iterators.Consumers.Monadic.Total
 
-set_option linter.missingDocs true
-
 public section
 
 /-!
@@ -72,9 +70,6 @@ provided by the standard library.
 @[ext]
 class IteratorLoop (α : Type w) (m : Type w → Type w') {β : Type w} [Iterator α m β]
     (n : Type x → Type x') where
-  /--
-  Iteration over the iterator `it` in the manner expected by `for` loops.
-  -/
   forIn : ∀ (_liftBind : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ) (γ : Type x),
       (plausible_forInStep : β → γ → ForInStep γ → Prop) →
       (it : IterM (α := α) m β) → γ →
@@ -87,9 +82,7 @@ end Typeclasses
 structure IteratorLoop.WithWF (α : Type w) (m : Type w → Type w') {β : Type w} [Iterator α m β]
     {γ : Type x} (PlausibleForInStep : β → γ → ForInStep γ → Prop)
     (hwf : IteratorLoop.WellFounded α m PlausibleForInStep) where
-  /-- Internal implementation detail of the iterator library. -/
   it : IterM (α := α) m β
-  /-- Internal implementation detail of the iterator library. -/
   acc : γ
 
 instance IteratorLoop.WithWF.instWellFoundedRelation
@@ -170,7 +163,6 @@ Asserts that a given `IteratorLoop` instance is equal to `IteratorLoop.defaultIm
 -/
 class LawfulIteratorLoop (α : Type w) (m : Type w → Type w') (n : Type x → Type x')
     [Monad m] [Monad n] [Iterator α m β] [i : IteratorLoop α m n] where
-  /-- The implementation of `IteratorLoop.forIn` in `i` is equal to the default implementation. -/
   lawful lift [LawfulMonadLiftBindFunction lift] γ it init
       (Pl : β → γ → ForInStep γ → Prop) (wf : IteratorLoop.WellFounded α m Pl)
       (f : (b : β) → it.IsPlausibleIndirectOutput b → (c : γ) → n (Subtype (Pl b c))) :
@@ -227,7 +219,6 @@ instance IterM.instForInOfIteratorLoop {m : Type w → Type w'} {n : Type w →
   haveI : ForIn' n (IterM (α := α) m β) β _ := IterM.instForIn'
   instForInOfForIn'
 
-/-- Internal implementation detail of the iterator library. -/
 @[always_inline, inline]
 def IterM.Partial.instForIn' {m : Type w → Type w'} {n : Type w → Type w''}
     {α : Type w} {β : Type w} [Iterator α m β] [IteratorLoop α m n] [MonadLiftT m n] [Monad n] :
@@ -235,7 +226,6 @@ def IterM.Partial.instForIn' {m : Type w → Type w'} {n : Type w → Type w''}
   forIn' it init f :=
     haveI := @IterM.instForIn'; forIn' it.it init f
 
-/-- Internal implementation detail of the iterator library. -/
 @[always_inline, inline]
 def IterM.Total.instForIn' {m : Type w → Type w'} {n : Type w → Type w''}
     {α : Type w} {β : Type w} [Iterator α m β] [IteratorLoop α m n] [MonadLiftT m n] [Monad n]

src/Init/Data/Iterators/Consumers/Monadic/Partial.lean

@@ -8,8 +8,6 @@ module
 prelude
 public import Init.Data.Iterators.Basic
 
-set_option linter.missingDocs true
-
 public section
 
 namespace Std
@@ -18,9 +16,6 @@ namespace Std
 A wrapper around an iterator that provides partial consumers. See `IterM.allowNontermination`.
 -/
 structure IterM.Partial {α : Type w} (m : Type w → Type w') (β : Type w) where
-  /--
-  The wrapped iterator, which was wrapped by `IterM.allowNontermination`.
-  -/
   it : IterM (α := α) m β
 
 /--

src/Init/Data/Iterators/Consumers/Monadic/Total.lean

@@ -9,19 +9,12 @@ prelude
 public import Init.Data.Iterators.Basic
 
 set_option doc.verso true
-set_option linter.missingDocs true
 
 public section
 
 namespace Std
 
-/--
-A wrapper around an iterator that provides total consumers. See `IterM.ensureTermination`.
--/
 structure IterM.Total {α : Type w} (m : Type w → Type w') (β : Type w) where
-  /--
-  The wrapped iterator, which was wrapped by `IterM.ensureTermination`.
-  -/
   it : IterM (α := α) m β
 
 /--

src/Init/Data/Iterators/Consumers/Partial.lean

@@ -8,8 +8,6 @@ module
 prelude
 public import Init.Data.Iterators.Basic
 
-set_option linter.missingDocs true
-
 public section
 
 namespace Std
@@ -18,9 +16,6 @@ namespace Std
 A wrapper around an iterator that provides partial consumers. See `Iter.allowNontermination`.
 -/
 structure Iter.Partial {α : Type w} (β : Type w) where
-  /--
-  The wrapped iterator, which was wrapped by `Iter.allowNontermination`.
-  -/
   it : Iter (α := α) β
 
 /--

src/Init/Data/Iterators/Consumers/Stream.lean

@@ -9,8 +9,6 @@ prelude
 public import Init.Data.Stream
 public import Init.Data.Iterators.Consumers.Access
 
-set_option linter.missingDocs true
-
 public section
 
 namespace Std

src/Init/Data/Iterators/Consumers/Total.lean

@@ -9,19 +9,12 @@ prelude
 public import Init.Data.Iterators.Basic
 
 set_option doc.verso true
-set_option linter.missingDocs true
 
 public section
 
 namespace Std
 
-/--
-A wrapper around an iterator that provides total consumers. See `Iter.ensureTermination`.
--/
 structure Iter.Total {α : Type w} (β : Type w) where
-  /--
-  The wrapped iterator, which was wrapped by `Iter.ensureTermination`.
-  -/
   it : Iter (α := α) β
 
 /--

src/Init/Data/Iterators/Internal.lean

@@ -7,3 +7,4 @@ module
 
 prelude
 public import Init.Data.Iterators.Internal.LawfulMonadLiftFunction
+public import Init.Data.Iterators.Internal.Termination

src/Init/Data/Iterators/Internal/Termination.lean

@@ -0,0 +1,63 @@
+/-
+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
+public import Init.Data.Iterators.Basic
+
+public section
+
+/-!
+This is an internal module used by iterator implementations.
+-/
+
+namespace Std.Iterators
+
+/--
+Internal implementation detail of the iterator library.
+The purpose of this class is that it implies a `Finite` instance but
+it is more convenient to implement.
+-/
+structure FinitenessRelation (α : Type w) (m : Type w → Type w') {β : Type w}
+    [Iterator α m β] where
+  rel : (IterM (α := α) m β) → (IterM (α := α) m β) → Prop
+  wf : WellFounded rel
+  subrelation : ∀ {it it'}, it'.IsPlausibleSuccessorOf it → rel it' it
+
+theorem Finite.of_finitenessRelation
+    {α : Type w} {m : Type w → Type w'} {β : Type w}
+    [Iterator α m β] (r : FinitenessRelation α m) : Finite α m where
+  wf := by
+    refine Subrelation.wf (r := r.rel) ?_ ?_
+    · intro x y h
+      apply FinitenessRelation.subrelation
+      exact h
+    · apply InvImage.wf
+      exact r.wf
+
+/--
+Internal implementation detail of the iterator library.
+The purpose of this class is that it implies a `Productive` instance but
+it is more convenient to implement.
+-/
+structure ProductivenessRelation (α : Type w) (m : Type w → Type w') {β : Type w}
+    [Iterator α m β] where
+  rel : (IterM (α := α) m β) → (IterM (α := α) m β) → Prop
+  wf : WellFounded rel
+  subrelation : ∀ {it it'}, it'.IsPlausibleSkipSuccessorOf it → rel it' it
+
+theorem Productive.of_productivenessRelation
+    {α : Type w} {m : Type w → Type w'} {β : Type w}
+    [Iterator α m β] (r : ProductivenessRelation α m) : Productive α m where
+  wf := by
+    refine Subrelation.wf (r := r.rel) ?_ ?_
+    · intro x y h
+      apply ProductivenessRelation.subrelation
+      exact h
+    · apply InvImage.wf
+      exact r.wf
+
+end Std.Iterators

src/Init/Data/Iterators/Lemmas/Combinators/Attach.lean

@@ -27,7 +27,8 @@ theorem Iter.unattach_eq_toIter_unattach_toIterM [Iterator α Id β] {it : Iter
 
 theorem Iter.unattach_toList_attachWith [Iterator α Id β]
     {it : Iter (α := α) β} {hP}
-    [Finite α Id] :
+    [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] :
     (it.attachWith P hP).toList.unattach = it.toList := by
   simp [Iter.unattach_eq_toIter_unattach_toIterM,
     ← Id.run_map (f := List.unattach), IterM.map_unattach_toList_attachWith,
@@ -36,7 +37,8 @@ theorem Iter.unattach_toList_attachWith [Iterator α Id β]
 @[simp]
 theorem Iter.toList_attachWith [Iterator α Id β]
     {it : Iter (α := α) β} {hP}
-    [Finite α Id] :
+    [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] :
     (it.attachWith P hP).toList = it.toList.attachWith P
         (fun out h => hP out (isPlausibleIndirectOutput_of_mem_toList h)) := by
   apply List.ext_getElem
@@ -48,14 +50,16 @@ theorem Iter.toList_attachWith [Iterator α Id β]
 
 theorem Iter.unattach_toListRev_attachWith [Iterator α Id β]
     {it : Iter (α := α) β} {hP}
-    [Finite α Id] :
+    [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] :
     (it.attachWith P hP).toListRev.unattach = it.toListRev := by
   simp [toListRev_eq]
 
 @[simp]
 theorem Iter.toListRev_attachWith [Iterator α Id β]
     {it : Iter (α := α) β} {hP}
-    [Finite α Id] :
+    [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] :
     (it.attachWith P hP).toListRev = it.toListRev.attachWith P
         (fun out h => hP out (isPlausibleIndirectOutput_of_mem_toListRev h)) := by
   simp [toListRev_eq]
@@ -63,14 +67,16 @@ theorem Iter.toListRev_attachWith [Iterator α Id β]
 @[simp]
 theorem Iter.unattach_toArray_attachWith [Iterator α Id β]
     {it : Iter (α := α) β} {hP}
-    [Finite α Id] :
+    [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] :
     (it.attachWith P hP).toListRev.unattach = it.toListRev := by
   simp [toListRev_eq]
 
 @[simp]
 theorem Iter.toArray_attachWith [Iterator α Id β]
     {it : Iter (α := α) β} {hP}
-    [Finite α Id] :
+    [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] :
     (it.attachWith P hP).toArray = it.toArray.attachWith P
         (fun out h => hP out (isPlausibleIndirectOutput_of_mem_toArray h)) := by
   suffices (it.attachWith P hP).toArray.toList = (it.toArray.attachWith P
@@ -84,6 +90,7 @@ theorem Iter.count_attachWith [Iterator α Id β]
     [Finite α Id] [IteratorLoop α Id Id]
     [LawfulIteratorLoop α Id Id] :
     (it.attachWith P hP).count = it.count := by
+  letI : IteratorCollect α Id Id := .defaultImplementation
   rw [← Iter.length_toList_eq_count, toList_attachWith]
   simp
 

src/Init/Data/Iterators/Lemmas/Combinators/FilterMap.lean

@@ -9,7 +9,6 @@ prelude
 public import Init.Data.Iterators.Lemmas.Consumers
 public import Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap
 public import Init.Data.Iterators.Combinators.FilterMap
-import Init.Control.Lawful.MonadAttach.Lemmas
 
 public section
 
@@ -33,15 +32,15 @@ theorem Iter.mapWithPostcondition_eq_toIter_mapWithPostcondition_toIterM [Monad
     it.mapWithPostcondition f = (letI : MonadLift Id m := ⟨pure⟩; it.toIterM.mapWithPostcondition f) :=
   rfl
 
-theorem Iter.filterMapM_eq_toIter_filterMapM_toIterM [Monad m] [MonadAttach m] {f : β → m (Option γ)} :
+theorem Iter.filterMapM_eq_toIter_filterMapM_toIterM [Monad m] {f : β → m (Option γ)} :
     it.filterMapM f = (letI : MonadLift Id m := ⟨pure⟩; it.toIterM.filterMapM f) :=
   rfl
 
-theorem Iter.filterM_eq_toIter_filterM_toIterM [Monad m] [MonadAttach m] {f : β → m (ULift Bool)} :
+theorem Iter.filterM_eq_toIter_filterM_toIterM [Monad m] {f : β → m (ULift Bool)} :
     it.filterM f = (letI : MonadLift Id m := ⟨pure⟩; it.toIterM.filterM f) :=
   rfl
 
-theorem Iter.mapM_eq_toIter_mapM_toIterM [Monad m] [MonadAttach m] {f : β → m γ} :
+theorem Iter.mapM_eq_toIter_mapM_toIterM [Monad m] {f : β → m γ} :
     it.mapM f = (letI : MonadLift Id m := ⟨pure⟩; it.toIterM.mapM f) :=
   rfl
 
@@ -109,7 +108,7 @@ theorem Iter.step_filterWithPostcondition {f : β → PostconditionT n (ULift Bo
   | .done h => rfl
 
 theorem Iter.step_mapWithPostcondition {f : β → PostconditionT n γ}
-    [Monad n] [LawfulMonad n] :
+    [Monad n] [LawfulMonad n] [MonadLiftT m n] :
   (it.mapWithPostcondition f).step = (do
     match it.step with
     | .yield it' out h => do
@@ -130,15 +129,15 @@ theorem Iter.step_mapWithPostcondition {f : β → PostconditionT n γ}
   | .done h => rfl
 
 theorem Iter.step_filterMapM {β' : Type w} {f : β → n (Option β')}
-    [Monad n] [MonadAttach n] [LawfulMonad n] [MonadLiftT m n] :
+    [Monad n] [LawfulMonad n] [MonadLiftT m n] :
   (it.filterMapM f).step = (do
     match it.step with
     | .yield it' out h => do
-      match ← MonadAttach.attach (f out) with
-      | ⟨none, hf⟩ =>
-        pure <| .deflate <| .skip (it'.filterMapM f) (.yieldNone (out := out) h hf)
-      | ⟨some out', hf⟩ =>
-        pure <| .deflate <| .yield (it'.filterMapM f) out' (.yieldSome (out := out) h hf)
+      match ← f out with
+      | none =>
+        pure <| .deflate <| .skip (it'.filterMapM f) (.yieldNone (out := out) h .intro)
+      | some out' =>
+        pure <| .deflate <| .yield (it'.filterMapM f) out' (.yieldSome (out := out) h .intro)
     | .skip it' h =>
       pure <| .deflate <| .skip (it'.filterMapM f) (.skip h)
     | .done h =>
@@ -155,15 +154,15 @@ theorem Iter.step_filterMapM {β' : Type w} {f : β → n (Option β')}
   | .done h => rfl
 
 theorem Iter.step_filterM {f : β → n (ULift Bool)}
-    [Monad n] [MonadAttach n] [LawfulMonad n] [MonadLiftT m n] :
+    [Monad n] [LawfulMonad n] [MonadLiftT m n] :
   (it.filterM f).step = (do
     match it.step with
     | .yield it' out h => do
-      match ← MonadAttach.attach (f out) with
-      | ⟨.up false, hf⟩ =>
-        pure <| .deflate <| .skip (it'.filterM f) (.yieldNone (out := out) h ⟨⟨.up false, hf⟩, rfl⟩)
-      | ⟨.up true, hf⟩ =>
-        pure <| .deflate <| .yield (it'.filterM f) out (.yieldSome (out := out) h ⟨⟨.up true, hf⟩, rfl⟩)
+      match ← f out with
+      | .up false =>
+        pure <| .deflate <| .skip (it'.filterM f) (.yieldNone (out := out) h ⟨⟨.up false, .intro⟩, rfl⟩)
+      | .up true =>
+        pure <| .deflate <| .yield (it'.filterM f) out (.yieldSome (out := out) h ⟨⟨.up true, .intro⟩, rfl⟩)
     | .skip it' h =>
       pure <| .deflate <| .skip (it'.filterM f) (.skip h)
     | .done h =>
@@ -173,19 +172,20 @@ theorem Iter.step_filterM {f : β → n (ULift Bool)}
   generalize it.toIterM.step = step
   match step.inflate with
   | .yield it' out h =>
-    simp only
-    apply bind_congr; intro step
+    simp [PostconditionT.lift]
+    apply bind_congr
+    intro step
     rcases step with _ | _ <;> rfl
   | .skip it' h => rfl
   | .done h => rfl
 
 theorem Iter.step_mapM {f : β → n γ}
-    [Monad n] [MonadAttach n] [LawfulMonad n] :
+    [Monad n] [LawfulMonad n] :
   (it.mapM f).step = (do
     match it.step with
     | .yield it' out h => do
-      let out' ← MonadAttach.attach (f out)
-      pure <| .deflate <| .yield (it'.mapM f) out'.val (.yieldSome h ⟨⟨out', out'.property⟩, rfl⟩)
+      let out' ← f out
+      pure <| .deflate <| .yield (it'.mapM f) out' (.yieldSome h ⟨⟨out', True.intro⟩, rfl⟩)
     | .skip it' h =>
       pure <| .deflate <| .skip (it'.mapM f) (.skip h)
     | .done h =>
@@ -291,417 +291,174 @@ def Iter.val_step_filter {f : β → Bool} :
   · simp
 
 @[simp]
-theorem Iter.toList_filterMap [Finite α Id]
+theorem Iter.toList_filterMap
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] [Finite α Id]
     {f : β → Option γ} :
     (it.filterMap f).toList = it.toList.filterMap f := by
   simp [filterMap_eq_toIter_filterMap_toIterM, toList_eq_toList_toIterM, IterM.toList_filterMap]
 
 @[simp]
-theorem Iter.toList_mapWithPostcondition [Monad m] [LawfulMonad m] [Finite α Id]
-    {f : β → PostconditionT m γ} :
-    (it.mapWithPostcondition f).toList = it.toList.mapM (fun x => (f x).run) := by
-  simp [Iter.mapWithPostcondition, IterM.toList_mapWithPostcondition, Iter.toList_eq_toList_toIterM]
-
-@[simp]
-theorem Iter.toList_mapM [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Finite α Id] {f : β → m γ} :
-    (it.mapM f).toList = it.toList.mapM f := by
-  simp [Iter.mapM_eq_toIter_mapM_toIterM, IterM.toList_mapM, Iter.toList_eq_toList_toIterM]
-
-@[simp]
-theorem Iter.toList_map [Finite α Id] {f : β → γ} :
+theorem Iter.toList_map
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] [Finite α Id]
+    {f : β → γ} :
     (it.map f).toList = it.toList.map f := by
   simp [map_eq_toIter_map_toIterM, IterM.toList_map, Iter.toList_eq_toList_toIterM]
 
 @[simp]
-theorem Iter.toList_filter [Finite α Id] {f : β → Bool} :
+theorem Iter.toList_filter
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] [Finite α Id]
+    {f : β → Bool} :
     (it.filter f).toList = it.toList.filter f := by
   simp [filter_eq_toIter_filter_toIterM, IterM.toList_filter, Iter.toList_eq_toList_toIterM]
 
 @[simp]
-theorem Iter.toList_filterMapWithPostcondition_filterMapWithPostcondition
-    [Monad m] [LawfulMonad m] [Monad n] [LawfulMonad n] [MonadLiftT m n] [LawfulMonadLiftT m n]
-    [Finite α Id]
-    {f : β → PostconditionT m (Option γ)} {g : γ → PostconditionT n (Option δ)} :
-    ((it.filterMapWithPostcondition f).filterMapWithPostcondition g).toList =
-      (it.filterMapWithPostcondition (m := n) (fun b => do
-        match ← (haveI : MonadLift m n := ⟨monadLift⟩; f b) with
-        | none => return none
-        | some fb => g fb)).toList := by
-  simp only [Iter.filterMapWithPostcondition]
-  rw [IterM.toList_filterMapWithPostcondition_filterMapWithPostcondition,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-  rfl
-
-@[simp]
-theorem Iter.toList_mapWithPostcondition_mapWithPostcondition
-    [Monad m] [LawfulMonad m] [Monad n] [LawfulMonad n] [MonadLiftT m n] [LawfulMonadLiftT m n]
-    [Finite α Id]
-    {f : β → PostconditionT m γ} {g : γ → PostconditionT n δ} :
-    ((it.mapWithPostcondition f).mapWithPostcondition g).toList =
-      (it.mapWithPostcondition (m := n) (haveI : MonadLift m n := ⟨monadLift⟩; fun b => f b >>= g)).toList := by
-  simp only [Iter.mapWithPostcondition]
-  rw [IterM.toList_mapWithPostcondition_mapWithPostcondition,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-
-@[simp]
-theorem Iter.toListRev_filterMap [Finite α Id]
+theorem Iter.toListRev_filterMap
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] [Finite α Id]
     {f : β → Option γ} :
     (it.filterMap f).toListRev = it.toListRev.filterMap f := by
   simp [filterMap_eq_toIter_filterMap_toIterM, toListRev_eq_toListRev_toIterM, IterM.toListRev_filterMap]
 
 @[simp]
-theorem Iter.toListRev_map [Finite α Id]
+theorem Iter.toListRev_map
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] [Finite α Id]
     {f : β → γ} :
     (it.map f).toListRev = it.toListRev.map f := by
   simp [map_eq_toIter_map_toIterM, IterM.toListRev_map, Iter.toListRev_eq_toListRev_toIterM]
 
 @[simp]
-theorem Iter.toListRev_filter [Finite α Id]
+theorem Iter.toListRev_filter
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] [Finite α Id]
     {f : β → Bool} :
     (it.filter f).toListRev = it.toListRev.filter f := by
   simp [filter_eq_toIter_filter_toIterM, IterM.toListRev_filter, Iter.toListRev_eq_toListRev_toIterM]
 
 @[simp]
-theorem Iter.toArray_filterMap [Finite α Id]
+theorem Iter.toArray_filterMap
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] [Finite α Id]
     {f : β → Option γ} :
     (it.filterMap f).toArray = it.toArray.filterMap f := by
   simp [filterMap_eq_toIter_filterMap_toIterM, toArray_eq_toArray_toIterM, IterM.toArray_filterMap]
 
 @[simp]
-theorem Iter.toArray_mapWithPostcondition [Monad m] [LawfulMonad m] [Finite α Id]
-    {f : β → PostconditionT m γ} :
-    (it.mapWithPostcondition f).toArray = it.toArray.mapM (fun x => (f x).run) := by
-  simp [Iter.mapWithPostcondition, IterM.toArray_mapWithPostcondition, Iter.toArray_eq_toArray_toIterM]
-
-@[simp]
-theorem Iter.toArray_mapM [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Finite α Id] {f : β → m γ} :
-    (it.mapM f).toArray = it.toArray.mapM f := by
-  simp [Iter.mapM_eq_toIter_mapM_toIterM, IterM.toArray_mapM, Iter.toArray_eq_toArray_toIterM]
-
-@[simp]
-theorem Iter.toArray_map [Finite α Id] {f : β → γ} :
+theorem Iter.toArray_map
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] [Finite α Id]
+    {f : β → γ} :
     (it.map f).toArray = it.toArray.map f := by
   simp [map_eq_toIter_map_toIterM, IterM.toArray_map, Iter.toArray_eq_toArray_toIterM]
 
 @[simp]
-theorem Iter.toArray_filter[Finite α Id] {f : β → Bool} :
+theorem Iter.toArray_filter
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] [Finite α Id]
+    {f : β → Bool} :
     (it.filter f).toArray = it.toArray.filter f := by
   simp [filter_eq_toIter_filter_toIterM, IterM.toArray_filter, Iter.toArray_eq_toArray_toIterM]
 
-@[simp]
-theorem Iter.toArray_filterMapWithPostcondition_filterMapWithPostcondition
-    [Monad m] [LawfulMonad m] [Monad n] [LawfulMonad n] [MonadLiftT m n] [LawfulMonadLiftT m n]
-    [Finite α Id]
-    {f : β → PostconditionT m (Option γ)} {g : γ → PostconditionT n (Option δ)} :
-    ((it.filterMapWithPostcondition f).filterMapWithPostcondition g).toArray =
-      (it.filterMapWithPostcondition (m := n) (fun b => do
-        match ← (haveI : MonadLift m n := ⟨monadLift⟩; f b) with
-        | none => return none
-        | some fb => g fb)).toArray := by
-  simp only [Iter.filterMapWithPostcondition]
-  rw [IterM.toArray_filterMapWithPostcondition_filterMapWithPostcondition,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-  rfl
-
-@[simp]
-theorem Iter.toArray_mapWithPostcondition_mapWithPostcondition
-    [Monad m] [LawfulMonad m] [Monad n] [LawfulMonad n] [MonadLiftT m n] [LawfulMonadLiftT m n]
-    [Finite α Id]
-    {f : β → PostconditionT m γ} {g : γ → PostconditionT n δ} :
-    ((it.mapWithPostcondition f).mapWithPostcondition g).toArray =
-      (it.mapWithPostcondition (m := n) (haveI : MonadLift m n := ⟨monadLift⟩; fun b => f b >>= g)).toArray := by
-  simp only [Iter.mapWithPostcondition]
-  rw [IterM.toArray_mapWithPostcondition_mapWithPostcondition,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-
-section ForIn
-
-theorem Iter.forIn_filterMapWithPostcondition
-    [Monad n] [LawfulMonad n] [Monad o] [LawfulMonad o]
-    [MonadLiftT n o] [LawfulMonadLiftT n o] [Finite α Id]
-    [IteratorLoop α Id o] [LawfulIteratorLoop α Id o]
-    {it : Iter (α := α) β} {f : β → PostconditionT n (Option β₂)} {init : γ}
-    {g : β₂ → γ → o (ForInStep γ)} :
-    forIn (it.filterMapWithPostcondition f) init g = forIn it init (fun out acc => do
-        match ← (f out).run with
-        | some c => g c acc
-        | none => return .yield acc) := by
-  simp [Iter.forIn_eq_forIn_toIterM, filterMapWithPostcondition, IterM.forIn_filterMapWithPostcondition,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]; rfl
-
-theorem Iter.forIn_filterMapM
-    [Monad n] [LawfulMonad n] [Monad o] [LawfulMonad o]
-    [MonadAttach n] [WeaklyLawfulMonadAttach n]
-    [MonadLiftT n o] [LawfulMonadLiftT n o]
-    [Finite α Id] [IteratorLoop α Id o] [LawfulIteratorLoop α Id o]
-    {it : Iter (α := α) β} {f : β → n (Option β₂)} {init : γ} {g : β₂ → γ → o (ForInStep γ)} :
-    forIn (it.filterMapM f) init g = forIn it init (fun out acc => do
-        match ← f out with
-        | some c => g c acc
-        | none => return .yield acc) := by
-  simp [filterMapM, forIn_eq_forIn_toIterM, IterM.forIn_filterMapM,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]; rfl
-
-theorem Iter.forIn_filterMap
-    [Monad n] [LawfulMonad n] [Finite α Id]
-    [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {it : Iter (α := α) β} {f : β → Option β₂} {init : γ} {g : β₂ → γ → n (ForInStep γ)} :
-    forIn (it.filterMap f) init g = forIn it init (fun out acc => do
-        match f out with
-        | some c => g c acc
-        | none => return .yield acc) := by
-  simp [filterMap, forIn_eq_forIn_toIterM, IterM.forIn_filterMap]; rfl
-
-theorem Iter.forIn_mapWithPostcondition
-    [Monad n] [LawfulMonad n] [Monad o] [LawfulMonad o]
-    [MonadLiftT n o] [LawfulMonadLiftT n o] [Finite α Id]
-    [IteratorLoop α Id o] [LawfulIteratorLoop α Id o]
-    {it : Iter (α := α) β} {f : β → PostconditionT n β₂} {init : γ}
-    {g : β₂ → γ → o (ForInStep γ)} :
-    forIn (it.mapWithPostcondition f) init g =
-      forIn it init (fun out acc => do g (← (f out).run) acc) := by
-  simp [mapWithPostcondition, forIn_eq_forIn_toIterM, IterM.forIn_mapWithPostcondition,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-
-theorem Iter.forIn_mapM
-    [Monad n] [LawfulMonad n] [Monad o] [LawfulMonad o]
-    [MonadAttach n] [WeaklyLawfulMonadAttach n]
-    [MonadLiftT n o] [LawfulMonadLiftT n o]
-    [Finite α Id]
-    [IteratorLoop α Id o] [LawfulIteratorLoop α Id o]
-    {it : Iter (α := α) β} {f : β → n β₂} {init : γ} {g : β₂ → γ → o (ForInStep γ)} :
-    forIn (it.mapM f) init g = forIn it init (fun out acc => do g (← f out) acc) := by
-  rw [mapM, forIn_eq_forIn_toIterM, IterM.forIn_mapM, instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-
-theorem Iter.forIn_map
-    [Monad n] [LawfulMonad n]
-    [Finite α Id] [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {it : Iter (α := α) β} {f : β → β₂} {init : γ} {g : β₂ → γ → n (ForInStep γ)} :
-    forIn (it.map f) init g = forIn it init (fun out acc => do g (f out) acc) := by
-  simp [map, forIn_eq_forIn_toIterM, IterM.forIn_map]
-
-theorem Iter.forIn_filterWithPostcondition
-    [Monad n] [LawfulMonad n] [Monad o] [LawfulMonad o]
-    [MonadLiftT n o] [LawfulMonadLiftT n o]
-    [Finite α Id] [IteratorLoop α Id o] [LawfulIteratorLoop α Id o]
-    {it : Iter (α := α) β} {f : β → PostconditionT n (ULift Bool)} {init : γ}
-    {g : β → γ → o (ForInStep γ)} :
-    haveI : MonadLift n o := ⟨monadLift⟩
-    forIn (it.filterWithPostcondition f) init g =
-      forIn it init (fun out acc => do if (← (f out).run).down then g out acc else return .yield acc) := by
-  simp [filterWithPostcondition, forIn_eq_forIn_toIterM, IterM.forIn_filterWithPostcondition,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-
-theorem Iter.forIn_filterM
-    [Monad n] [LawfulMonad n] [Monad o] [LawfulMonad o]
-    [MonadAttach n] [WeaklyLawfulMonadAttach n]
-    [MonadLiftT n o] [LawfulMonadLiftT n o] [Finite α Id]
-    [IteratorLoop α Id o] [LawfulIteratorLoop α Id o]
-    {it : Iter (α := α) β} {f : β → n (ULift Bool)} {init : γ} {g : β → γ → o (ForInStep γ)} :
-    forIn (it.filterM f) init g = forIn it init (fun out acc => do if (← f out).down then g out acc else return .yield acc) := by
-  simp [filterM, forIn_eq_forIn_toIterM, IterM.forIn_filterM,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-
-theorem Iter.forIn_filter
-    [Monad n] [LawfulMonad n]
-    [Finite α Id] [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {it : Iter (α := α) β} {f : β → Bool} {init : γ} {g : β → γ → n (ForInStep γ)} :
-    forIn (it.filter f) init g = forIn it init (fun out acc => do if f out then g out acc else return .yield acc) := by
-  simp [filter, forIn_eq_forIn_toIterM, IterM.forIn_filter]
-
-end ForIn
-
 section Fold
 
-theorem Iter.foldM_filterMapWithPostcondition {α β γ δ : Type w}
-    {n : Type w → Type w''} {o : Type w → Type w'''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [Monad o] [LawfulMonad n] [LawfulMonad o]
-    [IteratorLoop α Id n] [IteratorLoop α Id o]
-    [LawfulIteratorLoop α Id n] [LawfulIteratorLoop α Id o]
-    [MonadLiftT n o] [LawfulMonadLiftT n o]
-    {f : β → PostconditionT n (Option γ)} {g : δ → γ → o δ} {init : δ} {it : Iter (α := α) β} :
-    (it.filterMapWithPostcondition f).foldM (init := init) g =
-      it.foldM (init := init) (fun d b => do
-          let some c ← (f b).run | pure d
-          g d c) := by
-  rw [filterMapWithPostcondition, IterM.foldM_filterMapWithPostcondition, foldM_eq_foldM_toIterM,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]; rfl
-
-theorem Iter.foldM_filterMapM {α β γ δ : Type w}
-    {n : Type w → Type w''} {o : Type w → Type w'''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
-    [Monad o] [LawfulMonad o]
-    [IteratorLoop α Id n] [IteratorLoop α Id o]
-    [LawfulIteratorLoop α Id n] [LawfulIteratorLoop α Id o]
-    [MonadLiftT n o] [LawfulMonadLiftT n o]
-    {f : β → n (Option γ)} {g : δ → γ → o δ} {init : δ} {it : Iter (α := α) β} :
+theorem Iter.foldM_filterMapM {α β γ δ : Type w} {m : Type w → Type w'} {n : Type w → Type w''}
+    [Iterator α Id β] [Finite α Id] [Monad m] [Monad n] [LawfulMonad m] [LawfulMonad n]
+    [IteratorLoop α Id Id] [IteratorLoop α Id m] [IteratorLoop α Id n]
+    [MonadLiftT m n] [LawfulMonadLiftT m n]
+    [LawfulIteratorLoop α Id Id] [LawfulIteratorLoop α Id m] [LawfulIteratorLoop α Id n]
+    {f : β → m (Option γ)} {g : δ → γ → n δ} {init : δ} {it : Iter (α := α) β} :
     (it.filterMapM f).foldM (init := init) g =
       it.foldM (init := init) (fun d b => do
           let some c ← f b | pure d
           g d c) := by
-  simp [filterMapM, IterM.foldM_filterMapM, foldM_eq_foldM_toIterM,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]; rfl
+  rw [foldM_eq_foldM_toIterM, filterMapM_eq_toIter_filterMapM_toIterM, IterM.foldM_filterMapM]
+  congr
+  simp [instMonadLiftTOfMonadLift, Id.instMonadLiftTOfPure]
 
-theorem Iter.foldM_mapWithPostcondition {α β γ δ : Type w}
-    {n : Type w → Type w''} {o : Type w → Type w'''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad m] [Monad n] [Monad o] [LawfulMonad m][LawfulMonad n] [LawfulMonad o]
-    [IteratorLoop α Id n] [IteratorLoop α Id o]
-    [LawfulIteratorLoop α Id n] [LawfulIteratorLoop α Id o]
-    [MonadLiftT n o] [LawfulMonadLiftT n o]
-    {f : β → PostconditionT n γ} {g : δ → γ → o δ} {init : δ} {it : Iter (α := α) β} :
-    (it.mapWithPostcondition f).foldM (init := init) g =
-      it.foldM (init := init) (fun d b => do let c ← (f b).run; g d c) := by
-  simp [mapWithPostcondition, IterM.foldM_mapWithPostcondition, foldM_eq_foldM_toIterM,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-
-theorem Iter.foldM_mapM {α β γ δ : Type w}
-    {n : Type w → Type w''} {o : Type w → Type w'''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
-    [Monad o] [LawfulMonad o]
-    [IteratorLoop α Id n] [IteratorLoop α Id o]
-    [LawfulIteratorLoop α Id n] [LawfulIteratorLoop α Id o]
-    [MonadLiftT n o] [LawfulMonadLiftT n o]
-    {f : β → n γ} {g : δ → γ → o δ} {init : δ} {it : Iter (α := α) β} :
-    haveI : MonadLift n o := ⟨MonadLiftT.monadLift⟩
+theorem Iter.foldM_mapM {α β γ δ : Type w} {m : Type w → Type w'} {n : Type w → Type w''}
+    [Iterator α Id β] [Finite α Id] [Monad m] [Monad n] [LawfulMonad m] [LawfulMonad n]
+    [IteratorLoop α Id m] [IteratorLoop α Id n]
+    [LawfulIteratorLoop α Id m] [LawfulIteratorLoop α Id n]
+    [MonadLiftT m n] [LawfulMonadLiftT m n]
+    {f : β → m γ} {g : δ → γ → n δ} {init : δ} {it : Iter (α := α) β} :
     (it.mapM f).foldM (init := init) g =
       it.foldM (init := init) (fun d b => do let c ← f b; g d c) := by
-  simp [mapM, IterM.foldM_mapM, foldM_eq_foldM_toIterM,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
+  rw [foldM_eq_foldM_toIterM, mapM_eq_toIter_mapM_toIterM, IterM.foldM_mapM]
+  congr
+  simp [instMonadLiftTOfMonadLift, Id.instMonadLiftTOfPure]
 
-theorem Iter.foldM_filterWithPostcondition {α β δ : Type w}
-    {n : Type w → Type w''} {o : Type w → Type w'''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [Monad o] [LawfulMonad n] [LawfulMonad o]
-    [IteratorLoop α Id n] [IteratorLoop α Id o]
-    [LawfulIteratorLoop α Id n] [LawfulIteratorLoop α Id o]
-    [MonadLiftT n o] [LawfulMonadLiftT n o]
-    {f : β → PostconditionT n (ULift Bool)} {g : δ → β → o δ} {init : δ} {it : Iter (α := α) β} :
-    (it.filterWithPostcondition f).foldM (init := init) g =
-      it.foldM (init := init) (fun d b => do if (← (f b).run).down then g d b else pure d) := by
-  simp [filterWithPostcondition, IterM.foldM_filterWithPostcondition, foldM_eq_foldM_toIterM,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-
-theorem Iter.foldM_filterM {α β δ : Type w}
-    {n : Type w → Type w''} {o : Type w → Type w'''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
-    [Monad o] [LawfulMonad o]
-    [IteratorLoop α Id n] [IteratorLoop α Id o]
-    [LawfulIteratorLoop α Id n] [LawfulIteratorLoop α Id o]
-    [MonadLiftT n o] [LawfulMonadLiftT n o]
-    {f : β → n (ULift Bool)} {g : δ → β → o δ} {init : δ} {it : Iter (α := α) β} :
-    (it.filterM f).foldM (init := init) g =
-      it.foldM (init := init) (fun d b => do if (← f b).down then g d b else pure d) := by
-  simp [filterM, IterM.foldM_filterM, foldM_eq_foldM_toIterM,
-    instMonadLiftTOfMonadLift_instMonadLiftTOfPure]
-
-theorem Iter.foldM_filterMap {α β γ δ : Type w} {n : Type w → Type w''}
-    [Iterator α Id β] [Finite α Id] [Monad n] [LawfulMonad n]
-    [IteratorLoop α Id n]
-    [LawfulIteratorLoop α Id n]
-    {f : β → Option γ} {g : δ → γ → n δ} {init : δ} {it : Iter (α := α) β} :
+theorem Iter.foldM_filterMap {α β γ : Type w} {δ : Type x} {m : Type x → Type w'}
+    [Iterator α Id β] [Finite α Id] [Monad m] [LawfulMonad m]
+    [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    {f : β → Option γ} {g : δ → γ → m δ} {init : δ} {it : Iter (α := α) β} :
     (it.filterMap f).foldM (init := init) g =
       it.foldM (init := init) (fun d b => do
           let some c := f b | pure d
           g d c) := by
-  simp [filterMap, IterM.foldM_filterMap, foldM_eq_foldM_toIterM]; rfl
+  induction it using Iter.inductSteps generalizing init with | step it ihy ihs
+  rw [foldM_eq_match_step, foldM_eq_match_step, step_filterMap]
+  -- There seem to be some type dependencies that, combined with nested match expressions,
+  -- force us to split a lot.
+  split <;> rename_i h
+  · split at h
+    · split at h
+      · cases h
+      · cases h; simp [*, ihy ‹_›]
+    · cases h
+    · cases h
+  · split at h
+    · split at h
+      · cases h; simp [*, ihy ‹_›]
+      · cases h
+    · cases h; simp [*, ihs ‹_›]
+    · cases h
+  · split at h
+    · split at h
+      · cases h
+      · cases h
+    · cases h
+    · simp [*]
 
-theorem Iter.foldM_map {α β γ δ : Type w} {n : Type w → Type w''}
-    [Iterator α Id β] [Finite α Id] [Monad n] [LawfulMonad n]
-    [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {f : β → γ} {g : δ → γ → n δ} {init : δ} {it : Iter (α := α) β} :
+theorem Iter.foldM_map {α β γ : Type w} {δ : Type x} {m : Type x → Type w'}
+    [Iterator α Id β] [Finite α Id] [Monad m] [LawfulMonad m]
+    [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    {f : β → γ} {g : δ → γ → m δ} {init : δ} {it : Iter (α := α) β} :
     (it.map f).foldM (init := init) g =
-      it.foldM (init := init) (fun d b => do g d (f b)) := by
-  simp [foldM_eq_forIn, forIn_map]
+      it.foldM (init := init) (fun d b => g d (f b)) := by
+  induction it using Iter.inductSteps generalizing init with | step it ihy ihs
+  rw [foldM_eq_match_step, foldM_eq_match_step, step_map]
+  cases it.step using PlausibleIterStep.casesOn
+  · simp [*, ihy ‹_›]
+  · simp [*, ihs ‹_›]
+  · simp
 
-theorem Iter.foldM_filter {α β δ : Type w} {n : Type w → Type w''}
-    [Iterator α Id β] [Finite α Id] [Monad n] [LawfulMonad n]
-    [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {f : β → Bool} {g : δ → β → n δ} {init : δ} {it : Iter (α := α) β} :
-    (it.filter f).foldM (init := init) g =
-      it.foldM (init := init) (fun d b => if f b then g d b else pure d) := by
-  simp only [foldM_eq_forIn, forIn_filter]
-  congr 1; ext out acc
-  cases f out <;> simp
-
-theorem Iter.fold_filterMapWithPostcondition {α β γ δ : Type w} {n : Type w → Type w''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [LawfulMonad n]
-    [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {f : β → PostconditionT n (Option γ)} {g : δ → γ → δ} {init : δ} {it : Iter (α := α) β} :
-    (it.filterMapWithPostcondition f).fold (init := init) g =
-      it.foldM (init := init) (fun d b => do
-          let some c ← (f b).run | pure d
-          return g d c) := by
-  simp [filterMapWithPostcondition, IterM.fold_filterMapWithPostcondition, foldM_eq_foldM_toIterM]
-  rfl
-
-theorem Iter.fold_filterMapM {α β γ δ : Type w} {n : Type w → Type w''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
-    [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {f : β → n (Option γ)} {g : δ → γ → δ} {init : δ} {it : Iter (α := α) β} :
+theorem Iter.fold_filterMapM {α β γ δ : Type w} {m : Type w → Type w'}
+    [Iterator α Id β] [Finite α Id] [Monad m] [LawfulMonad m]
+    [IteratorLoop α Id Id.{w}] [IteratorLoop α Id m]
+    [LawfulIteratorLoop α Id Id] [LawfulIteratorLoop α Id m]
+    {f : β → m (Option γ)} {g : δ → γ → δ} {init : δ} {it : Iter (α := α) β} :
     (it.filterMapM f).fold (init := init) g =
       it.foldM (init := init) (fun d b => do
           let some c ← f b | pure d
           return g d c) := by
-  simp [filterMapM, IterM.fold_filterMapM, foldM_eq_foldM_toIterM]; rfl
+  rw [foldM_eq_foldM_toIterM, filterMapM_eq_toIter_filterMapM_toIterM, IterM.fold_filterMapM]
+  rfl
 
-theorem Iter.fold_mapWithPostcondition {α β γ δ : Type w} {n : Type w → Type w''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [LawfulMonad n]
-    [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {f : β → PostconditionT n γ} {g : δ → γ → δ} {init : δ} {it : Iter (α := α) β} :
-    (it.mapWithPostcondition f).fold (init := init) g =
-      it.foldM (init := init) (fun d b => do let c ← (f b).run; return g d c) := by
-  simp [mapWithPostcondition, IterM.fold_mapWithPostcondition, foldM_eq_foldM_toIterM]
-
-theorem Iter.fold_mapM {α β γ δ : Type w} {n : Type w → Type w''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
-    [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {f : β → n γ} {g : δ → γ → δ} {init : δ} {it : Iter (α := α) β} :
+theorem Iter.fold_mapM {α β γ δ : Type w} {m : Type w → Type w'}
+    [Iterator α Id β] [Finite α Id] [Monad m] [LawfulMonad m]
+    [IteratorLoop α Id Id.{w}] [IteratorLoop α Id m]
+    [LawfulIteratorLoop α Id Id] [LawfulIteratorLoop α Id m]
+    {f : β → m γ} {g : δ → γ → δ} {init : δ} {it : Iter (α := α) β} :
     (it.mapM f).fold (init := init) g =
-      it.foldM (init := init) (fun d b => do let c ← f b; return g d c) := by
-  simp [mapM, IterM.fold_mapM, foldM_eq_foldM_toIterM]
+      it.foldM (init := init) (fun d b => do return g d (← f b)) := by
+  rw [foldM_eq_foldM_toIterM, mapM_eq_toIter_mapM_toIterM, IterM.fold_mapM]
 
-theorem Iter.fold_filterWithPostcondition {α β δ : Type w}
-    {n : Type w → Type w''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [LawfulMonad n]
-    [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {f : β → PostconditionT n (ULift Bool)} {g : δ → β → δ} {init : δ} {it : Iter (α := α) β} :
-    (it.filterWithPostcondition f).fold (init := init) g =
-      it.foldM (init := init) (fun d b => return if (← (f b).run).down then g d b else d) := by
-  simp [filterWithPostcondition, IterM.fold_filterWithPostcondition, foldM_eq_foldM_toIterM]
-
-theorem Iter.fold_filterM {α β δ : Type w} {n : Type w → Type w''}
-    [Iterator α Id β] [Finite α Id]
-    [Monad n] [MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
-    [IteratorLoop α Id n] [LawfulIteratorLoop α Id n]
-    {f : β → n (ULift Bool)} {g : δ → β → δ} {init : δ} {it : Iter (α := α) β} :
-    (it.filterM f).fold (init := init) g =
-      it.foldM (init := init) (fun d b => return if (← f b).down then g d b else d) := by
-  simp [filterM, IterM.fold_filterM, foldM_eq_foldM_toIterM]
-
-theorem Iter.fold_filterMap {α β γ δ : Type w}
-    [Iterator α Id β] [Finite α Id]
-    [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
+theorem Iter.fold_filterMap {α β γ : Type w} {δ : Type x}
+    [Iterator α Id β] [Finite α Id] [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
     {f : β → Option γ} {g : δ → γ → δ} {init : δ} {it : Iter (α := α) β} :
     (it.filterMap f).fold (init := init) g =
       it.fold (init := init) (fun d b =>
           match f b with
           | some c => g d c
           | _ => d) := by
-  simp [filterMap, IterM.fold_filterMap, fold_eq_fold_toIterM]; rfl
+  simp only [fold_eq_foldM, foldM_filterMap]
+  rfl
 
-theorem Iter.fold_map {α β γ δ : Type w}
+theorem Iter.fold_map {α β γ : Type w} {δ : Type x}
     [Iterator α Id β] [Finite α Id]
     [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
     {f : β → γ} {g : δ → γ → δ} {init : δ} {it : Iter (α := α) β} :
@@ -709,14 +466,6 @@ theorem Iter.fold_map {α β γ δ : Type w}
       it.fold (init := init) (fun d b => g d (f b)) := by
   simp [fold_eq_foldM, foldM_map]
 
-theorem Iter.fold_filter {α β δ : Type w}
-    [Iterator α Id β] [Finite α Id]
-    [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
-    {f : β → Bool} {g : δ → β → δ} {init : δ} {it : Iter (α := α) β} :
-    (it.filter f).fold (init := init) g =
-      it.fold (init := init) (fun d b => if f b then g d b else d) := by
-  simp [filter, IterM.fold_filter, fold_eq_fold_toIterM]
-
 end Fold
 
 section Count
@@ -731,7 +480,7 @@ theorem Iter.count_map {α β β' : Type w} [Iterator α Id β]
 end Count
 
 theorem Iter.anyM_filterMapM {α β β' : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [LawfulMonad m]
     {it : Iter (α := α) β} {f : β → m (Option β')} {p : β' → m (ULift Bool)} :
     (it.filterMapM f).anyM p = (it.mapM (pure (f := m))).anyM (fun x => do
       match ← f x with
@@ -746,24 +495,14 @@ This lemma expresses `Iter.anyM` in terms of `IterM.anyM`.
 It requires all involved types to live in `Type 0`.
 -/
 theorem Iter.anyM_eq_anyM_mapM_pure {α β : Type} {m : Type → Type w'} [Iterator α Id β]
-    [Finite α Id] [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    [Finite α Id] [Monad m] [LawfulMonad m] [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
     {it : Iter (α := α) β} {p : β → m Bool} :
     it.anyM p = ULift.down <$> (it.mapM (α := α) (pure (f := m))).anyM (fun x => ULift.up <$> p x) := by
   rw [anyM_eq_forIn, IterM.anyM_eq_forIn, map_eq_pure_bind]
   induction it using Iter.inductSteps with | step it ihy ihs =>
   rw [forIn_eq_match_step, IterM.forIn_eq_match_step, bind_assoc, step_mapM]
   cases it.step using PlausibleIterStep.casesOn
-  · rename_i out _
-    simp only [bind_assoc, pure_bind, map_eq_pure_bind, Shrink.inflate_deflate,
-      liftM, monadLift]
-    have {x : m Bool} : x = MonadAttach.attach (pure out) >>= (fun _ => x) := by
-      rw (occs := [1]) [show x = pure out >>= (fun _ => x) by simp]
-      conv => lhs; rw [← WeaklyLawfulMonadAttach.map_attach (x := pure out)]
-      simp
-    refine Eq.trans this ?_
-    simp only [WeaklyLawfulMonadAttach.bind_attach_of_nonempty (x := pure out), pure_bind]
-    split; rotate_left; rfl
+  · simp only [bind_assoc, liftM_pure, pure_bind, map_eq_pure_bind, Shrink.inflate_deflate]
     apply bind_congr; intro px
     split
     · simp
@@ -772,13 +511,13 @@ theorem Iter.anyM_eq_anyM_mapM_pure {α β : Type} {m : Type → Type w'} [Itera
   · simp
 
 theorem Iter.anyM_mapM {α β β' : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [LawfulMonad m]
     {it : Iter (α := α) β} {f : β → m β'} {p : β' → m (ULift Bool)} :
     (it.mapM f).anyM p = (it.mapM (pure (f := m))).anyM (fun x => do p (← f x)) := by
   rw [mapM_eq_toIter_mapM_toIterM, IterM.anyM_mapM, mapM_eq_toIter_mapM_toIterM]
 
 theorem Iter.anyM_filterM {α β : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [LawfulMonad m]
     {it : Iter (α := α) β} {f : β → m (ULift Bool)} {p : β → m (ULift Bool)} :
     (it.filterM f).anyM p = (it.mapM (pure (f := m))).anyM (fun x => do
         if (← f x).down then
@@ -838,8 +577,8 @@ theorem Iter.anyM_filter {α β : Type w} {m : Type → Type w'}
   · simp
 
 theorem Iter.any_filterMapM {α β β' : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [IteratorLoop α Id m]
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m] [LawfulIteratorLoop α Id m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [IteratorLoop α Id m]
+    [LawfulMonad m] [LawfulIteratorLoop α Id m]
     {it : Iter (α := α) β} {f : β → m (Option β')} {p : β' → Bool} :
     (it.filterMapM f).any p = (it.mapM (pure (f := m))).anyM (fun x => do
       match ← f x with
@@ -848,15 +587,15 @@ theorem Iter.any_filterMapM {α β β' : Type w} {m : Type w → Type w'}
   simp [IterM.any_eq_anyM, anyM_filterMapM]
 
 theorem Iter.any_mapM {α β β' : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [IteratorLoop α Id m]
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m] [LawfulIteratorLoop α Id m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [IteratorLoop α Id m]
+    [LawfulMonad m] [LawfulIteratorLoop α Id m]
     {it : Iter (α := α) β} {f : β → m β'} {p : β' → Bool} :
     (it.mapM f).any p = (it.mapM pure).anyM (fun x => (.up <| p ·) <$> (f x)) := by
   simp [IterM.any_eq_anyM, anyM_mapM]
 
 theorem Iter.any_filterM {α β : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [IteratorLoop α Id m]
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m] [LawfulIteratorLoop α Id m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [IteratorLoop α Id m]
+    [LawfulMonad m] [LawfulIteratorLoop α Id m]
     {it : Iter (α := α) β} {f : β → m (ULift Bool)} {p : β → Bool} :
     (it.filterM f).any p = (it.mapM (pure (f := m))).anyM (fun x => do
         if (← f x).down then
@@ -898,7 +637,7 @@ theorem Iter.any_map {α β β' : Type w}
   · simp
 
 theorem Iter.allM_filterMapM {α β β' : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [LawfulMonad m]
     {it : Iter (α := α) β} {f : β → m (Option β')} {p : β' → m (ULift Bool)} :
     (it.filterMapM f).allM p = (it.mapM (pure (f := m))).allM (fun x => do
       match ← f x with
@@ -912,19 +651,29 @@ This lemma expresses `Iter.allM` in terms of `IterM.allM`.
 It requires all involved types to live in `Type 0`.
 -/
 theorem Iter.allM_eq_allM_mapM_pure {α β : Type} {m : Type → Type w'} [Iterator α Id β]
-    [Finite α Id] [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [IteratorLoop α Id m] [LawfulIteratorLoop α Id m] {it : Iter (α := α) β} {p : β → m Bool} :
+    [Finite α Id] [Monad m] [LawfulMonad m] [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    {it : Iter (α := α) β} {p : β → m Bool} :
     it.allM p = ULift.down <$> (it.mapM (α := α) (pure (f := m))).allM (fun x => ULift.up <$> p x) := by
-  simp [allM_eq_not_anyM_not, anyM_eq_anyM_mapM_pure, IterM.allM_eq_not_anyM_not]
+  rw [allM_eq_forIn, IterM.allM_eq_forIn, map_eq_pure_bind]
+  induction it using Iter.inductSteps with | step it ihy ihs =>
+  rw [forIn_eq_match_step, IterM.forIn_eq_match_step, bind_assoc, step_mapM]
+  cases it.step using PlausibleIterStep.casesOn
+  · simp only [bind_assoc, liftM_pure, pure_bind, map_eq_pure_bind, Shrink.inflate_deflate]
+    apply bind_congr; intro px
+    split
+    · simp [ihy ‹_›]
+    · simp
+  · simp [ihs ‹_›]
+  · simp
 
 theorem Iter.allM_mapM {α β β' : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [LawfulMonad m]
     {it : Iter (α := α) β} {f : β → m β'} {p : β' → m (ULift Bool)} :
     (it.mapM f).allM p = (it.mapM (pure (f := m))).allM (fun x => do p (← f x)) := by
   rw [mapM_eq_toIter_mapM_toIterM, IterM.allM_mapM, mapM_eq_toIter_mapM_toIterM]
 
 theorem Iter.allM_filterM {α β : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [LawfulMonad m]
     {it : Iter (α := α) β} {f : β → m (ULift Bool)} {p : β → m (ULift Bool)} :
     (it.filterM f).allM p = (it.mapM (pure (f := m))).allM (fun x => do
         if (← f x).down then
@@ -984,9 +733,8 @@ theorem Iter.allM_filter {α β : Type w} {m : Type → Type w'}
   · simp
 
 theorem Iter.all_filterMapM {α β β' : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [IteratorLoop α Id m]
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [LawfulIteratorLoop α Id m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [IteratorLoop α Id m]
+    [LawfulMonad m] [LawfulIteratorLoop α Id m]
     {it : Iter (α := α) β} {f : β → m (Option β')} {p : β' → Bool} :
     (it.filterMapM f).all p = (it.mapM (pure (f := m))).allM (fun x => do
       match ← f x with
@@ -995,15 +743,15 @@ theorem Iter.all_filterMapM {α β β' : Type w} {m : Type w → Type w'}
   simp [IterM.all_eq_allM, allM_filterMapM]
 
 theorem Iter.all_mapM {α β β' : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [IteratorLoop α Id m]
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [LawfulIteratorLoop α Id m] {it : Iter (α := α) β} {f : β → m β'} {p : β' → Bool} :
+    [Iterator α Id β] [Finite α Id] [Monad m] [IteratorLoop α Id m]
+    [LawfulMonad m] [LawfulIteratorLoop α Id m]
+    {it : Iter (α := α) β} {f : β → m β'} {p : β' → Bool} :
     (it.mapM f).all p = (it.mapM pure).allM (fun x => (.up <| p ·) <$> (f x)) := by
   simp [IterM.all_eq_allM, allM_mapM]
 
 theorem Iter.all_filterM {α β : Type w} {m : Type w → Type w'}
-    [Iterator α Id β] [Finite α Id] [IteratorLoop α Id m]
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m] [LawfulIteratorLoop α Id m]
+    [Iterator α Id β] [Finite α Id] [Monad m] [IteratorLoop α Id m]
+    [LawfulMonad m] [LawfulIteratorLoop α Id m]
     {it : Iter (α := α) β} {f : β → m (ULift Bool)} {p : β → Bool} :
     (it.filterM f).all p = (it.mapM (pure (f := m))).allM (fun x => do
         if (← f x).down then

src/Init/Data/Iterators/Lemmas/Combinators/FlatMap.lean

@@ -10,7 +10,6 @@ import Init.Data.Iterators.Lemmas.Combinators.FilterMap
 public import Init.Data.Iterators.Combinators.FlatMap
 import all Init.Data.Iterators.Combinators.FlatMap
 public import Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap
-import Init.Control.Lawful.MonadAttach.Lemmas
 
 namespace Std
 open Std.Internal Std.Iterators
@@ -18,51 +17,43 @@ open Std.Internal Std.Iterators
 namespace Iterators.Types
 
 public theorem Flatten.IsPlausibleStep.outerYield_flatMapM_pure {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m] [Iterator α Id β]
-    [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
     {f : β → m (IterM (α := α₂) m γ)} {it₁ it₁' : Iter (α := α) β} {it₂' b}
-    (h : it₁.IsPlausibleStep (.yield it₁' b)) (h' : MonadAttach.CanReturn (f b) it₂') :
+    (h : it₁.IsPlausibleStep (.yield it₁' b)) :
     (it₁.flatMapAfterM f none).IsPlausibleStep (.skip (it₁'.flatMapAfterM f (some it₂'))) := by
-  apply outerYield_flatMapM (b := b)
-  · exact FilterMap.PlausibleStep.yieldSome h (by simp)
-  · exact h'
+  apply outerYield_flatMapM
+  exact .yieldSome h (out' := b) (by simp [PostconditionT.lift, PostconditionT.bind])
 
 public theorem Flatten.IsPlausibleStep.outerSkip_flatMapM_pure {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
     {f : β → m (IterM (α := α₂) m γ)} {it₁ it₁' : Iter (α := α) β}
     (h : it₁.IsPlausibleStep (.skip it₁')) :
     (it₁.flatMapAfterM f none).IsPlausibleStep (.skip (it₁'.flatMapAfterM f none)) :=
   outerSkip_flatMapM (.skip h)
 
 public theorem Flatten.IsPlausibleStep.outerDone_flatMapM_pure {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
     {f : β → m (IterM (α := α₂) m γ)} {it₁ : Iter (α := α) β}
     (h : it₁.IsPlausibleStep .done) :
     (it₁.flatMapAfterM f none).IsPlausibleStep .done :=
   outerDone_flatMapM (.done h)
 
 public theorem Flatten.IsPlausibleStep.innerYield_flatMapM_pure {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
     {f : β → m (IterM (α := α₂) m γ)} {it₁ : Iter (α := α) β} {it₂ it₂' b}
     (h : it₂.IsPlausibleStep (.yield it₂' b)) :
     (it₁.flatMapAfterM f (some it₂)).IsPlausibleStep (.yield (it₁.flatMapAfterM f (some it₂')) b) :=
   innerYield_flatMapM h
 
 public theorem Flatten.IsPlausibleStep.innerSkip_flatMapM_pure {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
     {f : β → m (IterM (α := α₂) m γ)} {it₁ : Iter (α := α) β} {it₂ it₂'}
     (h : it₂.IsPlausibleStep (.skip it₂')) :
     (it₁.flatMapAfterM f (some it₂)).IsPlausibleStep (.skip (it₁.flatMapAfterM f (some it₂'))) :=
   innerSkip_flatMapM h
 
 public theorem Flatten.IsPlausibleStep.innerDone_flatMapM_pure {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
     {f : β → m (IterM (α := α₂) m γ)} {it₁ : Iter (α := α) β} {it₂}
     (h : it₂.IsPlausibleStep .done) :
     (it₁.flatMapAfterM f (some it₂)).IsPlausibleStep (.skip (it₁.flatMapAfterM f none)) :=
@@ -113,16 +104,14 @@ public theorem Flatten.IsPlausibleStep.innerDone_flatMap_pure {α : Type w} {β
 end Iterators.Types
 
 public theorem Iter.step_flatMapAfterM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m] [Iterator α Id β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
     {f : β → m (IterM (α := α₂) m γ)} {it₁ : Iter (α := α) β} {it₂ : Option (IterM (α := α₂) m γ)} :
   (it₁.flatMapAfterM f it₂).step = (do
     match it₂ with
     | none =>
       match it₁.step with
       | .yield it₁' b h =>
-        let fx ← MonadAttach.attach (f b)
-        return .deflate (.skip (it₁'.flatMapAfterM f (some fx.val)) (.outerYield_flatMapM_pure h fx.property))
+        return .deflate (.skip (it₁'.flatMapAfterM f (some (← f b))) (.outerYield_flatMapM_pure h))
       | .skip it₁' h => return .deflate (.skip (it₁'.flatMapAfterM f none) (.outerSkip_flatMapM_pure h))
       | .done h => return .deflate (.done (.outerDone_flatMapM_pure h))
     | some it₂ =>
@@ -133,22 +122,18 @@ public theorem Iter.step_flatMapAfterM {α : Type w} {β : Type w} {α₂ : Type
         return .deflate (.skip (it₁.flatMapAfterM f (some it₂')) (.innerSkip_flatMapM_pure h))
       | .done h =>
         return .deflate (.skip (it₁.flatMapAfterM f none) (.innerDone_flatMapM_pure h))) := by
-  simp only [flatMapAfterM, IterM.step_flatMapAfterM, Iter.step_mapWithPostcondition,
-    PostconditionT.operation_pure]
+  simp only [flatMapAfterM, IterM.step_flatMapAfterM, Iter.step_mapM]
   split
   · split <;> simp [*]
   · rfl
 
 public theorem Iter.step_flatMapM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α Id β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ]
     {f : β → m (IterM (α := α₂) m γ)} {it₁ : Iter (α := α) β} :
   (it₁.flatMapM f).step = (do
     match it₁.step with
     | .yield it₁' b h =>
-      let fx ← MonadAttach.attach (f b)
-      return .deflate (.skip (it₁'.flatMapAfterM f (some fx.val)) (.outerYield_flatMapM_pure h fx.property))
+      return .deflate (.skip (it₁'.flatMapAfterM f (some (← f b))) (.outerYield_flatMapM_pure h))
     | .skip it₁' h => return .deflate (.skip (it₁'.flatMapAfterM f none) (.outerSkip_flatMapM_pure h))
     | .done h => return .deflate (.done (.outerDone_flatMapM_pure h))) := by
   simp [flatMapM, step_flatMapAfterM]
@@ -186,9 +171,10 @@ public theorem Iter.step_flatMap {α : Type w} {β : Type w} {α₂ : Type w}
     | .done h => .done (.outerDone_flatMap_pure h)) := by
   simp [flatMap, step_flatMapAfter]
 
-public theorem Iter.toList_flatMapAfterM {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α Id β] [Iterator α₂ m γ] [Finite α Id] [Finite α₂ m]
+public theorem Iter.toList_flatMapAfterM {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ] [Finite α Id] [Finite α₂ m]
+    [IteratorCollect α Id m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α Id m] [LawfulIteratorCollect α₂ m m]
     {f : β → m (IterM (α := α₂) m γ)}
     {it₁ : Iter (α := α) β} {it₂ : Option (IterM (α := α₂) m γ)} :
     (it₁.flatMapAfterM f it₂).toList = do
@@ -197,11 +183,17 @@ public theorem Iter.toList_flatMapAfterM {α α₂ β γ : Type w} {m : Type w
       | some it₂ => return (← it₂.toList) ++
           (← List.flatten <$> (it₁.mapM fun b => do (← f b).toList).toList) := by
   simp only [flatMapAfterM, IterM.toList_flatMapAfterM]
-  split <;> simp [IterM.toList_mapM_eq_toList_mapWithPostcondition]
+  split
+  · simp only [mapM, IterM.toList_mapM_mapM, monadLift_self]
+    congr <;> simp
+  · apply bind_congr; intro step
+    simp only [mapM, IterM.toList_mapM_mapM, monadLift_self, bind_pure_comp, Functor.map_map]
+    congr <;> simp
 
-public theorem Iter.toArray_flatMapAfterM {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α Id β] [Iterator α₂ m γ] [Finite α Id] [Finite α₂ m]
+public theorem Iter.toArray_flatMapAfterM {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ] [Finite α Id] [Finite α₂ m]
+    [IteratorCollect α Id m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α Id m] [LawfulIteratorCollect α₂ m m]
     {f : β → m (IterM (α := α₂) m γ)}
     {it₁ : Iter (α := α) β} {it₂ : Option (IterM (α := α₂) m γ)} :
     (it₁.flatMapAfterM f it₂).toArray = do
@@ -210,47 +202,58 @@ public theorem Iter.toArray_flatMapAfterM {α α₂ β γ : Type w} {m : Type w
       | some it₂ => return (← it₂.toArray) ++
           (← Array.flatten <$> (it₁.mapM fun b => do (← f b).toArray).toArray) := by
   simp only [flatMapAfterM, IterM.toArray_flatMapAfterM]
-  split <;> simp [IterM.toArray_mapM_eq_toArray_mapWithPostcondition]
+  split
+  · simp only [mapM, IterM.toArray_mapM_mapM, monadLift_self]
+    congr <;> simp
+  · apply bind_congr; intro step
+    simp only [mapM, IterM.toArray_mapM_mapM, monadLift_self, bind_pure_comp, Functor.map_map]
+    congr <;> simp
 
-public theorem Iter.toList_flatMapM {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α Id β] [Iterator α₂ m γ] [Finite α Id] [Finite α₂ m]
+public theorem Iter.toList_flatMapM {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ] [Finite α Id] [Finite α₂ m]
+    [IteratorCollect α Id m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α Id m] [LawfulIteratorCollect α₂ m m]
     {f : β → m (IterM (α := α₂) m γ)}
     {it₁ : Iter (α := α) β} :
     (it₁.flatMapM f).toList = List.flatten <$> (it₁.mapM fun b => do (← f b).toList).toList := by
   simp [flatMapM, toList_flatMapAfterM]
 
-public theorem Iter.toArray_flatMapM {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α Id β] [Iterator α₂ m γ] [Finite α Id] [Finite α₂ m]
+public theorem Iter.toArray_flatMapM {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α Id β] [Iterator α₂ m γ] [Finite α Id] [Finite α₂ m]
+    [IteratorCollect α Id m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α Id m] [LawfulIteratorCollect α₂ m m]
     {f : β → m (IterM (α := α₂) m γ)}
     {it₁ : Iter (α := α) β} :
     (it₁.flatMapM f).toArray = Array.flatten <$> (it₁.mapM fun b => do (← f b).toArray).toArray := by
   simp [flatMapM, toArray_flatMapAfterM]
 
 public theorem Iter.toList_flatMapAfter {α α₂ β γ : Type w} [Iterator α Id β] [Iterator α₂ Id γ]
-    [Finite α Id] [Finite α₂ Id]
+    [Finite α Id] [Finite α₂ Id] [IteratorCollect α Id Id] [IteratorCollect α₂ Id Id]
+    [LawfulIteratorCollect α Id Id] [LawfulIteratorCollect α₂ Id Id]
     {f : β → Iter (α := α₂) γ} {it₁ : Iter (α := α) β} {it₂ : Option (Iter (α := α₂) γ)} :
     (it₁.flatMapAfter f it₂).toList = match it₂ with
       | none => (it₁.map fun b => (f b).toList).toList.flatten
       | some it₂ => it₂.toList ++
           (it₁.map fun b => (f b).toList).toList.flatten := by
   simp only [flatMapAfter, Iter.toList, toIterM_toIter, IterM.toList_flatMapAfter]
-  cases it₂ <;> simp [map, IterM.toList_map_eq_toList_mapM, - IterM.toList_map]
+  cases it₂ <;> simp [map, IterM.toList_map_eq_toList_mapM]
 
 public theorem Iter.toArray_flatMapAfter {α α₂ β γ : Type w} [Iterator α Id β] [Iterator α₂ Id γ]
-    [Finite α Id] [Finite α₂ Id]
+    [Finite α Id] [Finite α₂ Id] [IteratorCollect α Id Id] [IteratorCollect α₂ Id Id]
+    [LawfulIteratorCollect α Id Id] [LawfulIteratorCollect α₂ Id Id]
     {f : β → Iter (α := α₂) γ} {it₁ : Iter (α := α) β} {it₂ : Option (Iter (α := α₂) γ)} :
     (it₁.flatMapAfter f it₂).toArray = match it₂ with
       | none => (it₁.map fun b => (f b).toArray).toArray.flatten
       | some it₂ => it₂.toArray ++
           (it₁.map fun b => (f b).toArray).toArray.flatten := by
   simp only [flatMapAfter, Iter.toArray, toIterM_toIter, IterM.toArray_flatMapAfter]
-  cases it₂ <;> simp [map, IterM.toArray_map_eq_toArray_mapM, - IterM.toArray_map]
+  cases it₂ <;> simp [map, IterM.toArray_map_eq_toArray_mapM]
 
 public theorem Iter.toList_flatMap {α α₂ β γ : Type w} [Iterator α Id β] [Iterator α₂ Id γ]
     [Finite α Id] [Finite α₂ Id]
     [Iterator α Id β] [Iterator α₂ Id γ] [Finite α Id] [Finite α₂ Id]
+    [IteratorCollect α Id Id] [IteratorCollect α₂ Id Id]
+    [LawfulIteratorCollect α Id Id] [LawfulIteratorCollect α₂ Id Id]
     {f : β → Iter (α := α₂) γ} {it₁ : Iter (α := α) β} :
     (it₁.flatMap f).toList = (it₁.map fun b => (f b).toList).toList.flatten := by
   simp [flatMap, toList_flatMapAfter]
@@ -258,6 +261,8 @@ public theorem Iter.toList_flatMap {α α₂ β γ : Type w} [Iterator α Id β]
 public theorem Iter.toArray_flatMap {α α₂ β γ : Type w} [Iterator α Id β] [Iterator α₂ Id γ]
     [Finite α Id] [Finite α₂ Id]
     [Iterator α Id β] [Iterator α₂ Id γ] [Finite α Id] [Finite α₂ Id]
+    [IteratorCollect α Id Id] [IteratorCollect α₂ Id Id]
+    [LawfulIteratorCollect α Id Id] [LawfulIteratorCollect α₂ Id Id]
     {f : β → Iter (α := α₂) γ} {it₁ : Iter (α := α) β} :
     (it₁.flatMap f).toArray = (it₁.map fun b => (f b).toArray).toArray.flatten := by
   simp [flatMap, toArray_flatMapAfter]

src/Init/Data/Iterators/Lemmas/Combinators/Monadic/Attach.lean

@@ -26,7 +26,8 @@ theorem IterM.step_attachWith [Iterator α m β] [Monad m] {it : IterM (α := α
 @[simp]
 theorem IterM.map_unattach_toList_attachWith [Iterator α m β] [Monad m]
     {it : IterM (α := α) m β} {hP}
-    [Finite α m] [LawfulMonad m] :
+    [Finite α m] [IteratorCollect α m m]
+    [LawfulMonad m] [LawfulIteratorCollect α m m] :
     List.unattach <$> (it.attachWith P hP).toList = it.toList := by
   induction it using IterM.inductSteps with | step it ihy ihs
   rw [IterM.toList_eq_match_step, IterM.toList_eq_match_step, step_attachWith]
@@ -45,7 +46,8 @@ theorem IterM.map_unattach_toList_attachWith [Iterator α m β] [Monad m]
 @[simp]
 theorem IterM.map_unattach_toListRev_attachWith [Iterator α m β] [Monad m] [Monad n]
     {it : IterM (α := α) m β} {hP}
-    [Finite α m] [LawfulMonad m] :
+    [Finite α m] [IteratorCollect α m m]
+    [LawfulMonad m] [LawfulIteratorCollect α m m] :
     List.unattach <$> (it.attachWith P hP).toListRev = it.toListRev := by
   rw [toListRev_eq, toListRev_eq, ← map_unattach_toList_attachWith (it := it) (hP := hP)]
   simp [-map_unattach_toList_attachWith]
@@ -53,8 +55,8 @@ theorem IterM.map_unattach_toListRev_attachWith [Iterator α m β] [Monad m] [Mo
 @[simp]
 theorem IterM.map_unattach_toArray_attachWith [Iterator α m β] [Monad m] [Monad n]
     {it : IterM (α := α) m β} {hP}
-    [Finite α m]
-    [LawfulMonad m] :
+    [Finite α m] [IteratorCollect α m m]
+    [LawfulMonad m] [LawfulIteratorCollect α m m] :
     (·.map Subtype.val) <$> (it.attachWith P hP).toArray = it.toArray := by
   rw [← toArray_toList, ← toArray_toList, ← map_unattach_toList_attachWith (it := it) (hP := hP)]
   simp [-map_unattach_toList_attachWith, -IterM.toArray_toList]
@@ -64,6 +66,7 @@ theorem IterM.count_attachWith [Iterator α m β] [Monad m] [Monad n]
     {it : IterM (α := α) m β} {hP}
     [Finite α m] [IteratorLoop α m m] [LawfulMonad m] [LawfulIteratorLoop α m m] :
     (it.attachWith P hP).count = it.count := by
+  letI : IteratorCollect α m m := .defaultImplementation
   rw [← up_length_toList_eq_count, ← up_length_toList_eq_count,
     ← map_unattach_toList_attachWith (it := it) (P := P) (hP := hP)]
   simp only [Functor.map_map, List.length_unattach]

src/Init/Data/Iterators/Lemmas/Combinators/Monadic/FlatMap.lean

@@ -37,43 +37,43 @@ theorem IterM.step_flattenAfter {α α₂ β : Type w} {m : Type w → Type w'}
 namespace Iterators.Types
 
 public theorem Flatten.IsPlausibleStep.outerYield_flatMapM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ]
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ]
     {f : β → m (IterM (α := α₂) m γ)} {it₁ it₁' : IterM (α := α) m β} {it₂' b}
-    (h : it₁.IsPlausibleStep (.yield it₁' b)) (h' : MonadAttach.CanReturn (f b) it₂') :
+    (h : it₁.IsPlausibleStep (.yield it₁' b)) :
     (it₁.flatMapAfterM f none).IsPlausibleStep (.skip (it₁'.flatMapAfterM f (some it₂'))) :=
-  .outerYield (.yieldSome h ⟨⟨_, h'⟩, rfl⟩)
+  .outerYield (.yieldSome h ⟨⟨_, trivial⟩, rfl⟩)
 
 public theorem Flatten.IsPlausibleStep.outerSkip_flatMapM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α m β]
-    [Iterator α₂ m γ] {f : β → m (IterM (α := α₂) m γ)} {it₁ it₁' : IterM (α := α) m β}
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ]
+    {f : β → m (IterM (α := α₂) m γ)} {it₁ it₁' : IterM (α := α) m β}
     (h : it₁.IsPlausibleStep (.skip it₁')) :
     (it₁.flatMapAfterM f none).IsPlausibleStep (.skip (it₁'.flatMapAfterM f none)) :=
   .outerSkip (.skip h)
 
 public theorem Flatten.IsPlausibleStep.outerDone_flatMapM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α m β]
-    [Iterator α₂ m γ] {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β}
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ]
+    {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β}
     (h : it₁.IsPlausibleStep .done) :
     (it₁.flatMapAfterM f none).IsPlausibleStep .done :=
   .outerDone (.done h)
 
 public theorem Flatten.IsPlausibleStep.innerYield_flatMapM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α m β]
-    [Iterator α₂ m γ] {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β} {it₂ it₂' b}
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ]
+    {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β} {it₂ it₂' b}
     (h : it₂.IsPlausibleStep (.yield it₂' b)) :
     (it₁.flatMapAfterM f (some it₂)).IsPlausibleStep (.yield (it₁.flatMapAfterM f (some it₂')) b) :=
   .innerYield h
 
 public theorem Flatten.IsPlausibleStep.innerSkip_flatMapM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α m β]
-    [Iterator α₂ m γ] {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β} {it₂ it₂'}
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ]
+    {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β} {it₂ it₂'}
     (h : it₂.IsPlausibleStep (.skip it₂')) :
     (it₁.flatMapAfterM f (some it₂)).IsPlausibleStep (.skip (it₁.flatMapAfterM f (some it₂'))) :=
   .innerSkip h
 
 public theorem Flatten.IsPlausibleStep.innerDone_flatMapM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [LawfulMonad m] [Iterator α m β]
-    [Iterator α₂ m γ] {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β} {it₂}
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ]
+    {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β} {it₂}
     (h : it₂.IsPlausibleStep .done) :
     (it₁.flatMapAfterM f (some it₂)).IsPlausibleStep (.skip (it₁.flatMapAfterM f none)) :=
   .innerDone h
@@ -123,16 +123,14 @@ public theorem Flatten.IsPlausibleStep.innerDone_flatMap {α : Type w} {β : Typ
 end Iterators.Types
 
 public theorem IterM.step_flatMapAfterM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α m β] [Iterator α₂ m γ] {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β}
-    {it₂ : Option (IterM (α := α₂) m γ)} :
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ]
+    {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β} {it₂ : Option (IterM (α := α₂) m γ)} :
   (it₁.flatMapAfterM f it₂).step = (do
     match it₂ with
     | none =>
       match (← it₁.step).inflate with
       | .yield it₁' b h =>
-        let fx ← MonadAttach.attach (f b)
-        return .deflate (.skip (it₁'.flatMapAfterM f (some fx.val)) (.outerYield_flatMapM h fx.property))
+        return .deflate (.skip (it₁'.flatMapAfterM f (some (← f b))) (.outerYield_flatMapM h))
       | .skip it₁' h => return .deflate (.skip (it₁'.flatMapAfterM f none) (.outerSkip_flatMapM h))
       | .done h => return .deflate (.done (.outerDone_flatMapM h))
     | some it₂ =>
@@ -144,22 +142,17 @@ public theorem IterM.step_flatMapAfterM {α : Type w} {β : Type w} {α₂ : Typ
   split
   · simp only [bind_assoc]
     apply bind_congr; intro step
-    cases step.inflate using PlausibleIterStep.casesOn
-    · simp only [bind_pure_comp, bind_map_left, Shrink.inflate_deflate]
-    · simp
-    · simp
+    cases step.inflate using PlausibleIterStep.casesOn <;> simp
   · rfl
 
 public theorem IterM.step_flatMapM {α : Type w} {β : Type w} {α₂ : Type w}
-    {γ : Type w} {m : Type w → Type w'} [Monad m] [MonadAttach m] [LawfulMonad m]
-    [WeaklyLawfulMonadAttach m] [Iterator α m β] [Iterator α₂ m γ] {f : β → m (IterM (α := α₂) m γ)}
-    {it₁ : IterM (α := α) m β} :
+    {γ : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ]
+    {f : β → m (IterM (α := α₂) m γ)} {it₁ : IterM (α := α) m β} :
   (it₁.flatMapM f).step = (do
     match (← it₁.step).inflate with
     | .yield it₁' b h =>
-      let fx ← MonadAttach.attach (f b)
-      return .deflate (.skip (it₁'.flatMapAfterM f (some fx.val))
-        (.outerYield_flatMapM h fx.property))
+      return .deflate (.skip (it₁'.flatMapAfterM f (some (← f b)))
+        (.outerYield_flatMapM h))
     | .skip it₁' h => return .deflate (.skip (it₁'.flatMapAfterM f none) (.outerSkip_flatMapM h))
     | .done h => return .deflate (.done (.outerDone_flatMapM h))) := by
   simp [flatMapM, step_flatMapAfterM]
@@ -198,9 +191,10 @@ public theorem IterM.step_flatMap {α : Type w} {β : Type w} {α₂ : Type w}
     | .done h => return .deflate (.done (.outerDone_flatMap h))) := by
   simp [flatMap, step_flatMapAfter]
 
-theorem IterM.toList_flattenAfter {α α₂ β : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
+theorem IterM.toList_flattenAfter {α α₂ β : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m]
     [Iterator α m (IterM (α := α₂) m β)] [Iterator α₂ m β] [Finite α m] [Finite α₂ m]
+    [IteratorCollect α m m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α m m] [LawfulIteratorCollect α₂ m m]
     {it₁ : IterM (α := α) m (IterM (α := α₂) m β)} {it₂ : Option (IterM (α := α₂) m β)} :
     (it₁.flattenAfter it₂).toList = do
       match it₂ with
@@ -213,10 +207,7 @@ theorem IterM.toList_flattenAfter {α α₂ β : Type w} {m : Type w → Type w'
     simp only [bind_assoc, map_eq_pure_bind]
     apply bind_congr; intro step
     cases step.inflate using PlausibleIterStep.casesOn
-    · simp only [bind_pure_comp, pure_bind, Shrink.inflate_deflate,
-        bind_map_left, Functor.map_map, List.flatten_cons, ihy₁ ‹_›]
-      conv => lhs; rw [← WeaklyLawfulMonadAttach.map_attach (x := IterM.toList _)]
-      simp
+    · simp [ihy₁ ‹_›]
     · simp [ihs₁ ‹_›]
     · simp
   cases it₂
@@ -232,31 +223,42 @@ theorem IterM.toList_flattenAfter {α α₂ β : Type w} {m : Type w → Type w'
     · simp [ihs₂ ‹_›]
     · simp [hn]
 
-theorem IterM.toArray_flattenAfter {α α₂ β : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
+theorem IterM.toArray_flattenAfter {α α₂ β : Type w} {m : Type w → Type w'} [Monad m] [LawfulMonad m]
     [Iterator α m (IterM (α := α₂) m β)] [Iterator α₂ m β] [Finite α m] [Finite α₂ m]
+    [IteratorCollect α m m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α m m] [LawfulIteratorCollect α₂ m m]
     {it₁ : IterM (α := α) m (IterM (α := α₂) m β)} {it₂ : Option (IterM (α := α₂) m β)} :
     (it₁.flattenAfter it₂).toArray = do
       match it₂ with
       | none => Array.flatten <$> (it₁.mapM fun it₂ => it₂.toArray).toArray
       | some it₂ => return (← it₂.toArray) ++ (← Array.flatten <$> (it₁.mapM fun it₂ => it₂.toArray).toArray) := by
-  simp only [← IterM.toArray_toList, toList_flattenAfter]
-  split
-  · simp only [Functor.map_map]
-    simp only [← Array.flatten_map_toArray_toArray, ← Functor.map_map]
-    rw [IterM.toArray_toList, IterM.toArray_toList, ← IterM.toArray_map, IterM.toArray_map_mapM]
-    apply congrArg (it₁.mapM · |>.toArray |> Functor.map Array.flatten); ext it₂
-    simp
-  · simp only [bind_pure_comp, Functor.map_map, map_bind, Array.flatten_toArray, bind_map_left,
-      List.append_toArray]
-    apply bind_congr; intro bs
-    simp only [← Functor.map_map, ← IterM.toList_map, IterM.toList_map_mapM]
-    apply congrArg (fun f => List.toArray <$> HAppend.hAppend bs <$> List.flatten <$> (mapM f it₁).toList)
-    simp
+  induction it₁ using IterM.inductSteps generalizing it₂ with | step it₁ ihy₁ ihs₁ =>
+  have hn : (it₁.flattenAfter none).toArray =
+      Array.flatten <$> (it₁.mapM fun it₂ => it₂.toArray).toArray := by
+    rw [toArray_eq_match_step, toArray_eq_match_step, step_flattenAfter, step_mapM]
+    simp only [bind_assoc, map_eq_pure_bind]
+    apply bind_congr; intro step
+    cases step.inflate using PlausibleIterStep.casesOn
+    · simp [ihy₁ ‹_›]
+    · simp [ihs₁ ‹_›]
+    · simp
+  cases it₂
+  · exact hn
+  · rename_i ih₂
+    induction ih₂ using IterM.inductSteps with | step it₂ ihy₂ ihs₂ =>
+    rw [toArray_eq_match_step, step_flattenAfter, bind_assoc]
+    simp only
+    rw [toArray_eq_match_step, bind_assoc]
+    apply bind_congr; intro step
+    cases step.inflate using PlausibleIterStep.casesOn
+    · simp [ihy₂ ‹_›]
+    · simp [ihs₂ ‹_›]
+    · simp [hn]
 
-public theorem IterM.toList_flatMapAfterM {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+public theorem IterM.toList_flatMapAfterM {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+    [IteratorCollect α m m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α m m] [LawfulIteratorCollect α₂ m m]
     {f : β → m (IterM (α := α₂) m γ)}
     {it₁ : IterM (α := α) m β} {it₂ : Option (IterM (α := α₂) m γ)} :
     (it₁.flatMapAfterM f it₂).toList = do
@@ -266,9 +268,10 @@ public theorem IterM.toList_flatMapAfterM {α α₂ β γ : Type w} {m : Type w
           (← List.flatten <$> (it₁.mapM fun b => do (← f b).toList).toList) := by
   simp [flatMapAfterM, toList_flattenAfter]; rfl
 
-public theorem IterM.toArray_flatMapAfterM {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+public theorem IterM.toArray_flatMapAfterM {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+    [IteratorCollect α m m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α m m] [LawfulIteratorCollect α₂ m m]
     {f : β → m (IterM (α := α₂) m γ)}
     {it₁ : IterM (α := α) m β} {it₂ : Option (IterM (α := α₂) m γ)} :
     (it₁.flatMapAfterM f it₂).toArray = do
@@ -278,25 +281,28 @@ public theorem IterM.toArray_flatMapAfterM {α α₂ β γ : Type w} {m : Type w
           (← Array.flatten <$> (it₁.mapM fun b => do (← f b).toArray).toArray) := by
   simp [flatMapAfterM, toArray_flattenAfter]; rfl
 
-public theorem IterM.toList_flatMapM {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+public theorem IterM.toList_flatMapM {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+    [IteratorCollect α m m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α m m] [LawfulIteratorCollect α₂ m m]
     {f : β → m (IterM (α := α₂) m γ)}
     {it₁ : IterM (α := α) m β} :
     (it₁.flatMapM f).toList = List.flatten <$> (it₁.mapM fun b => do (← f b).toList).toList := by
   simp [flatMapM, toList_flatMapAfterM]
 
-public theorem IterM.toArray_flatMapM {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+public theorem IterM.toArray_flatMapM {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+    [IteratorCollect α m m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α m m] [LawfulIteratorCollect α₂ m m]
     {f : β → m (IterM (α := α₂) m γ)}
     {it₁ : IterM (α := α) m β} :
     (it₁.flatMapM f).toArray = Array.flatten <$> (it₁.mapM fun b => do (← f b).toArray).toArray := by
   simp [flatMapM, toArray_flatMapAfterM]
 
-public theorem IterM.toList_flatMapAfter {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+public theorem IterM.toList_flatMapAfter {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+    [IteratorCollect α m m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α m m] [LawfulIteratorCollect α₂ m m]
     {f : β → IterM (α := α₂) m γ}
     {it₁ : IterM (α := α) m β} {it₂ : Option (IterM (α := α₂) m γ)} :
     (it₁.flatMapAfter f it₂).toList = do
@@ -306,9 +312,10 @@ public theorem IterM.toList_flatMapAfter {α α₂ β γ : Type w} {m : Type w
           (← List.flatten <$> (it₁.mapM fun b => (f b).toList).toList) := by
   simp [flatMapAfter, toList_flattenAfter]; rfl
 
-public theorem IterM.toArray_flatMapAfter {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+public theorem IterM.toArray_flatMapAfter {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+    [IteratorCollect α m m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α m m] [LawfulIteratorCollect α₂ m m]
     {f : β → IterM (α := α₂) m γ}
     {it₁ : IterM (α := α) m β} {it₂ : Option (IterM (α := α₂) m γ)} :
     (it₁.flatMapAfter f it₂).toArray = do
@@ -318,19 +325,21 @@ public theorem IterM.toArray_flatMapAfter {α α₂ β γ : Type w} {m : Type w
           (← Array.flatten <$> (it₁.mapM fun b => (f b).toArray).toArray) := by
   simp [flatMapAfter, toArray_flattenAfter]; rfl
 
-public theorem IterM.toList_flatMap {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+public theorem IterM.toList_flatMap {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
     [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+    [IteratorCollect α m m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α m m] [LawfulIteratorCollect α₂ m m]
     {f : β → IterM (α := α₂) m γ}
     {it₁ : IterM (α := α) m β} :
     (it₁.flatMap f).toList = List.flatten <$> (it₁.mapM fun b => (f b).toList).toList := by
   simp [flatMap, toList_flatMapAfter]
 
-public theorem IterM.toArray_flatMap {α α₂ β γ : Type w} {m : Type w → Type w'}
-    [Monad m] [MonadAttach m] [LawfulMonad m] [WeaklyLawfulMonadAttach m]
-    [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+public theorem IterM.toArray_flatMap {α α₂ β γ : Type w} {m : Type w → Type w'} [Monad m]
+    [LawfulMonad m] [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
     [Iterator α m β] [Iterator α₂ m γ] [Finite α m] [Finite α₂ m]
+    [IteratorCollect α m m] [IteratorCollect α₂ m m]
+    [LawfulIteratorCollect α m m] [LawfulIteratorCollect α₂ m m]
     {f : β → IterM (α := α₂) m γ}
     {it₁ : IterM (α := α) m β} :
     (it₁.flatMap f).toArray = Array.flatten <$> (it₁.mapM fun b => (f b).toArray).toArray := by

src/Init/Data/Iterators/Lemmas/Combinators/Monadic/Take.lean

@@ -47,6 +47,7 @@ theorem IterM.step_take {α m β} [Monad m] [Iterator α m β] {n : Nat}
 
 theorem IterM.toList_take_zero {α m β} [Monad m] [LawfulMonad m] [Iterator α m β]
     [Finite (Take α m) m]
+    [IteratorCollect (Take α m) m m] [LawfulIteratorCollect (Take α m) m m]
     {it : IterM (α := α) m β} :
     (it.take 0).toList = pure [] := by
   rw [toList_eq_match_step]
@@ -66,6 +67,7 @@ theorem IterM.step_toTake {α m β} [Monad m] [Iterator α m β] [Finite α m]
 
 @[simp]
 theorem IterM.toList_toTake {α m β} [Monad m] [LawfulMonad m] [Iterator α m β] [Finite α m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     it.toTake.toList = it.toList := by
   induction it using IterM.inductSteps with | step it ihy ihs

src/Init/Data/Iterators/Lemmas/Combinators/Monadic/ULift.lean

@@ -31,8 +31,8 @@ theorem IterM.step_uLift [Iterator α m β] [Monad n] {it : IterM (α := α) m
 
 @[simp]
 theorem IterM.toList_uLift [Iterator α m β] [Monad m] [Monad n] {it : IterM (α := α) m β}
-    [MonadLiftT m (ULiftT n)] [Finite α m]
-    [LawfulMonad m] [LawfulMonad n]
+    [MonadLiftT m (ULiftT n)] [Finite α m] [IteratorCollect α m m]
+    [LawfulMonad m] [LawfulMonad n] [LawfulIteratorCollect α m m]
     [LawfulMonadLiftT m (ULiftT n)] :
     (it.uLift n).toList =
       (fun l => l.down.map ULift.up) <$> (monadLift it.toList : ULiftT n _).run := by
@@ -47,8 +47,8 @@ theorem IterM.toList_uLift [Iterator α m β] [Monad m] [Monad n] {it : IterM (
 
 @[simp]
 theorem IterM.toListRev_uLift [Iterator α m β] [Monad m] [Monad n] {it : IterM (α := α) m β}
-    [MonadLiftT m (ULiftT n)] [Finite α m]
-    [LawfulMonad m] [LawfulMonad n]
+    [MonadLiftT m (ULiftT n)] [Finite α m] [IteratorCollect α m m]
+    [LawfulMonad m] [LawfulMonad n] [LawfulIteratorCollect α m m]
     [LawfulMonadLiftT m (ULiftT n)] :
     (it.uLift n).toListRev =
       (fun l => l.down.map ULift.up) <$> (monadLift it.toListRev : ULiftT n _).run := by
@@ -57,8 +57,8 @@ theorem IterM.toListRev_uLift [Iterator α m β] [Monad m] [Monad n] {it : IterM
 
 @[simp]
 theorem IterM.toArray_uLift [Iterator α m β] [Monad m] [Monad n] {it : IterM (α := α) m β}
-    [MonadLiftT m (ULiftT n)] [Finite α m]
-    [LawfulMonad m] [LawfulMonad n]
+    [MonadLiftT m (ULiftT n)] [Finite α m] [IteratorCollect α m m]
+    [LawfulMonad m] [LawfulMonad n] [LawfulIteratorCollect α m m]
     [LawfulMonadLiftT m (ULiftT n)] :
     (it.uLift n).toArray =
       (fun l => l.down.map ULift.up) <$> (monadLift it.toArray : ULiftT n _).run := by

src/Init/Data/Iterators/Lemmas/Combinators/Take.lean

@@ -63,7 +63,8 @@ theorem Iter.atIdxSlow?_take {α β}
 
 @[simp]
 theorem Iter.toList_take_of_finite {α β} [Iterator α Id β] {n : Nat}
-    [Finite α Id] {it : Iter (α := α) β} :
+    [Finite α Id] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
+    {it : Iter (α := α) β} :
     (it.take n).toList = it.toList.take n := by
   induction it using Iter.inductSteps generalizing n with | step it ihy ihs
   rw [Iter.toList_eq_match_step, Iter.toList_eq_match_step, Iter.step_take]
@@ -79,19 +80,23 @@ theorem Iter.toList_take_of_finite {α β} [Iterator α Id β] {n : Nat}
 
 @[simp]
 theorem Iter.toListRev_take_of_finite {α β} [Iterator α Id β] {n : Nat}
-    [Finite α Id] {it : Iter (α := α) β} :
+    [Finite α Id] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
+    {it : Iter (α := α) β} :
     (it.take n).toListRev = it.toListRev.drop (it.toList.length - n) := by
   rw [toListRev_eq, toList_take_of_finite, List.reverse_take, toListRev_eq]
 
 @[simp]
 theorem Iter.toArray_take_of_finite {α β} [Iterator α Id β] {n : Nat}
-    [Finite α Id] {it : Iter (α := α) β} :
+    [Finite α Id] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
+    {it : Iter (α := α) β} :
     (it.take n).toArray = it.toArray.take n := by
   rw [← toArray_toList, ← toArray_toList, List.take_toArray, toList_take_of_finite]
 
 @[simp]
 theorem Iter.toList_take_zero {α β} [Iterator α Id β]
-    [Finite (Take α Id) Id] {it : Iter (α := α) β} :
+    [Finite (Take α Id) Id]
+    [IteratorCollect (Take α Id) Id Id] [LawfulIteratorCollect (Take α Id) Id Id]
+    {it : Iter (α := α) β} :
     (it.take 0).toList = [] := by
   rw [toList_eq_match_step]
   simp [step_take]
@@ -108,7 +113,9 @@ theorem Iter.step_toTake {α β} [Iterator α Id β] [Finite α Id]
   cases it.toIterM.step.run.inflate using PlausibleIterStep.casesOn <;> simp
 
 @[simp]
-theorem Iter.toList_toTake {α β} [Iterator α Id β] [Finite α Id] {it : Iter (α := α) β} :
+theorem Iter.toList_toTake {α β} [Iterator α Id β] [Finite α Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
+    {it : Iter (α := α) β} :
     it.toTake.toList = it.toList := by
   simp [toTake_eq_toIter_toTake_toIterM, toList_eq_toList_toIterM]
 

src/Init/Data/Iterators/Lemmas/Combinators/ULift.lean

@@ -37,7 +37,8 @@ theorem Iter.step_uLift [Iterator α Id β] {it : Iter (α := α) β} :
 
 @[simp]
 theorem Iter.toList_uLift [Iterator α Id β] {it : Iter (α := α) β}
-    [Finite α Id] :
+    [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] :
     it.uLift.toList = it.toList.map ULift.up := by
   simp only [monadLift, uLift_eq_toIter_uLift_toIterM, IterM.toList_toIter]
   rw [IterM.toList_uLift]
@@ -45,13 +46,15 @@ theorem Iter.toList_uLift [Iterator α Id β] {it : Iter (α := α) β}
 
 @[simp]
 theorem Iter.toListRev_uLift [Iterator α Id β] {it : Iter (α := α) β}
-    [Finite α Id] :
+    [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] :
     it.uLift.toListRev = it.toListRev.map ULift.up := by
   rw [toListRev_eq, toListRev_eq, toList_uLift, List.map_reverse]
 
 @[simp]
 theorem Iter.toArray_uLift [Iterator α Id β] {it : Iter (α := α) β}
-    [Finite α Id] :
+    [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] :
     it.uLift.toArray = it.toArray.map ULift.up := by
   rw [← toArray_toList, ← toArray_toList, toList_uLift]
   simp [-toArray_toList]

src/Init/Data/Iterators/Lemmas/Consumers.lean

@@ -9,4 +9,3 @@ prelude
 public import Init.Data.Iterators.Lemmas.Consumers.Monadic
 public import Init.Data.Iterators.Lemmas.Consumers.Collect
 public import Init.Data.Iterators.Lemmas.Consumers.Loop
-public import Init.Data.Iterators.Lemmas.Consumers.Access

src/Init/Data/Iterators/Lemmas/Consumers/Access.lean

@@ -1,26 +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
-public import Init.Data.Iterators.Consumers.Access
-
-namespace Std.Iter
-open Std.Iterators
-
-public theorem atIdxSlow?_eq_match [Iterator α Id β] [Productive α Id]
-    {n : Nat} {it : Iter (α := α) β} :
-    it.atIdxSlow? n =
-      (match it.step.val with
-      | .yield it' out =>
-        match n with
-        | 0 => some out
-        | n + 1 => it'.atIdxSlow? n
-      | .skip it' => it'.atIdxSlow? n
-      | .done => none) := by
-  fun_induction it.atIdxSlow? n <;> simp_all
-
-end Std.Iter

src/Init/Data/Iterators/Lemmas/Consumers/Collect.lean

@@ -19,13 +19,13 @@ public section
 namespace Std
 open Std.Iterators
 
-theorem Iter.toArray_eq_toArray_toIterM {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toArray_eq_toArray_toIterM {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.toArray = it.toIterM.toArray.run :=
   (rfl)
 
-theorem Iter.toList_eq_toList_toIterM {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toList_eq_toList_toIterM {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.toList = it.toIterM.toList.run :=
   (rfl)
 
@@ -35,14 +35,14 @@ theorem Iter.toListRev_eq_toListRev_toIterM {α β} [Iterator α Id β] [Finite
   (rfl)
 
 @[simp]
-theorem Iter.toArray_ensureTermination {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toArray_ensureTermination {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.ensureTermination.toArray = it.toArray :=
   (rfl)
 
 @[simp]
-theorem Iter.toList_ensureTermination {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toList_ensureTermination {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.ensureTermination.toList = it.toList :=
   (rfl)
 
@@ -52,7 +52,7 @@ theorem Iter.toListRev_ensureTermination_eq_toListRev {α β} [Iterator α Id β
   (rfl)
 
 @[simp]
-theorem IterM.toList_toIter {α β} [Iterator α Id β] [Finite α Id]
+theorem IterM.toList_toIter {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
     {it : IterM (α := α) Id β} :
     it.toIter.toList = it.toList.run :=
   (rfl)
@@ -64,50 +64,51 @@ theorem IterM.toListRev_toIter {α β} [Iterator α Id β] [Finite α Id]
   (rfl)
 
 @[simp]
-theorem Iter.toList_toArray {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toList_toArray {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.toArray.toList = it.toList := by
   simp [toArray_eq_toArray_toIterM, toList_eq_toList_toIterM, ← IterM.toList_toArray]
 
 theorem Iter.toList_toArray_ensureTermination {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.ensureTermination.toArray.toList = it.toList := by
   simp
 
 @[simp]
-theorem Iter.toArray_toList {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toArray_toList {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.toList.toArray = it.toArray := by
   simp [toArray_eq_toArray_toIterM, toList_eq_toList_toIterM, ← IterM.toArray_toList]
 
 theorem Iter.toArray_toList_ensureTermination {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.ensureTermination.toList.toArray = it.toArray := by
   simp
 
 @[simp]
 theorem Iter.reverse_toListRev [Iterator α Id β] [Finite α Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} :
     it.toListRev.reverse = it.toList := by
   simp [toListRev_eq_toListRev_toIterM, toList_eq_toList_toIterM, ← IterM.reverse_toListRev]
 
 theorem Iter.reverse_toListRev_ensureTermination [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.ensureTermination.toListRev.reverse = it.toList := by
   simp
 
-theorem Iter.toListRev_eq {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toListRev_eq {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.toListRev = it.toList.reverse := by
   simp [Iter.toListRev_eq_toListRev_toIterM, Iter.toList_eq_toList_toIterM, IterM.toListRev_eq]
 
 theorem Iter.toListRev_ensureTermination {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.ensureTermination.toListRev = it.toList.reverse := by
   simp [toListRev_eq]
 
-theorem Iter.toArray_eq_match_step {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toArray_eq_match_step {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.toArray = match it.step.val with
       | .yield it' out => #[out] ++ it'.toArray
       | .skip it' => it'.toArray
@@ -117,16 +118,16 @@ theorem Iter.toArray_eq_match_step {α β} [Iterator α Id β] [Finite α Id]
   generalize it.toIterM.step.run = step
   cases step.inflate using PlausibleIterStep.casesOn <;> simp
 
-theorem Iter.toArray_ensureTermination_eq_match_step {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toArray_ensureTermination_eq_match_step {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.ensureTermination.toArray = match it.step.val with
       | .yield it' out => #[out] ++ it'.toArray
       | .skip it' => it'.toArray
       | .done => #[] := by
   rw [toArray_ensureTermination, toArray_eq_match_step]
 
-theorem Iter.toList_eq_match_step {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toList_eq_match_step {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.toList = match it.step.val with
       | .yield it' out => out :: it'.toList
       | .skip it' => it'.toList
@@ -134,8 +135,8 @@ theorem Iter.toList_eq_match_step {α β} [Iterator α Id β] [Finite α Id]
   rw [← Iter.toList_toArray, Iter.toArray_eq_match_step]
   split <;> simp [Iter.toList_toArray]
 
-theorem Iter.toList_ensureTermination_eq_match_step {α β} [Iterator α Id β] [Finite α Id]
-    {it : Iter (α := α) β} :
+theorem Iter.toList_ensureTermination_eq_match_step {α β} [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id]
+    [LawfulIteratorCollect α Id Id] {it : Iter (α := α) β} :
     it.ensureTermination.toList = match it.step.val with
       | .yield it' out => out :: it'.toList
       | .skip it' => it'.toList
@@ -159,7 +160,7 @@ theorem Iter.toListRev_ensureTermination_eq_match_step {α β} [Iterator α Id
   rw [toListRev_ensureTermination_eq_toListRev, toListRev_eq_match_step]
 
 theorem Iter.getElem?_toList_eq_atIdxSlow? {α β}
-    [Iterator α Id β] [Finite α Id]
+    [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {k : Nat} :
     it.toList[k]? = it.atIdxSlow? k := by
   induction it using Iter.inductSteps generalizing k with | step it ihy ihs
@@ -171,15 +172,15 @@ theorem Iter.getElem?_toList_eq_atIdxSlow? {α β}
   · simp
 
 theorem Iter.toList_eq_of_atIdxSlow?_eq {α₁ α₂ β}
-    [Iterator α₁ Id β] [Finite α₁ Id]
-    [Iterator α₂ Id β] [Finite α₂ Id]
+    [Iterator α₁ Id β] [Finite α₁ Id] [IteratorCollect α₁ Id Id] [LawfulIteratorCollect α₁ Id Id]
+    [Iterator α₂ Id β] [Finite α₂ Id] [IteratorCollect α₂ Id Id] [LawfulIteratorCollect α₂ Id Id]
     {it₁ : Iter (α := α₁) β} {it₂ : Iter (α := α₂) β}
     (h : ∀ k, it₁.atIdxSlow? k = it₂.atIdxSlow? k) :
     it₁.toList = it₂.toList := by
   ext; simp [getElem?_toList_eq_atIdxSlow?, h]
 
 theorem Iter.isPlausibleIndirectOutput_of_mem_toList
-    [Iterator α Id β] [Finite α Id]
+    [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {b : β} :
     b ∈ it.toList → it.IsPlausibleIndirectOutput b := by
   induction it using Iter.inductSteps with | step it ihy ihs
@@ -202,7 +203,7 @@ theorem Iter.isPlausibleIndirectOutput_of_mem_toList
     simp
 
 theorem Iter.isPlausibleIndirectOutput_of_mem_toListRev
-    [Iterator α Id β] [Finite α Id]
+    [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {b : β} :
     b ∈ it.toListRev → it.IsPlausibleIndirectOutput b := by
   intro h
@@ -210,7 +211,7 @@ theorem Iter.isPlausibleIndirectOutput_of_mem_toListRev
   simpa [toListRev_eq] using h
 
 theorem Iter.isPlausibleIndirectOutput_of_mem_toArray
-    [Iterator α Id β] [Finite α Id]
+    [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {b : β} :
     b ∈ it.toArray → it.IsPlausibleIndirectOutput b := by
   intro h

src/Init/Data/Iterators/Lemmas/Consumers/Loop.lean

@@ -150,7 +150,8 @@ private theorem Iter.forIn'_toList.aux {ρ : Type u} {α : Type v} {γ : Type x}
   cases h; rfl
 
 theorem Iter.isPlausibleStep_iff_step_eq {α β} [Iterator α Id β]
-    [Finite α Id] [LawfulDeterministicIterator α Id]
+    [IteratorCollect α Id Id] [Finite α Id]
+    [LawfulIteratorCollect α Id Id] [LawfulDeterministicIterator α Id]
     {it : Iter (α := α) β} {step} :
     it.IsPlausibleStep step ↔ it.step.val = step := by
   obtain ⟨step', hs'⟩ := LawfulDeterministicIterator.isPlausibleStep_eq_eq (it := it.toIterM)
@@ -169,7 +170,8 @@ theorem Iter.isPlausibleStep_iff_step_eq {α β} [Iterator α Id β]
     simpa using h
 
 theorem Iter.mem_toList_iff_isPlausibleIndirectOutput {α β} [Iterator α Id β]
-    [Finite α Id] [LawfulDeterministicIterator α Id]
+    [IteratorCollect α Id Id] [Finite α Id]
+    [LawfulIteratorCollect α Id Id] [LawfulDeterministicIterator α Id]
     {it : Iter (α := α) β} {out : β} :
     out ∈ it.toList ↔ it.IsPlausibleIndirectOutput out := by
   induction it using Iter.inductSteps with | step it ihy ihs
@@ -215,7 +217,8 @@ theorem Iter.mem_toList_iff_isPlausibleIndirectOutput {α β} [Iterator α Id β
         simp [heq, IterStep.successor] at h₁
 
 theorem Iter.mem_toArray_iff_isPlausibleIndirectOutput {α β} [Iterator α Id β]
-    [Finite α Id] [LawfulDeterministicIterator α Id]
+    [IteratorCollect α Id Id] [Finite α Id]
+    [LawfulIteratorCollect α Id Id] [LawfulDeterministicIterator α Id]
     {it : Iter (α := α) β} {out : β} :
     out ∈ it.toArray ↔ it.IsPlausibleIndirectOutput out := by
   rw [← Iter.toArray_toList, List.mem_toArray, mem_toList_iff_isPlausibleIndirectOutput]
@@ -223,6 +226,7 @@ theorem Iter.mem_toArray_iff_isPlausibleIndirectOutput {α β} [Iterator α Id
 theorem Iter.forIn'_toList {α β : Type w} [Iterator α Id β]
     [Finite α Id] {m : Type x → Type x'} [Monad m] [LawfulMonad m]
     [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     [LawfulDeterministicIterator α Id]
     {γ : Type x} {it : Iter (α := α) β} {init : γ}
     {f : (out : β) → _ → γ → m (ForInStep γ)} :
@@ -256,6 +260,7 @@ theorem Iter.forIn'_toList {α β : Type w} [Iterator α Id β]
 theorem Iter.forIn'_toArray {α β : Type w} [Iterator α Id β]
     [Finite α Id] {m : Type x → Type x'} [Monad m] [LawfulMonad m]
     [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     [LawfulDeterministicIterator α Id]
     {γ : Type x} {it : Iter (α := α) β} {init : γ}
     {f : (out : β) → _ → γ → m (ForInStep γ)} :
@@ -266,6 +271,7 @@ theorem Iter.forIn'_toArray {α β : Type w} [Iterator α Id β]
 theorem Iter.forIn'_eq_forIn'_toList {α β : Type w} [Iterator α Id β]
     [Finite α Id] {m : Type x → Type x'} [Monad m] [LawfulMonad m]
     [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     [LawfulDeterministicIterator α Id]
     {γ : Type x} {it : Iter (α := α) β} {init : γ}
     {f : (out : β) → _ → γ → m (ForInStep γ)} :
@@ -277,6 +283,7 @@ theorem Iter.forIn'_eq_forIn'_toList {α β : Type w} [Iterator α Id β]
 theorem Iter.forIn'_eq_forIn'_toArray {α β : Type w} [Iterator α Id β]
     [Finite α Id] {m : Type x → Type x'} [Monad m] [LawfulMonad m]
     [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     [LawfulDeterministicIterator α Id]
     {γ : Type x} {it : Iter (α := α) β} {init : γ}
     {f : (out : β) → _ → γ → m (ForInStep γ)} :
@@ -288,6 +295,7 @@ theorem Iter.forIn'_eq_forIn'_toArray {α β : Type w} [Iterator α Id β]
 theorem Iter.forIn_toList {α β : Type w} [Iterator α Id β]
     [Finite α Id] {m : Type x → Type x'} [Monad m] [LawfulMonad m]
     [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {γ : Type x} {it : Iter (α := α) β} {init : γ}
     {f : β → γ → m (ForInStep γ)} :
     ForIn.forIn it.toList init f = ForIn.forIn it init f := by
@@ -313,6 +321,7 @@ theorem Iter.forIn_toList {α β : Type w} [Iterator α Id β]
 theorem Iter.forIn_toArray {α β : Type w} [Iterator α Id β]
     [Finite α Id] {m : Type x → Type x'} [Monad m] [LawfulMonad m]
     [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {γ : Type x} {it : Iter (α := α) β} {init : γ}
     {f : β → γ → m (ForInStep γ)} :
     ForIn.forIn it.toArray init f = ForIn.forIn it init f := by
@@ -353,15 +362,15 @@ theorem Iter.foldM_eq_match_step {α β : Type w} {γ : Type x} [Iterator α Id
 
 theorem Iter.foldlM_toList {α β : Type w} {γ : Type x} [Iterator α Id β] [Finite α Id]
     {m : Type x → Type x'} [Monad m] [LawfulMonad m] [IteratorLoop α Id m]
-    [LawfulIteratorLoop α Id m]
+    [LawfulIteratorLoop α Id m] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {f : γ → β → m γ} {init : γ} {it : Iter (α := α) β} :
-    it.toList.foldlM (init := init) f = it.foldM (init := init) f:= by
-  rw [foldM_eq_forIn, ← Iter.forIn_toList]
-  simp
+    it.toList.foldlM (init := init) f = it.foldM (init := init) f := by
+  rw [Iter.foldM_eq_forIn, ← Iter.forIn_toList]
+  simp only [List.forIn_yield_eq_foldlM, id_map']
 
 theorem Iter.foldlM_toArray {α β : Type w} {γ : Type x} [Iterator α Id β] [Finite α Id]
     {m : Type x → Type x'} [Monad m] [LawfulMonad m] [IteratorLoop α Id m]
-    [LawfulIteratorLoop α Id m]
+    [LawfulIteratorLoop α Id m] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {f : γ → β → m γ} {init : γ} {it : Iter (α := α) β} :
     it.toArray.foldlM (init := init) f = it.foldM (init := init) f := by
   rw [Iter.foldM_eq_forIn, ← Iter.forIn_toArray]
@@ -370,6 +379,7 @@ theorem Iter.foldlM_toArray {α β : Type w} {γ : Type x} [Iterator α Id β] [
 theorem IterM.forIn_eq_foldM {α β : Type w} [Iterator α Id β]
     [Finite α Id] {m : Type x → Type x'} [Monad m] [LawfulMonad m]
     [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {γ : Type x} {it : Iter (α := α) β} {init : γ}
     {f : β → γ → m (ForInStep γ)} :
     forIn it init f = ForInStep.value <$>
@@ -434,12 +444,14 @@ theorem Iter.fold_hom {γ₁ : Type x₁} {γ₂ : Type x₂} [Iterator α Id β
 
 theorem Iter.toList_eq_fold {α β : Type w} [Iterator α Id β]
     [Finite α Id] [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} :
     it.toList = it.fold (init := []) (fun l out => l ++ [out]) := by
   rw [Iter.toList_eq_toList_toIterM, IterM.toList_eq_fold, Iter.fold_eq_fold_toIterM]
 
 theorem Iter.toArray_eq_fold {α β : Type w} [Iterator α Id β]
     [Finite α Id] [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} :
     it.toArray = it.fold (init := #[]) (fun xs out => xs.push out) := by
   simp only [← toArray_toList, toList_eq_fold]
@@ -449,6 +461,7 @@ theorem Iter.toArray_eq_fold {α β : Type w} [Iterator α Id β]
 @[simp]
 theorem Iter.foldl_toList {α β : Type w} {γ : Type x} [Iterator α Id β] [Finite α Id]
     [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {f : γ → β → γ} {init : γ} {it : Iter (α := α) β} :
     it.toList.foldl (init := init) f = it.fold (init := init) f := by
   rw [fold_eq_foldM, List.foldl_eq_foldlM, ← Iter.foldlM_toList]
@@ -456,6 +469,7 @@ theorem Iter.foldl_toList {α β : Type w} {γ : Type x} [Iterator α Id β] [Fi
 @[simp]
 theorem Iter.foldl_toArray {α β : Type w} {γ : Type x} [Iterator α Id β] [Finite α Id]
     [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {f : γ → β → γ} {init : γ} {it : Iter (α := α) β} :
     it.toArray.foldl (init := init) f = it.fold (init := init) f := by
   rw [fold_eq_foldM, Array.foldl_eq_foldlM, ← Iter.foldlM_toArray]
@@ -495,6 +509,7 @@ theorem Iter.count_eq_match_step {α β : Type w} [Iterator α Id β]
 
 @[simp]
 theorem Iter.size_toArray_eq_count {α β : Type w} [Iterator α Id β] [Finite α Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
     {it : Iter (α := α) β} :
     it.toArray.size = it.count := by
@@ -506,6 +521,7 @@ def Iter.size_toArray_eq_size := @size_toArray_eq_count
 
 @[simp]
 theorem Iter.length_toList_eq_count {α β : Type w} [Iterator α Id β] [Finite α Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
     {it : Iter (α := α) β} :
     it.toList.length = it.count := by
@@ -516,6 +532,7 @@ def Iter.length_toList_eq_size := @length_toList_eq_count
 
 @[simp]
 theorem Iter.length_toListRev_eq_count {α β : Type w} [Iterator α Id β] [Finite α Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
     {it : Iter (α := α) β} :
     it.toListRev.length = it.count := by
@@ -558,6 +575,7 @@ theorem Iter.anyM_eq_match_step {α β : Type w} {m : Type → Type w'} [Iterato
 
 theorem Iter.anyM_toList {α β : Type w} {m : Type → Type w'} [Iterator α Id β]
     [Finite α Id] [Monad m] [LawfulMonad m] [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {p : β → m Bool} :
     it.toList.anyM p = it.anyM p := by
   induction it using Iter.inductSteps with | step it ihy ihs =>
@@ -569,6 +587,7 @@ theorem Iter.anyM_toList {α β : Type w} {m : Type → Type w'} [Iterator α Id
 
 theorem Iter.anyM_toArray {α β : Type w} {m : Type → Type w'} [Iterator α Id β]
     [Finite α Id] [Monad m] [LawfulMonad m] [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {p : β → m Bool} :
     it.toArray.anyM p = it.anyM p := by
   simp only [← Iter.toArray_toList, List.anyM_toArray, anyM_toList]
@@ -615,6 +634,7 @@ theorem Iter.any_eq_forIn {α β : Type w} [Iterator α Id β]
 
 theorem Iter.any_toList {α β : Type w} [Iterator α Id β]
     [Finite α Id] [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {p : β → Bool} :
     it.toList.any p = it.any p := by
   induction it using Iter.inductSteps with | step it ihy ihs =>
@@ -627,6 +647,7 @@ theorem Iter.any_toList {α β : Type w} [Iterator α Id β]
 
 theorem Iter.any_toArray {α β : Type w} [Iterator α Id β]
     [Finite α Id] [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {p : β → Bool} :
     it.toArray.any p = it.any p := by
   simp only [← Iter.toArray_toList, List.any_toArray, any_toList]
@@ -705,6 +726,7 @@ theorem Iter.all_eq_forIn {α β : Type w} [Iterator α Id β]
 
 theorem Iter.all_toList {α β : Type w} [Iterator α Id β]
     [Finite α Id] [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {p : β → Bool} :
     it.toList.all p = it.all p := by
   induction it using Iter.inductSteps with | step it ihy ihs =>
@@ -717,6 +739,7 @@ theorem Iter.all_toList {α β : Type w} [Iterator α Id β]
 
 theorem Iter.all_toArray {α β : Type w} [Iterator α Id β]
     [Finite α Id] [IteratorLoop α Id Id] [LawfulIteratorLoop α Id Id]
+    [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {p : β → Bool} :
     it.toArray.all p = it.all p := by
   simp only [← Iter.toArray_toList, List.all_toArray, all_toList]
@@ -770,8 +793,8 @@ theorem Iter.findSomeM?_eq_match_step {α β : Type w} {γ : Type x} {m : Type x
   · simp
 
 theorem Iter.findSomeM?_toList {α β : Type w} {γ : Type x} {m : Type x → Type w'} [Monad m]
-    [Iterator α Id β] [IteratorLoop α Id m]
-    [LawfulMonad m] [Finite α Id] [LawfulIteratorLoop α Id m]
+    [Iterator α Id β] [IteratorLoop α Id m] [IteratorCollect α Id Id]
+    [LawfulMonad m] [Finite α Id] [LawfulIteratorLoop α Id m] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {f : β → m (Option γ)} :
     it.toList.findSomeM? f = it.findSomeM? f := by
   induction it using Iter.inductSteps with | step it ihy ihs
@@ -813,8 +836,8 @@ theorem Iter.findSome?_eq_match_step {α β : Type w} {γ : Type x}
   · simp
 
 theorem Iter.findSome?_toList {α β : Type w} {γ : Type x}
-    [Iterator α Id β] [IteratorLoop α Id Id]
-    [Finite α Id] [LawfulIteratorLoop α Id Id]
+    [Iterator α Id β] [IteratorLoop α Id Id] [IteratorCollect α Id Id]
+    [Finite α Id] [LawfulIteratorLoop α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {f : β → Option γ} :
     it.toList.findSome? f = it.findSome? f := by
   simp [findSome?_eq_findSomeM?, List.findSome?_eq_findSomeM?, findSomeM?_toList]
@@ -824,6 +847,7 @@ theorem Iter.findSomeM?_pure {α β : Type w} {γ : Type x} {m : Type x → Type
     [LawfulMonad m] [Finite α Id] [LawfulIteratorLoop α Id m] [LawfulIteratorLoop α Id Id]
     {it : Iter (α := α) β} {f : β → Option γ} :
     it.findSomeM? (pure <| f ·) = pure (f := m) (it.findSome? f) := by
+  letI : IteratorCollect α Id Id := .defaultImplementation
   simp [← findSomeM?_toList, ← findSome?_toList, List.findSomeM?_pure]
 
 theorem Iter.findM?_eq_findSomeM? {α β : Type w} {m : Type w → Type w'} [Monad m]
@@ -850,15 +874,15 @@ theorem Iter.findM?_eq_match_step {α β : Type w} {m : Type w → Type w'} [Mon
   · simp
 
 theorem Iter.findM?_toList {α β : Type} {m : Type → Type w'} [Monad m]
-    [Iterator α Id β] [IteratorLoop α Id m]
-    [LawfulMonad m] [Finite α Id] [LawfulIteratorLoop α Id m]
+    [Iterator α Id β] [IteratorLoop α Id m] [IteratorCollect α Id Id]
+    [LawfulMonad m] [Finite α Id] [LawfulIteratorLoop α Id m] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {f : β → m Bool} :
     it.toList.findM? f = it.findM? (.up <$> f ·) := by
   simp [findM?_eq_findSomeM?, List.findM?_eq_findSomeM?, findSomeM?_toList]
 
 theorem Iter.findM?_eq_findM?_toList {α β : Type} {m : Type → Type w'} [Monad m]
-    [Iterator α Id β] [IteratorLoop α Id m]
-    [LawfulMonad m] [Finite α Id] [LawfulIteratorLoop α Id m]
+    [Iterator α Id β] [IteratorLoop α Id m] [IteratorCollect α Id Id]
+    [LawfulMonad m] [Finite α Id] [LawfulIteratorLoop α Id m] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {f : β → m (ULift Bool)} :
     it.findM? f = it.toList.findM? (ULift.down <$> f ·) := by
   simp [findM?_toList]
@@ -894,8 +918,8 @@ theorem Iter.find?_eq_match_step {α β : Type w}
   · simp
 
 theorem Iter.find?_toList {α β : Type w}
-    [Iterator α Id β] [IteratorLoop α Id Id]
-    [Finite α Id] [LawfulIteratorLoop α Id Id]
+    [Iterator α Id β] [IteratorLoop α Id Id] [IteratorCollect α Id Id]
+    [Finite α Id] [LawfulIteratorLoop α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {f : β → Bool} :
     it.toList.find? f = it.find? f := by
   simp [find?_eq_findSome?, List.find?_eq_findSome?_guard, findSome?_toList, Option.guard_def]

src/Init/Data/Iterators/Lemmas/Consumers/Monadic/Collect.lean

@@ -18,65 +18,84 @@ public section
 namespace Std
 open Std.Iterators Std.Internal
 
-variable {α β : Type w} {m : Type w → Type w'} {it : IterM (α := α) m β}
+variable {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''}
+  {lift : ⦃δ : Type w⦄ → m δ → n δ} {f : β → n γ} {it : IterM (α := α) m β}
 
-private theorem IterM.toArray.go_eq [Monad m]
-    [Iterator α m β] [LawfulMonad m] [Finite α m] {acc : Array β} :
-    go it acc (m := m) = (do
+private theorem IterM.DefaultConsumers.toArrayMapped.go_eq [Monad n]
+    [Iterator α m β] [LawfulMonad n] [Finite α m] {acc : Array γ} :
+    letI : MonadLift m n := ⟨lift (δ := _)⟩
+    go lift f it acc (m := m) = (do
       match (← it.step).inflate.val with
-      | .yield it' out => go it' (acc.push out)
-      | .skip it' => go it' acc
+      | .yield it' out => go lift f it' (acc.push (← f out))
+      | .skip it' => go lift f it' acc
       | .done => return acc) := by
-  rw [toArray.go, WellFounded.extrinsicFix₂_eq_apply]
+  letI : MonadLift m n := ⟨lift (δ := _)⟩
+  rw [toArrayMapped.go, WellFounded.extrinsicFix₂_eq_apply]
   · simp only
     apply bind_congr; intro step
-    cases step.inflate using PlausibleIterStep.casesOn <;> simp [go]
+    cases step.inflate using PlausibleIterStep.casesOn
+    · apply bind_congr; intro fx
+      simp [go]
+    · simp [go]
+    · simp
   · simp only [show (IterM.finitelyManySteps! = IterM.finitelyManySteps) by rfl]
     apply InvImage.wf
     exact WellFoundedRelation.wf
 
-private theorem IterM.toArray.go.aux₁ [Monad m] [LawfulMonad m]
-    [Iterator α m β] [Finite α m] {b : β} {bs : Array β} :
-    IterM.toArray.go it (#[b] ++ bs) (m := m) =
-      (#[b] ++ ·) <$> IterM.toArray.go it bs (m := m) := by
+private theorem IterM.DefaultConsumers.toArrayMapped.go.aux₁ [Monad n] [LawfulMonad n]
+    [Iterator α m β] [Finite α m] {b : γ} {bs : Array γ} :
+    IterM.DefaultConsumers.toArrayMapped.go lift f it (#[b] ++ bs) (m := m) =
+      (#[b] ++ ·) <$> IterM.DefaultConsumers.toArrayMapped.go lift f it bs (m := m) := by
   induction it using IterM.inductSteps generalizing bs with | step it ihy ihs
   rw [go_eq, map_eq_pure_bind, go_eq, bind_assoc]
   apply bind_congr; intro step
   cases step.inflate using PlausibleIterStep.casesOn <;> simp (discharger := assumption) [ihy, ihs]
 
-private theorem IterM.toArray.go.aux₂ [Monad m] [LawfulMonad m]
-    [Iterator α m β] [Finite α m] {acc : Array β} :
-    IterM.toArray.go it acc (m := m) =
-      (acc ++ ·) <$> it.toArray := by
+private theorem IterM.DefaultConsumers.toArrayMapped.go.aux₂ [Monad n] [LawfulMonad n]
+    [Iterator α m β] [Finite α m] {acc : Array γ} :
+    IterM.DefaultConsumers.toArrayMapped.go lift f it acc (m := m) =
+      (acc ++ ·) <$> IterM.DefaultConsumers.toArrayMapped lift f it (m := m) := by
   rw [← Array.toArray_toList (xs := acc)]
   generalize acc.toList = acc
   induction acc with
-  | nil => simp [toArray]
+  | nil => simp [toArrayMapped]
   | cons x xs ih =>
-    rw [List.toArray_cons, IterM.toArray.go.aux₁, ih]
+    rw [List.toArray_cons, IterM.DefaultConsumers.toArrayMapped.go.aux₁, ih]
     simp only [Functor.map_map, Array.append_assoc]
 
-theorem IterM.toArray_eq_match_step [Monad m] [LawfulMonad m]
+theorem IterM.DefaultConsumers.toArrayMapped_eq_match_step [Monad n] [LawfulMonad n]
     [Iterator α m β] [Finite α m] :
-    IterM.toArray it (m := m) = (do
+    IterM.DefaultConsumers.toArrayMapped lift f it (m := m) = letI : MonadLift m n := ⟨lift (δ := _)⟩; (do
+      match (← it.step).inflate.val with
+      | .yield it' out =>
+        return #[← f out] ++ (← IterM.DefaultConsumers.toArrayMapped lift f it' (m := m))
+      | .skip it' => IterM.DefaultConsumers.toArrayMapped lift f it' (m := m)
+      | .done => return #[]) := by
+  rw [IterM.DefaultConsumers.toArrayMapped, IterM.DefaultConsumers.toArrayMapped.go_eq]
+  apply bind_congr
+  intro step
+  cases step.inflate using PlausibleIterStep.casesOn <;>
+    simp [IterM.DefaultConsumers.toArrayMapped.go.aux₂]
+
+@[simp]
+theorem IterM.toArray_ensureTermination [Monad m] [Iterator α m β] [Finite α m]
+    [IteratorCollect α m m] {it : IterM (α := α) m β} :
+    it.ensureTermination.toArray = it.toArray :=
+  (rfl)
+
+theorem IterM.toArray_eq_match_step [Monad m] [LawfulMonad m] [Iterator α m β] [Finite α m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m] :
+    it.toArray = (do
       match (← it.step).inflate.val with
       | .yield it' out => return #[out] ++ (← it'.toArray)
       | .skip it' => it'.toArray
       | .done => return #[]) := by
-  rw [IterM.toArray, IterM.toArray.go_eq]
-  apply bind_congr
-  intro step
-  cases step.inflate using PlausibleIterStep.casesOn <;>
-    simp [IterM.toArray.go.aux₂]
-
-@[simp]
-theorem IterM.toArray_ensureTermination [Monad m] [Iterator α m β] [Finite α m]
-    {it : IterM (α := α) m β} :
-    it.ensureTermination.toArray = it.toArray :=
-  (rfl)
+  simp only [IterM.toArray, LawfulIteratorCollect.toArrayMapped_eq]
+  rw [IterM.DefaultConsumers.toArrayMapped_eq_match_step]
+  simp [bind_pure_comp, pure_bind]
 
 theorem IterM.toArray_ensureTermination_eq_match_step [Monad m] [LawfulMonad m] [Iterator α m β]
-    [Finite α m] :
+    [Finite α m] [IteratorCollect α m m] [LawfulIteratorCollect α m m] :
     it.ensureTermination.toArray = (do
       match (← it.step).inflate.val with
       | .yield it' out => return #[out] ++ (← it'.toArray)
@@ -86,34 +105,34 @@ theorem IterM.toArray_ensureTermination_eq_match_step [Monad m] [LawfulMonad m]
 
 @[simp]
 theorem IterM.toList_ensureTermination [Monad m] [Iterator α m β] [Finite α m]
-    {it : IterM (α := α) m β} :
+    [IteratorCollect α m m] {it : IterM (α := α) m β} :
     it.ensureTermination.toList = it.toList :=
   (rfl)
 
 @[simp]
-theorem IterM.toList_toArray [Monad m] [Iterator α m β] [Finite α m]
+theorem IterM.toList_toArray [Monad m] [Iterator α m β] [Finite α m] [IteratorCollect α m m]
     {it : IterM (α := α) m β} :
     Array.toList <$> it.toArray = it.toList := by
   simp [IterM.toList]
 
 theorem IterM.toList_toArray_ensureTermination [Monad m] [Iterator α m β] [Finite α m]
-    {it : IterM (α := α) m β} :
+    [IteratorCollect α m m] {it : IterM (α := α) m β} :
     Array.toList <$> it.ensureTermination.toArray = it.toList := by
   simp
 
 @[simp]
 theorem IterM.toArray_toList [Monad m] [LawfulMonad m] [Iterator α m β] [Finite α m]
-    {it : IterM (α := α) m β} :
+    [IteratorCollect α m m] {it : IterM (α := α) m β} :
     List.toArray <$> it.toList = it.toArray := by
   simp [IterM.toList, -toList_toArray]
 
 theorem IterM.toArray_toList_ensureTermination [Monad m] [LawfulMonad m] [Iterator α m β] [Finite α m]
-    {it : IterM (α := α) m β} :
+    [IteratorCollect α m m] {it : IterM (α := α) m β} :
     List.toArray <$> it.ensureTermination.toList = it.toArray := by
   rw [toList_ensureTermination, toArray_toList]
 
 theorem IterM.toList_eq_match_step [Monad m] [LawfulMonad m] [Iterator α m β] [Finite α m]
-    {it : IterM (α := α) m β} :
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m] {it : IterM (α := α) m β} :
     it.toList = (do
       match (← it.step).inflate.val with
       | .yield it' out => return out :: (← it'.toList)
@@ -126,7 +145,7 @@ theorem IterM.toList_eq_match_step [Monad m] [LawfulMonad m] [Iterator α m β]
   split <;> simp
 
 theorem IterM.toList_ensureTermination_eq_match_step [Monad m] [LawfulMonad m] [Iterator α m β]
-    [Finite α m] {it : IterM (α := α) m β} :
+    [Finite α m] [IteratorCollect α m m] [LawfulIteratorCollect α m m] {it : IterM (α := α) m β} :
     it.ensureTermination.toList = (do
       match (← it.step).inflate.val with
       | .yield it' out => return out :: (← it'.toList)
@@ -200,6 +219,7 @@ theorem IterM.toListRev_ensureTermination_eq_match_step [Monad m] [LawfulMonad m
 
 @[simp]
 theorem IterM.reverse_toListRev [Monad m] [LawfulMonad m] [Iterator α m β] [Finite α m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     List.reverse <$> it.toListRev = it.toList := by
   apply Eq.symm
@@ -212,19 +232,35 @@ theorem IterM.reverse_toListRev [Monad m] [LawfulMonad m] [Iterator α m β] [Fi
 
 @[simp]
 theorem IterM.reverse_toListRev_ensureTermination [Monad m] [LawfulMonad m] [Iterator α m β]
-    [Finite α m]
+    [Finite α m] [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     List.reverse <$> it.ensureTermination.toListRev = it.toList := by
   rw [toListRev_ensureTermination_eq_toListRev, reverse_toListRev]
 
 theorem IterM.toListRev_eq [Monad m] [LawfulMonad m] [Iterator α m β] [Finite α m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     it.toListRev = List.reverse <$> it.toList := by
   simp [← IterM.reverse_toListRev]
 
 theorem IterM.toListRev_ensureTermination [Monad m] [LawfulMonad m] [Iterator α m β] [Finite α m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     it.ensureTermination.toListRev = List.reverse <$> it.toList := by
   simp [← IterM.reverse_toListRev]
 
+theorem LawfulIteratorCollect.toArray_eq {α β : Type w} {m : Type w → Type w'}
+    [Monad m] [Iterator α m β] [Finite α m] [IteratorCollect α m m]
+    [hl : LawfulIteratorCollect α m m]
+    {it : IterM (α := α) m β} :
+    it.toArray = (letI : IteratorCollect α m m := .defaultImplementation; it.toArray) := by
+  simp [IterM.toArray, toArrayMapped_eq, IteratorCollect.defaultImplementation]
+
+theorem LawfulIteratorCollect.toList_eq {α β : Type w} {m : Type w → Type w'}
+    [Monad m] [Iterator α m β] [Finite α m] [IteratorCollect α m m]
+    [hl : LawfulIteratorCollect α m m]
+    {it : IterM (α := α) m β} :
+    it.toList = (letI : IteratorCollect α m m := .defaultImplementation; it.toList) := by
+  simp [IterM.toList, toArray_eq, -IterM.toList_toArray]
+
 end Std

src/Init/Data/Iterators/Lemmas/Consumers/Monadic/Loop.lean

@@ -218,34 +218,6 @@ theorem IterM.forIn_eq_match_step {α β : Type w} {m : Type w → Type w'} [Ite
   simp only [forIn]
   exact forIn'_eq_match_step
 
-theorem IterM.forIn_toList {α β : Type w} [Monad m] [LawfulMonad m] [Iterator α Id β]
-    [Finite α Id] [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
-    {it : IterM (α := α) Id β} {f : β → γ → m (ForInStep γ)} {init : γ} :
-    ForIn.forIn it.toList.run init f = ForIn.forIn it init f := by
-  rw [List.forIn_eq_foldlM]
-  induction it using IterM.inductSteps generalizing init with | step it ihy ihs
-  rw [forIn_eq_match_step, IterM.toList_eq_match_step]
-  simp only [map_eq_pure_bind, Id.run_bind, liftM, monadLift, pure_bind]
-  cases it.step.run.inflate using PlausibleIterStep.casesOn
-  · rename_i it' out h
-    simp only [List.foldlM_cons, bind_pure_comp, map_bind, Id.run_map]
-    apply bind_congr
-    intro forInStep
-    cases forInStep
-    · induction it'.toList.run <;> simp [*]
-    · simp only [ForIn.forIn] at ihy
-      simp [ihy h]
-  · rename_i it' h
-    simp only [bind_pure_comp]
-    rw [ihs h]
-  · simp
-
-theorem IterM.forIn_toArray {α β : Type w} [Monad m] [LawfulMonad m] [Iterator α Id β]
-    [Finite α Id] [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
-    {it : IterM (α := α) Id β} {f : β → γ → m (ForInStep γ)} {init : γ} :
-    ForIn.forIn it.toArray.run init f = ForIn.forIn it init f := by
-  simp [← toArray_toList, forIn_toList]
-
 theorem IterM.forM_eq_forIn {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
     [Finite α m] {n : Type w → Type w''} [Monad m] [Monad n] [LawfulMonad n]
     [IteratorLoop α m n] [LawfulIteratorLoop α m n]
@@ -354,6 +326,7 @@ theorem IterM.fold_hom {m : Type w → Type w'} [Iterator α m β] [Finite α m]
 
 theorem IterM.toList_eq_fold {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
     [Finite α m] [Monad m] [LawfulMonad m] [IteratorLoop α m m] [LawfulIteratorLoop α m m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     it.toList = it.fold (init := []) (fun l out => l ++ [out]) := by
   suffices h : ∀ l' : List β, (l' ++ ·) <$> it.toList =
@@ -376,43 +349,13 @@ theorem IterM.toList_eq_fold {α β : Type w} {m : Type w → Type w'} [Iterator
 
 theorem IterM.toArray_eq_fold {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
     [Finite α m] [Monad m] [LawfulMonad m] [IteratorLoop α m m] [LawfulIteratorLoop α m m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     it.toArray = it.fold (init := #[]) (fun xs out => xs.push out) := by
   simp only [← toArray_toList, toList_eq_fold]
   rw [← fold_hom]
   simp
 
-theorem IterM.foldlM_toList {α β : Type w} [Monad m] [LawfulMonad m] [Iterator α Id β]
-    [Finite α Id] [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
-    {it : IterM (α := α) Id β} {f : γ → β → m γ} {init : γ} :
-    it.toList.run.foldlM f init = it.foldM f init := by
-  simp [foldM_eq_forIn, ← forIn_toList]
-
-theorem IterM.foldlM_toArray {α β : Type w} [Monad m] [LawfulMonad m] [Iterator α Id β]
-    [Finite α Id] [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
-    {it : IterM (α := α) Id β} {f : γ → β → m γ} {init : γ} :
-    it.toArray.run.foldlM f init = it.foldM f init := by
-  simp [← toArray_toList, foldlM_toList]
-
-theorem IterM.foldl_toList {α β : Type w} [Monad m] [LawfulMonad m] [Iterator α m β]
-    [Finite α m] [IteratorLoop α m m] [LawfulIteratorLoop α m m]
-    {it : IterM (α := α) m β} {f : γ → β → γ} {init : γ} :
-    (·.foldl f init) <$> it.toList = it.fold f init := by
-  induction it using IterM.inductSteps generalizing init with | step it ihy ihs
-  rw [toList_eq_match_step, fold_eq_match_step]
-  simp only [bind_pure_comp, map_bind]
-  apply bind_congr; intro step
-  cases step.inflate using PlausibleIterStep.casesOn
-  · simp [ihy ‹_›]
-  · simp [ihs ‹_›]
-  · simp
-
-theorem IterM.foldl_toArray {α β : Type w} [Monad m] [LawfulMonad m] [Iterator α m β]
-    [Finite α m] [IteratorLoop α m m] [LawfulIteratorLoop α m m]
-    {it : IterM (α := α) m β} {f : γ → β → γ} {init : γ} :
-    (·.foldl f init) <$> it.toArray = it.fold f init := by
-  simp only [← toArray_toList, Functor.map_map, List.foldl_toArray, foldl_toList]
-
 theorem IterM.drain_eq_fold {α β : Type w} {m : Type w → Type w'} [Iterator α m β] [Finite α m]
     [Monad m] [IteratorLoop α m m] {it : IterM (α := α) m β} :
     it.drain = it.fold (init := PUnit.unit) (fun _ _ => .unit) :=
@@ -441,6 +384,7 @@ theorem IterM.drain_eq_match_step {α β : Type w} {m : Type w → Type w'} [Ite
 
 theorem IterM.drain_eq_map_toList {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
     [Finite α m] [Monad m] [LawfulMonad m] [IteratorLoop α m m] [LawfulIteratorLoop α m m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     it.drain = (fun _ => .unit) <$> it.toList := by
   induction it using IterM.inductSteps with | step it ihy ihs
@@ -457,12 +401,14 @@ theorem IterM.drain_eq_map_toList {α β : Type w} {m : Type w → Type w'} [Ite
 
 theorem IterM.drain_eq_map_toListRev {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
     [Finite α m] [Monad m] [LawfulMonad m] [IteratorLoop α m m] [LawfulIteratorLoop α m m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     it.drain = (fun _ => .unit) <$> it.toListRev := by
   simp [IterM.drain_eq_map_toList, IterM.toListRev_eq]
 
 theorem IterM.drain_eq_map_toArray {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
     [Finite α m] [Monad m] [LawfulMonad m] [IteratorLoop α m m] [LawfulIteratorLoop α m m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     it.drain = (fun _ => .unit) <$> it.toList := by
   simp [IterM.drain_eq_map_toList]
@@ -506,6 +452,7 @@ theorem IterM.count_eq_match_step {α β : Type w} {m : Type w → Type w'} [Ite
 @[simp]
 theorem IterM.up_size_toArray_eq_count {α β : Type w} [Iterator α m β] [Finite α m]
     [Monad m] [LawfulMonad m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     [IteratorLoop α m m] [LawfulIteratorLoop α m m]
     {it : IterM (α := α) m β} :
     (.up <| ·.size) <$> it.toArray = it.count := by
@@ -516,6 +463,7 @@ theorem IterM.up_size_toArray_eq_count {α β : Type w} [Iterator α m β] [Fini
 @[simp]
 theorem IterM.up_length_toList_eq_count {α β : Type w} [Iterator α m β] [Finite α m]
     [Monad m] [LawfulMonad m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     [IteratorLoop α m m] [LawfulIteratorLoop α m m]
     {it : IterM (α := α) m β} :
     (.up <| ·.length) <$> it.toList = it.count := by
@@ -526,6 +474,7 @@ theorem IterM.up_length_toList_eq_count {α β : Type w} [Iterator α m β] [Fin
 @[simp]
 theorem IterM.up_length_toListRev_eq_count {α β : Type w} [Iterator α m β] [Finite α m]
     [Monad m] [LawfulMonad m]
+    [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     [IteratorLoop α m m] [LawfulIteratorLoop α m m]
     {it : IterM (α := α) m β} :
     (.up <| ·.length) <$> it.toListRev = it.count := by

src/Init/Data/Iterators/Lemmas/Producers/List.lean

@@ -34,17 +34,17 @@ theorem List.step_iter_cons {x : β} {xs : List β} :
   simp [List.iter, List.iterM, IterM.mk, IterM.toIter, Iter.step, Iter.toIterM, IterM.step,
     Iterator.step]
 
-@[simp, grind =]
+@[simp]
 theorem List.toArray_iter {l : List β} :
     l.iter.toArray = l.toArray := by
   simp [List.iter, List.toArray_iterM, Iter.toArray_eq_toArray_toIterM]
 
-@[simp, grind =]
+@[simp]
 theorem List.toList_iter {l : List β} :
     l.iter.toList = l := by
   simp [List.iter, List.toList_iterM]
 
-@[simp, grind =]
+@[simp]
 theorem List.toListRev_iter {l : List β} :
     l.iter.toListRev = l.reverse := by
   simp [List.iter, Iter.toListRev_eq_toListRev_toIterM, List.toListRev_iterM]

src/Init/Data/Iterators/Lemmas/Producers/Monadic/List.lean

@@ -38,23 +38,31 @@ theorem List.step_iterM {l : List β} :
       | x :: xs => pure (.deflate ⟨.yield (xs.iterM m) x, rfl⟩) := by
   cases l <;> simp [List.step_iterM_cons, List.step_iterM_nil]
 
-@[simp, grind =]
-theorem List.toArray_iterM [LawfulMonad m] {β : Type w} {l : List β} :
-  (l.iterM m).toArray = pure l.toArray := by
+theorem Std.Iterators.Types.ListIterator.toArrayMapped_iterM [Monad n] [LawfulMonad n]
+    {β : Type w} {γ : Type w} {lift : ⦃δ : Type w⦄ → m δ → n δ}
+    [LawfulMonadLiftFunction lift] {f : β → n γ} {l : List β} :
+    IteratorCollect.toArrayMapped lift f (l.iterM m) (m := m) = List.toArray <$> l.mapM f := by
+  rw [LawfulIteratorCollect.toArrayMapped_eq]
   induction l with
   | nil =>
-    rw [IterM.toArray_eq_match_step]
-    simp [List.step_iterM_nil]
+    rw [IterM.DefaultConsumers.toArrayMapped_eq_match_step]
+    simp [List.step_iterM_nil, LawfulMonadLiftFunction.lift_pure]
   | cons x xs ih =>
-    rw [IterM.toArray_eq_match_step]
-    simp [List.step_iterM_cons, pure_bind, ih]
+    rw [IterM.DefaultConsumers.toArrayMapped_eq_match_step]
+    simp [List.step_iterM_cons, List.mapM_cons, pure_bind, ih, LawfulMonadLiftFunction.lift_pure]
 
-@[simp, grind =]
+@[simp]
+theorem List.toArray_iterM [LawfulMonad m] {l : List β} :
+    (l.iterM m).toArray = pure l.toArray := by
+  simp only [IterM.toArray, ListIterator.toArrayMapped_iterM]
+  rw [List.mapM_pure, map_pure, List.map_id']
+
+@[simp]
 theorem List.toList_iterM [LawfulMonad m] {l : List β} :
     (l.iterM m).toList = pure l := by
   rw [← IterM.toList_toArray, List.toArray_iterM, map_pure, List.toList_toArray]
 
-@[simp, grind =]
+@[simp]
 theorem List.toListRev_iterM [LawfulMonad m] {l : List β} :
     (l.iterM m).toListRev = pure l.reverse := by
   simp [IterM.toListRev_eq, List.toList_iterM]

src/Init/Data/Iterators/PostconditionMonad.lean

@@ -53,11 +53,6 @@ def PostconditionT.lift {α : Type w} {m : Type w → Type w'} [Functor m] (x :
     PostconditionT m α :=
   ⟨fun _ => True, (⟨·, .intro⟩) <$> x⟩
 
-@[always_inline, inline, expose]
-def PostconditionT.attachLift {α : Type w} {m : Type w → Type w'} [MonadAttach m]
-    (x : m α) : PostconditionT m α :=
-  ⟨MonadAttach.CanReturn x, MonadAttach.attach x⟩
-
 @[always_inline, inline, expose]
 protected def PostconditionT.pure {m : Type w → Type w'} [Pure m] {α : Type w}
     (a : α) : PostconditionT m α :=
@@ -72,7 +67,7 @@ def PostconditionT.liftWithProperty {α : Type w} {m : Type w → Type w'} {P :
   ⟨P, x⟩
 
 /--
-Given a function `f : α → β`, returns a function `PostconditionT m α → PostconditionT m β`,
+Given a function `f : α → β`, returns a a function `PostconditionT m α → PostconditionT m β`,
 turning `PostconditionT m` into a functor.
 
 The postcondition of the `x.map f` states that the return value is the image under `f` of some
@@ -85,7 +80,7 @@ protected def PostconditionT.map {m : Type w → Type w'} [Functor m] {α : Type
     (fun a => ⟨f a.val, _, rfl⟩) <$> x.operation⟩
 
 /--
-Given a function `α → PostconditionT m β`, returns a function
+Given a function `α → PostconditionT m β`, returns a a function
 `PostconditionT m α → PostconditionT m β`, turning `PostconditionT m` into a monad.
 -/
 @[always_inline, inline, expose]
@@ -121,11 +116,6 @@ def PostconditionT.run {m : Type w → Type w'} [Monad m] {α : Type w} (x : Pos
     m α :=
   (fun a => a.val) <$> x.operation
 
-theorem PostconditionT.run_eq_map {m : Type w → Type w'} [Monad m] {α : Type w}
-    {x : PostconditionT m α} :
-    x.run = Subtype.val <$> x.operation :=
-  (rfl)
-
 instance {m : Type w → Type w'} [Functor m] : Functor (PostconditionT m) where
   map := PostconditionT.map
 
@@ -248,28 +238,6 @@ theorem PostconditionT.operation_bind' {m : Type w → Type w'} [Monad m] {α :
       (fun fa => ⟨fa.1, by exact⟨a.1, a.2, fa.2⟩⟩) <$> (f a.1).operation) := by
   rfl
 
-theorem PostconditionT.operation_eq_map_mk_operation {m : Type w → Type w'}
-    [Monad m] [LawfulMonad m] {x : PostconditionT m α} :
-    x.operation = (fun a => ⟨a.val, a.property⟩) <$> x.operation := by
-  simp
-
-theorem PostconditionT.operation_bind_eq_operation_bind_mk {m : Type w → Type w'}
-    [Monad m] {x : PostconditionT m α} {f : Subtype x.Property → m β} :
-    x.operation >>= f = x.operation >>= (fun a => f ⟨a.val, a.property⟩) := by
-  rfl
-
-@[simp]
-theorem PostconditionT.run_bind {m : Type w → Type w'} [Monad m] [LawfulMonad m]
-    {α : Type w} {β : Type w} {x : PostconditionT m α} {f : α → PostconditionT m β} :
-    (x.bind f).run = x.run >>= (f · |>.run) := by
-  simp [run_eq_map]
-
-@[simp]
-theorem PostconditionT.run_bind' {m : Type w → Type w'} [Monad m] [LawfulMonad m]
-    {α : Type w} {β : Type w} {x : PostconditionT m α} {f : α → PostconditionT m β} :
-    (x >>= f).run = x.run >>= (f · |>.run) :=
-  run_bind
-
 @[simp]
 theorem PostconditionT.property_lift {m : Type w → Type w'} [Functor m] {α : Type w}
     {x : m α} : (lift x : PostconditionT m α).Property = (fun _ => True) := by
@@ -281,18 +249,6 @@ theorem PostconditionT.operation_lift {m : Type w → Type w'} [Functor m] {α :
       (⟨·, property_lift (m := m) ▸ True.intro⟩) <$> x := by
   rfl
 
-@[simp]
-theorem PostconditionT.run_attachLift {m : Type w → Type w'} [Monad m] [MonadAttach m]
-    [WeaklyLawfulMonadAttach m] {α : Type w}
-    {x : m α} : (attachLift x).run = x := by
-  simp [attachLift, run_eq_map, WeaklyLawfulMonadAttach.map_attach]
-
-@[simp]
-theorem PostconditionT.operation_attachLift {m : Type w → Type w'} [Monad m] [MonadAttach m]
-    {α : Type w} {x : m α} : (attachLift x : PostconditionT m α).operation =
-      MonadAttach.attach x := by
-  rfl
-
 instance {m : Type w → Type w'} {n : Type w → Type w''} [MonadLift m n] :
     MonadLift (PostconditionT m) (PostconditionT n) where
   monadLift x := ⟨_, monadLift x.operation⟩

src/Init/Data/Iterators/Producers/Monadic/List.lean

@@ -7,6 +7,7 @@ module
 
 prelude
 public import Init.Data.Iterators.Consumers
+public import Init.Data.Iterators.Internal.Termination
 
 @[expose] public section
 
@@ -64,7 +65,7 @@ instance ListIterator.instIterator {α : Type w} [Pure m] : Iterator (ListIterat
 
 private def ListIterator.instFinitenessRelation [Pure m] :
     FinitenessRelation (ListIterator α) m where
-  Rel := InvImage WellFoundedRelation.rel (ListIterator.list ∘ IterM.internalState)
+  rel := InvImage WellFoundedRelation.rel (ListIterator.list ∘ IterM.internalState)
   wf := InvImage.wf _ WellFoundedRelation.wf
   subrelation {it it'} h := by
     simp_wf
@@ -74,6 +75,11 @@ private def ListIterator.instFinitenessRelation [Pure m] :
 instance ListIterator.instFinite [Pure m] : Finite (ListIterator α) m :=
   by exact Finite.of_finitenessRelation ListIterator.instFinitenessRelation
 
+@[always_inline, inline]
+instance ListIterator.instIteratorCollect{α : Type w} [Monad m] {n : Type w → Type w''} [Monad n] :
+    IteratorCollect (ListIterator α) m n :=
+  .defaultImplementation
+
 @[always_inline, inline]
 instance ListIterator.instIteratorLoop {α : Type w} [Monad m] {n : Type x → Type x'} [Monad n] :
     IteratorLoop (ListIterator α) m n :=

src/Init/Data/LawfulHashable.lean

@@ -11,7 +11,7 @@ public import Init.Core
 public section
 
 /--
-The `BEq α` and `Hashable α` instances on `α` are compatible. This means that `a == b` implies
+The `BEq α` and `Hashable α` instances on `α` are compatible. This means that that `a == b` implies
 `hash a = hash b`.
 
 This is automatic if the `BEq` instance is lawful.

src/Init/Data/List/Basic.lean

@@ -169,10 +169,10 @@ Examples:
   | a::as, b::bs, eqv => eqv a b && isEqv as bs eqv
   | _,     _,     _   => false
 
-@[simp, grind =] theorem isEqv_nil_nil : isEqv ([] : List α) [] eqv = true := rfl
-@[simp, grind =] theorem isEqv_nil_cons : isEqv ([] : List α) (a::as) eqv = false := rfl
-@[simp, grind =] theorem isEqv_cons_nil : isEqv (a::as : List α) [] eqv = false := rfl
-@[grind =] theorem isEqv_cons₂ : isEqv (a::as) (b::bs) eqv = (eqv a b && isEqv as bs eqv) := rfl
+@[simp] theorem isEqv_nil_nil : isEqv ([] : List α) [] eqv = true := rfl
+@[simp] theorem isEqv_nil_cons : isEqv ([] : List α) (a::as) eqv = false := rfl
+@[simp] theorem isEqv_cons_nil : isEqv (a::as : List α) [] eqv = false := rfl
+theorem isEqv_cons₂ : isEqv (a::as) (b::bs) eqv = (eqv a b && isEqv as bs eqv) := rfl
 
 
 /-! ## Lexicographic ordering -/
@@ -717,7 +717,6 @@ Examples:
  * `["red", "green", "blue"].leftpad 3 "blank" = ["red", "green", "blue"]`
  * `["red", "green", "blue"].leftpad 1 "blank" = ["red", "green", "blue"]`
 -/
-@[simp, grind =]
 def leftpad (n : Nat) (a : α) (l : List α) : List α := replicate (n - length l) a ++ l
 
 
@@ -731,7 +730,6 @@ Examples:
  * `["red", "green", "blue"].rightpad 3 "blank" = ["red", "green", "blue"]`
  * `["red", "green", "blue"].rightpad 1 "blank" = ["red", "green", "blue"]`
 -/
-@[simp, grind =]
 def rightpad (n : Nat) (a : α) (l : List α) : List α := l ++ replicate (n - length l) a
 
 /-! ### reduceOption -/

src/Init/Data/List/Control.lean

@@ -50,7 +50,7 @@ Users that want to use `mapM` with `Applicative` should use `mapA` instead.
 Applies the monadic action `f` to every element in the list, left-to-right, and returns the list of
 results.
 
-This implementation is tail recursive. `List.mapM'` is a non-tail-recursive variant that may be
+This implementation is tail recursive. `List.mapM'` is a a non-tail-recursive variant that may be
 more convenient to reason about. `List.forM` is the variant that discards the results and
 `List.mapA` is the variant that works with `Applicative`.
 -/
@@ -107,7 +107,7 @@ Applies the monadic action `f` to the corresponding elements of two lists, left-
 at the end of the shorter list. `zipWithM f as bs` is equivalent to `mapM id (zipWith f as bs)`
 for lawful `Monad` instances.
 
-This implementation is tail recursive. `List.zipWithM'` is a non-tail-recursive variant that may
+This implementation is tail recursive. `List.zipWithM'` is a a non-tail-recursive variant that may
 be more convenient to reason about.
 -/
 @[inline, expose]

src/Init/Data/List/Lemmas.lean

@@ -97,11 +97,10 @@ open Nat
 
 /-! ### length -/
 
+-- Note: this is not a good `grind` candidate,
+-- as in some circumstances it results in many case splits.
 theorem eq_nil_of_length_eq_zero (_ : length l = 0) : l = [] := match l with | [] => rfl
 
-grind_pattern eq_nil_of_length_eq_zero => length l where
-  guard l.length = 0
-
 theorem ne_nil_of_length_eq_add_one (_ : length l = n + 1) : l ≠ [] := fun _ => nomatch l
 
 theorem ne_nil_of_length_pos (_ : 0 < length l) : l ≠ [] := fun _ => nomatch l
@@ -2941,6 +2940,9 @@ theorem getLast?_replicate {a : α} {n : Nat} : (replicate n a).getLast? = if n
 
 /-! ### leftpad -/
 
+-- We unfold `leftpad` and `rightpad` for verification purposes.
+attribute [simp, grind =] leftpad rightpad
+
 -- `length_leftpad` and `length_rightpad` are in `Init.Data.List.Nat.Basic`.
 
 theorem leftpad_prefix {n : Nat} {a : α} {l : List α} :

src/Init/Data/List/Sublist.lean

@@ -249,13 +249,12 @@ theorem Sublist.eq_of_length : l₁ <+ l₂ → length l₁ = length l₂ → l
   | .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 activate `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
 
--- Only activate `eq_of_length_le` if we're already thinking about lengths.
-grind_pattern Sublist.eq_of_length_le => l₁ <+ l₂, length l₁, length l₂ where
-  guard length l₂ ≤ length l₁
-
 theorem Sublist.length_eq (s : l₁ <+ l₂) : length l₁ = length l₂ ↔ l₁ = l₂ :=
   ⟨s.eq_of_length, congrArg _⟩
 

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

@@ -223,16 +223,6 @@ theorem testBit_lt_two_pow {x i : Nat} (lt : x < 2^i) : x.testBit i = false := b
     exfalso
     exact Nat.not_le_of_gt lt (ge_two_pow_of_testBit p)
 
-theorem testBit_of_two_pow_le_and_two_pow_add_one_gt {n i : Nat}
-    (hle : 2^i ≤ n) (hgt : n < 2^(i + 1)) : n.testBit i = true := by
-  rcases exists_ge_and_testBit_of_ge_two_pow hle with ⟨i', ⟨_, _⟩⟩
-  have : i = i' := by
-    false_or_by_contra
-    have : 2 ^ (i + 1) ≤ 2 ^ i' := Nat.pow_le_pow_of_le (by decide) (by omega)
-    have : n.testBit i' = false := testBit_lt_two_pow (by omega)
-    simp_all only [Bool.false_eq_true]
-  rwa [this]
-
 theorem lt_pow_two_of_testBit (x : Nat) (p : ∀i, i ≥ n → testBit x i = false) : x < 2^n := by
   apply Decidable.by_contra
   intro not_lt
@@ -241,10 +231,6 @@ theorem lt_pow_two_of_testBit (x : Nat) (p : ∀i, i ≥ n → testBit x i = fal
   have test_false := p _ i_ge_n
   simp [test_true] at test_false
 
-theorem testBit_log2 {n : Nat} (h : n ≠ 0) : n.testBit n.log2 = true := by
-  have := log2_eq_iff (n := n) (k := n.log2) (by omega)
-  apply testBit_of_two_pow_le_and_two_pow_add_one_gt <;> omega
-
 private theorem succ_mod_two : succ x % 2 = 1 - x % 2 := by
   induction x with
   | zero =>

src/Init/Data/Nat/Gcd.lean

@@ -129,9 +129,6 @@ theorem gcd_assoc (m n k : Nat) : gcd (gcd m n) k = gcd m (gcd n k) :=
       (Nat.dvd_trans (gcd_dvd_right m (gcd n k)) (gcd_dvd_right n k)))
 instance : Std.Associative gcd := ⟨gcd_assoc⟩
 
-theorem gcd_left_comm (m n k : Nat) : gcd m (gcd n k) = gcd n (gcd m k) := by
-  rw [← gcd_assoc, ← gcd_assoc, gcd_comm m n]
-
 @[simp] theorem gcd_one_right (n : Nat) : gcd n 1 = 1 := (gcd_comm n 1).trans (gcd_one_left n)
 
 theorem gcd_mul_left (m n k : Nat) : gcd (m * n) (m * k) = m * gcd n k := by

src/Init/Data/Nat/Lemmas.lean

@@ -10,7 +10,7 @@ import all Init.Data.Nat.Bitwise.Basic
 public import Init.Data.Nat.MinMax
 public import Init.Data.Nat.Log2
 import all Init.Data.Nat.Log2
-public import Init.Data.Nat.Power2.Basic
+public import Init.Data.Nat.Power2
 public import Init.Data.Nat.Mod
 import Init.TacticsExtra
 import Init.BinderPredicates

src/Init/Data/Nat/Power2.lean

@@ -6,5 +6,66 @@ Authors: Leonardo de Moura
 module
 
 prelude
-public import Init.Data.Nat.Power2.Basic
-public import Init.Data.Nat.Power2.Lemmas
+public import Init.Data.Nat.Linear
+
+public section
+
+namespace Nat
+
+theorem nextPowerOfTwo_dec {n power : Nat} (h₁ : power > 0) (h₂ : power < n) : n - power * 2 < n - power := by
+  have : power * 2 = power + power := by simp +arith
+  rw [this, Nat.sub_add_eq]
+  exact Nat.sub_lt (Nat.zero_lt_sub_of_lt h₂) h₁
+
+/--
+Returns the least power of two that's greater than or equal to `n`.
+
+Examples:
+ * `Nat.nextPowerOfTwo 0 = 1`
+ * `Nat.nextPowerOfTwo 1 = 1`
+ * `Nat.nextPowerOfTwo 2 = 2`
+ * `Nat.nextPowerOfTwo 3 = 4`
+ * `Nat.nextPowerOfTwo 5 = 8`
+-/
+def nextPowerOfTwo (n : Nat) : Nat :=
+  go 1 (by decide)
+where
+  go (power : Nat) (h : power > 0) : Nat :=
+    if power < n then
+      go (power * 2) (Nat.mul_pos h (by decide))
+    else
+      power
+  termination_by n - power
+  decreasing_by simp_wf; apply nextPowerOfTwo_dec <;> assumption
+
+/--
+A natural number `n` is a power of two if there exists some `k : Nat` such that `n = 2 ^ k`.
+-/
+def isPowerOfTwo (n : Nat) := ∃ k, n = 2 ^ k
+
+theorem isPowerOfTwo_one : isPowerOfTwo 1 :=
+  ⟨0, by decide⟩
+
+theorem isPowerOfTwo_mul_two_of_isPowerOfTwo (h : isPowerOfTwo n) : isPowerOfTwo (n * 2) :=
+  have ⟨k, h⟩ := h
+  ⟨k+1, by simp [h, Nat.pow_succ]⟩
+
+theorem pos_of_isPowerOfTwo (h : isPowerOfTwo n) : n > 0 := by
+  have ⟨k, h⟩ := h
+  rw [h]
+  apply Nat.pow_pos
+  decide
+
+theorem isPowerOfTwo_nextPowerOfTwo (n : Nat) : n.nextPowerOfTwo.isPowerOfTwo := by
+  apply isPowerOfTwo_go
+  apply isPowerOfTwo_one
+where
+  isPowerOfTwo_go (power : Nat) (h₁ : power > 0) (h₂ : power.isPowerOfTwo) : (nextPowerOfTwo.go n power h₁).isPowerOfTwo := by
+    unfold nextPowerOfTwo.go
+    split
+    . exact isPowerOfTwo_go (power*2) (Nat.mul_pos h₁ (by decide)) (Nat.isPowerOfTwo_mul_two_of_isPowerOfTwo h₂)
+    . assumption
+  termination_by n - power
+  decreasing_by simp_wf; apply nextPowerOfTwo_dec <;> assumption
+
+end Nat