perf: parallelize rw? tactic

Use `MetaM.parIterWithCancel` to try all candidate rewrites in parallel
while preserving deterministic result ordering. When an rfl-closeable
result is found (and `stopAtRfl` is true), or the maximum number of
results is reached, remaining tasks are cancelled.

This removes the old sequential `takeListAux` implementation along with
the heartbeat-based early termination and `RewriteResultConfig` structure.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

.claude/CLAUDE.md

@@ -1,29 +1,6 @@
 To build Lean you should use `make -j -C build/release`.
 
-## Running Tests
-
-See `doc/dev/testing.md` for full documentation. Quick reference:
-
-```bash
-# Full test suite (use after builds to verify correctness)
-make -j -C build/release test ARGS="-j$(nproc)"
-
-# Specific test by name (supports regex via ctest -R)
-make -j -C build/release test ARGS='-R grind_ematch --output-on-failure'
-
-# Rerun only previously failed tests
-make -j -C build/release test ARGS='--rerun-failed --output-on-failure'
-
-# Single test from tests/lean/run/ (quick check during development)
-cd tests/lean/run && ./test_single.sh example_test.lean
-
-# ctest directly (from stage1 build dir)
-cd build/release/stage1 && ctest -j$(nproc) --output-on-failure --timeout 300
-```
-
-The full test suite includes `tests/lean/`, `tests/lean/run/`, `tests/lean/interactive/`,
-`tests/compiler/`, `tests/pkg/`, Lake tests, and more. Using `make test` or `ctest` runs
-all of them; `test_single.sh` in `tests/lean/run/` only covers that one directory.
+To run a test you should use `cd tests/lean/run && ./test_single.sh example_test.lean`.
 
 ## New features
 
@@ -52,38 +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.
-```
-
-**Changelog labels:** Add one `changelog-*` label to categorize the PR for release notes:
-- `changelog-language` - Language features and metaprograms
-- `changelog-tactics` - User facing tactics
-- `changelog-server` - Language server, widgets, and IDE extensions
-- `changelog-pp` - Pretty printing
-- `changelog-library` - Library
-- `changelog-compiler` - Compiler, runtime, and FFI
-- `changelog-lake` - Lake
-- `changelog-doc` - Documentation
-- `changelog-ffi` - FFI changes
-- `changelog-other` - Other changes
-- `changelog-no` - Do not include this PR in the release changelog
-
-If you're unsure which label applies, it's fine to omit the label and let reviewers add it.
-
-## 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.

.claude/commands/release.md

@@ -13,54 +13,12 @@ These comments explain the scripts' behavior, which repositories get special han
 ## Arguments
 - `version`: The version to release (e.g., v4.24.0)
 
-## Release Notes (Required for -rc1 releases)
-
-For first release candidates (`-rc1`), you must create release notes BEFORE the reference-manual toolchain bump PR can be merged.
-
-**Steps to create release notes:**
-
-1. Generate the release notes:
-   ```bash
-   cd /path/to/lean4
-   python3 script/release_notes.py --since <previous_version> > /tmp/release-notes-<version>.md
-   ```
-   Replace `<previous_version>` with the last stable release (e.g., `v4.27.0` when releasing `v4.28.0-rc1`).
-
-2. Review `/tmp/release-notes-<version>.md` for common issues:
-   - **Unterminated code blocks**: Look for code fences that aren't closed. Fetch original PR with `gh pr view <number>` to repair.
-   - **Truncated descriptions**: Some may end mid-sentence. Complete them from the original PR.
-   - **Markdown issues**: Other syntax problems that could cause parsing errors.
-
-3. Create the release notes file in the reference-manual repository:
-   - File path: `Manual/Releases/v<version>.lean` (e.g., `v4_28_0.lean`)
-   - Use Verso format with proper imports and `#doc (Manual)` block
-   - **Use `#` for headers, not `##`** (Verso uses level 1 for subsections)
-   - **Use plain ` ``` ` not ` ```lean `** (the latter executes code)
-   - **Wrap underscore identifiers in backticks**: `` `bv_decide` `` not `bv_decide`
-
-4. Update `Manual/Releases.lean`:
-   - Add import: `import Manual.Releases.«v4_28_0»`
-   - Add include: `{include 0 Manual.Releases.«v4_28_0»}`
-
-5. Build to verify: `lake build Manual.Releases.v4_28_0`
-
-6. Create a **separate PR** for release notes (not bundled with toolchain bump):
-   ```bash
-   git checkout -b v<version>-release-notes
-   gh pr create --title "doc: add v<version> release notes"
-   ```
-
-For subsequent RCs (`-rc2`, etc.) and stable releases, just update the version number in the existing release notes file title.
-
-See `doc/dev/release_checklist.md` section "Writing the release notes" for full details.
-
 ## Process
 
 1. Run `script/release_checklist.py {version}` to check the current status
 2. **CRITICAL: If preliminary lean4 checks fail, STOP immediately and alert the user**
-   - Check for: release branch exists, CMake version correct, tag exists, release page exists, release notes file exists
+   - Check for: release branch exists, CMake version correct, tag exists, release page exists, release notes exist
    - **IMPORTANT**: The release page is created AUTOMATICALLY by CI after pushing the tag - DO NOT create it manually
-   - **IMPORTANT**: For -rc1 releases, release notes must be created before proceeding
    - Do NOT create any PRs or proceed with repository updates if these checks fail
 3. Create a todo list tracking all repositories that need updates
 4. **CRITICAL RULE: You can ONLY run `release_steps.py` for a repository if `release_checklist.py` explicitly says to do so**
@@ -81,7 +39,6 @@ See `doc/dev/release_checklist.md` section "Writing the release notes" for full
 
 ## Important Notes
 
-- **NEVER merge PRs autonomously** - always wait for the user to merge PRs themselves
 - The `release_steps.py` script is idempotent - it's safe to rerun
 - The `release_checklist.py` script is idempotent - it's safe to rerun
 - Some repositories depend on others (e.g., mathlib4 depends on batteries, aesop, etc.)
@@ -103,15 +60,6 @@ Every time you run `release_checklist.py`, you MUST:
 This summary should be provided EVERY time you run the checklist, not just after creating new PRs.
 The user needs to see the complete picture of what's waiting for review.
 
-## Nightly Infrastructure
-
-The nightly build system uses branches and tags across two repositories:
-
-- `leanprover/lean4` has **branches** `nightly` and `nightly-with-mathlib` tracking the latest nightly builds
-- `leanprover/lean4-nightly` has **dated tags** like `nightly-2026-01-23`
-
-When a nightly succeeds with mathlib, all three should point to the same commit. Don't confuse these: branches are in the main lean4 repo, dated tags are in lean4-nightly.
-
 ## Error Handling
 
 **CRITICAL**: If something goes wrong or a command fails:

.gitattributes

@@ -4,7 +4,6 @@ RELEASES.md merge=union
 stage0/** binary linguist-generated
 # The following file is often manually edited, so do show it in diffs
 stage0/src/stdlib_flags.h -binary -linguist-generated
-doc/std/grove/GroveStdlib/Generated/** linguist-generated
 # These files should not have line endings translated on Windows, because
 # it throws off parser tests. Later lines override earlier ones, so the
 # runner code is still treated as ordinary text.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -9,7 +9,7 @@ assignees: ''
 
 ### Prerequisites
 
-<!-- Please put an X between the brackets as you perform the following steps: -->
+Please put an X between the brackets as you perform the following steps:
 
 * [ ] Check that your issue is not already filed:
       https://github.com/leanprover/lean4/issues

.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
@@ -102,7 +102,7 @@ jobs:
         if: matrix.cmultilib
       - name: Restore Cache
         id: restore-cache
-        uses: actions/cache/restore@v5
+        uses: actions/cache/restore@v4
         with:
           # NOTE: must be in sync with `save` below and with `restore-cache` in `update-stage0.yml`
           path: |
@@ -175,7 +175,7 @@ jobs:
         # Caching on cancellation created some mysterious issues perhaps related to improper build
         # shutdown
         if: steps.restore-cache.outputs.cache-hit != 'true' && !cancelled()
-        uses: actions/cache/save@v5
+        uses: actions/cache/save@v4
         with:
           # NOTE: must be in sync with `restore` above
           path: |
@@ -220,7 +220,7 @@ jobs:
           path: pack/*
       - name: Lean stats
         run: |
-          build/$TARGET_STAGE/bin/lean --stats src/Lean.lean
+          build/$TARGET_STAGE/bin/lean --stats src/Lean.lean -Dexperimental.module=true
         if: ${{ !matrix.cross }}
       - name: Test
         id: test

.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/check-stdlib-flags.yml

@@ -1,57 +0,0 @@
-name: Check stdlib_flags.h modifications
-
-on:
-  pull_request:
-    types: [opened, synchronize, reopened, labeled, unlabeled]
-
-jobs:
-  check-stdlib-flags:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check if stdlib_flags.h was modified
-        uses: actions/github-script@v8
-        with:
-          script: |
-            // Get the list of files changed in this PR
-            const files = await github.paginate(
-              github.rest.pulls.listFiles,
-              {
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                pull_number: context.payload.pull_request.number,
-              }
-            );
-
-            // Check if stdlib_flags.h was modified
-            const stdlibFlagsModified = files.some(file =>
-              file.filename === 'src/stdlib_flags.h'
-            );
-
-            if (stdlibFlagsModified) {
-              console.log('src/stdlib_flags.h was modified in this PR');
-
-              // Check if the unlock label is present
-
-              const { data: pr } = await github.rest.pulls.get({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                pull_number: context.issue.number,
-              });
-
-              const hasUnlockLabel = pr.labels.some(label =>
-                label.name === 'unlock-upstream-stdlib-flags'
-              );
-
-              if (!hasUnlockLabel) {
-                core.setFailed(
-                  'src/stdlib_flags.h was modified. This is likely a mistake. If you would like to change ' +
-                  'bootstrapping settings or request a stage0 update, you should modify stage0/src/stdlib_flags.h. ' +
-                  'If you really want to change src/stdlib_flags.h (which should be extremely rare), set the ' +
-                  'unlock-upstream-stdlib-flags label.'
-                );
-              } else {
-                console.log('Found unlock-upstream-stdlib-flags');
-              }
-            } else {
-              console.log('src/stdlib_flags.h was not modified');
-            }

.github/workflows/ci.yml

@@ -50,9 +50,9 @@ 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')
+        if: github.event_name == 'schedule' && github.repository == 'leanprover/lean4' || inputs.action == 'release nightly'
       - name: Set Nightly
         if: github.event_name == 'schedule' && github.repository == 'leanprover/lean4' || inputs.action == 'release nightly'
         id: set-nightly
@@ -60,23 +60,10 @@ jobs:
           if [[ -n '${{ secrets.PUSH_NIGHTLY_TOKEN }}' ]]; then
             git remote add nightly https://foo:'${{ secrets.PUSH_NIGHTLY_TOKEN }}'@github.com/${{ github.repository_owner }}/lean4-nightly.git
             git fetch nightly --tags
-            if [[ '${{ github.event_name }}' == 'workflow_dispatch' ]]; then
-              # Manual re-release: create a revision of the most recent nightly
-              BASE_NIGHTLY=$(git tag -l 'nightly-*' | sort -rV | head -1)
-              # Strip any existing -revK suffix to get the base date tag
-              BASE_NIGHTLY="${BASE_NIGHTLY%%-rev*}"
-              REV=1
-              while git rev-parse "refs/tags/${BASE_NIGHTLY}-rev${REV}" >/dev/null 2>&1; do
-                REV=$((REV + 1))
-              done
-              LEAN_VERSION_STRING="${BASE_NIGHTLY}-rev${REV}"
+            LEAN_VERSION_STRING="nightly-$(date -u +%F)"
+            # do nothing if commit already has a different tag
+            if [[ "$(git name-rev --name-only --tags --no-undefined HEAD 2> /dev/null || echo "$LEAN_VERSION_STRING")" == "$LEAN_VERSION_STRING" ]]; then
               echo "nightly=$LEAN_VERSION_STRING" >> "$GITHUB_OUTPUT"
-            else
-              # Scheduled: do nothing if commit already has a different tag
-              LEAN_VERSION_STRING="nightly-$(date -u +%F)"
-              if [[ "$(git name-rev --name-only --tags --no-undefined HEAD 2> /dev/null || echo "$LEAN_VERSION_STRING")" == "$LEAN_VERSION_STRING" ]]; then
-                echo "nightly=$LEAN_VERSION_STRING" >> "$GITHUB_OUTPUT"
-              fi
             fi
           fi
 
@@ -128,7 +115,7 @@ jobs:
           CMAKE_MAJOR=$(grep -E "^set\(LEAN_VERSION_MAJOR " src/CMakeLists.txt | grep -oE '[0-9]+')
           CMAKE_MINOR=$(grep -E "^set\(LEAN_VERSION_MINOR " src/CMakeLists.txt | grep -oE '[0-9]+')
           CMAKE_PATCH=$(grep -E "^set\(LEAN_VERSION_PATCH " src/CMakeLists.txt | grep -oE '[0-9]+')
-          CMAKE_IS_RELEASE=$(grep -m 1 -E "^set\(LEAN_VERSION_IS_RELEASE " src/CMakeLists.txt | sed -nE 's/^set\(LEAN_VERSION_IS_RELEASE ([0-9]+)\).*/\1/p')
+          CMAKE_IS_RELEASE=$(grep -E "^set\(LEAN_VERSION_IS_RELEASE " src/CMakeLists.txt | grep -oE '[0-9]+')
 
           # Expected values from tag parsing
           TAG_MAJOR="${{ steps.set-release.outputs.LEAN_VERSION_MAJOR }}"
@@ -273,24 +260,18 @@ jobs:
               {
                 "name": "Linux fsanitize",
                 // Always run on large if available, more reliable regarding timeouts
-                "os": large ? "nscloud-ubuntu-22.04-amd64-16x32-with-cache" : "ubuntu-latest",
+                "os": large ? "nscloud-ubuntu-22.04-amd64-8x16-with-cache" : "ubuntu-latest",
                 "enabled": level >= 2,
                 // do not fail nightlies on this for now
                 "secondary": level <= 2,
                 "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|grind_bitvec2|grind_constProp|grind_indexmap|grind_list|grind_lint|grind_array_attach|grind_ite_trace|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.
+                "CTEST_OPTIONS": "-E 'StackOverflow|reverse-ffi|interactive|async_select_channel'"
               },
               {
                 "name": "macOS",
@@ -446,11 +427,11 @@ jobs:
     runs-on: ubuntu-latest
     needs: build
     steps:
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v6
         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
@@ -471,14 +452,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v6
+        uses: actions/checkout@v5
         with:
           # needed for tagging
           fetch-depth: 0
           # Doesn't seem to be working when additionally fetching from lean4-nightly
           #filter: tree:0
           token: ${{ secrets.PUSH_NIGHTLY_TOKEN }}
-      - uses: actions/download-artifact@v7
+      - uses: actions/download-artifact@v6
         with:
           path: artifacts
       - name: Prepare Nightly Release
@@ -488,7 +469,7 @@ jobs:
           git tag "${{ needs.configure.outputs.nightly }}"
           git push nightly "${{ needs.configure.outputs.nightly }}"
           git push -f origin refs/tags/${{ needs.configure.outputs.nightly }}:refs/heads/nightly
-          last_tag="$(git log HEAD^ --simplify-by-decoration --pretty="format:%d" | grep -o "nightly-[^ ,)]*" | head -n 1)"
+          last_tag="$(git log HEAD^ --simplify-by-decoration --pretty="format:%d" | grep -o "nightly-[-0-9]*" | head -n 1)"
           echo -e "*Changes since ${last_tag}:*\n\n" > diff.md
           git show "$last_tag":RELEASES.md > old.md
           #./script/diff_changelogs.py old.md doc/changes.md >> diff.md
@@ -496,7 +477,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
@@ -511,18 +492,8 @@ jobs:
           gh workflow -R leanprover/release-index run update-index.yml
         env:
           GITHUB_TOKEN: ${{ secrets.RELEASE_INDEX_TOKEN }}
-      - name: Generate mathlib nightly-testing app token
-        id: mathlib-app-token
-        uses: actions/create-github-app-token@29824e69f54612133e76f7eaac726eef6c875baf # v2.2.1
-        continue-on-error: true
-        with:
-          app-id: ${{ secrets.MATHLIB_NIGHTLY_TESTING_APP_ID }}
-          private-key: ${{ secrets.MATHLIB_NIGHTLY_TESTING_PRIVATE_KEY }}
-          owner: leanprover-community
-          repositories: mathlib4-nightly-testing
       - name: Update toolchain on mathlib4's nightly-testing branch
-        if: steps.mathlib-app-token.outcome == 'success'
         run: |
-          gh workflow -R leanprover-community/mathlib4-nightly-testing run nightly_bump_and_merge.yml
+          gh workflow -R leanprover-community/mathlib4-nightly-testing run nightly_bump_toolchain.yml
         env:
-          GITHUB_TOKEN: ${{ steps.mathlib-app-token.outputs.token }}
+          GITHUB_TOKEN: ${{ secrets.MATHLIB4_BOT }}

.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/grove.yml

@@ -51,7 +51,7 @@ jobs:
       - name: Fetch upstream invalidated facts
         if: ${{ steps.should-run.outputs.should-run == 'true' && steps.workflow-info.outputs.pullRequestNumber != '' }}
         id: fetch-upstream
-        uses: TwoFx/grove-action/fetch-upstream@v0.5
+        uses: TwoFx/grove-action/fetch-upstream@v0.4
         with:
           artifact-name: grove-invalidated-facts
           base-ref: master
@@ -65,7 +65,6 @@ jobs:
           workflow: ci.yml
           path: artifacts
           name: "build-Linux release"
-          allow_forks: true
           name_is_regexp: true
 
       - name: Unpack toolchain
@@ -96,7 +95,7 @@ jobs:
       - name: Build
         if: ${{ steps.should-run.outputs.should-run == 'true' }}
         id: build
-        uses: TwoFx/grove-action/build@v0.5
+        uses: TwoFx/grove-action/build@v0.4
         with:
           project-path: doc/std/grove
           script-name: grove-stdlib

.github/workflows/pr-release.yml

@@ -20,9 +20,7 @@ on:
 jobs:
   on-success:
     runs-on: ubuntu-latest
-    # Run even if CI fails, as long as build artifacts are available
-    # The "Verify release artifacts exist" step will fail if necessary artifacts are missing
-    if: github.event.workflow_run.event == 'pull_request' && github.repository == 'leanprover/lean4'
+    if: github.event.workflow_run.conclusion == 'success' && github.event.workflow_run.event == 'pull_request' && github.repository == 'leanprover/lean4'
     steps:
       - name: Retrieve information about the original workflow
         uses: potiuk/get-workflow-origin@v1_1 # https://github.com/marketplace/actions/get-workflow-origin
@@ -43,19 +41,6 @@ jobs:
           name: build-.*
           name_is_regexp: true
 
-      # Verify artifacts were downloaded before any side effects (tag creation, release deletion).
-      - name: Verify release artifacts exist
-        if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
-        run: |
-          shopt -s nullglob
-          files=(artifacts/*/*)
-          if [ ${#files[@]} -eq 0 ]; then
-            echo "::error::No artifacts found matching artifacts/*/*"
-            exit 1
-          fi
-          echo "Found ${#files[@]} artifacts to upload:"
-          printf '%s\n' "${files[@]}"
-
       - name: Push tag
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
         run: |
@@ -77,44 +62,42 @@ jobs:
           git -C lean4.git remote add pr-releases https://foo:'${{ secrets.PR_RELEASES_TOKEN }}'@github.com/${{ github.repository_owner }}/lean4-pr-releases.git
           git -C lean4.git push -f pr-releases pr-release-${{ steps.workflow-info.outputs.pullRequestNumber }}
           git -C lean4.git push -f pr-releases pr-release-${{ steps.workflow-info.outputs.pullRequestNumber }}-"${SHORT_SHA}"
-      - name: Delete existing releases if present
+      - name: Delete existing release if present
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
         run: |
-          # Delete any existing releases for this PR.
-          # The short format release is always recreated with the latest commit.
-          # The SHA-suffixed release should be unique per commit, but delete just in case.
+          # Try to delete any existing release for the current PR (just the version without the SHA suffix).
           gh release delete --repo ${{ github.repository_owner }}/lean4-pr-releases pr-release-${{ steps.workflow-info.outputs.pullRequestNumber }} -y || true
-          gh release delete --repo ${{ github.repository_owner }}/lean4-pr-releases pr-release-${{ steps.workflow-info.outputs.pullRequestNumber }}-${{ env.SHORT_SHA }} -y || true
         env:
           GH_TOKEN: ${{ secrets.PR_RELEASES_TOKEN }}
-      # We use `gh release create` instead of `softprops/action-gh-release` because
-      # the latter enumerates all releases to check for existing ones, which fails
-      # when the repository has more than 10000 releases (GitHub API pagination limit).
-      # Upstream fix: https://github.com/softprops/action-gh-release/pull/725
       - name: Release (short format)
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
-        run: |
-          # There are coredump files in deeper subdirectories; artifacts/*/* gets the release archives.
-          gh release create \
-            --repo ${{ github.repository_owner }}/lean4-pr-releases \
-            --title "Release for PR ${{ steps.workflow-info.outputs.pullRequestNumber }}" \
-            --notes "" \
-            pr-release-${{ steps.workflow-info.outputs.pullRequestNumber }} \
-            artifacts/*/*
+        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.
+          files: artifacts/*/*
+          fail_on_unmatched_files: true
+          draft: false
+          tag_name: pr-release-${{ steps.workflow-info.outputs.pullRequestNumber }}
+          repository: ${{ github.repository_owner }}/lean4-pr-releases
         env:
-          GH_TOKEN: ${{ secrets.PR_RELEASES_TOKEN }}
+          # The token used here must have `workflow` privileges.
+          GITHUB_TOKEN: ${{ secrets.PR_RELEASES_TOKEN }}
 
       - name: Release (SHA-suffixed format)
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
-        run: |
-          gh release create \
-            --repo ${{ github.repository_owner }}/lean4-pr-releases \
-            --title "Release for PR ${{ steps.workflow-info.outputs.pullRequestNumber }} (${{ steps.workflow-info.outputs.sourceHeadSha }})" \
-            --notes "" \
-            pr-release-${{ steps.workflow-info.outputs.pullRequestNumber }}-${{ env.SHORT_SHA }} \
-            artifacts/*/*
+        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.
+          files: artifacts/*/*
+          fail_on_unmatched_files: true
+          draft: false
+          tag_name: pr-release-${{ steps.workflow-info.outputs.pullRequestNumber }}-${{ env.SHORT_SHA }}
+          repository: ${{ github.repository_owner }}/lean4-pr-releases
         env:
-          GH_TOKEN: ${{ secrets.PR_RELEASES_TOKEN }}
+          # The token used here must have `workflow` privileges.
+          GITHUB_TOKEN: ${{ secrets.PR_RELEASES_TOKEN }}
 
       - name: Report release status (short format)
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
@@ -144,7 +127,7 @@ jobs:
               description: "${{ github.repository_owner }}/lean4-pr-releases:pr-release-${{ steps.workflow-info.outputs.pullRequestNumber }}-${{ env.SHORT_SHA }}",
             });
 
-      - name: Add toolchain-available label
+      - name: Add label
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
         uses: actions/github-script@v8
         with:
@@ -170,18 +153,6 @@ jobs:
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
         uses: dcarbone/install-jq-action@v3.2.0
 
-      # Generate a token for posting comments to Lean PRs about mathlib compatibility.
-      # This app is in the leanprover org and installed on leanprover/lean4.
-      - name: Generate GitHub App token for Lean PR comments
-        if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
-        id: mathlib-comment-token
-        uses: actions/create-github-app-token@3ff1caaa28b64c9cc276ce0a02e2ff584f3900c5 # v2.0.2
-        with:
-          app-id: ${{ secrets.MATHLIB_LEAN_PR_TESTING_APP_ID }}
-          private-key: ${{ secrets.MATHLIB_LEAN_PR_TESTING_PRIVATE_KEY }}
-          owner: leanprover
-          repositories: lean4
-
       # Check that the most recently nightly coincides with 'git merge-base HEAD master'
       - name: Check merge-base and nightly-testing-YYYY-MM-DD for Mathlib/Batteries
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
@@ -195,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"
@@ -216,9 +195,8 @@ jobs:
 
           if [[ -n "$MESSAGE" ]]; then
             # Check if force-mathlib-ci label is present
-            # Use GITHUB_TOKEN for read-only label fetch (MATHLIB4_COMMENT_BOT is only for posting comments)
             LABELS="$(curl --retry 3 --location --silent \
-                          -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+                          -H "Authorization: token ${{ secrets.MATHLIB4_COMMENT_BOT }}" \
                           -H "Accept: application/vnd.github.v3+json" \
                           "https://api.github.com/repos/leanprover/lean4/issues/${{ steps.workflow-info.outputs.pullRequestNumber }}/labels" \
                           | jq -r '.[].name')"
@@ -239,10 +217,10 @@ jobs:
 
             # Use GitHub API to check if a comment already exists
             existing_comment="$(curl --retry 3 --location --silent \
-                                    -H "Authorization: token ${{ steps.mathlib-comment-token.outputs.token }}" \
+                                    -H "Authorization: token ${{ secrets.MATHLIB4_COMMENT_BOT }}" \
                                     -H "Accept: application/vnd.github.v3+json" \
                                     "https://api.github.com/repos/leanprover/lean4/issues/${{ steps.workflow-info.outputs.pullRequestNumber }}/comments" \
-                                    | jq 'first(.[] | select(.body | test("^- . Mathlib") or startswith("Mathlib CI status")) | select(.user.login == "mathlib-lean-pr-testing[bot]"))')"
+                                    | jq 'first(.[] | select(.body | test("^- . Mathlib") or startswith("Mathlib CI status")) | select(.user.login == "leanprover-community-bot"))')"
             existing_comment_id="$(echo "$existing_comment" | jq -r .id)"
             existing_comment_body="$(echo "$existing_comment" | jq -r .body)"
 
@@ -252,14 +230,14 @@ jobs:
               echo "Posting message to the comments: $MESSAGE"
 
               # Append new result to the existing comment or post a new comment
-              # Use the mathlib-lean-pr-testing app token so Mathlib CI can subsequently edit the comment.
+              # It's essential we use the MATHLIB4_COMMENT_BOT token here, so that Mathlib CI can subsequently edit the comment.
               if [ -z "$existing_comment_id" ]; then
                 INTRO="Mathlib CI status ([docs](https://leanprover-community.github.io/contribute/tags_and_branches.html)):"
                 # Post new comment with a bullet point
                 echo "Posting as new comment at leanprover/lean4/issues/${{ steps.workflow-info.outputs.pullRequestNumber }}/comments"
                 curl -L -s \
                   -X POST \
-                  -H "Authorization: token ${{ steps.mathlib-comment-token.outputs.token }}" \
+                  -H "Authorization: token ${{ secrets.MATHLIB4_COMMENT_BOT }}" \
                   -H "Accept: application/vnd.github.v3+json" \
                   -d "$(jq --null-input --arg intro "$INTRO" --arg val "$MESSAGE" '{"body":($intro + "\n" + $val)}')" \
                   "https://api.github.com/repos/leanprover/lean4/issues/${{ steps.workflow-info.outputs.pullRequestNumber }}/comments"
@@ -268,7 +246,7 @@ jobs:
                 echo "Appending to existing comment at leanprover/lean4/issues/${{ steps.workflow-info.outputs.pullRequestNumber }}/comments"
                 curl -L -s \
                   -X PATCH \
-                  -H "Authorization: token ${{ steps.mathlib-comment-token.outputs.token }}" \
+                  -H "Authorization: token ${{ secrets.MATHLIB4_COMMENT_BOT }}" \
                   -H "Accept: application/vnd.github.v3+json" \
                   -d "$(jq --null-input --arg existing "$existing_comment_body" --arg message "$MESSAGE" '{"body":($existing + "\n" + $message)}')" \
                   "https://api.github.com/repos/leanprover/lean4/issues/comments/$existing_comment_id"
@@ -409,18 +387,6 @@ jobs:
       # We next automatically create a Batteries branch using this toolchain.
       # Batteries doesn't itself have a mechanism to report results of CI from this branch back to Lean
       # Instead this is taken care of by Mathlib CI, which will fail if Batteries fails.
-
-      # Generate a token from the mathlib-nightly-testing GitHub App for cross-org access
-      - name: Generate GitHub App token for leanprover-community repos
-        if: steps.workflow-info.outputs.pullRequestNumber != '' && steps.ready.outputs.mathlib_ready == 'true'
-        id: mathlib-app-token
-        uses: actions/create-github-app-token@3ff1caaa28b64c9cc276ce0a02e2ff584f3900c5 # v2.0.2
-        with:
-          app-id: ${{ secrets.MATHLIB_NIGHTLY_TESTING_APP_ID }}
-          private-key: ${{ secrets.MATHLIB_NIGHTLY_TESTING_PRIVATE_KEY }}
-          owner: leanprover-community
-          repositories: batteries,mathlib4-nightly-testing
-
       - name: Cleanup workspace
         if: steps.workflow-info.outputs.pullRequestNumber != '' && steps.ready.outputs.mathlib_ready == 'true'
         run: |
@@ -429,10 +395,10 @@ 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: ${{ steps.mathlib-app-token.outputs.token }}
+          token: ${{ secrets.MATHLIB4_BOT }}
           ref: nightly-testing
           fetch-depth: 0 # This ensures we check out all tags and branches.
           filter: tree:0
@@ -489,10 +455,10 @@ 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: ${{ steps.mathlib-app-token.outputs.token }}
+          token: ${{ secrets.MATHLIB4_BOT }}
           ref: nightly-testing
           fetch-depth: 0 # This ensures we check out all tags and branches.
           filter: tree:0
@@ -549,18 +515,6 @@ jobs:
         run: |
           git push origin lean-pr-testing-${{ steps.workflow-info.outputs.pullRequestNumber }}
 
-      - name: Add mathlib4-nightly-available label
-        if: steps.workflow-info.outputs.pullRequestNumber != '' && steps.ready.outputs.mathlib_ready == 'true'
-        uses: actions/github-script@v8
-        with:
-          script: |
-            await github.rest.issues.addLabels({
-              issue_number: ${{ steps.workflow-info.outputs.pullRequestNumber }},
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              labels: ['mathlib4-nightly-available']
-            })
-
       # We next automatically create a reference manual branch using this toolchain.
       # Reference manual CI will be responsible for reporting back success or failure
       # to the PR comments asynchronously (and thus transitively SubVerso/Verso).
@@ -572,7 +526,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"
@@ -58,7 +58,7 @@ jobs:
       shell: 'nix develop -c bash -euxo pipefail {0}'
     - name: Restore Cache
       if: env.should_update_stage0 == 'yes'
-      uses: actions/cache/restore@v5
+      uses: actions/cache/restore@v4
       with:
         # NOTE: must be in sync with `restore-cache` in `build-template.yml`
         path: |

CMakeLists.txt

@@ -10,22 +10,22 @@ option(USE_MIMALLOC "use mimalloc" ON)
 get_cmake_property(vars CACHE_VARIABLES)
 foreach(var ${vars})
   get_property(currentHelpString CACHE "${var}" PROPERTY HELPSTRING)
-  if(var MATCHES "STAGE0_(.*)")
+  if("${var}" MATCHES "STAGE0_(.*)")
     list(APPEND STAGE0_ARGS "-D${CMAKE_MATCH_1}=${${var}}")
-  elseif(var MATCHES "STAGE1_(.*)")
+  elseif("${var}" MATCHES "STAGE1_(.*)")
     list(APPEND STAGE1_ARGS "-D${CMAKE_MATCH_1}=${${var}}")
-  elseif(currentHelpString MATCHES "No help, variable specified on the command line." OR currentHelpString STREQUAL "")
+  elseif("${currentHelpString}" MATCHES "No help, variable specified on the command line." OR "${currentHelpString}" STREQUAL "")
     list(APPEND CL_ARGS "-D${var}=${${var}}")
-    if(var MATCHES "USE_GMP|CHECK_OLEAN_VERSION|LEAN_VERSION_.*|LEAN_SPECIAL_VERSION_DESC")
+    if("${var}" MATCHES "USE_GMP|CHECK_OLEAN_VERSION|LEAN_VERSION_.*|LEAN_SPECIAL_VERSION_DESC")
       # must forward options that generate incompatible .olean format
       list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
-    elseif(var MATCHES "LLVM*|PKG_CONFIG|USE_LAKE|USE_MIMALLOC")
+    elseif("${var}" MATCHES "LLVM*|PKG_CONFIG|USE_LAKE|USE_MIMALLOC")
       list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
     endif()
-  elseif(var MATCHES "USE_MIMALLOC")
+  elseif("${var}" MATCHES "USE_MIMALLOC")
     list(APPEND CL_ARGS "-D${var}=${${var}}")
     list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
-  elseif((var MATCHES "CMAKE_.*") AND NOT (var MATCHES "CMAKE_BUILD_TYPE") AND NOT (var MATCHES "CMAKE_HOME_DIRECTORY"))
+  elseif(("${var}" MATCHES "CMAKE_.*") AND NOT ("${var}" MATCHES "CMAKE_BUILD_TYPE") AND NOT ("${var}" MATCHES "CMAKE_HOME_DIRECTORY"))
     list(APPEND PLATFORM_ARGS "-D${var}=${${var}}")
   endif()
 endforeach()
@@ -34,19 +34,17 @@ include(ExternalProject)
 project(LEAN CXX C)
 
 if(NOT (DEFINED STAGE0_CMAKE_EXECUTABLE_SUFFIX))
-  set(STAGE0_CMAKE_EXECUTABLE_SUFFIX "${CMAKE_EXECUTABLE_SUFFIX}")
+    set(STAGE0_CMAKE_EXECUTABLE_SUFFIX "${CMAKE_EXECUTABLE_SUFFIX}")
 endif()
 
 # Don't do anything with cadical on wasm
-if(NOT CMAKE_SYSTEM_NAME MATCHES "Emscripten")
+if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
   find_program(CADICAL cadical)
   if(NOT CADICAL)
     set(CADICAL_CXX c++)
-    if(CADICAL_USE_CUSTOM_CXX)
+    if (CADICAL_USE_CUSTOM_CXX)
       set(CADICAL_CXX ${CMAKE_CXX_COMPILER})
-      # Use same platform flags as for Lean executables, in particular from `prepare-llvm-linux.sh`,
-      # but not Lean-specific `LEAN_EXTRA_CXX_FLAGS` such as fsanitize.
-      set(CADICAL_CXXFLAGS "${CMAKE_CXX_FLAGS}")
+      set(CADICAL_CXXFLAGS "${LEAN_EXTRA_CXX_FLAGS}")
       set(CADICAL_LDFLAGS "-Wl,-rpath=\\$$ORIGIN/../lib")
     endif()
     find_program(CCACHE ccache)
@@ -54,51 +52,42 @@ if(NOT CMAKE_SYSTEM_NAME MATCHES "Emscripten")
       set(CADICAL_CXX "${CCACHE} ${CADICAL_CXX}")
     endif()
     # missing stdio locking API on Windows
-    if(CMAKE_SYSTEM_NAME MATCHES "Windows")
+    if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
       string(APPEND CADICAL_CXXFLAGS " -DNUNLOCKED")
     endif()
     string(APPEND CADICAL_CXXFLAGS " -DNCLOSEFROM")
-    ExternalProject_Add(
-      cadical
+    ExternalProject_add(cadical
       PREFIX cadical
       GIT_REPOSITORY https://github.com/arminbiere/cadical
       GIT_TAG rel-2.1.2
       CONFIGURE_COMMAND ""
-      BUILD_COMMAND
-        $(MAKE) -f ${CMAKE_SOURCE_DIR}/src/cadical.mk CMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX}
-        CXX=${CADICAL_CXX} CXXFLAGS=${CADICAL_CXXFLAGS} LDFLAGS=${CADICAL_LDFLAGS}
+      BUILD_COMMAND $(MAKE) -f ${CMAKE_SOURCE_DIR}/src/cadical.mk
+        CMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX}
+        CXX=${CADICAL_CXX}
+        CXXFLAGS=${CADICAL_CXXFLAGS}
+        LDFLAGS=${CADICAL_LDFLAGS}
       BUILD_IN_SOURCE ON
-      INSTALL_COMMAND ""
-    )
-    set(
-      CADICAL
-      ${CMAKE_BINARY_DIR}/cadical/cadical${CMAKE_EXECUTABLE_SUFFIX}
-      CACHE FILEPATH
-      "path to cadical binary"
-      FORCE
-    )
+      INSTALL_COMMAND "")
+    set(CADICAL ${CMAKE_BINARY_DIR}/cadical/cadical${CMAKE_EXECUTABLE_SUFFIX} CACHE FILEPATH "path to cadical binary" FORCE)
     list(APPEND EXTRA_DEPENDS cadical)
   endif()
   list(APPEND CL_ARGS -DCADICAL=${CADICAL})
 endif()
 
-if(USE_MIMALLOC)
-  ExternalProject_Add(
-    mimalloc
+if (USE_MIMALLOC)
+  ExternalProject_add(mimalloc
     PREFIX mimalloc
     GIT_REPOSITORY https://github.com/microsoft/mimalloc
     GIT_TAG v2.2.3
     # just download, we compile it as part of each stage as it is small
     CONFIGURE_COMMAND ""
     BUILD_COMMAND ""
-    INSTALL_COMMAND ""
-  )
+    INSTALL_COMMAND "")
   list(APPEND EXTRA_DEPENDS mimalloc)
 endif()
 
-if(NOT STAGE1_PREV_STAGE)
-  ExternalProject_Add(
-    stage0
+if (NOT STAGE1_PREV_STAGE)
+  ExternalProject_add(stage0
     SOURCE_DIR "${LEAN_SOURCE_DIR}/stage0"
     SOURCE_SUBDIR src
     BINARY_DIR stage0
@@ -106,49 +95,38 @@ if(NOT STAGE1_PREV_STAGE)
     # (however, CI will override this as we need to embed the githash into the stage 1 library built
     # by stage 0)
     CMAKE_ARGS -DSTAGE=0 -DUSE_GITHASH=OFF ${PLATFORM_ARGS} ${STAGE0_ARGS}
-    BUILD_ALWAYS
-      ON # cmake doesn't auto-detect changes without a download method
-    INSTALL_COMMAND
-      "" # skip install
+    BUILD_ALWAYS ON  # cmake doesn't auto-detect changes without a download method
+    INSTALL_COMMAND ""  # skip install
     DEPENDS ${EXTRA_DEPENDS}
   )
   list(APPEND EXTRA_DEPENDS stage0)
 endif()
-ExternalProject_Add(
-  stage1
+ExternalProject_add(stage1
   SOURCE_DIR "${LEAN_SOURCE_DIR}"
   SOURCE_SUBDIR src
   BINARY_DIR stage1
-  CMAKE_ARGS
-    -DSTAGE=1 -DPREV_STAGE=${CMAKE_BINARY_DIR}/stage0
-    -DPREV_STAGE_CMAKE_EXECUTABLE_SUFFIX=${STAGE0_CMAKE_EXECUTABLE_SUFFIX} ${CL_ARGS} ${STAGE1_ARGS}
+  CMAKE_ARGS -DSTAGE=1 -DPREV_STAGE=${CMAKE_BINARY_DIR}/stage0 -DPREV_STAGE_CMAKE_EXECUTABLE_SUFFIX=${STAGE0_CMAKE_EXECUTABLE_SUFFIX} ${CL_ARGS} ${STAGE1_ARGS}
   BUILD_ALWAYS ON
   INSTALL_COMMAND ""
   DEPENDS ${EXTRA_DEPENDS}
   STEP_TARGETS configure
 )
-ExternalProject_Add(
-  stage2
+ExternalProject_add(stage2
   SOURCE_DIR "${LEAN_SOURCE_DIR}"
   SOURCE_SUBDIR src
   BINARY_DIR stage2
-  CMAKE_ARGS
-    -DSTAGE=2 -DPREV_STAGE=${CMAKE_BINARY_DIR}/stage1 -DPREV_STAGE_CMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX}
-    ${CL_ARGS}
+  CMAKE_ARGS -DSTAGE=2 -DPREV_STAGE=${CMAKE_BINARY_DIR}/stage1 -DPREV_STAGE_CMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX} ${CL_ARGS}
   BUILD_ALWAYS ON
   INSTALL_COMMAND ""
   DEPENDS stage1
   EXCLUDE_FROM_ALL ON
   STEP_TARGETS configure
 )
-ExternalProject_Add(
-  stage3
+ExternalProject_add(stage3
   SOURCE_DIR "${LEAN_SOURCE_DIR}"
   SOURCE_SUBDIR src
   BINARY_DIR stage3
-  CMAKE_ARGS
-    -DSTAGE=3 -DPREV_STAGE=${CMAKE_BINARY_DIR}/stage2 -DPREV_STAGE_CMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX}
-    ${CL_ARGS}
+  CMAKE_ARGS -DSTAGE=3 -DPREV_STAGE=${CMAKE_BINARY_DIR}/stage2 -DPREV_STAGE_CMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX} ${CL_ARGS}
   BUILD_ALWAYS ON
   INSTALL_COMMAND ""
   DEPENDS stage2
@@ -157,14 +135,24 @@ ExternalProject_Add(
 
 # targets forwarded to appropriate stages
 
-add_custom_target(update-stage0 COMMAND $(MAKE) -C stage1 update-stage0 DEPENDS stage1)
+add_custom_target(update-stage0
+  COMMAND $(MAKE) -C stage1 update-stage0
+  DEPENDS stage1)
 
-add_custom_target(update-stage0-commit COMMAND $(MAKE) -C stage1 update-stage0-commit DEPENDS stage1)
+add_custom_target(update-stage0-commit
+  COMMAND $(MAKE) -C stage1 update-stage0-commit
+  DEPENDS stage1)
 
-add_custom_target(test COMMAND $(MAKE) -C stage1 test DEPENDS stage1)
+add_custom_target(test
+  COMMAND $(MAKE) -C stage1 test
+  DEPENDS stage1)
 
-add_custom_target(clean-stdlib COMMAND $(MAKE) -C stage1 clean-stdlib DEPENDS stage1)
+add_custom_target(clean-stdlib
+  COMMAND $(MAKE) -C stage1 clean-stdlib
+  DEPENDS stage1)
 
 install(CODE "execute_process(COMMAND make -C stage1 install)")
 
-add_custom_target(check-stage3 COMMAND diff "stage2/bin/lean" "stage3/bin/lean" DEPENDS stage3)
+add_custom_target(check-stage3
+  COMMAND diff "stage2/bin/lean" "stage3/bin/lean"
+  DEPENDS stage3)

doc/dev/bootstrap.md

@@ -6,7 +6,7 @@ building Lean itself - which is needed to again build those parts. This cycle is
 broken by using pre-built C files checked into the repository (which ultimately
 go back to a point where the Lean compiler was not written in Lean) in place of
 these Lean inputs and then compiling everything in multiple stages up to a fixed
-point. The build directory is organized into these stages:
+point. The build directory is organized in these stages:
 
 ```bash
 stage0/
@@ -79,7 +79,7 @@ with the contents of `src/stdlib_flags.h`, bringing them back in sync.
 NOTE: A full rebuild of stage 1 will only be triggered when the *committed* contents of `stage0/` are changed.
 Thus if you change files in it manually instead of through `update-stage0-commit` (see below) or fetching updates from git, you either need to commit those changes first or run `make -C build/release clean-stdlib`.
 The same is true for further stages except that a rebuild of them is retriggered on any committed change, not just to a specific directory.
-Thus when debugging e.g. stage 2 failures, you can resume the build from these failures on but you may want to explicitly call `clean-stdlib` to either observe changes from `.olean` files of modules that built successfully or to check that you did not break modules that built successfully at some prior point.
+Thus when debugging e.g. stage 2 failures, you can resume the build from these failures on but may want to explicitly call `clean-stdlib` to either observe changes from `.olean` files of modules that built successfully or to check that you did not break modules that built successfully at some prior point.
 
 If you have write access to the lean4 repository, you can also manually
 trigger that process, for example to be able to use new features in the compiler itself.
@@ -101,7 +101,7 @@ The script `script/rebase-stage0.sh` can be used for that.
 
 The CI should prevent PRs with changes to stage0 (besides `stdlib_flags.h`)
 from entering `master` through the (squashing!) merge queue, and label such PRs
-with the `changes-stage0` label. Such PRs should have a cleaned-up history,
+with the `changes-stage0` label. Such PRs should have a cleaned up history,
 with separate stage0 update commits; then coordinate with the admins to merge
 your PR using rebase merge, bypassing the merge queue.
 

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/dev/release_checklist.md

@@ -30,7 +30,7 @@ We'll use `v4.6.0` as the intended release version as a running example.
     run `script/release_notes.py --since v4.5.0` on the `releases/v4.6.0` branch,
     and see the section "Writing the release notes" below for more information.
   - Release notes live in https://github.com/leanprover/reference-manual, in e.g. `Manual/Releases/v4.6.0.lean`.
-    It's best if you update these at the same time as you update the `lean-toolchain` for the `reference-manual` repository, see below.
+    It's best if you update these at the same time as a you update the `lean-toolchain` for the `reference-manual` repository, see below.
 - Go to https://github.com/leanprover/lean4/releases and verify that the `v4.6.0` release appears.
   - Verify on Github that "Set as the latest release" is checked.
 - Next, we will move a curated list of downstream repos to the latest stable release.
@@ -54,7 +54,7 @@ We'll use `v4.6.0` as the intended release version as a running example.
     - `verso`:
       - The `subverso` dependency is unusual in that it needs to be compatible with _every_ Lean release simultaneously.
         Usually you don't need to do anything.
-        If you think something is wrong here, please contact David Thrane Christiansen (@david-christiansen)
+        If you think something is wrong here please contact David Thrane Christiansen (@david-christiansen)
       - Warnings during `lake update` and `lake build` are expected.
     - `reference-manual`: the release notes generated by `script/release_notes.py` as described above must be included in
       `Manual/Releases/v4.6.0.lean`, and `import` and `include` statements adding in `Manual/Releases.lean`. 
@@ -69,10 +69,6 @@ We'll use `v4.6.0` as the intended release version as a running example.
     - `repl`:
       There are two copies of `lean-toolchain`/`lakefile.lean`:
       in the root, and in `test/Mathlib/`. Edit both, and run `lake update` in both directories.
-    - `lean-fro.org`:
-      After updating the toolchains and running `lake update`, you must run `scripts/update.sh` to regenerate
-      the site content. This script updates generated files that depend on the Lean version.
-      The `release_steps.py` script handles this automatically.
 - An awkward situation that sometimes occurs (e.g. with Verso) is that the `master`/`main` branch has already been moved
   to a nightly toolchain that comes *after* the stable toolchain we are
   targeting. In this case it is necessary to create a branch `releases/v4.6.0` from the last commit which was on
@@ -218,21 +214,6 @@ Please read https://leanprover-community.github.io/contribute/tags_and_branches.
 
 # Writing the release notes
 
-Release notes content is only written for the first release candidate (`-rc1`). For subsequent RCs and stable releases,
-just update the title in the existing release notes file (see "Release notes title format" below).
-
-## Release notes title format
-
-The title in the `#doc (Manual)` line must follow these formats:
-
-- **For -rc1**: `"Lean 4.7.0-rc1 (2024-03-15)"` — Include the RC suffix and the release date
-- **For -rc2, -rc3, etc.**: `"Lean 4.7.0-rc2 (2024-03-20)"` — Update the RC number and date
-- **For stable release**: `"Lean 4.7.0 (2024-04-01)"` — Remove the RC suffix but keep the date
-
-The date should be the actual date when the tag was pushed (or when CI completed and created the release page).
-
-## Generating the release notes
-
 Release notes are automatically generated from the commit history, using `script/release_notes.py`.
 
 Run this as `script/release_notes.py --since v4.6.0`, where `v4.6.0` is the *previous* release version.
@@ -247,113 +228,4 @@ Some judgement is required here: ignore commits which look minor,
 but manually add items to the release notes for significant PRs that were rebase-merged.
 
 There can also be pre-written entries in `./releases_drafts`, which should be all incorporated in the release notes and then deleted from the branch.
-
-## Reviewing and fixing the generated markdown
-
-Before adding the release notes to the reference manual, carefully review the generated markdown for these common issues:
-
-1. **Unterminated code blocks**: PR descriptions sometimes have unclosed code fences. Look for code blocks
-   that don't have a closing ` ``` `. If found, fetch the original PR description with `gh pr view <number>`
-   and repair the code block with the complete content.
-
-2. **Truncated descriptions**: Some PR descriptions may end abruptly mid-sentence. Review these and complete
-   the descriptions based on the original PR.
-
-3. **Markdown syntax issues**: Check for other markdown problems that could cause parsing errors.
-
-## Creating the release notes file
-
-The release notes go in `Manual/Releases/v4_7_0.lean` in the reference-manual repository.
-
-The file structure must follow the Verso format:
-
-```lean
-/-
-Copyright (c) 2025 Lean FRO LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Author: <Your Name>
--/
-
-import VersoManual
-import Manual.Meta
-import Manual.Meta.Markdown
-
-open Manual
-open Verso.Genre
-open Verso.Genre.Manual
-open Verso.Genre.Manual.InlineLean
-
-#doc (Manual) "Lean 4.7.0-rc1 (2024-03-15)" =>
-%%%
-tag := "release-v4.7.0"
-file := "v4.7.0"
-%%%
-
-<release notes content here>
-```
-
-**Important formatting rules for Verso:**
-- Use `#` for section headers inside the document, not `##` (Verso uses header level 1 for subsections)
-- Use plain ` ``` ` for code blocks, not ` ```lean ` (the latter will cause Lean to execute the code)
-- Identifiers with underscores like `bv_decide` should be wrapped in backticks: `` `bv_decide` ``
-  (otherwise the underscore may be interpreted as markdown emphasis)
-
-## Updating Manual/Releases.lean
-
-After creating the release notes file, update `Manual/Releases.lean` to include it:
-
-1. Add the import near the top with other version imports:
-   ```lean
-   import Manual.Releases.«v4_7_0»
-   ```
-
-2. Add the include statement after the other includes:
-   ```lean
-   {include 0 Manual.Releases.«v4_7_0»}
-   ```
-
-## Building and verifying
-
-Build the release notes to check for errors:
-```bash
-lake build Manual.Releases.v4_7_0
-```
-
-Common errors and fixes:
-- "Wrong header nesting - got ## but expected at most #": Change `##` to `#`
-- "Tactic 'X' failed" or similar: Code is being executed; change ` ```lean ` to ` ``` `
-- "'_'" errors: Underscore in identifier being parsed as emphasis; wrap in backticks
-
-## Creating the PR
-
-**Important: Timing with the reference-manual tag**
-
-The reference-manual repository deploys documentation when a version tag is pushed. If you merge
-release notes AFTER the tag is created, the deployed documentation won't include them.
-
-You have two options:
-
-1. **Preferred**: Include the release notes in the same PR as the toolchain bump (or merge the
-   release notes PR before creating the tag). This ensures the tag includes the release notes.
-
-2. **If release notes are merged after the tag**: You must regenerate the tag to trigger a new deployment:
-   ```bash
-   cd /path/to/reference-manual
-   git fetch origin
-   git tag -d v4.7.0-rc1  # Delete local tag
-   git tag v4.7.0-rc1 origin/main  # Create tag at current main (which has release notes)
-   git push origin :refs/tags/v4.7.0-rc1  # Delete remote tag
-   git push origin v4.7.0-rc1  # Push new tag (triggers Deploy workflow)
-   ```
-
-If creating a separate PR for release notes:
-```bash
-git checkout -b v4.7.0-release-notes
-git add Manual/Releases/v4_7_0.lean Manual/Releases.lean
-git commit -m "doc: add v4.7.0 release notes"
-git push -u origin v4.7.0-release-notes
-gh pr create --title "doc: add v4.7.0 release notes" --body "This PR adds the release notes for Lean v4.7.0."
-```
-
-See `./releases_drafts/README.md` for more information about pre-written release note entries.
 See `./releases_drafts/README.md` for more information.

doc/dev/testing.md

@@ -51,10 +51,6 @@ All these tests are included by [src/shell/CMakeLists.txt](https://github.com/le
   codes and do not check the expected output even though output is
   produced, it is ignored.
 
-  **Note:** Tests in this directory run with `-Dlinter.all=false` to reduce noise.
-  If your test needs to verify linter behavior (e.g., deprecation warnings),
-  explicitly enable the relevant linter with `set_option linter.<name> true`.
-
 - [`tests/lean/interactive`](https://github.com/leanprover/lean4/tree/master/tests/lean/interactive/): are designed to test server requests at a
   given position in the input file. Each .lean file contains comments
   that indicate how to simulate a client request at that position.

doc/examples/IJCAR2026/README.md

@@ -1,6 +0,0 @@
-# IJCAR 2026: `grind`, An SMT-Inspired Tactic for Lean 4
-
-Ancillary materials for the paper.
-
-- `examples.lean`: interactive examples from the paper
-- `analyze_grind_loc.py`: script used for the evaluation section, analyzing `grind` adoption and lines-of-code changes in Mathlib

doc/examples/IJCAR2026/analyze_grind_loc.py

@@ -1,401 +0,0 @@
-#!/usr/bin/env python3
-"""
-Analyze grind adoption LoC changes in mathlib.
-
-For each theorem/lemma in master that uses grind, find the most recent
-commit where it didn't use grind, and measure the LoC change.
-
-This script was used in preparing the "Evaluation" section of the grind paper.
-"""
-
-import subprocess
-import re
-import csv
-import sys
-from pathlib import Path
-from dataclasses import dataclass
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from typing import Iterator
-from functools import lru_cache
-
-
-@dataclass
-class GrindUsage:
-    file: str
-    line_no: int
-    decl_name: str
-    decl_type: str  # theorem, lemma, def, example, etc.
-
-
-@dataclass
-class LocChange:
-    file: str
-    decl_name: str
-    decl_type: str
-    old_loc: int
-    new_loc: int
-    loc_saved: int
-    commit_sha: str
-    commit_date: str
-
-
-def run_git(args: list[str], repo: str = ".") -> str:
-    """Run a git command and return stdout."""
-    result = subprocess.run(
-        ["git", "-C", repo] + args,
-        capture_output=True, text=True, check=True
-    )
-    return result.stdout
-
-
-def run_git_safe(args: list[str], repo: str = ".") -> str | None:
-    """Run a git command, return None on failure."""
-    result = subprocess.run(
-        ["git", "-C", repo] + args,
-        capture_output=True, text=True
-    )
-    if result.returncode != 0:
-        return None
-    return result.stdout
-
-
-@lru_cache(maxsize=4096)
-def get_file_at_commit(repo: str, commit: str, file_path: str) -> str | None:
-    """Get file contents at a specific commit (cached)."""
-    return run_git_safe(["show", f"{commit}:{file_path}"], repo)
-
-
-def find_grind_usages(repo: str = ".") -> tuple[list[GrindUsage], int, int]:
-    """Find all declarations using grind in current master.
-    Returns (usages, total_grind_calls, grind_in_decls) where:
-    - total_grind_calls is the count of grind tactic calls (after filtering comments/attrs)
-    - grind_in_decls is the count of those that are inside named declarations
-    """
-    # Use git grep to find lines containing 'grind' (excludes lake packages)
-    result = run_git(["grep", "-n", "grind", "master", "--", "Mathlib/"], repo)
-
-    usages = []
-    seen = set()  # (file, decl_name) to dedupe
-    total_grind_calls = 0
-    grind_in_decls = 0
-
-    for line in result.strip().split('\n'):
-        if not line:
-            continue
-        # Format: master:path/to/file.lean:123:line content
-        match = re.match(r'^master:(.+\.lean):(\d+):(.*)$', line)
-        if not match:
-            continue
-
-        file_path, line_no_str, content = match.groups()
-        line_no = int(line_no_str)
-
-        # Skip comments and attributes (not tactic calls)
-        content_stripped = content.strip()
-        if content_stripped.startswith('--') or content_stripped.startswith('/-'):
-            continue
-        if content_stripped.startswith('attribute'):
-            continue
-        if '@[' in content and 'grind' in content:
-            # Could be an attribute like @[grind =], skip
-            if 'by' not in content and ':=' not in content:
-                continue
-
-        total_grind_calls += 1
-
-        # Find the declaration this grind belongs to
-        decl_name, decl_type = find_decl_at_line(repo, file_path, line_no)
-        if decl_name is None:
-            continue
-
-        grind_in_decls += 1
-
-        key = (file_path, decl_name)
-        if key in seen:
-            continue
-        seen.add(key)
-
-        usages.append(GrindUsage(
-            file=file_path,
-            line_no=line_no,
-            decl_name=decl_name,
-            decl_type=decl_type
-        ))
-
-    return usages, total_grind_calls, grind_in_decls
-
-
-def find_decl_at_line(repo: str, file_path: str, grind_line: int) -> tuple[str | None, str | None]:
-    """
-    Find the declaration name and type that contains the grind at the given line.
-    Search backwards from grind_line to find the most recent declaration.
-    """
-    # Get file content at master
-    content = get_file_at_commit(repo, "master", file_path)
-    if content is None:
-        return None, None
-
-    lines = content.split('\n')
-
-    # Search backwards from grind_line for a declaration
-    # Match declarations with optional leading modifiers and attributes
-    decl_pattern = re.compile(r'^(?:@\[.*?\]\s*)*(?:private\s+|protected\s+|noncomputable\s+|scoped\s+)*(theorem|lemma|def|example|instance|abbrev|structure|class)\s+(\w+)')
-
-    for i in range(grind_line - 1, -1, -1):
-        if i >= len(lines):
-            continue
-        line = lines[i]
-        match = decl_pattern.match(line)
-        if match:
-            return match.group(2), match.group(1)
-
-    return None, None
-
-
-def find_grind_introduction_commit(repo: str, file_path: str, decl_name: str) -> str | None:
-    """
-    Find the commit that introduced grind to this declaration.
-    Returns None if the declaration was born with grind.
-    """
-    # First, find the line range of the declaration in master
-    content = get_file_at_commit(repo, "master", file_path)
-    if content is None:
-        return None
-
-    lines = content.split('\n')
-    decl_start = None
-    decl_end = None
-
-    # Find declaration start
-    decl_pattern = re.compile(rf'^(?:@\[.*?\]\s*)*(?:private\s+|protected\s+|noncomputable\s+|scoped\s+)*(theorem|lemma|def|example|instance|abbrev|structure|class)\s+{re.escape(decl_name)}\b')
-    for i, line in enumerate(lines):
-        if decl_pattern.match(line):
-            decl_start = i
-            break
-
-    if decl_start is None:
-        return None
-
-    # Find declaration end (next top-level declaration or EOF)
-    end_patterns = re.compile(r'^(?:private\s+|protected\s+|noncomputable\s+|scoped\s+)*(theorem|lemma|def|example|instance|abbrev|structure|class|namespace|section|end\s|@\[|#|/-)')
-    for i in range(decl_start + 1, len(lines)):
-        line = lines[i]
-        if line and not line[0].isspace() and end_patterns.match(line):
-            decl_end = i
-            break
-    if decl_end is None:
-        decl_end = len(lines)
-
-    # Find grind line within declaration
-    grind_line = None
-    for i in range(decl_start, decl_end):
-        if 'grind' in lines[i]:
-            grind_line = i + 1  # 1-indexed
-            break
-
-    if grind_line is None:
-        return None
-
-    # Use git blame to find when that grind line was added
-    blame_result = run_git_safe(["blame", "-L", f"{grind_line},{grind_line}", "--porcelain", "master", "--", file_path], repo)
-    if blame_result is None:
-        return None
-
-    # First line of porcelain output is the commit SHA
-    first_line = blame_result.split('\n')[0]
-    commit_sha = first_line.split()[0]
-
-    # Check if this declaration existed before this commit (without grind)
-    parent_sha = run_git_safe(["rev-parse", f"{commit_sha}^"], repo)
-    if parent_sha is None:
-        return None  # Initial commit, born with grind
-    parent_sha = parent_sha.strip()
-
-    # Check if declaration existed in parent
-    parent_content = get_file_at_commit(repo, parent_sha, file_path)
-    if parent_content is None:
-        # File didn't exist in parent - might be new file or renamed
-        return None
-
-    # Check if declaration existed and didn't have grind
-    if decl_name not in parent_content:
-        return None  # Declaration didn't exist - born with grind
-
-    # Check if it already had grind in parent
-    parent_lines = parent_content.split('\n')
-    in_decl = False
-    for line in parent_lines:
-        if decl_pattern.match(line):
-            in_decl = True
-        elif in_decl:
-            if line and not line[0].isspace() and end_patterns.match(line):
-                break
-            if 'grind' in line:
-                # Already had grind in parent — not the introduction commit
-                return None
-
-    return commit_sha
-
-
-def extract_proof_loc(repo: str, file_path: str, decl_name: str, commit: str) -> int | None:
-    """
-    Extract the number of lines in a declaration's proof at a given commit.
-    Returns None if the declaration doesn't exist at that commit.
-    """
-    content = get_file_at_commit(repo, commit, file_path)
-    if content is None:
-        return None
-
-    lines = content.split('\n')
-
-    # Find declaration start
-    decl_pattern = re.compile(rf'^(?:@\[.*?\]\s*)*(?:private\s+|protected\s+|noncomputable\s+|scoped\s+)*(theorem|lemma|def|example|instance|abbrev|structure|class)\s+{re.escape(decl_name)}\b')
-    decl_start = None
-    for i, line in enumerate(lines):
-        if decl_pattern.match(line):
-            decl_start = i
-            break
-
-    if decl_start is None:
-        return None
-
-    # Find declaration end
-    end_patterns = re.compile(r'^(?:private\s+|protected\s+|noncomputable\s+|scoped\s+)*(theorem|lemma|def|example|instance|abbrev|structure|class|namespace|section|end\s|@\[|#|/-)')
-    decl_end = None
-    for i in range(decl_start + 1, len(lines)):
-        line = lines[i]
-        if line and not line[0].isspace() and end_patterns.match(line):
-            decl_end = i
-            break
-    if decl_end is None:
-        decl_end = len(lines)
-
-    # Count non-empty lines in declaration
-    loc = sum(1 for i in range(decl_start, decl_end) if lines[i].strip())
-    return loc
-
-
-def get_commit_date(repo: str, sha: str) -> str:
-    """Get the date of a commit."""
-    result = run_git(["log", "-1", "--format=%ci", sha], repo)
-    return result.strip().split()[0]  # Just the date part
-
-
-def analyze_usage_detailed(repo: str, usage: GrindUsage) -> tuple[LocChange | None, str]:
-    """Analyze a single grind usage, returning (result, skip_reason)."""
-    commit = find_grind_introduction_commit(repo, usage.file, usage.decl_name)
-    if commit is None:
-        return None, "born_with_grind"
-
-    parent = run_git_safe(["rev-parse", f"{commit}^"], repo)
-    if parent is None:
-        return None, "no_parent"
-    parent = parent.strip()
-
-    old_loc = extract_proof_loc(repo, usage.file, usage.decl_name, parent)
-    new_loc = extract_proof_loc(repo, usage.file, usage.decl_name, "master")
-
-    if old_loc is None:
-        return None, "old_loc_failed"
-    if new_loc is None:
-        return None, "new_loc_failed"
-
-    commit_date = get_commit_date(repo, commit)
-
-    return LocChange(
-        file=usage.file,
-        decl_name=usage.decl_name,
-        decl_type=usage.decl_type,
-        old_loc=old_loc,
-        new_loc=new_loc,
-        loc_saved=old_loc - new_loc,
-        commit_sha=commit[:12],
-        commit_date=commit_date
-    ), "success"
-
-
-def main(repo: str = "."):
-    print("Finding grind usages in master...", file=sys.stderr)
-    usages, total_grind_calls, grind_in_decls = find_grind_usages(repo)
-    print(f"Found {len(usages)} declarations using grind ({grind_in_decls}/{total_grind_calls} grind calls)", file=sys.stderr)
-
-    print("Analyzing git history (this may take a while)...", file=sys.stderr)
-    results: list[LocChange] = []
-    skip_reasons: dict[str, int] = {}
-
-    with ThreadPoolExecutor(max_workers=64) as executor:
-        futures = {executor.submit(analyze_usage_detailed, repo, usage): usage for usage in usages}
-
-        for i, future in enumerate(as_completed(futures)):
-            if (i + 1) % 50 == 0:
-                print(f"  Progress: {i + 1}/{len(usages)}", file=sys.stderr, flush=True)
-
-            result, reason = future.result()
-            if result:
-                results.append(result)
-            else:
-                skip_reasons[reason] = skip_reasons.get(reason, 0) + 1
-
-    total_skipped = sum(skip_reasons.values())
-    print(f"\nAnalyzed {len(results)} declarations, skipped {total_skipped}:", file=sys.stderr)
-    for reason, count in sorted(skip_reasons.items(), key=lambda x: -x[1]):
-        print(f"  - {reason}: {count}", file=sys.stderr)
-
-    # Sort by LoC saved (descending)
-    results.sort(key=lambda r: r.loc_saved, reverse=True)
-
-    # Output CSV
-    writer = csv.writer(sys.stdout)
-    writer.writerow(["file", "declaration", "type", "old_loc", "new_loc", "loc_saved", "commit", "date"])
-    for r in results:
-        writer.writerow([r.file, r.decl_name, r.decl_type, r.old_loc, r.new_loc, r.loc_saved, r.commit_sha, r.commit_date])
-
-    # Summary stats to stderr
-    total_old = sum(r.old_loc for r in results) if results else 0
-    total_new = sum(r.new_loc for r in results) if results else 0
-    total_saved = sum(r.loc_saved for r in results) if results else 0
-    avg_saved = total_saved / len(results) if results else 0
-
-    print("\n" + "=" * 60, file=sys.stderr)
-    print("GRIND ADOPTION LOC ANALYSIS", file=sys.stderr)
-    print("=" * 60, file=sys.stderr)
-
-    print("\n## Declaration Counts\n", file=sys.stderr)
-    print(f"  Total grind tactic calls:         {total_grind_calls}", file=sys.stderr)
-    print(f"  In named declarations:            {grind_in_decls} ({total_grind_calls - grind_in_decls} in anonymous/other)", file=sys.stderr)
-    print(f"  Unique declarations:              {len(usages)}", file=sys.stderr)
-    print(f"  Converted to grind:               {len(results)}", file=sys.stderr)
-    print(f"  Born with grind:                  {skip_reasons.get('born_with_grind', 0)}", file=sys.stderr)
-    if skip_reasons.get('old_loc_failed', 0) > 0:
-        print(f"  Could not trace history:          {skip_reasons.get('old_loc_failed', 0)}", file=sys.stderr)
-
-    print("\n## Lines of Code Impact\n", file=sys.stderr)
-    print(f"  Total LoC before grind:           {total_old}", file=sys.stderr)
-    print(f"  Total LoC after grind:            {total_new}", file=sys.stderr)
-    print(f"  Total LoC saved:                  {total_saved}", file=sys.stderr)
-    print(f"  Average LoC saved per theorem:    {avg_saved:.1f}", file=sys.stderr)
-    big_savings = sum(1 for r in results if r.loc_saved >= 10)
-    print(f"  Declarations shrunk by 10+ lines: {big_savings}", file=sys.stderr)
-
-    if results:
-        print("\n## Top 10 Biggest LoC Savings\n", file=sys.stderr)
-        for r in results[:10]:
-            print(f"  {r.loc_saved:+4d} lines: {r.decl_name} ({r.file})", file=sys.stderr)
-
-        # Show any that got bigger (negative savings)
-        got_bigger = [r for r in results if r.loc_saved < 0]
-        if got_bigger:
-            print(f"\n## Declarations That Got Bigger ({len(got_bigger)} total)\n", file=sys.stderr)
-            print("  (showing 5 worst):", file=sys.stderr)
-            for r in got_bigger[-5:]:  # Show worst 5
-                print(f"  {r.loc_saved:+4d} lines: {r.decl_name} ({r.file})", file=sys.stderr)
-
-    print("\n" + "=" * 60, file=sys.stderr)
-
-
-if __name__ == "__main__":
-    import argparse
-    parser = argparse.ArgumentParser(description="Analyze grind LoC savings")
-    parser.add_argument("--repo", "-r", default=".", help="Repository path")
-    args = parser.parse_args()
-    main(args.repo)

doc/examples/IJCAR2026/examples.lean

@@ -1,127 +0,0 @@
-/- Examples from the paper "grind: An SMT-Inspired Tactic for Lean 4" -/
-open Lean Grind
-
-/- Congruence closure. -/
-
-example (f : Nat → Nat) (h : a = b) : f (f b) = f (f a) := by grind
-
-/-
-E-matching.
-
-Any `f` that is the left inverse of `g` would work on this example.
--/
-def f (x : Nat) := x - 1
-def g (x : Nat) := x + 1
-
-@[grind =] theorem fg : f (g x) = x := by simp [f, g]
-example : f a = b → a = g c → b = c := by grind
-
-/-
-Any `R` that is transitive and symmetric would work on this example.
--/
-def R : Nat → Nat → Prop := (· % 7 = · % 7)
-@[grind →] theorem Rtrans : R x y → R y z → R x z := by grind [R]
-@[grind →] theorem Rsymm  : R x y → R y x := by grind [R]
-example : R a b → R c b → R d c → R a d := by grind
-
-/- Big step operational semantics example. -/
-
-abbrev Variable := String
-def State := Variable → Nat
-inductive Stmt : Type where
-  | skip : Stmt
-  | assign : Variable → (State → Nat) → Stmt
-  | seq : Stmt → Stmt → Stmt
-  | ifThenElse : (State → Prop) → Stmt → Stmt → Stmt
-  | whileDo : (State → Prop) → Stmt → Stmt
-infix:60 ";; " => Stmt.seq
-export Stmt (skip assign seq ifThenElse whileDo)
-set_option quotPrecheck false in
-notation s:70 "[" x:70 "↦" n:70 "]" => (fun v ↦ if v = x then n else s v)
-inductive BigStep : Stmt → State → State → Prop where
-  | skip (s : State) : BigStep skip s s
-  | assign (x : Variable) (a : State → Nat) (s : State) : BigStep (assign x a) s (s[x ↦ a s])
-  | seq {S T : Stmt} {s t u : State} (hS : BigStep S s t) (hT : BigStep T t u) :
-    BigStep (S;; T) s u
-  | if_true {B : State → Prop} {s t : State} (hcond : B s) (S T : Stmt) (hbody : BigStep S s t) :
-    BigStep (ifThenElse B S T) s t
-  | if_false {B : State → Prop} {s t : State} (hcond : ¬ B s) (S T : Stmt) (hbody : BigStep T s t) :
-    BigStep (ifThenElse B S T) s t
-  | while_true {B S s t u} (hcond : B s) (hbody : BigStep S s t) (hrest : BigStep (whileDo B S) t u) :
-    BigStep (whileDo B S) s u
-  | while_false {B S s} (hcond : ¬ B s) : BigStep (whileDo B S) s s
-notation:55 "(" S:55 "," s:55 ")" " ==> " t:55 => BigStep S s t
-
-example {B S T s t} (hcond : B s) : (ifThenElse B S T, s) ==> t → (S, s) ==> t := by
-  grind [cases BigStep]
-
-theorem cases_if_of_true {B S T s t} (hcond : B s) : (ifThenElse B S T, s) ==> t → (S, s) ==> t := by
-  grind [cases BigStep]
-
-theorem cases_if_of_false {B S T s t} (hcond : ¬ B s) : (ifThenElse B S T, s) ==> t → (T, s) ==> t := by
-  grind [cases BigStep]
-
-example {B S T s t} : (ifThenElse B S T, s) ==> t ↔ (B s ∧ (S, s) ==> t) ∨ (¬ B s ∧ (T, s) ==> t) := by
-  grind [BigStep] -- shortcut for `cases BigStep` and `intro BigStep`
-
-attribute [grind] BigStep
-theorem if_iff {B S T s t} : (ifThenElse B S T, s) ==>
-    t ↔ (B s ∧ (S, s) ==> t) ∨ (¬ B s ∧ (T, s) ==> t) := by grind
-
-/- Dependent pattern matching. -/
-
-inductive Vec (α : Type u) : Nat → Type u
-  | nil : Vec α 0
-  | cons : α → Vec α n → Vec α (n+1)
-@[grind =] def Vec.head : Vec α (n+1) → α
-  | .cons a _ => a
-example (as bs : Vec Int (n+1)) : as.head = bs.head
-    → (match as, bs with
-       | .cons a _, .cons b _ => a + b) = 2 * as.head := by grind
-
-/- Theory solvers. -/
-
-example [CommRing α] (a b c : α) :
-    a + b + c = 3 →
-    a^2 + b^2 + c^2 = 5 →
-    a^3 + b^3 + c^3 = 7 →
-    a^4 + b^4 + c^4 = 9 := by grind
-
-example (x : BitVec 8) : (x - 16) * (x + 16) = x^2 := by grind
-
-example [CommSemiring α] [AddRightCancel α] (x y : α) :
-    x^2*y = 1 → x*y^2 = y → y*x = 1 := by grind
-
-example (a b : UInt32) : a ≤ 2 → b ≤ 3 → a + b ≤ 5 := by grind
-
-example [LE α] [Std.IsLinearPreorder α] (a b c d : α) :
-    a ≤ b → ¬ (c ≤ b) → ¬ (d ≤ c) → a ≤ d := by grind
-
-/- Theory combination. -/
-
-example [CommRing α] [NoNatZeroDivisors α]
-    (a b c : α) (f : α → Nat) :
-    a + b + c = 3 → a^2 + b^2 + c^2 = 5 → a^3 + b^3 + c^3 = 7 →
-    f (a^4 + b^4) + f (9 - c^4) ≠ 1 := by grind
-
-/- Interactive mode. -/
-
--- Remark: Mathlib contains the definition of `Real`, `sin`, and `cos`.
-axiom Real : Type
-instance : Lean.Grind.CommRing Real := sorry
-
-axiom cos : Real → Real
-axiom sin : Real → Real
-axiom trig_identity : ∀ x, (cos x)^2 + (sin x)^2 = 1
-
--- Manually specify the patterns for `trig_identity`
-grind_pattern trig_identity => cos x
-grind_pattern trig_identity => sin x
-
-example : (cos x + sin x)^2 = 2 * cos x * sin x + 1 := by
-  grind? -- Provides code action
-
-example : (cos x + sin x)^2 = 2 * cos x * sin x + 1 := by
-  grind =>
-    instantiate only [trig_identity]
-    ring

doc/std/grove/GroveStdlib/Generated.lean

@@ -4,7 +4,6 @@ import GroveStdlib.Generated.«associative-creation-operations»
 import GroveStdlib.Generated.«associative-modification-operations»
 import GroveStdlib.Generated.«associative-create-then-query»
 import GroveStdlib.Generated.«associative-all-operations-covered»
-import GroveStdlib.Generated.«slice-producing»
 
 /-
 This file is autogenerated by grove. You can manually edit it, for example to resolve merge
@@ -21,4 +20,3 @@ def restoreState : RestoreStateM Unit := do
   «associative-modification-operations».restoreState
   «associative-create-then-query».restoreState
   «associative-all-operations-covered».restoreState
-  «slice-producing».restoreState

doc/std/grove/GroveStdlib/Generated/slice-producing.lean

@@ -1,459 +0,0 @@
-import Grove.Framework
-
-/-
-This file is autogenerated by grove. You can manually edit it, for example to resolve merge
-conflicts, but be careful.
--/
-
-open Grove.Framework Widget
-
-namespace GroveStdlib.Generated.«slice-producing»
-
-def «c8a13d6d-7ed6-4cd1-a386-23e2d55ce6f7» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "c8a13d6d-7ed6-4cd1-a386-23e2d55ce6f7"
-  rowId := "c8a13d6d-7ed6-4cd1-a386-23e2d55ce6f7"
-  rowState := #[⟨"String", "String.slice", Declaration.def {
-    name := `String.slice
-    renderedStatement := "String.slice (s : String) (startInclusive endExclusive : s.Pos)\n  (h : startInclusive ≤ endExclusive) : String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.slice", Declaration.def {
-    name := `String.Slice.slice
-    renderedStatement := "String.Slice.slice (s : String.Slice) (newStart newEnd : s.Pos) (h : newStart ≤ newEnd) :\n  String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"string-pos-forwards", "String.Pos.slice", Declaration.def {
-    name := `String.Pos.slice
-    renderedStatement := "String.Pos.slice {s : String} (pos p₀ p₁ : s.Pos) (h₁ : p₀ ≤ pos) (h₂ : pos ≤ p₁) :\n  (s.slice p₀ p₁ ⋯).Pos"
-    isDeprecated := false
-  }
-⟩,⟨"string-pos-backwards", "String.Pos.ofSlice", Declaration.def {
-    name := `String.Pos.ofSlice
-    renderedStatement := "String.Pos.ofSlice {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} (pos : (s.slice p₀ p₁ h).Pos) : s.Pos"
-    isDeprecated := false
-  }
-⟩,⟨"string-slice-pos-forwards", "String.Slice.Pos.slice", Declaration.def {
-    name := `String.Slice.Pos.slice
-    renderedStatement := "String.Slice.Pos.slice {s : String.Slice} (pos p₀ p₁ : s.Pos) (h₁ : p₀ ≤ pos) (h₂ : pos ≤ p₁) :\n  (s.slice p₀ p₁ ⋯).Pos"
-    isDeprecated := false
-  }
-⟩,⟨"string-slice-pos-backwards", "String.Slice.Pos.ofSlice", Declaration.def {
-    name := `String.Slice.Pos.ofSlice
-    renderedStatement := "String.Slice.Pos.ofSlice {s : String.Slice} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁}\n  (pos : (s.slice p₀ p₁ h).Pos) : s.Pos"
-    isDeprecated := false
-  }
-⟩,⟨"string-pos-noproof", "String.Pos.sliceOrPanic", Declaration.def {
-    name := `String.Pos.sliceOrPanic
-    renderedStatement := "String.Pos.sliceOrPanic {s : String} (pos p₀ p₁ : s.Pos) {h : p₀ ≤ p₁} : (s.slice p₀ p₁ h).Pos"
-    isDeprecated := false
-  }
-⟩,⟨"string-slice-pos-noproof", "String.Slice.Pos.sliceOrPanic", Declaration.def {
-    name := `String.Slice.Pos.sliceOrPanic
-    renderedStatement := "String.Slice.Pos.sliceOrPanic {s : String.Slice} (pos p₀ p₁ : s.Pos) {h : p₀ ≤ p₁} :\n  (s.slice p₀ p₁ h).Pos"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .done
-    comment := ""
-  }
-def «21b4fdfd-f8b3-44f5-a59e-57f1dc1d6819» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "21b4fdfd-f8b3-44f5-a59e-57f1dc1d6819"
-  rowId := "21b4fdfd-f8b3-44f5-a59e-57f1dc1d6819"
-  rowState := #[⟨"String", "String.slice?", Declaration.def {
-    name := `String.slice?
-    renderedStatement := "String.slice? (s : String) (startInclusive endExclusive : s.Pos) : Option String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.slice?", Declaration.def {
-    name := `String.Slice.slice?
-    renderedStatement := "String.Slice.slice? (s : String.Slice) (newStart newEnd : s.Pos) : Option String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .postponed
-    comment := "Would be good to have better support"
-  }
-def «6f2b6ecb-2f0c-4e45-9da3-eb7f2e15eff0» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "6f2b6ecb-2f0c-4e45-9da3-eb7f2e15eff0"
-  rowId := "6f2b6ecb-2f0c-4e45-9da3-eb7f2e15eff0"
-  rowState := #[⟨"String", "String.slice!", Declaration.def {
-    name := `String.slice!
-    renderedStatement := "String.slice! (s : String) (p₁ p₂ : s.Pos) : String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.slice!", Declaration.def {
-    name := `String.Slice.slice!
-    renderedStatement := "String.Slice.slice! (s : String.Slice) (newStart newEnd : s.Pos) : String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"string-pos-forwards", "String.Pos.slice!", Declaration.def {
-    name := `String.Pos.slice!
-    renderedStatement := "String.Pos.slice! {s : String} (pos p₀ p₁ : s.Pos) : (s.slice! p₀ p₁).Pos"
-    isDeprecated := false
-  }
-⟩,⟨"string-pos-backwards", "String.Pos.ofSlice!", Declaration.def {
-    name := `String.Pos.ofSlice!
-    renderedStatement := "String.Pos.ofSlice! {s : String} {p₀ p₁ : s.Pos} (pos : (s.slice! p₀ p₁).Pos) : s.Pos"
-    isDeprecated := false
-  }
-⟩,⟨"string-slice-pos-forwards", "String.Slice.Pos.slice!", Declaration.def {
-    name := `String.Slice.Pos.slice!
-    renderedStatement := "String.Slice.Pos.slice! {s : String.Slice} (pos p₀ p₁ : s.Pos) : (s.slice! p₀ p₁).Pos"
-    isDeprecated := false
-  }
-⟩,⟨"string-slice-pos-backwards", "String.Slice.Pos.ofSlice!", Declaration.def {
-    name := `String.Slice.Pos.ofSlice!
-    renderedStatement := "String.Slice.Pos.ofSlice! {s : String.Slice} {p₀ p₁ : s.Pos} (pos : (s.slice! p₀ p₁).Pos) : s.Pos"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .done
-    comment := ""
-  }
-def «a3bdf66d-bc11-4019-aee9-2f1c1701de52» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "a3bdf66d-bc11-4019-aee9-2f1c1701de52"
-  rowId := "a3bdf66d-bc11-4019-aee9-2f1c1701de52"
-  rowState := #[⟨"String", "String.trimAsciiStart", Declaration.def {
-    name := `String.trimAsciiStart
-    renderedStatement := "String.trimAsciiStart (s : String) : String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.trimAsciiStart", Declaration.def {
-    name := `String.Slice.trimAsciiStart
-    renderedStatement := "String.Slice.trimAsciiStart (s : String.Slice) : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing `of` version at least"
-  }
-def «f12b2730-7a4d-465c-8a6d-9d051c300fd5» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "f12b2730-7a4d-465c-8a6d-9d051c300fd5"
-  rowId := "f12b2730-7a4d-465c-8a6d-9d051c300fd5"
-  rowState := #[⟨"String", "String.trimAsciiEnd", Declaration.def {
-    name := `String.trimAsciiEnd
-    renderedStatement := "String.trimAsciiEnd (s : String) : String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.trimAsciiEnd", Declaration.def {
-    name := `String.Slice.trimAsciiEnd
-    renderedStatement := "String.Slice.trimAsciiEnd (s : String.Slice) : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing `of` version at least"
-  }
-def «32307b55-d6d1-4756-a947-dbe4dfde573c» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "32307b55-d6d1-4756-a947-dbe4dfde573c"
-  rowId := "32307b55-d6d1-4756-a947-dbe4dfde573c"
-  rowState := #[⟨"String", "String.trimAscii", Declaration.def {
-    name := `String.trimAscii
-    renderedStatement := "String.trimAscii (s : String) : String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.trimAscii", Declaration.def {
-    name := `String.Slice.trimAscii
-    renderedStatement := "String.Slice.trimAscii (s : String.Slice) : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing `of` version at least\n"
-  }
-def «dce95a38-f55a-4d6a-ae79-078ffe4b5c15» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "dce95a38-f55a-4d6a-ae79-078ffe4b5c15"
-  rowId := "dce95a38-f55a-4d6a-ae79-078ffe4b5c15"
-  rowState := #[⟨"String", "String.toSlice", Declaration.def {
-    name := `String.toSlice
-    renderedStatement := "String.toSlice (s : String) : String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"string-pos-forwards", "String.Pos.toSlice", Declaration.def {
-    name := `String.Pos.toSlice
-    renderedStatement := "String.Pos.toSlice {s : String} (pos : s.Pos) : s.toSlice.Pos"
-    isDeprecated := false
-  }
-⟩,⟨"string-pos-backwards", "String.Pos.ofToSlice", Declaration.def {
-    name := `String.Pos.ofToSlice
-    renderedStatement := "String.Pos.ofToSlice {s : String} (pos : s.toSlice.Pos) : s.Pos"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .done
-    comment := ""
-  }
-def «005a3f30-5dab-493f-b168-32c36a2bdf7c» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "005a3f30-5dab-493f-b168-32c36a2bdf7c"
-  rowId := "005a3f30-5dab-493f-b168-32c36a2bdf7c"
-  rowState := #[⟨"String.Slice", "String.Slice.str", Declaration.def {
-    name := `String.Slice.str
-    renderedStatement := "String.Slice.str (self : String.Slice) : String"
-    isDeprecated := false
-  }
-⟩,⟨"string-slice-pos-forwards", "String.Slice.Pos.str", Declaration.def {
-    name := `String.Slice.Pos.str
-    renderedStatement := "String.Slice.Pos.str {s : String.Slice} (pos : s.Pos) : s.str.Pos"
-    isDeprecated := false
-  }
-⟩,⟨"string-slice-pos-backwards", "String.Slice.Pos.ofStr", Declaration.def {
-    name := `String.Slice.Pos.ofStr
-    renderedStatement := "String.Slice.Pos.ofStr {s : String.Slice} (pos : s.str.Pos) (h₁ : s.startInclusive ≤ pos)\n  (h₂ : pos ≤ s.endExclusive) : s.Pos"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing `no proof` version\n"
-  }
-def «5f1a154c-ae2f-43a1-9409-2ce95b163ef3» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "5f1a154c-ae2f-43a1-9409-2ce95b163ef3"
-  rowId := "5f1a154c-ae2f-43a1-9409-2ce95b163ef3"
-  rowState := #[⟨"String", "String.drop", Declaration.def {
-    name := `String.drop
-    renderedStatement := "String.drop (s : String) (n : Nat) : String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.drop", Declaration.def {
-    name := `String.Slice.drop
-    renderedStatement := "String.Slice.drop (s : String.Slice) (n : Nat) : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing position transformations"
-  }
-def «179518d1-ad07-4b2b-8ffe-3b7616e4c4ab» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "179518d1-ad07-4b2b-8ffe-3b7616e4c4ab"
-  rowId := "179518d1-ad07-4b2b-8ffe-3b7616e4c4ab"
-  rowState := #[⟨"String", "String.take", Declaration.def {
-    name := `String.take
-    renderedStatement := "String.take (s : String) (n : Nat) : String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.take", Declaration.def {
-    name := `String.Slice.take
-    renderedStatement := "String.Slice.take (s : String.Slice) (n : Nat) : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing position transformations"
-  }
-def «55c587fd-a7a8-4633-a4ae-e2c4e768ad28» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "55c587fd-a7a8-4633-a4ae-e2c4e768ad28"
-  rowId := "55c587fd-a7a8-4633-a4ae-e2c4e768ad28"
-  rowState := #[⟨"String", "String.dropWhile", Declaration.def {
-    name := `String.dropWhile
-    renderedStatement := "String.dropWhile {ρ : Type} (s : String) (pat : ρ) [String.Slice.Pattern.ForwardPattern pat] :\n  String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.dropWhile", Declaration.def {
-    name := `String.Slice.dropWhile
-    renderedStatement := "String.Slice.dropWhile {ρ : Type} (s : String.Slice) (pat : ρ)\n  [String.Slice.Pattern.ForwardPattern pat] : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing position transformations"
-  }
-def «d4444684-4279-4400-9be2-561a7cdb32c1» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "d4444684-4279-4400-9be2-561a7cdb32c1"
-  rowId := "d4444684-4279-4400-9be2-561a7cdb32c1"
-  rowState := #[⟨"String", "String.takeWhile", Declaration.def {
-    name := `String.takeWhile
-    renderedStatement := "String.takeWhile {ρ : Type} (s : String) (pat : ρ) [String.Slice.Pattern.ForwardPattern pat] :\n  String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.takeWhile", Declaration.def {
-    name := `String.Slice.takeWhile
-    renderedStatement := "String.Slice.takeWhile {ρ : Type} (s : String.Slice) (pat : ρ)\n  [String.Slice.Pattern.ForwardPattern pat] : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing position transformations"
-  }
-def «1c9e6689-65a0-4d4b-b001-256e83917d98» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "1c9e6689-65a0-4d4b-b001-256e83917d98"
-  rowId := "1c9e6689-65a0-4d4b-b001-256e83917d98"
-  rowState := #[⟨"String", "String.dropEndWhile", Declaration.def {
-    name := `String.dropEndWhile
-    renderedStatement := "String.dropEndWhile {ρ : Type} (s : String) (pat : ρ) [String.Slice.Pattern.BackwardPattern pat] :\n  String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.dropEndWhile", Declaration.def {
-    name := `String.Slice.dropEndWhile
-    renderedStatement := "String.Slice.dropEndWhile {ρ : Type} (s : String.Slice) (pat : ρ)\n  [String.Slice.Pattern.BackwardPattern pat] : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing position transformations"
-  }
-def «b836052b-3470-4a8e-8989-6951c898de37» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "b836052b-3470-4a8e-8989-6951c898de37"
-  rowId := "b836052b-3470-4a8e-8989-6951c898de37"
-  rowState := #[⟨"String", "String.takeEndWhile", Declaration.def {
-    name := `String.takeEndWhile
-    renderedStatement := "String.takeEndWhile {ρ : Type} (s : String) (pat : ρ) [String.Slice.Pattern.BackwardPattern pat] :\n  String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.takeEndWhile", Declaration.def {
-    name := `String.Slice.takeEndWhile
-    renderedStatement := "String.Slice.takeEndWhile {ρ : Type} (s : String.Slice) (pat : ρ)\n  [String.Slice.Pattern.BackwardPattern pat] : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing position transformations"
-  }
-def «5aa777d8-9642-43d8-9e20-30400fb8bb9d» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "5aa777d8-9642-43d8-9e20-30400fb8bb9d"
-  rowId := "5aa777d8-9642-43d8-9e20-30400fb8bb9d"
-  rowState := #[⟨"String", "String.dropPrefix", Declaration.def {
-    name := `String.dropPrefix
-    renderedStatement := "String.dropPrefix {ρ : Type} (s : String) (pat : ρ) [String.Slice.Pattern.ForwardPattern pat] :\n  String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.dropPrefix", Declaration.def {
-    name := `String.Slice.dropPrefix
-    renderedStatement := "String.Slice.dropPrefix {ρ : Type} (s : String.Slice) (pat : ρ)\n  [String.Slice.Pattern.ForwardPattern pat] : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing position transformations"
-  }
-def «80e3869d-fcfe-459d-8433-fe221f7b3c7a» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "80e3869d-fcfe-459d-8433-fe221f7b3c7a"
-  rowId := "80e3869d-fcfe-459d-8433-fe221f7b3c7a"
-  rowState := #[⟨"String", "String.dropSuffix", Declaration.def {
-    name := `String.dropSuffix
-    renderedStatement := "String.dropSuffix {ρ : Type} (s : String) (pat : ρ) [String.Slice.Pattern.BackwardPattern pat] :\n  String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.dropSuffix", Declaration.def {
-    name := `String.Slice.dropSuffix
-    renderedStatement := "String.Slice.dropSuffix {ρ : Type} (s : String.Slice) (pat : ρ)\n  [String.Slice.Pattern.BackwardPattern pat] : String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .bad
-    comment := "Missing position transformations"
-  }
-def «4feda3e0-903b-4d52-b34e-0af70f7866e0» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "4feda3e0-903b-4d52-b34e-0af70f7866e0"
-  rowId := "4feda3e0-903b-4d52-b34e-0af70f7866e0"
-  rowState := #[⟨"String", "String.dropPrefix?", Declaration.def {
-    name := `String.dropPrefix?
-    renderedStatement := "String.dropPrefix? {ρ : Type} (s : String) (pat : ρ) [String.Slice.Pattern.ForwardPattern pat] :\n  Option String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.dropPrefix?", Declaration.def {
-    name := `String.Slice.dropPrefix?
-    renderedStatement := "String.Slice.dropPrefix? {ρ : Type} (s : String.Slice) (pat : ρ)\n  [String.Slice.Pattern.ForwardPattern pat] : Option String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .postponed
-    comment := "Missing position transformations"
-  }
-def «45ca44c8-fbd5-4400-8297-a60778f302b0» : AssociationTable.Fact .declaration where
-  widgetId := "slice-producing"
-  factId := "45ca44c8-fbd5-4400-8297-a60778f302b0"
-  rowId := "45ca44c8-fbd5-4400-8297-a60778f302b0"
-  rowState := #[⟨"String", "String.dropSuffix?", Declaration.def {
-    name := `String.dropSuffix?
-    renderedStatement := "String.dropSuffix? {ρ : Type} (s : String) (pat : ρ) [String.Slice.Pattern.BackwardPattern pat] :\n  Option String.Slice"
-    isDeprecated := false
-  }
-⟩,⟨"String.Slice", "String.Slice.dropSuffix?", Declaration.def {
-    name := `String.Slice.dropSuffix?
-    renderedStatement := "String.Slice.dropSuffix? {ρ : Type} (s : String.Slice) (pat : ρ)\n  [String.Slice.Pattern.BackwardPattern pat] : Option String.Slice"
-    isDeprecated := false
-  }
-⟩,]
-  metadata := {
-    status := .postponed
-    comment := "Missing position transformations"
-  }
-
-def table : AssociationTable.Data .declaration where
-  widgetId := "slice-producing"
-  rows := #[
-    ⟨"c8a13d6d-7ed6-4cd1-a386-23e2d55ce6f7", "slice", #[⟨"String", "String.slice"⟩,⟨"String.Slice", "String.Slice.slice"⟩,⟨"string-pos-forwards", "String.Pos.slice"⟩,⟨"string-pos-backwards", "String.Pos.ofSlice"⟩,⟨"string-slice-pos-forwards", "String.Slice.Pos.slice"⟩,⟨"string-slice-pos-backwards", "String.Slice.Pos.ofSlice"⟩,⟨"string-pos-noproof", "String.Pos.sliceOrPanic"⟩,⟨"string-slice-pos-noproof", "String.Slice.Pos.sliceOrPanic"⟩,]⟩,
-    ⟨"21b4fdfd-f8b3-44f5-a59e-57f1dc1d6819", "slice?", #[⟨"String", "String.slice?"⟩,⟨"String.Slice", "String.Slice.slice?"⟩,]⟩,
-    ⟨"6f2b6ecb-2f0c-4e45-9da3-eb7f2e15eff0", "slice!", #[⟨"String", "String.slice!"⟩,⟨"String.Slice", "String.Slice.slice!"⟩,⟨"string-pos-forwards", "String.Pos.slice!"⟩,⟨"string-pos-backwards", "String.Pos.ofSlice!"⟩,⟨"string-slice-pos-forwards", "String.Slice.Pos.slice!"⟩,⟨"string-slice-pos-backwards", "String.Slice.Pos.ofSlice!"⟩,]⟩,
-    ⟨"a3bdf66d-bc11-4019-aee9-2f1c1701de52", "trimAsciiStart", #[⟨"String", "String.trimAsciiStart"⟩,⟨"String.Slice", "String.Slice.trimAsciiStart"⟩,]⟩,
-    ⟨"f12b2730-7a4d-465c-8a6d-9d051c300fd5", "trimAsciiEnd", #[⟨"String", "String.trimAsciiEnd"⟩,⟨"String.Slice", "String.Slice.trimAsciiEnd"⟩,]⟩,
-    ⟨"32307b55-d6d1-4756-a947-dbe4dfde573c", "trimAscii", #[⟨"String", "String.trimAscii"⟩,⟨"String.Slice", "String.Slice.trimAscii"⟩,]⟩,
-    ⟨"dce95a38-f55a-4d6a-ae79-078ffe4b5c15", "toSlice", #[⟨"String", "String.toSlice"⟩,⟨"string-pos-forwards", "String.Pos.toSlice"⟩,⟨"string-pos-backwards", "String.Pos.ofToSlice"⟩,]⟩,
-    ⟨"005a3f30-5dab-493f-b168-32c36a2bdf7c", "str", #[⟨"String.Slice", "String.Slice.str"⟩,⟨"string-slice-pos-forwards", "String.Slice.Pos.str"⟩,⟨"string-slice-pos-backwards", "String.Slice.Pos.ofStr"⟩,]⟩,
-    ⟨"5f1a154c-ae2f-43a1-9409-2ce95b163ef3", "drop", #[⟨"String", "String.drop"⟩,⟨"String.Slice", "String.Slice.drop"⟩,]⟩,
-    ⟨"179518d1-ad07-4b2b-8ffe-3b7616e4c4ab", "take", #[⟨"String", "String.take"⟩,⟨"String.Slice", "String.Slice.take"⟩,]⟩,
-    ⟨"55c587fd-a7a8-4633-a4ae-e2c4e768ad28", "dropWhile", #[⟨"String", "String.dropWhile"⟩,⟨"String.Slice", "String.Slice.dropWhile"⟩,]⟩,
-    ⟨"d4444684-4279-4400-9be2-561a7cdb32c1", "takeWhile", #[⟨"String", "String.takeWhile"⟩,⟨"String.Slice", "String.Slice.takeWhile"⟩,]⟩,
-    ⟨"1c9e6689-65a0-4d4b-b001-256e83917d98", "dropEndWhile", #[⟨"String", "String.dropEndWhile"⟩,⟨"String.Slice", "String.Slice.dropEndWhile"⟩,]⟩,
-    ⟨"b836052b-3470-4a8e-8989-6951c898de37", "takeEndWhile", #[⟨"String", "String.takeEndWhile"⟩,⟨"String.Slice", "String.Slice.takeEndWhile"⟩,]⟩,
-    ⟨"5aa777d8-9642-43d8-9e20-30400fb8bb9d", "dropPrefix", #[⟨"String", "String.dropPrefix"⟩,⟨"String.Slice", "String.Slice.dropPrefix"⟩,]⟩,
-    ⟨"80e3869d-fcfe-459d-8433-fe221f7b3c7a", "dropSuffix", #[⟨"String", "String.dropSuffix"⟩,⟨"String.Slice", "String.Slice.dropSuffix"⟩,]⟩,
-    ⟨"4feda3e0-903b-4d52-b34e-0af70f7866e0", "dropPrefix?", #[⟨"String", "String.dropPrefix?"⟩,⟨"String.Slice", "String.Slice.dropPrefix?"⟩,]⟩,
-    ⟨"45ca44c8-fbd5-4400-8297-a60778f302b0", "dropSuffix?", #[⟨"String", "String.dropSuffix?"⟩,⟨"String.Slice", "String.Slice.dropSuffix?"⟩,]⟩,
-  ]
-  facts := #[
-    «c8a13d6d-7ed6-4cd1-a386-23e2d55ce6f7»,
-    «21b4fdfd-f8b3-44f5-a59e-57f1dc1d6819»,
-    «6f2b6ecb-2f0c-4e45-9da3-eb7f2e15eff0»,
-    «a3bdf66d-bc11-4019-aee9-2f1c1701de52»,
-    «f12b2730-7a4d-465c-8a6d-9d051c300fd5»,
-    «32307b55-d6d1-4756-a947-dbe4dfde573c»,
-    «dce95a38-f55a-4d6a-ae79-078ffe4b5c15»,
-    «005a3f30-5dab-493f-b168-32c36a2bdf7c»,
-    «5f1a154c-ae2f-43a1-9409-2ce95b163ef3»,
-    «179518d1-ad07-4b2b-8ffe-3b7616e4c4ab»,
-    «55c587fd-a7a8-4633-a4ae-e2c4e768ad28»,
-    «d4444684-4279-4400-9be2-561a7cdb32c1»,
-    «1c9e6689-65a0-4d4b-b001-256e83917d98»,
-    «b836052b-3470-4a8e-8989-6951c898de37»,
-    «5aa777d8-9642-43d8-9e20-30400fb8bb9d»,
-    «80e3869d-fcfe-459d-8433-fe221f7b3c7a»,
-    «4feda3e0-903b-4d52-b34e-0af70f7866e0»,
-    «45ca44c8-fbd5-4400-8297-a60778f302b0»,
-  ]
-
-def restoreState : RestoreStateM Unit := do
-  addAssociationTable table

doc/std/grove/GroveStdlib/Std.lean

@@ -15,7 +15,7 @@ namespace GroveStdlib
 namespace Std
 
 def introduction : Node :=
-  .text ⟨"introduction", "Welcome to the interactive Lean standard library outline!"⟩
+  .text "Welcome to the interactive Lean standard library outline!"
 
 end Std
 

doc/std/grove/GroveStdlib/Std/CoreTypesAndOperations/StringsAndFormatting.lean

@@ -11,87 +11,9 @@ namespace GroveStdlib.Std.CoreTypesAndOperations
 
 namespace StringsAndFormatting
 
-open Lean Meta
-
-def introduction : Text where
-  id := "string-introduction"
-  content := Grove.Markdown.render [
-    .h1 "The Lean string library",
-    .text "The Lean standard library contains a fully-featured string library, centered around the types `String` and `String.Slice`.",
-    .text "`String` is defined as the subtype of `ByteArray` of valid UTF-8 strings. A `String.Slice` is a `String` together with a start and end position.",
-    .text "`String` is equivalent to `List Char`, but it has a more efficient runtime representation. While the logical model based on `ByteArray` is overwritten in the runtime, the runtime implementation is very similar to the logical model, with the main difference being that the length of a string in Unicode code points is cached in the runtime implementation.",
-    .text "We are considering removing this feature in the future (i.e., deprecating `String.length`), as the number of UTF-8 codepoints in a string is not particularly useful, and if needed it can be computed in linear time using `s.positions.count`."
-  ]
-
-def highLevelStringTypes : List Lean.Name :=
-  [`String, `String.Slice, `String.Pos, `String.Slice.Pos]
-
-def creatingStringsAndSlices : Text where
-  id := "transforming-strings-and-slices"
-  content := Grove.Markdown.render [
-    .h2 "Transforming strings and slices",
-    .text "The Lean standard library contains a number of functions that take one or more strings and slices and return a string or a slice.",
-    .text "If possible, these functions should avoid allocating a new string, and return a slice of their input(s) instead.",
-    .text "Usually, for every operation `f`, there will be functions `String.f` and `String.Slice.f`, where `String.f s` is defined as `String.Slice.f s.toSlice`.",
-    .text "In particular, functions that transform strings and slices should live in the `String` and `String.Slice` namespaces even if they involve a `String.Pos`/`String.Slice.Pos` (like `String.sliceTo`), for reasons that will become clear shortly.",
-
-    .h3 "Transforming positions",
-    .text "Since positions on strings and slices are dependent on the string or slice, whenever users transform a string/slice, they will be interested in interpreting positions on the original string/slice as positions on the result, or vice versa.",
-    .text "Consequently, every operation that transforms a string or slice should come with a corresponding set of transformations between positions, usually in both directions, possibly with one of the directions being conditional.",
-    .text "For example, given a string `s` and a position `p` on `s`, we have the slice `s.sliceFrom p`, which is the slice from `p` to the end of `s`. A position on `s.sliceFrom p` can always be interpreted as a position on `s`. This is the \"backwards\" transformation. Conversely, a position `q` on `s` can be interpreted as a position on `s.sliceFrom p` as long as `p ≤ q`. This is the conditional forwards direction.",
-    .text "The convention for naming these transformations is that the forwards transformation should have the same name as the transformation on strings/slices, but it should be located in the `String.Pos` or `String.Slice.Pos` namespace, depending on the type of the starting position (so that dot notation is possible for the forward direction). The backwards transformation should have the same name as the operation on strings/slices, but with an `of` prefix, and live in the same namespace as the forwards transformation (so in general dot notation will not be available).",
-    .text "So, in the `sliceFrom` example, the forward direction would be called `String.Pos.sliceFrom`, while the backwards direction should be called `String.Pos.ofSliceFrom` (not `String.Slice.Pos.ofSliceFrom`).",
-    .text "If one of the directions is conditional, it should have a corresponding panicking operation that does not require a proof; in our example this would be `String.Pos.sliceFrom!`.",
-    .text "Sometimes there is a name clash for the panicking operations if the operation on strings is already panicking. For example, there are both `String.slice` and `String.slice!`. If the original operation is already panicking, we only provide panicking transformation operations. But now `String.Pos.slice!` could refer both to the panicking forwards transformation associated with `String.slice`, and also to the (only) forwards transformation associated with `String.slice!`. In this situation, we use an `orPanic` suffix to disambiguate. So the panicking forwards operation associated with `String.slice` is called `String.Pos.sliceOrPanic`, and the forwards operation associated with `String.slice!` is called `String.Pos.slice!`."
-  ]
-
--- TODO: also include the `HAppend` instance(s)
-def sliceProducing : AssociationTable (β := Alias Lean.Name) .declaration
-    [`String, `String.Slice,
-     Alias.mk `String.Pos "string-pos-forwards" "String.Pos (forwards)",
-     Alias.mk `String.Pos "string-pos-backwards" "String.Pos (backwards)",
-     Alias.mk `String.Pos "string-pos-noproof" "String.Pos (no proof)",
-     Alias.mk `String.Slice.Pos "string-slice-pos-forwards" "String.Slice.Pos (forwards)",
-     Alias.mk `String.Slice.Pos "string-slice-pos-backwards" "String.Slice.Pos (backwards)",
-     Alias.mk `String.Slice.Pos "string-slice-pos-noproof" "String.Slice.Pos (no proof)"] where
-  id := "slice-producing"
-  title := "String functions returning strings or slices"
-  description := "Operations on strings and string slices that themselves return a new string slice."
-  dataSources n := DataSource.definitionsInNamespace n.inner
-
-def sliceProducingComplete : Assertion where
-  widgetId := "slice-producing-complete"
-  title := "Slice-producing table is complete"
-  description := "All functions in the `String.**` namespace that return a string or a slice are covered in the table"
-  check := do
-    let mut ans := #[]
-    let covered := Std.HashSet.ofArray (← valuesInAssociationTable sliceProducing)
-    let pred : DataSource.DeclarationPredicate :=
-      DataSource.DeclarationPredicate.all [.isDefinition, .not .isDeprecated,
-        .notInNamespace `String.Pos.Raw, .notInNamespace `String.Legacy,
-        .not .isInstance]
-    let env ← getEnv
-    for name in ← declarationsMatching `String pred do
-      let some c := env.find? name | continue
-      if c.type.getForallBody.getUsedConstants.any (fun n => n == ``String || n == ``String.Slice) then
-        let success : Bool := name.toString ∈ covered
-        ans := ans.push {
-          assertionId := name.toString
-          description := s!"`{name}` should appear in the table."
-          passed := success
-          message := s!"`{name}` was{if success then "" else " not"} found in the table."
-        }
-    return ans
-
 end StringsAndFormatting
 
-open StringsAndFormatting
-
 def stringsAndFormatting : Node :=
-  .section "strings-and-formatting" "Strings and formatting"
-    #[.text introduction,
-      .text creatingStringsAndSlices,
-      .associationTable sliceProducing,
-      .assertion sliceProducingComplete]
+  .section "strings-and-formatting" "Strings and formatting" #[]
 
-end GroveStdlib.Std.CoreTypesAndOperations
+end GroveStdlib.Std.CoreTypesAndOperations

doc/std/grove/lake-manifest.json

@@ -5,7 +5,7 @@
    "type": "git",
    "subDir": "backend",
    "scope": "",
-   "rev": "c580a425c9b7fa2aebaec2a1d8de16b2e2283c40",
+   "rev": "3e8aabdea58c11813c5d3b7eeb187ded44ee9a34",
    "name": "grove",
    "manifestFile": "lake-manifest.json",
    "inputRev": "master",
@@ -15,10 +15,10 @@
    "type": "git",
    "subDir": null,
    "scope": "leanprover",
-   "rev": "d9fc8ae23024be37424a189982c92356e37935c8",
+   "rev": "1604206fcd0462da9a241beeac0e2df471647435",
    "name": "Cli",
    "manifestFile": "lake-manifest.json",
-   "inputRev": "nightly-testing",
+   "inputRev": "main",
    "inherited": true,
    "configFile": "lakefile.toml"}],
  "name": "grovestdlib",

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

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1769018530,
-        "narHash": "sha256-S/5RU76BdQ32bbE99a+G9gMuatpVWEvIfeSjEqyoFS4=",
-        "rev": "88d3861acdd3d2f0e361767018218e51810df8a1",
+        "lastModified": 1745636243,
+        "narHash": "sha256-kbNvlQZf8wwok3d2X1kM/TlXH/MZ+03ZNv+IPPBx+DM=",
+        "rev": "f771eb401a46846c1aebd20552521b233dd7e18b",
         "type": "tarball",
-        "url": "https://releases.nixos.org/nixos/unstable/nixos-26.05pre931542.88d3861acdd3/nixexprs.tar.xz"
+        "url": "https://releases.nixos.org/nixos/unstable/nixos-25.05pre789333.f771eb401a46/nixexprs.tar.xz"
       },
       "original": {
         "type": "tarball",

flake.nix

@@ -18,7 +18,7 @@
       # An old nixpkgs for creating releases with an old glibc
       pkgsDist-old-aarch = import inputs.nixpkgs-old { localSystem.config = "aarch64-unknown-linux-gnu"; };
 
-      llvmPackages = pkgs.llvmPackages_19;
+      llvmPackages = pkgs.llvmPackages_15;
 
       devShellWithDist = pkgsDist: pkgs.mkShell.override {
           stdenv = pkgs.overrideCC pkgs.stdenv llvmPackages.clang;

script/Modulize.lean

@@ -29,7 +29,7 @@ def main (args : List String) : IO Unit := do
     if !msgs.toList.isEmpty then -- skip this file if there are parse errors
       msgs.forM fun msg => msg.toString >>= IO.println
       throw <| .userError "parse errors in file"
-    let `(header| $[module%$moduleTk?]? $[prelude%$preludeTk?]? $imps:import*) := header
+    let `(header| $[module%$moduleTk?]? $imps:import*) := header
       | throw <| .userError s!"unexpected header syntax of {path}"
     if moduleTk?.isSome then
       continue
@@ -38,11 +38,11 @@ def main (args : List String) : IO Unit := do
     let startPos := header.raw.getPos? |>.getD parserState.pos
 
     let dummyEnv ← mkEmptyEnvironment
-    let (initCmd, parserState', msgs') :=
+    let (initCmd, parserState', _) :=
       Parser.parseCommand inputCtx { env := dummyEnv, options := {} } parserState msgs
 
-    -- insert section if any trailing command (or error, which could be from an unknown command)
-    if !initCmd.isOfKind ``Parser.Command.eoi || msgs'.hasErrors then
+    -- insert section if any trailing command
+    if !initCmd.isOfKind ``Parser.Command.eoi then
       let insertPos? :=
           -- put below initial module docstring if any
           guard (initCmd.isOfKind ``Parser.Command.moduleDoc) *> initCmd.getTailPos? <|>
@@ -57,21 +57,19 @@ def main (args : List String) : IO Unit := do
         sec := "\n\n" ++ sec
       if insertPos?.isNone then
         sec := sec ++ "\n\n"
-      let insertPos := text.pos! insertPos
-      text := text.extract text.startPos insertPos ++ sec ++ text.extract insertPos text.endPos
+      text := text.extract 0 insertPos ++ sec ++ text.extract insertPos text.rawEndPos
 
     -- prepend each import with `public `
     for imp in imps.reverse do
       let insertPos := imp.raw.getPos?.get!
       let prfx := if doMeta then "public meta " else "public "
-      let insertPos := text.pos! insertPos
-      text := text.extract text.startPos insertPos ++ prfx ++ text.extract insertPos text.endPos
+      text := text.extract 0 insertPos ++ prfx ++ text.extract insertPos text.rawEndPos
 
     -- insert `module` header
-    let mut initText := text.extract text.startPos (text.pos! startPos)
-    if !initText.trimAscii.isEmpty then
+    let mut initText := text.extract 0 startPos
+    if !initText.trim.isEmpty then
       -- If there is a header comment, preserve it and put `module` in the line after
-      initText := initText.trimAsciiEnd.toString ++ "\n"
-    text := initText ++ "module\n\n" ++ text.extract (text.pos! startPos) text.endPos
+      initText := initText.trimRight ++ "\n"
+    text := initText ++ "module\n\n" ++ text.extract startPos text.rawEndPos
 
     IO.FS.writeFile path text

script/Shake.lean

@@ -3,41 +3,38 @@ Copyright (c) 2023 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Sebastian Ullrich
 -/
-module
-
-prelude
-public import Lean.Util.Path
+import Lake.CLI.Main
 import Lean.ExtraModUses
-import Lean.Parser.Module
-import Init.Data.Range.Polymorphic.Iterators
-meta import Lean.Parser.Module
 
-/-! # Shake: A Lean import minimizer
+/-! # `lake exe shake` command
 
 This command will check the current project (or a specified target module) and all dependencies for
 unused imports. This works by looking at generated `.olean` files to deduce required imports and
 ensuring that every import is used to contribute some constant or other elaboration dependency
-recorded by `recordExtraModUse` and friends.
+recorded by `recordExtraModUse`. Because recompilation is not needed this is quite fast (about 8
+seconds to check `Mathlib` and all dependencies).
 -/
 
+/-- 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
+
+  --fix
+    Apply the suggested fixes directly. Make sure you have a clean checkout
+    before running this, so you can review the changes.
+"
+
 open Lean
 
-namespace Lake.Shake
-
-/-- The parsed CLI arguments for shake. -/
-public structure Args where
-  keepImplied : Bool := false
-  keepPrefix : Bool := false
-  keepPublic : Bool := false
-  addPublic : Bool := false
-  force : Bool := false
-  githubStyle : Bool := false
-  explain : Bool := false
-  trace : Bool := false
-  fix : Bool := false
-  /-- `<MODULE>..`: the list of root modules to check -/
-  mods : Array Name := #[]
-
 /-- We use `Nat` as a bitset for doing efficient set operations.
 The bit indexes will usually be a module index. -/
 structure Bitset where
@@ -64,7 +61,7 @@ instance : Union Bitset where
 instance : XorOp Bitset where
   xor a b := { toNat := a.toNat ^^^ b.toNat }
 
-def has (s : Bitset) (i : Nat) : Bool := s.toNat.testBit i
+def has (s : Bitset) (i : Nat) : Bool := s ∩ {i} ≠ ∅
 
 end Bitset
 
@@ -91,7 +88,7 @@ def ofImport : Lean.Import → NeedsKind
 
 end NeedsKind
 
-/-- Logically, a map `NeedsKind → Set ModuleIdx`, or `Set Import`. -/
+/-- Logically, a map `NeedsKind → Bitset`. -/
 structure Needs where
   pub : Bitset
   priv : Bitset
@@ -127,20 +124,6 @@ def Needs.union (needs : Needs) (k : NeedsKind) (s : Bitset) : Needs :=
 def Needs.sub (needs : Needs) (k : NeedsKind) (s : Bitset) : Needs :=
   needs.modify k (fun s' => s' ^^^ (s' ∩ s))
 
-instance : Union Needs where
-  union a b := {
-    pub := a.pub ∪ b.pub
-    priv := a.priv ∪ b.priv
-    metaPub := a.metaPub ∪ b.metaPub
-    metaPriv := a.metaPriv ∪ b.metaPriv }
-
-/-- The list of edits that will be applied in `--fix`. `edits[i] = (removed, added)` where:
-
-* If `j ∈ removed` then we want to delete module named `j` from the imports of `i`
-* If `j ∈ added` then we want to add module index `j` to the imports of `i`.
--/
-abbrev Edits := Std.HashMap Name (Array Import × Array Import)
-
 /-- The main state of the checker, containing information on all loaded modules. -/
 structure State where
   env  : Environment
@@ -160,24 +143,9 @@ structure State where
   changes to upstream headers.
   -/
   transDepsOrig : Array Needs := #[]
-  /-- Modules that should always be preserved downstream. -/
-  preserve : Needs := default
-  /-- Edits to be applied to the module imports. -/
-  edits : Edits := {}
-
-  -- Memoizations
-  reservedNames : Std.HashSet Name := Id.run do
-    let mut m := {}
-    for (c, _) in env.constants do
-      if isReservedName env c then
-        m := m.insert c
-    return m
-  indirectModUses : Std.HashMap Name (Array ModuleIdx) :=
-    indirectModUseExt.getState env
-  modNames : Array Name :=
-    env.header.moduleNames
 
 def State.mods (s : State) := s.env.header.moduleData
+def State.modNames (s : State) := s.env.header.moduleNames
 
 /--
 Given module `j`'s transitive dependencies, computes the union of `transImps` and the transitive
@@ -217,38 +185,13 @@ def addTransitiveImps (transImps : Needs) (imp : Import) (j : Nat) (impTransImps
 
   transImps
 
-def isDeclMeta' (env : Environment) (declName : Name) : Bool :=
-  -- Matchers are not compiled by themselves but inlined by the compiler, so there is no IR decl
-  -- to be tagged as `meta`.
-  -- TODO: It would be better to base the entire `meta` inference on the IR only and consider module
-  -- 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
-
-/--
-Given an `Expr` reference, returns the declaration name that should be considered the reference, if
-any.
--/
-def getDepConstName? (s : State) (ref : Name) : Option Name := do
-  -- Ignore references to reserved names, they can be re-generated in-place
-  guard <| !s.reservedNames.contains ref
-  -- `_simp_...` constants are similar, use base decl instead
-  return if ref.isStr && ref.getString!.startsWith "_simp_" then
-    ref.getPrefix
-  else
-    ref
-
 /-- Calculates the needs for a given module `mod` from constants and recorded extra uses. -/
-def calcNeeds (s : State) (i : ModuleIdx) : Needs := Id.run do
-  let env := s.env
+def calcNeeds (env : Environment) (i : ModuleIdx) : Needs := Id.run do
   let mut needs := default
   for ci in env.header.moduleData[i]!.constants do
     -- Added guard for cases like `structure` that are still exported even if private
     let pubCI? := guard (!isPrivateName ci.name) *> (env.setExporting true).find? ci.name
-    let k := { isExported := pubCI?.isSome, isMeta := isDeclMeta' env ci.name }
+    let k := { isExported := pubCI?.isSome, isMeta := isMeta env ci.name }
     needs := visitExpr k ci.type needs
     if let some e := ci.value? (allowOpaque := true) then
       -- type and value has identical visibility under `meta`
@@ -263,33 +206,24 @@ def calcNeeds (s : State) (i : ModuleIdx) : Needs := Id.run do
   return needs
 where
   /-- Accumulate the results from expression `e` into `deps`. -/
-  visitExpr (k : NeedsKind) (e : Expr) (deps : Needs) : Needs :=
-    let env := s.env
-    Lean.Expr.foldConsts e deps fun c deps => Id.run do
-      let mut deps := deps
-      if let some c := getDepConstName? s c then
-        if let some j := env.getModuleIdxFor? c then
-          let k := { k with isMeta := k.isMeta && !isDeclMeta' env c }
-          if j != i then
-            deps := deps.union k {j}
-            for indMod in s.indirectModUses[c]?.getD #[] do
-              if s.transDeps[i]!.has k indMod then
-                deps := deps.union k {indMod}
-      return deps
-
-abbrev Explanations := Std.HashMap (ModuleIdx × NeedsKind) (Option (Name × Name))
+  visitExpr (k : NeedsKind) e deps :=
+    Lean.Expr.foldConsts e deps fun c deps => match env.getModuleIdxFor? c with
+      | some j =>
+        let k := { k with isMeta := k.isMeta && !isMeta env c }
+        if j != i then deps.union k {j} else deps
+      | _ => deps
 
 /--
 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
     let pubCI? := guard (!isPrivateName ci.name) *> (env.setExporting true).find? ci.name
-    let k := { isExported := pubCI?.isSome, isMeta := isDeclMeta' env ci.name }
+    let k := { isExported := pubCI?.isSome, isMeta := isMeta env ci.name }
     deps := visitExpr k ci.name ci.type deps
     if let some e := ci.value? (allowOpaque := true) then
       let k := if k.isMeta then k else
@@ -305,25 +239,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? s 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 s.indirectModUses[c]?.getD #[] do
-          if s.transDeps[i]!.has k indMod then
-            deps := addExplanation indMod k name (`_indirect ++ c) deps
-      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
+    Lean.Expr.foldConsts e deps fun c deps => match env.getModuleIdxFor? c with
+      | some i =>
+        let k := { k with isMeta := k.isMeta && !isMeta env c }
+        if
+          if let some (some (name', _)) := deps[(i, k)]? then
+            decide (name.toString.length < name'.toString.length)
+          else true
+        then
+          deps.insert (i, k) (name, c)
+        else
+          deps
+      | _ => deps
 
 partial def initStateFromEnv (env : Environment) : State := Id.run do
   let mut s := { env }
@@ -339,6 +266,13 @@ partial def initStateFromEnv (env : Environment) : State := Id.run do
   s := { s with transDepsOrig := s.transDeps }
   return s
 
+/-- The list of edits that will be applied in `--fix`. `edits[i] = (removed, added)` where:
+
+* If `j ∈ removed` then we want to delete module named `j` from the imports of `i`
+* If `j ∈ added` then we want to add module index `j` to the imports of `i`.
+-/
+abbrev Edits := Std.HashMap Name (Array Import × Array Import)
+
 /-- Register that we want to remove `tgt` from the imports of `src`. -/
 def Edits.remove (ed : Edits) (src : Name) (tgt : Import) : Edits :=
   match ed.get? src with
@@ -357,8 +291,8 @@ Returns `(path, inputCtx, imports, endPos)` where `imports` is the `Lean.Parser.
 and `endPos` is the position of the end of the header.
 -/
 def parseHeaderFromString (text path : String) :
-    IO (System.FilePath × (ictx : Parser.InputContext) ×
-      TSyntax ``Parser.Module.header × String.Pos ictx.fileMap.source) := do
+    IO (System.FilePath × Parser.InputContext ×
+      TSyntax ``Parser.Module.header × String.Pos.Raw) := do
   let inputCtx := Parser.mkInputContext text path
   let (header, parserState, msgs) ← Parser.parseHeader inputCtx
   if !msgs.toList.isEmpty then -- skip this file if there are parse errors
@@ -366,8 +300,8 @@ def parseHeaderFromString (text path : String) :
     throw <| .userError "parse errors in file"
   -- the insertion point for `add` is the first newline after the imports
   let insertion := header.raw.getTailPos?.getD parserState.pos
-  let insertion := inputCtx.fileMap.source.pos! insertion |>.find (· == '\n') |>.next!
-  pure ⟨path, inputCtx, header, insertion⟩
+  let insertion := text.findAux (· == '\n') text.rawEndPos insertion + '\n'
+  pure (path, inputCtx, header, insertion)
 
 /-- Parse a source file to extract the location of the import lines, for edits and error messages.
 
@@ -375,8 +309,8 @@ Returns `(path, inputCtx, imports, endPos)` where `imports` is the `Lean.Parser.
 and `endPos` is the position of the end of the header.
 -/
 def parseHeader (srcSearchPath : SearchPath) (mod : Name) :
-    IO (System.FilePath × (ictx : Parser.InputContext) ×
-      TSyntax ``Parser.Module.header × String.Pos ictx.fileMap.source) := do
+    IO (System.FilePath × Parser.InputContext ×
+      TSyntax ``Parser.Module.header × String.Pos.Raw) := do
   -- Parse the input file
   let some path ← srcSearchPath.findModuleWithExt "lean" mod
     | throw <| .userError s!"error: failed to find source file for {mod}"
@@ -386,7 +320,7 @@ def parseHeader (srcSearchPath : SearchPath) (mod : Name) :
 def decodeHeader : TSyntax ``Parser.Module.header → Option (TSyntax `module) × Option (TSyntax `prelude) × TSyntaxArray ``Parser.Module.import
   | `(Parser.Module.header| $[module%$moduleTk?]? $[prelude%$preludeTk?]? $imports*) =>
     (moduleTk?.map .mk, preludeTk?.map .mk, imports)
-  | stx => panic! s!"unexpected header syntax {stx}"
+  | _ => unreachable!
 
 def decodeImport : TSyntax ``Parser.Module.import → Import
   | `(Parser.Module.import| $[public%$pubTk?]? $[meta%$metaTk?]? import $[all%$allTk?]? $id) =>
@@ -395,176 +329,73 @@ def decodeImport : TSyntax ``Parser.Module.import → Import
 
 /-- Analyze and report issues from module `i`. Arguments:
 
-* `pkgs`: the first components of the input modules
 * `srcSearchPath`: Used to find the path for error reporting purposes
 * `i`: the module index
 * `needs`: the module's calculated needs
+* `pinned`: dependencies that should be preserved even if unused
+* `edits`: accumulates the list of edits to apply if `--fix` is true
 * `addOnly`: if true, only add missing imports, do not remove unused ones
 -/
-def visitModule (pkgs : Array Name) (srcSearchPath : SearchPath)
-    (i : Nat) (needs : Needs) (headerStx : TSyntax ``Parser.Module.header) (args : Args)
-    (addOnly := false) : StateT State IO Unit := do
-  let modName := (← get).modNames[i]!
-  if isExtraRevModUse (← get).env i then
-    modify fun s => { s with preserve := s.preserve.union (if args.addPublic then .pub else .priv) {i} }
-    if args.trace then
-      IO.eprintln s!"Preserving `{modName}` because of recorded extra rev use"
-
-  -- only process modules in the selected packages
-  -- TODO: should be after `keep-downstream` but core headers are not found yet?
-  if !pkgs.any (·.isPrefixOf modName) then
-    return
-
-  let (module?, prelude?, imports) := decodeHeader headerStx
-  if module?.any (·.raw.getTrailing?.any (·.toString.contains "shake: keep-downstream")) then
-    modify fun s => { s with preserve := s.preserve.union (if args.addPublic then .pub else .priv) {i} }
-
+def visitModule (srcSearchPath : SearchPath)
+    (i : Nat) (needs : Needs) (preserve : Needs) (edits : Edits) (headerStx : TSyntax ``Parser.Module.header)
+    (addOnly := false) (githubStyle := false) (explain := false) : StateT State IO Edits := do
   let s ← get
-
-  let addOnly := addOnly || module?.any (·.raw.getTrailing?.any (·.toString.contains "shake: keep-all"))
-  let mut deps := needs
-
-  -- Add additional preserved imports
-  for impStx in imports do
-    let imp := decodeImport impStx
-    let j := s.env.getModuleIdx? imp.module |>.get!
-    let k := NeedsKind.ofImport imp
-    if addOnly ||
-        -- TODO: allow per-library configuration instead of hardcoding `Init`
-        args.keepPublic && imp.isExported && !(`Init).isPrefixOf modName ||
-        impStx.raw.getTrailing?.any (·.toString.contains "shake: keep") then
-      deps := deps.union k {j}
-      if args.trace then
-        IO.eprintln s!"Adding `{imp}` as additional dependency"
-  for j in [0:s.mods.size] do
-    for k in NeedsKind.all do
-      -- Remove `meta` while preserving, no use-case for preserving `meta` so far.
-      -- Downgrade to private unless `--add-public` is used.
-      if s.transDepsOrig[i]!.has k j &&
-          (s.preserve.has { k with isMeta := false, isExported := false } j ||
-           s.preserve.has { k with isMeta := false, isExported := true } j) then
-        deps := deps.union { k with isMeta := false, isExported := k.isExported && args.addPublic } {j}
-
   -- Do transitive reduction of `needs` in `deps`.
-  if !addOnly then
-    for j in [0:s.mods.size] do
-      let transDeps := s.transDeps[j]!
-      for k in NeedsKind.all do
-        if deps.has k j then
-          let transDeps := addTransitiveImps .empty { k with module := .anonymous } j transDeps
-          for k' in NeedsKind.all do
-            deps := deps.sub k' (transDeps.sub k' {j} |>.get k')
-
+  let mut deps := needs
+  let (_, prelude?, imports) := decodeHeader headerStx
   if prelude?.isNone then
     deps := deps.union .pub {s.env.getModuleIdx? `Init |>.get!}
-
-  -- Accumulate `transDeps` which is the non-reflexive transitive closure of the still-live imports
-  let mut transDeps := Needs.empty
-  let mut alwaysAdd : Array Import := #[]  -- to be added even if implied by other imports
-  for imp in s.mods[i]!.imports do
-    let j := s.env.getModuleIdx? imp.module |>.get!
-    let k := NeedsKind.ofImport imp
-    if deps.has k j || imp.importAll then
-      transDeps := addTransitiveImps transDeps imp j s.transDeps[j]!
+  for imp in imports do
+    if addOnly || imp.raw.getTrailing?.any (·.toString.toSlice.contains "shake: keep") then
+      let imp := decodeImport imp
+      let j := s.env.getModuleIdx? imp.module |>.get!
+      let k := NeedsKind.ofImport imp
       deps := deps.union k {j}
-    -- skip folder-nested `public (meta)? import`s but remove `meta`
-    else if modName.isPrefixOf imp.module then
-      let imp := { imp with isMeta := false }
-      let k := { k with isMeta := false }
-      if args.trace then
-        IO.eprintln s!"`{imp}` is preserved as folder-nested import"
-      transDeps := addTransitiveImps transDeps imp j s.transDeps[j]!
-      deps := deps.union k {j}
-      if !s.mods[i]!.imports.contains imp then
-        alwaysAdd := alwaysAdd.push imp
-
-  -- If `transDeps` does not cover `deps`, then we have to add back some imports until it does.
-  -- To minimize new imports we pick only new imports which are not transitively implied by
-  -- another new import, so we visit module indices in descending order.
-  let mut keptPrefix := false
-  let mut newTransDeps := transDeps
-  let mut toAdd : Array Import := #[]
-  for j in (0...s.mods.size).toArray.reverse do
+  for j in [0:s.mods.size] do
+    let transDeps := s.transDeps[j]!
     for k in NeedsKind.all do
-      if deps.has k j && !newTransDeps.has k j && !newTransDeps.has { k with isExported := true } j then
-        -- `add-public/keep-prefix` may change the import and even module we're considering
-        let mut k := k
-        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 ""}"
-        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
-          k := { k with isExported := true }
-          imp := { imp with isExported := true }
-          if args.trace then
-            IO.eprintln s!"* upgrading to `{imp}` because of `--add-public`"
-        if args.keepPrefix then
-          let rec tryPrefix : Name → Option ModuleIdx
-            | .str p _ => tryPrefix p <|> (do
-              let j' ← s.env.getModuleIdx? p
-              -- `j'` must be reachable from `i` (allow downgrading from `meta`)
-              guard <| s.transDepsOrig[i]!.has k j' || s.transDepsOrig[i]!.has { k with isMeta := true } j'
-              let j'transDeps := addTransitiveImps .empty p j' s.transDeps[j']!
-              -- `j` must be publicly reachable from `j'` (now downgrading must be done in the other direction)
-              guard <| j'transDeps.has { k with isExported := true } j || j'transDeps.has { k with isExported := true, isMeta := false } j
-              return j')
-            | _ => none
-          if let some j' := tryPrefix imp.module then
-            imp := { imp with module := s.modNames[j']! }
-            j := j'
-            keptPrefix := true
-            if args.trace then
-              IO.eprintln s!"* upgrading to `{imp}` because of `--keep-prefix`"
-        if !s.mods[i]!.imports.contains imp then
-          toAdd := toAdd.push imp
+      if s.transDepsOrig[i]!.has k j && preserve.has k j then
         deps := deps.union k {j}
-        newTransDeps := addTransitiveImps newTransDeps imp j s.transDeps[j]!
+      if deps.has k j then
+        let transDeps := addTransitiveImps .empty { k with module := .anonymous } j transDeps
+        for k' in NeedsKind.all do
+          deps := deps.sub k' (transDeps.sub k' {j} |>.get k')
 
-  if keptPrefix then
-    -- if an import was replaced by `--keep-prefix`, we did not necessarily visit the modules in
-    -- dependency order anymore and so we have to redo the transitive closure checking
-    newTransDeps := transDeps
-    for j in (0...s.mods.size).toArray.reverse do
-      for k in NeedsKind.all do
-        if deps.has k j then
-          let mut imp : Import := { k with module := s.modNames[j]! }
-          if toAdd.contains imp && (newTransDeps.has k j || newTransDeps.has { k with isExported := true } j) then
-            if args.trace then
-              IO.eprintln s!"Removing `{imp}` from imports to be added because it is now implied"
-            toAdd := toAdd.erase imp
-            deps := deps.sub k {j}
-          else
-            newTransDeps := addTransitiveImps newTransDeps imp j s.transDeps[j]!
-
-  -- now that `toAdd` filtering is done, add `alwaysAdd`
-  toAdd := alwaysAdd ++ toAdd
-
-  -- Any import which is still not in `deps` was unused
+  -- Any import which is not in `transDeps` was unused.
+  -- Also accumulate `newDeps` which is the transitive closure of the remaining imports
   let mut toRemove : Array Import := #[]
+  let mut newDeps := Needs.empty
   for imp in s.mods[i]!.imports do
     let j := s.env.getModuleIdx? imp.module |>.get!
-    let k := NeedsKind.ofImport imp
-    if args.keepImplied && newTransDeps.has k j then
-      if args.trace && !deps.has k j then
-        IO.eprintln s!"`{imp}` is implied by other imports"
-    else if !deps.has k j then
-      if args.trace then
-        IO.eprintln s!"`{imp}` is now unused"
-      toRemove := toRemove.push imp
-    -- A private import should also be removed if the public version has been added
-    else if !k.isExported && !imp.importAll && newTransDeps.has { k with isExported := true } j then
-      if args.trace then
-        IO.eprintln s!"`{imp}` is already covered by `{ { imp with isExported := true } }`"
-      toRemove := toRemove.push imp
+    if
+        -- skip folder-nested imports
+        s.modNames[i]!.isPrefixOf imp.module ||
+        imp.importAll then
+      newDeps := addTransitiveImps newDeps imp j s.transDeps[j]!
+    else
+      let k := NeedsKind.ofImport imp
+      -- A private import should also be removed if the public version is needed
+      if !deps.has k j || !k.isExported && deps.has { k with isExported := true } j then
+        toRemove := toRemove.push imp
+      else
+        newDeps := addTransitiveImps newDeps imp j s.transDeps[j]!
+
+  -- If `newDeps` does not cover `deps`, then we have to add back some imports until it does.
+  -- To minimize new imports we pick only new imports which are not transitively implied by
+  -- another new import
+  let mut toAdd : Array Import := #[]
+  for j in [0:s.mods.size] do
+    for k in NeedsKind.all do
+      if deps.has k j && !newDeps.has k j && !newDeps.has { k with isExported := true } j then
+        let imp := { k with module := s.modNames[j]! }
+        toAdd := toAdd.push imp
+        newDeps := addTransitiveImps newDeps imp j s.transDeps[j]!
 
   -- mark and report the removals
-  modify fun s => { s with
-    edits := toRemove.foldl (init := s.edits) fun edits imp =>
-      edits.remove modName imp }
+  let mut edits := toRemove.foldl (init := edits) fun edits imp =>
+    edits.remove s.modNames[i]! imp
 
-  if !toAdd.isEmpty || !toRemove.isEmpty || args.explain then
+  if !toAdd.isEmpty || !toRemove.isEmpty || explain then
     if let some path ← srcSearchPath.findModuleWithExt "lean" s.modNames[i]! then
       println! "{path}:"
     else
@@ -573,26 +404,25 @@ def visitModule (pkgs : Array Name) (srcSearchPath : SearchPath)
   if !toRemove.isEmpty then
     println! "  remove {toRemove}"
 
-  if args.githubStyle then
+  if githubStyle then
     try
-      let ⟨path, inputCtx, stx, endHeader⟩ ← parseHeader srcSearchPath s.modNames[i]!
+      let (path, inputCtx, stx, endHeader) ← parseHeader srcSearchPath s.modNames[i]!
       let (_, _, imports) := decodeHeader stx
       for stx in imports do
         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
+        let pos := inputCtx.fileMap.toPosition endHeader
         println! "{path}:{pos.line-1}:1: warning: \
           add {toAdd} instead"
     catch _ => pure ()
 
   -- mark and report the additions
-  modify fun s => { s with
-    edits := toAdd.foldl (init := s.edits) fun edits imp =>
-      edits.add s.modNames[i]! imp }
+  edits := toAdd.foldl (init := edits) fun edits imp =>
+    edits.add s.modNames[i]! imp
 
   if !toAdd.isEmpty then
     println! "  add {toAdd}"
@@ -607,15 +437,14 @@ def visitModule (pkgs : Array Name) (srcSearchPath : SearchPath)
     let j := s.env.getModuleIdx? imp.module |>.get!
     newTransDepsI := addTransitiveImps newTransDepsI imp j s.transDeps[j]!
 
-  modify fun s => { s with transDeps := s.transDeps.set! i newTransDepsI }
+  set { s with transDeps := s.transDeps.set! i newTransDepsI }
 
-  if args.explain then
-    let explanation := getExplanations s i
+  if explain then
+    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!
-      let mut k := NeedsKind.ofImport imp
-      if let some exp? := explanation[(j, k)]? <|> guard args.addPublic *> explanation[(j, { k with isExported := false})]? then
+      if let some exp? := explanation[(j, NeedsKind.ofImport imp)]? then
         println! "  note: `{imp}` required"
         if let some (n, c) := exp? then
           println! "    because `{sanitize n}` refers to `{sanitize c}`"
@@ -626,92 +455,154 @@ def visitModule (pkgs : Array Name) (srcSearchPath : SearchPath)
         run j
     for i in toAdd do run i
 
+  return edits
+
+/-- 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
+
+/-- The parsed CLI arguments. See `help` for more information -/
+structure Args where
+  /-- `--help`: shows the help -/
+  help : Bool := false
+  /-- `--force`: skips the `lake build --no-build` sanity check -/
+  force : Bool := false
+  /-- `--gh-style`: output messages that can be parsed by `gh-problem-matcher-wrap` -/
+  githubStyle : Bool := false
+  /-- `--explain`: give constants explaining why each module is needed -/
+  explain : Bool := false
+  /-- `--fix`: apply the fixes directly -/
+  fix : Bool := false
+  /-- `<MODULE>..`: the list of root modules to check -/
+  mods : Array Name := #[]
+
 local instance : Ord Import where
-  compare :=
-    let _ := @lexOrd
-    compareOn fun imp => (!imp.isExported, imp.module.toString)
+  compare a b :=
+    if a.isExported && !b.isExported then
+      Ordering.lt
+    else if !a.isExported && b.isExported then
+      Ordering.gt
+    else
+      a.module.cmp b.module
 
-/--
-Run the shake analysis with the given arguments.
+/-- The main entry point. See `help` for more information on arguments. -/
+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
+    | "--force" :: rest => parseArgs { args with force := true } rest
+    | "--fix" :: rest => parseArgs { args with fix := true } rest
+    | "--explain" :: rest => parseArgs { args with explain := 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) (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
-  -- Only submodules of `pkgs` will be edited or have info reported on them
-  let pkgs := mods.map (·.getRoot)
+  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]!.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 := true) (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 := {} }
-  env := indirectModUseExt.toEnvExtension.setState (asyncMode := .sync) env { is with state := newState }
+  let env ← finalizeImport s (isModule := true) imps {} (leakEnv := false) (loadExts := false)
 
   StateT.run' (s := initStateFromEnv env) do
 
   let s ← get
+  -- Parse the config file
+
   -- Run the calculation of the `needs` array in parallel
   let needs := s.mods.mapIdx fun i _ =>
-    Task.spawn fun _ => calcNeeds s i
+    Task.spawn fun _ => calcNeeds s.env i
 
   -- Parse headers in parallel
   let headers ← s.mods.mapIdxM fun i _ =>
-    if !pkgs.any (·.isPrefixOf s.modNames[i]!) then
-      pure <| Task.pure <| .ok ⟨default, default, default, default⟩
-    else
-      BaseIO.asTask (parseHeader srcSearchPath s.modNames[i]! |>.toBaseIO)
+    BaseIO.asTask (parseHeader srcSearchPath s.modNames[i]! |>.toBaseIO)
 
   if args.fix then
     println! "The following changes will be made automatically:"
 
   -- Check all selected modules
+  let mut edits : Edits := ∅
+  let mut revNeeds : Needs := default
   for i in [0:s.mods.size], t in needs, header in headers do
     match header.get with
-    | .ok ⟨_, _, stx, _⟩ =>
-      visitModule pkgs srcSearchPath i t.get stx args
+    | .ok (_, _, stx, _) =>
+      edits ← visitModule (addOnly := !pkg.isPrefixOf s.modNames[i]!)
+        srcSearchPath i t.get revNeeds edits stx args.githubStyle args.explain
+      if isExtraRevModUse s.env i then
+        revNeeds := revNeeds.union .priv {i}
     | .error e =>
       println! e.toString
 
   if !args.fix then
     -- return error if any issues were found
-    return if (← get).edits.isEmpty then 0 else 1
+    return if edits.isEmpty then 0 else 1
 
   -- Apply the edits to existing files
   let mut count := 0
   for mod in s.modNames, header? in headers do
-    let some (remove, add) := (← get).edits[mod]? | continue
+    let some (remove, add) := edits[mod]? | continue
     let add : Array Import := add.qsortOrd
 
     -- Parse the input file
-    let .ok ⟨path, inputCtx, stx, insertion⟩ := header?.get | continue
+    let .ok (path, inputCtx, stx, insertion) := header?.get | continue
     let (_, _, imports) := decodeHeader stx
     let text := inputCtx.fileMap.source
 
     -- Calculate the edit result
-    let mut pos : String.Pos text := text.startPos
+    let mut pos : String.Pos.Raw := 0
     let mut out : String := ""
     let mut seen : Std.HashSet Import := {}
     for stx in imports do
       let mod := decodeImport stx
       if remove.contains mod || seen.contains mod then
-        out := out ++ text.extract pos (text.pos! stx.raw.getPos?.get!)
+        out := out ++ String.Pos.Raw.extract text pos stx.raw.getPos?.get!
         -- We use the end position of the syntax, but include whitespace up to the first newline
-        pos := text.pos! stx.raw.getTailPos?.get! |>.find '\n' |>.next!
+        pos := text.findAux (· == '\n') text.rawEndPos stx.raw.getTailPos?.get! + '\n'
       seen := seen.insert mod
-    out := out ++ text.extract pos insertion
+    out := out ++ String.Pos.Raw.extract text pos insertion
     for mod in add do
       if !seen.contains mod then
         seen := seen.insert mod
         out := out ++ s!"{mod}\n"
-    out := out ++ text.extract insertion text.endPos
+    out := out ++ String.Pos.Raw.extract text insertion text.rawEndPos
 
     IO.FS.writeFile path out
     count := count + 1

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/fmt

@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# This script expects to be run from the repo root.
-
-# Format cmake files
-find -regex '.*/CMakeLists\.txt\(\.in\)?\|.*\.cmake\(\.in\)?' \
-  ! -path './build/*' \
-  ! -path "./stage0/*" \
-  -exec \
-    uvx gersemi --in-place --line-length 120 --indent 2 \
-    --definitions src/cmake/Modules/ src/CMakeLists.txt \
-    -- {} +

script/lakefile.toml

@@ -3,3 +3,7 @@ name = "scripts"
 [[lean_exe]]
 name = "modulize"
 root = "Modulize"
+
+[[lean_exe]]
+name = "shake"
+root = "Shake"

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_checklist.py

@@ -185,30 +185,6 @@ def get_release_notes(tag_name):
     except Exception:
         return None
 
-def check_release_notes_file_exists(toolchain, github_token):
-    """Check if the release notes file exists in the reference-manual repository.
-
-    For -rc1 releases, this checks that the release notes have been created.
-    For subsequent RCs and stable releases, release notes should already exist.
-
-    Returns tuple (exists: bool, is_rc1: bool) where is_rc1 indicates if this is
-    the first release candidate (when release notes need to be written).
-    """
-    # Determine the release notes file path
-    # e.g., v4.28.0-rc1 -> Manual/Releases/v4_28_0.lean
-    base_version = strip_rc_suffix(toolchain.lstrip('v'))  # "4.28.0"
-    file_name = f"v{base_version.replace('.', '_')}.lean"  # "v4_28_0.lean"
-    file_path = f"Manual/Releases/{file_name}"
-
-    is_rc1 = toolchain.endswith("-rc1")
-
-    repo_url = "https://github.com/leanprover/reference-manual"
-
-    # Check if the file exists on main branch
-    content = get_branch_content(repo_url, "main", file_path, github_token)
-
-    return (content is not None, is_rc1)
-
 def get_branch_content(repo_url, branch, file_path, github_token):
     api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + f"/contents/{file_path}?ref={branch}"
     headers = {'Authorization': f'token {github_token}'} if github_token else {}
@@ -525,76 +501,6 @@ def check_proofwidgets4_release(repo_url, target_toolchain, github_token):
     print(f"     You will need to create and push a tag v0.0.{next_version}")
     return False
 
-def check_reference_manual_release_title(repo_url, toolchain, pr_branch, github_token):
-    """Check if the reference-manual release notes title matches the release type.
-
-    For RC releases (e.g., v4.27.0-rc1), the title should contain the exact RC suffix.
-    For final releases (e.g., v4.27.0), the title should NOT contain any "-rc".
-
-    Returns True if check passes or is not applicable, False if title needs updating.
-    """
-    is_rc = is_release_candidate(toolchain)
-
-    # For RC releases, get the base version and RC suffix
-    # e.g., "v4.27.0-rc1" -> version="4.27.0", rc_suffix="-rc1"
-    if is_rc:
-        parts = toolchain.lstrip('v').split('-', 1)
-        version = parts[0]
-        rc_suffix = '-' + parts[1] if len(parts) > 1 else ''
-    else:
-        version = toolchain.lstrip('v')
-        rc_suffix = ''
-
-    # Construct the release notes file path (e.g., Manual/Releases/v4_27_0.lean for v4.27.0)
-    file_name = f"v{version.replace('.', '_')}.lean"  # "v4_27_0.lean"
-    file_path = f"Manual/Releases/{file_name}"
-
-    # Try to get the file from the PR branch first, then fall back to main branch
-    content = get_branch_content(repo_url, pr_branch, file_path, github_token)
-    if content is None:
-        # Try the default branch
-        content = get_branch_content(repo_url, "main", file_path, github_token)
-
-    if content is None:
-        print(f"  ⚠️  Could not check release notes file: {file_path}")
-        return True  # Don't block on this
-
-    # Look for the #doc line with the title
-    for line in content.splitlines():
-        if line.strip().startswith('#doc') and 'Manual' in line:
-            has_rc_in_title = '-rc' in line.lower()
-
-            if is_rc:
-                # For RC releases, title should contain the exact RC suffix (e.g., "-rc1")
-                # Use regex to match exact suffix followed by non-digit (to avoid -rc1 matching -rc10)
-                # Pattern matches the RC suffix followed by a non-digit or end-of-string context
-                # e.g., "-rc1" followed by space, quote, paren, or similar
-                exact_match = re.search(rf'{re.escape(rc_suffix)}(?![0-9])', line, re.IGNORECASE)
-                if exact_match:
-                    print(f"  ✅ Release notes title correctly shows {rc_suffix}")
-                    return True
-                elif has_rc_in_title:
-                    print(f"  ❌ Release notes title shows wrong RC version (expected {rc_suffix})")
-                    print(f"     Update {file_path} to use '{rc_suffix}' in the title")
-                    return False
-                else:
-                    print(f"  ❌ Release notes title missing RC suffix")
-                    print(f"     Update {file_path} to include '{rc_suffix}' in the title")
-                    return False
-            else:
-                # For final releases, title should NOT contain -rc
-                if has_rc_in_title:
-                    print(f"  ❌ Release notes title still shows RC version")
-                    print(f"     Update {file_path} to remove '-rcN' from the title")
-                    return False
-                else:
-                    print(f"  ✅ Release notes title is updated for final release")
-                    return True
-
-    # If we didn't find the #doc line, don't block
-    print(f"  ⚠️  Could not find release notes title in {file_path}")
-    return True
-
 def run_mathlib_verify_version_tags(toolchain, verbose=False):
     """Run mathlib4's verify_version_tags.py script to validate the release tag.
 
@@ -738,27 +644,6 @@ def main():
     else:
         print(f"  ✅ Release notes page title looks good ('{actual_title}').")
 
-    # Check if release notes file exists in reference-manual repository
-    # For -rc1 releases, this is when release notes need to be written
-    # For subsequent RCs and stable releases, they should already exist
-    release_notes_exists, is_rc1 = check_release_notes_file_exists(toolchain, github_token)
-    base_version = strip_rc_suffix(toolchain.lstrip('v'))
-    release_notes_file = f"Manual/Releases/v{base_version.replace('.', '_')}.lean"
-
-    if not release_notes_exists:
-        if is_rc1:
-            print(f"  ❌ Release notes file not found: {release_notes_file}")
-            print(f"     This is an -rc1 release, so release notes need to be written.")
-            print(f"     Run `script/release_notes.py --since <previous_version>` to generate them.")
-            print(f"     See doc/dev/release_checklist.md section 'Writing the release notes' for details.")
-            lean4_success = False
-        else:
-            print(f"  ❌ Release notes file not found: {release_notes_file}")
-            print(f"     Release notes should have been created for -rc1. Check the reference-manual repository.")
-            lean4_success = False
-    else:
-        print(f"  ✅ Release notes file exists: {release_notes_file}")
-
     repo_status["lean4"] = lean4_success
 
     # If the release page doesn't exist, skip repository checks and master branch checks
@@ -824,11 +709,6 @@ def main():
                     print(f"     ⚠️  CI: {ci_message}")
                 else:
                     print(f"     ❓ CI: {ci_message}")
-
-                # For reference-manual, check that the release notes title has been updated
-                if name == "reference-manual":
-                    pr_branch = f"bump_to_{toolchain}"
-                    check_reference_manual_release_title(url, toolchain, pr_branch, github_token)
             else:
                 print(f"  ❌ PR with title '{pr_title}' does not exist")
                 print(f"     Run `script/release_steps.py {toolchain} {name}` to create it")

script/release_repos.yml

@@ -14,6 +14,13 @@ repositories:
     bump-branch: true
     dependencies: []
 
+  - name: verso
+    url: https://github.com/leanprover/verso
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies: []
+
   - name: lean4checker
     url: https://github.com/leanprover/lean4checker
     toolchain-tag: true
@@ -35,14 +42,6 @@ repositories:
     branch: main
     dependencies: []
 
-  - name: verso
-    url: https://github.com/leanprover/verso
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies:
-      - plausible
-
   - name: import-graph
     url: https://github.com/leanprover-community/import-graph
     toolchain-tag: true
@@ -51,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
@@ -128,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

script/release_steps.py

@@ -23,7 +23,6 @@ What this script does:
    - Special merging strategies for repositories with nightly-testing branches
    - Safety checks for repositories using bump branches
    - Custom build and test procedures
-   - lean-fro.org: runs scripts/update.sh to regenerate site content
 
 6. Commits the changes with message "chore: bump toolchain to {version}"
 
@@ -413,14 +412,20 @@ def execute_release_steps(repo, version, config):
         run_command("lake update", cwd=repo_path, stream_output=True)
         print(blue("Running `lake update` in examples/hero..."))
         run_command("lake update", cwd=repo_path / "examples" / "hero", stream_output=True)
-
-        # Run scripts/update.sh to regenerate content
-        print(blue("Running `scripts/update.sh` to regenerate content..."))
-        run_command("scripts/update.sh", cwd=repo_path, stream_output=True)
-        print(green("Content regenerated successfully"))
     elif repo_name == "cslib":
         print(blue("Updating lakefile.toml..."))
         run_command(f'perl -pi -e \'s/"v4\\.[0-9]+(\\.[0-9]+)?(-rc[0-9]+)?"/"' + version + '"/g\' lakefile.*', cwd=repo_path)
+        
+        print(blue("Updating docs/lakefile.toml..."))
+        run_command(f'perl -pi -e \'s/"v4\\.[0-9]+(\\.[0-9]+)?(-rc[0-9]+)?"/"' + version + '"/g\' lakefile.*', cwd=repo_path / "docs")
+
+        # Update lean-toolchain in docs
+        print(blue("Updating docs/lean-toolchain..."))
+        docs_toolchain = repo_path / "docs" / "lean-toolchain"
+        with open(docs_toolchain, "w") as f:
+            f.write(f"leanprover/lean4:{version}\n")
+        print(green(f"Updated docs/lean-toolchain to leanprover/lean4:{version}"))
+
         run_command("lake update", cwd=repo_path, stream_output=True)
     elif dependencies:
         run_command(f'perl -pi -e \'s/"v4\\.[0-9]+(\\.[0-9]+)?(-rc[0-9]+)?"/"' + version + '"/g\' lakefile.*', cwd=repo_path)

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
@@ -14,7 +15,6 @@ public import Init.RCases
 public import Init.Core
 public import Init.Control
 public import Init.WF
-public import Init.WFComputable
 public import Init.WFTactics
 public import Init.Data
 public import Init.System
@@ -37,12 +37,11 @@ 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
 public import Init.Try
-public meta import Init.Try  -- shake: keep (make sure `Try.Config` can be evaluated anywhere)
+public meta import Init.Try  -- make sure `Try.Config` can be evaluated anywhere
 public import Init.BinderNameHint
 public import Init.Task
 public import Init.MethodSpecsSimp

src/Init/BinderNameHint.lean

@@ -7,8 +7,7 @@ Authors: Joachim Breitner
 module
 
 prelude
-public import Init.Prelude
-import Init.Tactics
+public import Init.Tactics
 
 public section
 

src/Init/BinderPredicates.lean

@@ -6,10 +6,7 @@ Authors: Gabriel Ebner
 module
 
 prelude
-public meta import Init.Grind.Tactics
-public import Init.Notation
-import Init.Meta.Defs
-import Init.NotationExtra
+public import Init.NotationExtra
 
 public section
 

src/Init/ByCases.lean

@@ -6,9 +6,7 @@ Authors: Leonardo de Moura, Mario Carneiro
 module
 
 prelude
-public meta import Init.Grind.Tactics
-public import Init.Grind.Tactics
-import Init.SimpLemmas
+public import Init.Classical
 
 public section
 

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
 
@@ -142,7 +142,6 @@ is classically true but not constructively. -/
 
 /-- Transfer decidability of `¬ p` to decidability of `p`. -/
 -- This can not be an instance as it would be tried everywhere.
-@[instance_reducible]
 def decidable_of_decidable_not (p : Prop) [h : Decidable (¬ p)] : Decidable p :=
   match h with
   | isFalse h => isTrue (Classical.not_not.mp h)

src/Init/Coe.lean

@@ -116,7 +116,7 @@ On top of these instances this file defines several auxiliary type classes:
   * `CoeOTC := CoeOut* Coe*`
   * `CoeHTC := CoeHead? CoeOut* Coe*`
   * `CoeHTCT := CoeHead? CoeOut* Coe* CoeTail?`
-  * `CoeT := CoeHead? CoeOut* Coe* CoeTail? | CoeDep`
+  * `CoeDep := CoeHead? CoeOut* Coe* CoeTail? | CoeDep`
 
 -/
 

src/Init/Control.lean

@@ -16,5 +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
-public import Init.Control.EState

src/Init/Control/Basic.lean

@@ -29,7 +29,7 @@ instance (priority := 500) instForInOfForIn' [ForIn' m ρ α d] : ForIn m ρ α
     (f : (a : α) → a ∈ x → β → m (ForInStep β)) (g : (a : α) → β → m (ForInStep β))
     (h : ∀ a m b, f a m b = g a b) :
     forIn' x b f = forIn x b g := by
-  simp [forIn]
+  simp [instForInOfForIn']
   congr
   apply funext
   intro a
@@ -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
@@ -322,8 +322,6 @@ class MonadControl (m : semiOutParam (Type u → Type v)) (n : Type u → Type w
   -/
   restoreM : {α : Type u} → m (stM α) → n α
 
-attribute [reducible] MonadControl.stM
-
 /--
 A way to lift a computation from one monad to another while providing the lifted computation with a
 means of interpreting computations from the outer monad. This provides a means of lifting
@@ -351,8 +349,6 @@ class MonadControlT (m : Type u → Type v) (n : Type u → Type w) where
   -/
   restoreM {α : Type u} : stM α → n α
 
-attribute [reducible] MonadControlT.stM
-
 export MonadControlT (stM liftWith restoreM)
 
 @[always_inline]

src/Init/Control/EState.lean

@@ -7,7 +7,6 @@ module
 
 prelude
 public import Init.Data.ToString.Basic
-public import Init.Control.State
 
 public section
 universe u v
@@ -26,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

@@ -7,7 +7,6 @@ module
 
 prelude
 public import Init.Control.Lawful.Basic
-import Init.SimpLemmas
 
 public section
 
@@ -76,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

@@ -8,7 +8,7 @@ The identity Monad.
 module
 
 prelude
-public import Init.Control.MonadAttach
+public import Init.Core
 
 public section
 
@@ -67,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

@@ -6,9 +6,7 @@ Authors: Sebastian Ullrich, Leonardo de Moura, Mario Carneiro
 module
 
 prelude
-public import Init.Control.Id
-public import Init.Grind.Tactics
-import Init.Ext
+public import Init.Ext
 
 public section
 
@@ -250,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/Instances.lean

@@ -12,16 +12,11 @@ public import Init.Control.Option
 import all Init.Control.Option
 import all Init.Control.State
 public import Init.Control.StateRef
-public import Init.Control.State
-public import Init.Ext
 
 public section
 
 open Function
 
-@[simp, grind =] theorem monadMap_refl {m : Type _ → Type _} {α} (f : ∀ {α}, m α → m α) :
-    monadMap @f = @f α := rfl
-
 /-! # ExceptT -/
 
 namespace ExceptT
@@ -30,8 +25,6 @@ namespace ExceptT
   simp [run] at h
   assumption
 
-@[simp, grind =] theorem run_mk (x : m (Except ε α)) : run (mk x : ExceptT ε m α) = x := rfl
-
 @[simp, grind =] theorem run_pure [Monad m] (x : α) : run (pure x : ExceptT ε m α) = pure (Except.ok x) := rfl
 
 @[simp, grind =] theorem run_lift  [Monad.{u, v} m] (x : m α) : run (ExceptT.lift x : ExceptT ε m α) = (Except.ok <$> x : m (Except ε α)) := rfl
@@ -62,9 +55,6 @@ theorem run_bind [Monad m] (x : ExceptT ε m α) (f : α → ExceptT ε m β)
   apply bind_congr
   intro a; cases a <;> simp [Except.map]
 
-@[simp, grind =] theorem run_monadMap [MonadFunctorT n m] (f : {β : Type u} → n β → n β) (x : ExceptT ε m α)
-    : (monadMap @f x : ExceptT ε m α).run = monadMap @f (x.run) := rfl
-
 protected theorem seq_eq {α β ε : Type u} [Monad m] (mf : ExceptT ε m (α → β)) (x : ExceptT ε m α) : mf <*> x = mf >>= fun f => f <$> x :=
   rfl
 
@@ -104,30 +94,9 @@ instance [Monad m] [LawfulMonad m] : LawfulMonad (ExceptT ε m) where
 
 @[simp] theorem map_throw [Monad m] [LawfulMonad m] {α β : Type _} (f : α → β) (e : ε) :
     f <$> (throw e : ExceptT ε m α) = (throw e : ExceptT ε m β) := by
-  simp only [Functor.map, ExceptT.map, ExceptT.mk, throw, throwThe, MonadExceptOf.throw,
+  simp only [ExceptT.instMonad, ExceptT.map, ExceptT.mk, throw, throwThe, MonadExceptOf.throw,
     pure_bind]
 
-/-! Note that the `MonadControl` instance for `ExceptT` is not monad-generic. -/
-
-@[simp] theorem run_restoreM [Monad m] (x : stM m (ExceptT ε m) α) :
-    ExceptT.run (restoreM x) = pure x := rfl
-
-@[simp] theorem run_liftWith [Monad m] (f : ({β : Type u} → ExceptT ε m β → m (stM m (ExceptT ε m) β)) → m α) :
-    ExceptT.run (liftWith f) = Except.ok <$> (f fun x => x.run) :=
-  rfl
-
-@[simp] theorem run_controlAt [Monad m] [LawfulMonad m] (f : ({β : Type u} → ExceptT ε m β → m (stM m (ExceptT ε m) β)) → m (stM m (ExceptT ε m) α)) :
-    ExceptT.run (controlAt m f) = f fun x => x.run := by
-  simp [controlAt, run_bind, bind_map_left]
-
-@[simp] theorem run_control [Monad m] [LawfulMonad m] (f : ({β : Type u} → ExceptT ε m β → m (stM m (ExceptT ε m) β)) → m (stM m (ExceptT ε m) α)) :
-    ExceptT.run (control f) = f fun x => x.run := run_controlAt f
-
-@[simp, grind =]
-theorem run_adapt [Monad m] (f : ε → ε') (x : ExceptT ε m α)
-    : run (ExceptT.adapt f x : ExceptT ε' m α) = Except.mapError f <$> run x :=
-  rfl
-
 end ExceptT
 
 /-! # Except -/
@@ -181,9 +150,6 @@ namespace OptionT
   apply bind_congr
   intro a; cases a <;> simp [OptionT.pure, OptionT.mk]
 
-@[simp, grind =] theorem run_monadMap [MonadFunctorT n m] (f : {β : Type u} → n β → n β) (x : OptionT m α)
-    : (monadMap @f x : OptionT m α).run = monadMap @f (x.run) := rfl
-
 protected theorem seq_eq {α β : Type u} [Monad m] (mf : OptionT m (α → β)) (x : OptionT m α) : mf <*> x = mf >>= fun f => f <$> x :=
   rfl
 
@@ -245,24 +211,6 @@ instance [Monad m] [LawfulMonad m] : LawfulMonad (OptionT m) where
     (x <|> y).run = Option.elimM x.run y.run (fun x => pure (some x)) :=
   bind_congr fun | some _ => by rfl | none => by rfl
 
-/-! Note that the `MonadControl` instance for `OptionT` is not monad-generic. -/
-
-@[simp] theorem run_restoreM [Monad m] (x : stM m (OptionT m) α) :
-    OptionT.run (restoreM x) = pure x := rfl
-
-@[simp] theorem run_liftWith [Monad m] [LawfulMonad m] (f : ({β : Type u} → OptionT m β → m (stM m (OptionT m) β)) → m α) :
-    OptionT.run (liftWith f) = Option.some <$> (f fun x => x.run) := by
-  dsimp [liftWith]
-  rw [← bind_pure_comp]
-  rfl
-
-@[simp] theorem run_controlAt [Monad m] [LawfulMonad m] (f : ({β : Type u} → OptionT m β → m (stM m (OptionT m) β)) → m (stM m (OptionT m) α)) :
-    OptionT.run (controlAt m f) = f fun x => x.run := by
-  simp [controlAt, Option.elimM, Option.elim]
-
-@[simp] theorem run_control [Monad m] [LawfulMonad m] (f : ({β : Type u} → OptionT m β → m (stM m (OptionT m) β)) → m (stM m (OptionT m) α)) :
-    OptionT.run (control f) = f fun x => x.run := run_controlAt f
-
 end OptionT
 
 /-! # Option -/
@@ -284,9 +232,6 @@ namespace ReaderT
   simp [run] at h
   exact funext h
 
-@[simp, grind =] theorem run_mk (x : ρ → m α) (ctx : ρ) : run (.mk x : ReaderT ρ m α) ctx = x ctx :=
-  rfl
-
 @[simp, grind =] theorem run_pure [Monad m] (a : α) (ctx : ρ) : (pure a : ReaderT ρ m α).run ctx = pure a := rfl
 
 @[simp, grind =] theorem run_bind [Monad m] (x : ReaderT ρ m α) (f : α → ReaderT ρ m β) (ctx : ρ)
@@ -334,22 +279,6 @@ instance [Monad m] [LawfulMonad m] : LawfulMonad (ReaderT ρ m) where
   pure_bind      := by intros; apply ext; intros; simp
   bind_assoc     := by intros; apply ext; intros; simp
 
-/-! Note that the `MonadControl` instance for `ReaderT` is not monad-generic. -/
-
-@[simp] theorem run_restoreM [Monad m] (x : stM m (ReaderT ρ m) α) (ctx : ρ) :
-    ReaderT.run (restoreM x) ctx = pure x := rfl
-
-@[simp] theorem run_liftWith [Monad m] (f : ({β : Type u} → ReaderT ρ m β → m (stM m (ReaderT ρ m) β)) → m α) (ctx : ρ) :
-    ReaderT.run (liftWith f) ctx = (f fun x => x.run ctx) :=
-  rfl
-
-@[simp] theorem run_controlAt [Monad m] [LawfulMonad m] (f : ({β : Type u} → ReaderT ρ m β → m (stM m (ReaderT ρ m) β)) → m (stM m (ReaderT ρ m) α)) (ctx : ρ) :
-    ReaderT.run (controlAt m f) ctx = f fun x => x.run ctx := by
-  simp [controlAt]
-
-@[simp] theorem run_control [Monad m] [LawfulMonad m] (f : ({β : Type u} → ReaderT ρ m β → m (stM m (ReaderT ρ m) β)) → m (stM m (ReaderT ρ m) α)) (ctx : ρ) :
-    ReaderT.run (control f) ctx = f fun x => x.run ctx := run_controlAt f ctx
-
 end ReaderT
 
 /-! # StateRefT -/
@@ -364,20 +293,17 @@ namespace StateT
 @[ext, grind ext] theorem ext {x y : StateT σ m α} (h : ∀ s, x.run s = y.run s) : x = y :=
   funext h
 
-@[simp, grind =] theorem run_mk [Monad m] (x : σ → m (α × σ)) (s : σ) : run (.mk x) s = x s :=
-  rfl
-
 @[simp, grind =] theorem run'_eq [Monad m] (x : StateT σ m α) (s : σ) : run' x s = (·.1) <$> run x s :=
   rfl
 
 @[simp, grind =] theorem run_pure [Monad m] (a : α) (s : σ) : (pure a : StateT σ m α).run s = pure (a, s) := rfl
 
 @[simp, grind =] theorem run_bind [Monad m] (x : StateT σ m α) (f : α → StateT σ m β) (s : σ)
-    : (x >>= f).run s = x.run s >>= λ p => (f p.1).run p.2 := rfl
+    : (x >>= f).run s = x.run s >>= λ p => (f p.1).run p.2 := by
+  simp [bind, StateT.bind, run]
 
 @[simp, grind =] theorem run_map {α β σ : Type u} [Monad m] [LawfulMonad m] (f : α → β) (x : StateT σ m α) (s : σ) : (f <$> x).run s = (fun (p : α × σ) => (f p.1, p.2)) <$> x.run s := by
-  rw [← bind_pure_comp (m := m)]
-  rfl
+  simp [Functor.map, StateT.map, run, ←bind_pure_comp]
 
 @[simp, grind =] theorem run_get [Monad m] (s : σ)    : (get : StateT σ m σ).run s = pure (s, s) := rfl
 
@@ -386,13 +312,13 @@ namespace StateT
 @[simp, grind =] theorem run_modify [Monad m] (f : σ → σ) (s : σ) : (modify f : StateT σ m PUnit).run s = pure (⟨⟩, f s) := rfl
 
 @[simp, grind =] theorem run_modifyGet [Monad m] (f : σ → α × σ) (s : σ) : (modifyGet f : StateT σ m α).run s = pure ((f s).1, (f s).2) := by
-  rfl
+  simp [modifyGet, MonadStateOf.modifyGet, StateT.modifyGet, run]
 
 @[simp, grind =] theorem run_lift {α σ : Type u} [Monad m] (x : m α) (s : σ) : (StateT.lift x : StateT σ m α).run s = x >>= fun a => pure (a, s) := rfl
 
 @[grind =]
 theorem run_bind_lift {α σ : Type u} [Monad m] [LawfulMonad m] (x : m α) (f : α → StateT σ m β) (s : σ) : (StateT.lift x >>= f).run s = x >>= fun a => (f a).run s := by
-  simp
+  simp [StateT.lift, StateT.run, bind, StateT.bind]
 
 @[simp, grind =] theorem run_monadLift {α σ : Type u} [Monad m] [MonadLiftT n m] (x : n α) (s : σ) : (monadLift x : StateT σ m α).run s = (monadLift x : m α) >>= fun a => pure (a, s) := rfl
 
@@ -432,78 +358,20 @@ instance [Monad m] [LawfulMonad m] : LawfulMonad (StateT σ m) where
   pure_bind      := by intros; apply ext; intros; simp
   bind_assoc     := by intros; apply ext; intros; simp
 
-/-! Note that the `MonadControl` instance for `StateT` is not monad-generic. -/
-
-@[simp] theorem run_restoreM [Monad m] [LawfulMonad m] (x : stM m (StateT σ m) α) (s : σ) :
-    StateT.run (restoreM x) s = pure x := by
-  simp [restoreM, MonadControl.restoreM]
-  rfl
-
-@[simp] theorem run_liftWith [Monad m] [LawfulMonad m] (f : ({β : Type u} → StateT σ m β → m (stM m (StateT σ m) β)) → m α) (s : σ) :
-    StateT.run (liftWith f) s = ((·, s) <$> f fun x => x.run s) := by
-  simp [liftWith, MonadControl.liftWith, Function.comp_def]
-
-@[simp] theorem run_controlAt [Monad m] [LawfulMonad m] (f : ({β : Type u} → StateT σ m β → m (stM m (StateT σ m) β)) → m (stM m (StateT σ m) α)) (s : σ) :
-    StateT.run (controlAt m f) s = f fun x => x.run s := by
-  simp [controlAt]
-
-@[simp] theorem run_control [Monad m] [LawfulMonad m] (f : ({β : Type u} → StateT σ m β → m (stM m (StateT σ m) β)) → m (stM m (StateT σ m) α)) (s : σ) :
-    StateT.run (control f) s = f fun x => x.run s := run_controlAt f s
-
 end StateT
 
 /-! # EStateM -/
 
-namespace EStateM
-
-@[simp, grind =] theorem run_pure (a : α) (s : σ) :
-    EStateM.run (pure a : EStateM ε σ α) s = .ok a s := rfl
-
-@[simp, grind =] theorem run_get (s : σ) :
-    EStateM.run (get : EStateM ε σ σ) s = .ok s s := rfl
-
-@[simp, grind =] theorem run_set (s₁ s₂ : σ) :
-    EStateM.run (set s₁ : EStateM ε σ PUnit) s₂ = .ok .unit s₁ := rfl
-
-@[simp, grind =] theorem run_modify (f : σ → σ) (s : σ) :
-    EStateM.run (modify f : EStateM ε σ PUnit) s = .ok .unit (f s) := rfl
-
-@[simp, grind =] theorem run_modifyGet (f : σ → α × σ) (s : σ) :
-    EStateM.run (modifyGet f : EStateM ε σ α) s = .ok (f s).1 (f s).2 := rfl
-
-@[simp, grind =] theorem run_throw (e : ε) (s : σ):
-    EStateM.run (throw e : EStateM ε σ PUnit) s = .error e s := rfl
-
-@[simp, grind =] theorem run_bind (x : EStateM ε σ α) (f : α → EStateM ε σ β)
-    : EStateM.run (x >>= f : EStateM ε σ β) s
-      =
-      match EStateM.run x s with
-      | .ok x s => EStateM.run (f x) s
-      | .error e s => .error e s :=
-  rfl
-
-@[simp, grind =]
-theorem run_adaptExcept (f : ε → ε') (x : EStateM ε σ α) (s : σ)
-    : EStateM.run (EStateM.adaptExcept f x : EStateM ε' σ α) s
-     =
-     match EStateM.run x s with
-     | .ok x s => .ok x s
-     | .error e s => .error (f e) s := by
-  simp only [EStateM.run, EStateM.adaptExcept]
-  cases (x s) <;> rfl
-
 instance : LawfulMonad (EStateM ε σ) := .mk'
   (id_map := fun x => funext <| fun s => by
-    simp only [Functor.map, EStateM.map]
+    dsimp only [EStateM.instMonad, EStateM.map]
     match x s with
     | .ok _ _ => rfl
     | .error _ _ => rfl)
   (pure_bind := fun _ _ => by rfl)
   (bind_assoc := fun x _ _ => funext <| fun s => by
-    simp only [bind, EStateM.bind]
+    dsimp only [EStateM.instMonad, EStateM.bind]
     match x s with
     | .ok _ _ => rfl
     | .error _ _ => rfl)
   (map_const := fun _ _ => rfl)
-
-end EStateM

src/Init/Control/Lawful/Lemmas.lean

@@ -7,9 +7,7 @@ module
 
 prelude
 public import Init.Control.Lawful.Basic
-public import Init.Classical
-public import Init.Ext
-import Init.ByCases
+public import Init.ByCases
 
 public section
 

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,88 +0,0 @@
-/-
-Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Paul Reichert
--/
-module
-
-prelude
-import Init.Control.Lawful.MonadAttach.Lemmas
-public import Init.Control.Lawful.Basic
-public import Init.Control.State
-public import Init.Control.StateRef
-public import Init.Ext
-
-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,92 +0,0 @@
-/-
-Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Paul Reichert
--/
-module
-
-prelude
-import all Init.Control.MonadAttach
-public import Init.Classical
-public import Init.Control.Lawful.Basic
-public import Init.Control.Lawful.MonadLift.Basic
-import Init.Control.Lawful.MonadLift.Lemmas
-import Init.RCases
-
-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/Basic.lean

@@ -6,7 +6,7 @@ Authors: Quang Dao
 module
 
 prelude
-public import Init.Notation
+public import Init.Control.Basic
 
 public section
 

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

@@ -14,12 +14,8 @@ import all Init.Control.StateRef
 public import Init.Control.StateCps
 import all Init.Control.StateCps
 import all Init.Control.Id
-public import Init.Control.Lawful.MonadLift.Basic
-public import Init.Control.Option
-public import Init.Control.State
-public import Init.Control.StateRef
-import Init.Control.Lawful.Instances
-import Init.Control.Lawful.MonadLift.Lemmas
+public import Init.Control.Lawful.MonadLift.Lemmas
+public import Init.Control.Lawful.Instances
 
 public section
 
@@ -67,7 +63,7 @@ variable [Monad m] [LawfulMonad m]
 @[simp]
 theorem lift_bind {α β : Type u} (ma : m α) (f : α → m β) :
     OptionT.lift (ma >>= f) = OptionT.lift ma >>= (fun a => OptionT.lift (f a)) := by
-  simp only [bind, OptionT.bind, OptionT.mk, OptionT.lift, bind_pure_comp, bind_map_left,
+  simp only [instMonad, OptionT.bind, OptionT.mk, OptionT.lift, bind_pure_comp, bind_map_left,
     map_bind]
 
 instance : LawfulMonadLift m (OptionT m) where
@@ -83,7 +79,7 @@ variable [Monad m] [LawfulMonad m]
 @[simp]
 theorem lift_bind {α β ε : Type u} (ma : m α) (f : α → m β) :
     ExceptT.lift (ε := ε) (ma >>= f) = ExceptT.lift ma >>= (fun a => ExceptT.lift (f a)) := by
-  simp only [bind, ExceptT.bind, mk, ExceptT.lift, bind_map_left, ExceptT.bindCont, map_bind]
+  simp only [instMonad, ExceptT.bind, mk, ExceptT.lift, bind_map_left, ExceptT.bindCont, map_bind]
 
 instance : LawfulMonadLift m (ExceptT ε m) where
   monadLift_pure := lift_pure
@@ -93,7 +89,8 @@ instance : LawfulMonadLift (Except ε) (ExceptT ε m) where
   monadLift_pure _ := by
     simp only [MonadLift.monadLift, mk, pure, Except.pure, ExceptT.pure]
   monadLift_bind ma _ := by
-    simp only [bind, ExceptT.bind, mk, MonadLift.monadLift, pure_bind, ExceptT.bindCont, Except.bind]
+    simp only [instMonad, ExceptT.bind, mk, MonadLift.monadLift, pure_bind, ExceptT.bindCont,
+      Except.instMonad, Except.bind]
     rcases ma with _ | _ <;> simp
 
 end ExceptT

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

@@ -8,20 +8,11 @@ module
 prelude
 public import Init.Control.Lawful.Basic
 public import Init.Control.Lawful.MonadLift.Basic
-import Init.Ext
 
 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 [monadLift] at h; simp [h]
-  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.Core
-
-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, instance_reducible]
-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

@@ -7,7 +7,7 @@ module
 
 prelude
 public import Init.Data.Option.Basic
-public import Init.Control.MonadAttach
+public import Init.Control.Except
 
 public section
 
@@ -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

@@ -25,12 +25,6 @@ of a value and a state.
 @[expose] def StateT (σ : Type u) (m : Type u → Type v) (α : Type u) : Type (max u v) :=
   σ → m (α × σ)
 
-/--
-Interpret `σ → m (α × σ)` as an element of `StateT σ m α`.
--/
-@[always_inline, inline, expose]
-def StateT.mk {σ : Type u} {m : Type u → Type v} {α : Type u} (x : σ → m (α × σ)) : StateT σ m α := x
-
 /--
 Executes an action from a monad with added state in the underlying monad `m`. Given an initial
 state, it returns a value paired with the final state.
@@ -204,7 +198,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

@@ -7,7 +7,6 @@ module
 
 prelude
 public import Init.Control.Lawful.Basic
-public import Init.Ext
 
 public section
 
@@ -69,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

@@ -9,7 +9,6 @@ module
 
 prelude
 public import Init.System.ST
-public import Init.Control.Reader
 
 public section
 
@@ -65,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/Conv.lean

@@ -51,21 +51,6 @@ scoped syntax (name := withAnnotateState)
 /-- `skip` does nothing. -/
 syntax (name := skip) "skip" : conv
 
-/--
-`cbv` performs simplification that closely mimics call-by-value evaluation.
-It reduces the target term by unfolding definitions using their defining equations and
-applying matcher equations. The unfolding is propositional, so `cbv` also works
-with functions defined via well-founded recursion or partial fixpoints.
-
-The proofs produced by `cbv` only use the three standard axioms.
-In particular, they do not require trust in the correctness of the code
-generator.
-
-This tactic is experimental and its behavior is likely to change in upcoming
-releases of Lean.
--/
-syntax (name := cbv) "cbv" : conv
-
 /--
 Traverses into the left subterm of a binary operator.
 

src/Init/Core.lean

@@ -9,15 +9,10 @@ module
 
 prelude
 public import Init.SizeOf
-public import Init.Tactics
 
 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
@@ -206,7 +201,6 @@ An element of `α ⊕ β` is either an `a : α` wrapped in `Sum.inl` or a `b :
 indication of which of the two types was chosen. The union of a singleton set with itself contains
 one element, while `Unit ⊕ Unit` contains distinct values `inl ()` and `inr ()`.
 -/
-@[suggest_for Either]
 inductive Sum (α : Type u) (β : Type v) where
   /-- Left injection into the sum type `α ⊕ β`. -/
   | inl (val : α) : Sum α β
@@ -342,7 +336,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`.
 -/
@@ -489,8 +483,6 @@ class HasEquiv (α : Sort u) where
   the notion of equivalence is type-dependent. -/
   Equiv : α → α → Sort v
 
-attribute [reducible] HasEquiv.Equiv
-
 @[inherit_doc] infix:50 " ≈ "  => HasEquiv.Equiv
 
 recommended_spelling "equiv" for "≈" in [HasEquiv.Equiv, «term_≈_»]
@@ -517,12 +509,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 `\`. -/
@@ -545,10 +537,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
 
 /--
@@ -935,14 +927,6 @@ noncomputable def HEq.ndrec.{u1, u2} {α : Sort u2} {a : α} {motive : {β : Sor
 noncomputable def HEq.ndrecOn.{u1, u2} {α : Sort u2} {a : α} {motive : {β : Sort u2} → β → Sort u1} {β : Sort u2} {b : β} (h : a ≍ b) (m : motive a) : motive b :=
   h.rec m
 
-/-- `HEq.ndrec` specialized to homogeneous heterogeneous equality -/
-noncomputable def HEq.homo_ndrec.{u1, u2} {α : Sort u2} {a : α} {motive : α → Sort u1} (m : motive a) {b : α} (h : a ≍ b) : motive b :=
-  (eq_of_heq h).ndrec m
-
-/-- `HEq.ndrec` specialized to homogeneous heterogeneous equality, symmetric variant -/
-noncomputable def HEq.homo_ndrec_symm.{u1, u2} {α : Sort u2} {a : α} {motive : α → Sort u1} (m : motive a) {b : α} (h : b ≍ a) : motive b :=
-  (eq_of_heq h).ndrec_symm m
-
 /-- `HEq.ndrec` variant -/
 noncomputable def HEq.elim {α : Sort u} {a : α} {p : α → Sort v} {b : α} (h₁ : a ≍ b) (h₂ : p a) : p b :=
   eq_of_heq h₁ ▸ h₂
@@ -955,7 +939,9 @@ theorem HEq.subst {p : (T : Sort u) → T → Prop} (h₁ : a ≍ b) (h₂ : p
 @[symm] theorem HEq.symm (h : a ≍ b) : b ≍ a :=
   h.rec (HEq.refl a)
 
-
+/-- Propositionally equal terms are also heterogeneously equal. -/
+theorem heq_of_eq (h : a = a') : a ≍ a' :=
+  Eq.subst h (HEq.refl a)
 
 /-- Heterogeneous equality is transitive. -/
 theorem HEq.trans (h₁ : a ≍ b) (h₂ : b ≍ c) : a ≍ c :=
@@ -1384,7 +1370,7 @@ instance {α : Type u} {p : α → Prop} [BEq α] [LawfulBEq α] : LawfulBEq {x
 instance {α : Sort u} {p : α → Prop} [DecidableEq α] : DecidableEq {x : α // p x} :=
   fun ⟨a, h₁⟩ ⟨b, h₂⟩ =>
     if h : a = b then isTrue (by subst h; exact rfl)
-    else isFalse (fun h' => Subtype.noConfusion rfl .rfl (heq_of_eq h') (fun h' => absurd (eq_of_heq h') h))
+    else isFalse (fun h' => Subtype.noConfusion h' (fun h' => absurd h' h))
 
 end Subtype
 
@@ -1443,8 +1429,8 @@ instance [DecidableEq α] [DecidableEq β] : DecidableEq (α × β) :=
     | isTrue e₁ =>
       match decEq b b' with
       | isTrue e₂  => isTrue (e₁ ▸ e₂ ▸ rfl)
-      | isFalse n₂ => isFalse fun h => Prod.noConfusion rfl rfl (heq_of_eq h) fun _   e₂' => absurd (eq_of_heq e₂') n₂
-    | isFalse n₁ => isFalse fun h => Prod.noConfusion rfl rfl (heq_of_eq h) fun e₁' _   => absurd (eq_of_heq e₁') n₁
+      | isFalse n₂ => isFalse fun h => Prod.noConfusion h fun _   e₂' => absurd e₂' n₂
+    | isFalse n₁ => isFalse fun h => Prod.noConfusion h fun e₁' _   => absurd e₁' n₁
 
 instance [BEq α] [BEq β] : BEq (α × β) where
   beq := fun (a₁, b₁) (a₂, b₂) => a₁ == a₂ && b₁ == b₂
@@ -1489,29 +1475,6 @@ def Prod.map {α₁ : Type u₁} {α₂ : Type u₂} {β₁ : Type v₁} {β₂
 
 /-! # Dependent products -/
 
-instance {α : Type u} {β : α → Type v} [h₁ : DecidableEq α] [h₂ : ∀ a, DecidableEq (β a)] :
-    DecidableEq (Sigma β)
-  | ⟨a₁, b₁⟩, ⟨a₂, b₂⟩ =>
-    match a₁, b₁, a₂, b₂, h₁ a₁ a₂ with
-    | _, b₁, _, b₂, isTrue (Eq.refl _) =>
-      match b₁, b₂, h₂ _ b₁ b₂ with
-      | _, _, isTrue (Eq.refl _) => isTrue rfl
-      | _, _, isFalse n => isFalse fun h ↦
-        Sigma.noConfusion rfl .rfl (heq_of_eq h) fun _ e₂ ↦ n (eq_of_heq e₂)
-    | _, _, _, _, isFalse n => isFalse fun h ↦
-      Sigma.noConfusion rfl .rfl (heq_of_eq h) fun e₁ _ ↦ n (eq_of_heq e₁)
-
-instance {α : Sort u} {β : α → Sort v} [h₁ : DecidableEq α] [h₂ : ∀ a, DecidableEq (β a)] : DecidableEq (PSigma β)
-  | ⟨a₁, b₁⟩, ⟨a₂, b₂⟩ =>
-    match a₁, b₁, a₂, b₂, h₁ a₁ a₂ with
-    | _, b₁, _, b₂, isTrue (Eq.refl _) =>
-      match b₁, b₂, h₂ _ b₁ b₂ with
-      | _, _, isTrue (Eq.refl _) => isTrue rfl
-      | _, _, isFalse n => isFalse fun h ↦
-        PSigma.noConfusion rfl .rfl (heq_of_eq h) fun _ e₂ ↦ n (eq_of_heq e₂)
-    | _, _, _, _, isFalse n => isFalse fun h ↦
-      PSigma.noConfusion rfl .rfl (heq_of_eq h) fun e₁ _ ↦ n (eq_of_heq e₁)
-
 theorem Exists.of_psigma_prop {α : Sort u} {p : α → Prop} : (PSigma (fun x => p x)) → Exists (fun x => p x)
   | ⟨x, hx⟩ => ⟨x, hx⟩
 
@@ -1599,10 +1562,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
@@ -2363,10 +2322,8 @@ namespace Lean
 /--
 Depends on the correctness of the Lean compiler, interpreter, and all `[implemented_by ...]` and `[extern ...]` annotations.
 -/
-@[deprecated "in-kernel native reduction is deprecated; assert native evaluations with axioms instead" (since := "2026-02-01")]
 axiom trustCompiler : True
 
-set_option linter.deprecated false in
 /--
 When the kernel tries to reduce a term `Lean.reduceBool c`, it will invoke the Lean interpreter to evaluate `c`.
 The kernel will not use the interpreter if `c` is not a constant.
@@ -2386,13 +2343,11 @@ Recall that the compiler trusts the correctness of all `[implemented_by ...]` an
 If an extern function is executed, then the trusted code base will also include the implementation of the associated
 foreign function.
 -/
-@[deprecated "in-kernel native reduction is deprecated; assert native evaluations with axioms instead" (since := "2026-02-01")]
 opaque reduceBool (b : Bool) : Bool :=
   -- This ensures that `#print axioms` will track use of `reduceBool`.
   have := trustCompiler
   b
 
-set_option linter.deprecated false in
 /--
 Similar to `Lean.reduceBool` for closed `Nat` terms.
 
@@ -2400,14 +2355,12 @@ Remark: we do not have plans for supporting a generic `reduceValue {α} (a : α)
 The main issue is that it is non-trivial to convert an arbitrary runtime object back into a Lean expression.
 We believe `Lean.reduceBool` enables most interesting applications (e.g., proof by reflection).
 -/
-@[deprecated "in-kernel native reduction is deprecated; assert native evaluations with axioms instead" (since := "2026-02-01")]
 opaque reduceNat (n : Nat) : Nat :=
   -- This ensures that `#print axioms` will track use of `reduceNat`.
   have := trustCompiler
   n
 
 
-set_option linter.deprecated false in
 /--
 The axiom `ofReduceBool` is used to perform proofs by reflection. See `reduceBool`.
 
@@ -2421,10 +2374,8 @@ external type checkers that do not implement this feature.
 Keep in mind that if you are using Lean as programming language, you are already trusting the Lean compiler and interpreter.
 So, you are mainly losing the capability of type checking your development using external checkers.
 -/
-@[deprecated "in-kernel native reduction is deprecated; assert native evaluations with axioms instead" (since := "2026-02-01")]
 axiom ofReduceBool (a b : Bool) (h : reduceBool a = b) : a = b
 
-set_option linter.deprecated false in
 /--
 The axiom `ofReduceNat` is used to perform proofs by reflection. See `reduceBool`.
 
@@ -2434,7 +2385,6 @@ external type checkers that do not implement this feature.
 Keep in mind that if you are using Lean as programming language, you are already trusting the Lean compiler and interpreter.
 So, you are mainly losing the capability of type checking your development using external checkers.
 -/
-@[deprecated "in-kernel native reduction is deprecated; assert native evaluations with axioms instead" (since := "2026-02-01")]
 axiom ofReduceNat (a b : Nat) (h : reduceNat a = b) : a = b
 
 
@@ -2485,7 +2435,7 @@ class IdempotentOp (op : α → α → α) : Prop where
   idempotent : (x : α) → op x x = x
 
 /--
-`LeftIdentity op o` indicates `o` is a left identity of `op`.
+`LeftIdentify op o` indicates `o` is a left identity of `op`.
 
 This class does not require a proof that `o` is an identity, and
 is used primarily for inferring the identity using class resolution.
@@ -2493,7 +2443,7 @@ is used primarily for inferring the identity using class resolution.
 class LeftIdentity (op : α → β → β) (o : outParam α) : Prop
 
 /--
-`LawfulLeftIdentity op o` indicates `o` is a verified left identity of
+`LawfulLeftIdentify op o` indicates `o` is a verified left identity of
 `op`.
 -/
 class LawfulLeftIdentity (op : α → β → β) (o : outParam α) : Prop extends LeftIdentity op o where
@@ -2501,7 +2451,7 @@ class LawfulLeftIdentity (op : α → β → β) (o : outParam α) : Prop extend
   left_id : ∀ a, op o a = a
 
 /--
-`RightIdentity op o` indicates `o` is a right identity `o` of `op`.
+`RightIdentify op o` indicates `o` is a right identity `o` of `op`.
 
 This class does not require a proof that `o` is an identity, and is used
 primarily for inferring the identity using class resolution.
@@ -2509,7 +2459,7 @@ primarily for inferring the identity using class resolution.
 class RightIdentity (op : α → β → α) (o : outParam β) : Prop
 
 /--
-`LawfulRightIdentity op o` indicates `o` is a verified right identity of
+`LawfulRightIdentify op o` indicates `o` is a verified right identity of
 `op`.
 -/
 class LawfulRightIdentity (op : α → β → α) (o : outParam β) : Prop extends RightIdentity op o where

src/Init/Data/AC.lean

@@ -7,9 +7,7 @@ Authors: Dany Fabian
 module
 
 prelude
-public import Init.GetElem
-import Init.ByCases
-import Init.PropLemmas
+public import Init.ByCases
 
 @[expose] public section
 

src/Init/Data/Array.lean

@@ -30,7 +30,3 @@ public import Init.Data.Array.Erase
 public import Init.Data.Array.Zip
 public import Init.Data.Array.InsertIdx
 public import Init.Data.Array.Extract
-public import Init.Data.Array.MinMax
-public import Init.Data.Array.Nat
-public import Init.Data.Array.Int
-public import Init.Data.Array.Count

src/Init/Data/Array/Attach.lean

@@ -6,10 +6,8 @@ Authors: Joachim Breitner, Mario Carneiro
 module
 
 prelude
+public import Init.Data.Array.Count
 import all Init.Data.List.Attach
-public import Init.Data.Array.Lemmas
-import Init.Data.Array.Bootstrap
-import Init.Data.Array.Count
 
 public section
 
@@ -574,6 +572,9 @@ def unattach {α : Type _} {p : α → Prop} (xs : Array { x // p x }) : Array
 @[simp] theorem unattach_empty {p : α → Prop} : (#[] : Array { x // p x }).unattach = #[] := by
   simp [unattach]
 
+@[deprecated unattach_empty (since := "2025-05-26")]
+abbrev unattach_nil := @unattach_empty
+
 @[simp] theorem unattach_push {p : α → Prop} {a : { x // p x }} {xs : Array { x // p x }} :
     (xs.push a).unattach = xs.unattach.push a.1 := by
   simp only [unattach, Array.map_push]

src/Init/Data/Array/Basic.lean

@@ -11,9 +11,6 @@ public import Init.Data.List.ToArrayImpl
 import all Init.Data.List.ToArrayImpl
 public import Init.Data.Array.Set
 import all Init.Data.Array.Set
-public import Init.WF
-meta import Init.MetaTypes
-import Init.WFTactics
 
 public section
 
@@ -592,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
@@ -1353,7 +1348,7 @@ Examples:
 * `#[2, 4, 5, 6].any (· % 2 = 0) = true`
 * `#[2, 4, 5, 6].any (· % 2 = 1) = true`
 -/
-@[inline, expose, suggest_for Array.some]
+@[inline, expose]
 def any (as : Array α) (p : α → Bool) (start := 0) (stop := as.size) : Bool :=
   Id.run <| as.anyM (pure <| p ·) start stop
 
@@ -1371,7 +1366,7 @@ Examples:
 * `#[2, 4, 6].all (· % 2 = 0) = true`
 * `#[2, 4, 5, 6].all (· % 2 = 0) = false`
 -/
-@[inline, suggest_for Array.every]
+@[inline]
 def all (as : Array α) (p : α → Bool) (start := 0) (stop := as.size) : Bool :=
   Id.run <| as.allM (pure <| p ·) start stop
 
@@ -2125,7 +2120,7 @@ Examples:
 
 /-! ### Repr and ToString -/
 
-protected def repr {α : Type u} [Repr α] (xs : Array α) : Std.Format :=
+protected def Array.repr {α : Type u} [Repr α] (xs : Array α) : Std.Format :=
   let _ : Std.ToFormat α := ⟨repr⟩
   if xs.size == 0 then
     "#[]"

src/Init/Data/Array/BasicAux.lean

@@ -7,9 +7,7 @@ module
 
 prelude
 import all Init.Data.Array.Basic
-public import Init.Data.Array.Set
-public import Init.Util
-import Init.Data.Nat.Linear
+public import Init.Data.Nat.Linear
 
 public section
 

src/Init/Data/Array/BinSearch.lean

@@ -6,10 +6,7 @@ Authors: Leonardo de Moura
 module
 
 prelude
-public import Init.Data.Array.Basic
-import Init.Data.Bool
-import Init.Omega
-import Init.WFTactics
+public import Init.Data.Int.DivMod.Lemmas
 
 public section
 universe u v

src/Init/Data/Array/Bootstrap.lean

@@ -7,10 +7,8 @@ Authors: Mario Carneiro
 module
 
 prelude
+public import Init.Data.List.TakeDrop
 import all Init.Data.Array.Basic
-public import Init.Data.List.Control
-import Init.Data.List.Lemmas
-import Init.Data.List.TakeDrop
 
 public section
 
@@ -75,6 +73,9 @@ theorem foldrM_eq_reverse_foldlM_toList [Monad m] {f : α → β → m β} {init
   rcases xs with ⟨xs⟩
   simp [push, List.concat_eq_append]
 
+@[deprecated toList_push (since := "2025-05-26")]
+abbrev push_toList := @toList_push
+
 @[simp, grind =] theorem toListAppend_eq {xs : Array α} {l : List α} : xs.toListAppend l = xs.toList ++ l := by
   simp [toListAppend, ← foldr_toList]
 

src/Init/Data/Array/Count.lean

@@ -7,14 +7,8 @@ module
 
 prelude
 import all Init.Data.Array.Basic
-import Init.Grind.Util  -- shake: keep (`@[grind]` dependency)
-public import Init.BinderPredicates
-public import Init.Ext
-public import Init.NotationExtra
-import Init.Data.Array.Lemmas
-import Init.Data.Bool
-import Init.Data.List.Count
-import Init.Data.List.Nat.Count
+public import Init.Data.Array.Lemmas
+public import Init.Data.List.Nat.Count
 
 public section
 
@@ -68,12 +62,12 @@ theorem size_eq_countP_add_countP {xs : Array α} : xs.size = countP p xs + coun
   rcases xs with ⟨xs⟩
   simp [List.length_eq_countP_add_countP (p := p)]
 
+@[grind =]
 theorem countP_eq_size_filter {xs : Array α} : countP p xs = (filter p xs).size := by
   rcases xs with ⟨xs⟩
   simp [List.countP_eq_length_filter]
 
-grind_pattern countP_eq_size_filter => xs.countP p, xs.filter p
-
+@[grind =]
 theorem countP_eq_size_filter' : countP p = size ∘ filter p := by
   funext xs
   apply countP_eq_size_filter
@@ -98,18 +92,6 @@ theorem countP_le_size : countP p xs ≤ xs.size := by
   rcases xs with ⟨xs⟩
   simp
 
-/-- This lemma is only relevant for `grind`. -/
-@[grind ←=]
-theorem _root_.Std.Internal.Array.countP_eq_zero_of_forall {xs : Array α} (h : ∀ x ∈ xs, ¬ p x) : xs.countP p = 0 :=
-  countP_eq_zero.mpr h
-
-/-- This lemma is only relevant for `grind`. -/
-theorem _root_.Std.Internal.Array.not_of_countP_eq_zero_of_mem {xs : Array α} (h : xs.countP p = 0) (h' : x ∈ xs) : ¬ p x :=
-   countP_eq_zero.mp h _ h'
-
-grind_pattern Std.Internal.Array.not_of_countP_eq_zero_of_mem => xs.countP p, x ∈ xs where
-  guard xs.countP p = 0
-
 @[simp] theorem countP_eq_size {p} : countP p xs = xs.size ↔ ∀ a ∈ xs, p a := by
   rcases xs with ⟨xs⟩
   simp

src/Init/Data/Array/DecidableEq.lean

@@ -7,14 +7,8 @@ module
 
 prelude
 import all Init.Data.Array.Basic
-public import Init.Data.Array.Basic
-public import Init.Data.Nat.Lemmas
-import Init.ByCases
-import Init.Classical
-import Init.Data.BEq
-import Init.Data.Bool
-import Init.Data.List.Nat.BEq
-import Init.RCases
+public import Init.Data.BEq
+public import Init.Data.List.Nat.BEq
 
 public section
 
@@ -105,23 +99,23 @@ instance instDecidableEq [DecidableEq α] : DecidableEq (Array α) := fun xs ys
   | ⟨[]⟩ =>
     match ys with
     | ⟨[]⟩ => isTrue rfl
-    | ⟨_ :: _⟩ => isFalse (fun h => Array.noConfusion rfl (heq_of_eq h) (fun h => List.noConfusion rfl h))
+    | ⟨_ :: _⟩ => isFalse (Array.noConfusion · (List.noConfusion ·))
   | ⟨a :: as⟩ =>
     match ys with
-    | ⟨[]⟩ => isFalse (fun h => Array.noConfusion rfl (heq_of_eq h) (fun h => List.noConfusion rfl h))
+    | ⟨[]⟩ => isFalse (Array.noConfusion · (List.noConfusion ·))
     | ⟨b :: bs⟩ => instDecidableEqImpl ⟨a :: as⟩ ⟨b :: bs⟩
 
 @[csimp]
 theorem instDecidableEq_csimp : @instDecidableEq = @instDecidableEqImpl :=
   Subsingleton.allEq _ _
-
+  
 /--
 Equality with `#[]` is decidable even if the underlying type does not have decidable equality.
 -/
 instance instDecidableEqEmp (xs : Array α) : Decidable (xs = #[]) :=
   match xs with
   | ⟨[]⟩ => isTrue rfl
-  | ⟨_ :: _⟩ => isFalse (fun h => Array.noConfusion rfl (heq_of_eq h) (fun h => List.noConfusion rfl h))
+  | ⟨_ :: _⟩ => isFalse (Array.noConfusion · (List.noConfusion ·))
 
 /--
 Equality with `#[]` is decidable even if the underlying type does not have decidable equality.
@@ -129,23 +123,7 @@ Equality with `#[]` is decidable even if the underlying type does not have decid
 instance instDecidableEmpEq (ys : Array α) : Decidable (#[] = ys) :=
   match ys with
   | ⟨[]⟩ => 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 _ _
+  | ⟨_ :: _⟩ => isFalse (Array.noConfusion · (List.noConfusion ·))
 
 theorem beq_eq_decide [BEq α] (xs ys : Array α) :
     (xs == ys) = if h : xs.size = ys.size then

src/Init/Data/Array/Erase.lean

@@ -8,13 +8,6 @@ module
 prelude
 import all Init.Data.Array.Basic
 public import Init.Data.Array.Lemmas
-import Init.Data.Array.Bootstrap
-import Init.Data.Bool
-import Init.Data.List.Erase
-import Init.Data.List.Nat.Basic
-import Init.Data.List.Nat.Erase
-import Init.Data.List.TakeDrop
-import Init.Omega
 
 public section
 
@@ -396,6 +389,9 @@ theorem eraseIdx_append_of_size_le {xs : Array α} {k : Nat} (hk : xs.size ≤ k
   simp at hk
   simp [List.eraseIdx_append_of_length_le, *]
 
+@[deprecated eraseIdx_append_of_size_le (since := "2025-06-11")]
+abbrev eraseIdx_append_of_length_le := @eraseIdx_append_of_size_le
+
 @[grind =]
 theorem eraseIdx_append {xs ys : Array α} (h : k < (xs ++ ys).size) :
     eraseIdx (xs ++ ys) k =

src/Init/Data/Array/Extract.lean

@@ -6,16 +6,7 @@ Authors: Kim Morrison
 module
 
 prelude
-public import Init.BinderPredicates
-public import Init.Ext
-public import Init.NotationExtra
-import Init.ByCases
-import Init.Data.Array.Bootstrap
-import Init.Data.Array.Lemmas
-import Init.Data.Bool
-import Init.Data.List.Nat.TakeDrop
-import Init.Data.List.TakeDrop
-import Init.Omega
+public import Init.Data.Array.Lemmas
 
 public section
 

src/Init/Data/Array/FinRange.lean

@@ -6,11 +6,7 @@ Authors: François G. Dorais
 module
 
 prelude
-public import Init.Data.Array.Basic
-import Init.Data.Array.Lemmas
-import Init.Data.Array.OfFn
-import Init.Data.Fin.Lemmas
-import Init.Omega
+public import Init.Data.Array.OfFn
 
 public section
 

src/Init/Data/Array/Find.lean

@@ -6,22 +6,9 @@ Authors: Kim Morrison
 module
 
 prelude
-import Init.Data.List.Nat.Sum
+public import Init.Data.List.Nat.Find
 import all Init.Data.Array.Basic
-public import Init.Data.Array.Attach
-public import Init.Data.Option.BasicAux
-import Init.ByCases
-import Init.Data.Array.Bootstrap
-import Init.Data.Array.MapIdx
-import Init.Data.Bool
-import Init.Data.Fin.Lemmas
-import Init.Data.List.Count
-import Init.Data.List.Find
-import Init.Data.List.Impl
-import Init.Data.List.Nat.Find
-import Init.Data.List.Nat.TakeDrop
-import Init.Data.List.TakeDrop
-import Init.Omega
+public import Init.Data.Array.Range
 
 public section
 
@@ -127,7 +114,7 @@ theorem getElem_zero_flatten.proof {xss : Array (Array α)} (h : 0 < xss.flatten
   simp only [List.findSome?_toArray, List.findSome?_map, Function.comp_def, List.getElem?_toArray,
     List.findSome?_isSome_iff, isSome_getElem?]
   simp only [flatten_toArray_map_toArray, List.size_toArray, List.length_flatten,
-    List.sum_pos_iff_exists_pos_nat, List.mem_map] at h
+    Nat.sum_pos_iff_exists_pos, List.mem_map] at h
   obtain ⟨_, ⟨xs, m, rfl⟩, h⟩ := h
   exact ⟨xs, m, by simpa using h⟩
 
@@ -172,6 +159,9 @@ theorem find?_singleton {a : α} {p : α → Bool} :
     findRev? p (xs.push a) = findRev? p xs := by
   cases xs; simp [h]
 
+@[deprecated findRev?_push_of_neg (since := "2025-06-12")]
+abbrev findRev?_cons_of_neg := @findRev?_push_of_neg
+
 @[grind =]
 theorem finRev?_push {xs : Array α} :
     findRev? p (xs.push a) = (Option.guard p a).or (xs.findRev? p) := by
@@ -181,6 +171,9 @@ theorem finRev?_push {xs : Array α} :
   · rw [findRev?_push_of_pos, Option.guard_eq_some_iff.mpr ⟨rfl, h⟩]
     all_goals simp [h]
 
+@[deprecated finRev?_push (since := "2025-06-12")]
+abbrev findRev?_cons := @finRev?_push
+
 @[simp, grind =] theorem find?_eq_none : find? p xs = none ↔ ∀ x ∈ xs, ¬ p x := by
   cases xs; simp
 
@@ -687,39 +680,6 @@ theorem isNone_findFinIdx? {xs : Array α} {p : α → Bool} :
   simp only [Option.map_map, Function.comp_def, Fin.cast_cast]
   simp [Array.size]
 
-/-! ### find? and findFinIdx? -/
-
-theorem find?_eq_map_findFinIdx?_getElem {xs : Array α} {p : α → Bool} :
-    xs.find? p = (xs.findFinIdx? p).map (xs[·]) := by
-  cases xs
-  simp [List.find?_eq_map_findFinIdx?_getElem]
-  rfl
-
-theorem find?_eq_bind_findIdx?_getElem? {xs : Array α} {p : α → Bool} :
-    xs.find? p = (xs.findIdx? p).bind (xs[·]?) := by
-  cases xs
-  simp [List.find?_eq_bind_findIdx?_getElem?]
-
-theorem find?_eq_getElem?_findIdx {xs : Array α} {p : α → Bool} :
-    xs.find? p = xs[xs.findIdx p]? := by
-  cases xs
-  simp [List.find?_eq_getElem?_findIdx]
-
-theorem findIdx?_eq_bind_find?_idxOf? [BEq α] [LawfulBEq α] {xs : Array α} {p : α → Bool} :
-    xs.findIdx? p = (xs.find? p).bind (xs.idxOf? ·) := by
-  cases xs
-  simp [List.findIdx?_eq_bind_find?_idxOf?]
-
-theorem findFinIdx?_eq_bind_find?_finIdxOf? [BEq α] [LawfulBEq α] {xs : Array α} {p : α → Bool} :
-    xs.findFinIdx? p = (xs.find? p).bind (xs.finIdxOf? ·) := by
-  cases xs
-  simp [List.findFinIdx?_eq_bind_find?_finIdxOf?]
-
-theorem findIdx_eq_getD_bind_find?_idxOf? [BEq α] [LawfulBEq α] {xs : Array α} {p : α → Bool} :
-    xs.findIdx p = ((xs.find? p).bind (xs.idxOf? ·)).getD xs.size := by
-  cases xs
-  simp [List.findIdx_eq_getD_bind_find?_idxOf?]
-
 /-! ### idxOf
 
 The verification API for `idxOf` is still incomplete.

src/Init/Data/Array/GetLit.lean

@@ -7,8 +7,7 @@ Authors: Leonardo de Moura
 module
 
 prelude
-public import Init.GetElem
-import Init.Data.Array.Basic
+public import Init.Data.Array.Basic
 
 public section
 

src/Init/Data/Array/InsertIdx.lean

@@ -6,11 +6,7 @@ Authors: Kim Morrison
 module
 
 prelude
-public import Init.Data.Array.Basic
-import Init.Data.List.Nat.InsertIdx
-import Init.Data.List.ToArray
-import Init.Data.Nat.Lemmas
-import Init.Omega
+public import Init.Data.Array.Lemmas
 
 public section
 
@@ -57,6 +53,11 @@ theorem eraseIdx_insertIdx_self {i : Nat} {xs : Array α} (h : i ≤ xs.size) :
   rcases xs with ⟨xs⟩
   simp_all
 
+@[deprecated eraseIdx_insertIdx_self (since := "2025-06-15")]
+theorem eraseIdx_insertIdx {i : Nat} {xs : Array α} (h : i ≤ xs.size) :
+    (xs.insertIdx i a).eraseIdx i (by simp; omega) = xs := by
+  simp [eraseIdx_insertIdx_self]
+
 theorem insertIdx_eraseIdx_of_ge {as : Array α}
     (w₁ : i < as.size) (w₂ : j ≤ (as.eraseIdx i).size) (h : i ≤ j) :
     (as.eraseIdx i).insertIdx j a =

src/Init/Data/Array/Int.lean

@@ -1,77 +0,0 @@
-/-
-Copyright (c) 2026 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison, Sebastian Graf, Paul Reichert
--/
-module
-
-prelude
-public import Init.Data.List.Int.Sum
-public import Init.Data.Array.MinMax
-import Init.Data.Int.Lemmas
-
-public section
-
-set_option linter.listVariables true -- Enforce naming conventions for `List`/`Array`/`Vector` variables.
-set_option linter.indexVariables true -- Enforce naming conventions for index variables.
-
-namespace Array
-
-@[simp] theorem sum_replicate_int {n : Nat} {a : Int} : (replicate n a).sum = n * a := by
-  rw [← List.toArray_replicate, List.sum_toArray]
-  simp
-
-theorem sum_append_int {as₁ as₂ : Array Int} : (as₁ ++ as₂).sum = as₁.sum + as₂.sum := by
-  simp [sum_append]
-
-theorem sum_reverse_int (xs : Array Int) : xs.reverse.sum = xs.sum := by
-  simp [sum_reverse]
-
-theorem sum_eq_foldl_int {xs : Array Int} : xs.sum = xs.foldl (init := 0) (· + ·) := by
-  simp only [foldl_eq_foldr_reverse, Int.add_comm, ← sum_eq_foldr, sum_reverse_int]
-
-theorem min_mul_length_le_sum_int {xs : Array Int} (h : xs ≠ #[]) :
-    xs.min h * xs.size ≤ xs.sum := by
-  rcases xs with ⟨l⟩
-  simpa [List.min_toArray, List.sum_toArray] using List.min_mul_length_le_sum_int (by simpa using h)
-
-theorem mul_length_le_sum_of_min?_eq_some_int {xs : Array Int} (h : xs.min? = some x) :
-    x * xs.size ≤ xs.sum := by
-  rcases xs with ⟨l⟩
-  simpa [List.min?_toArray, List.sum_toArray] using
-    List.mul_length_le_sum_of_min?_eq_some_int (by simpa using h)
-
-theorem min_le_sum_div_length_int {xs : Array Int} (h : xs ≠ #[]) :
-    xs.min h ≤ xs.sum / xs.size := by
-  rcases xs with ⟨l⟩
-  simpa [List.min_toArray, List.sum_toArray] using List.min_le_sum_div_length_int (by simpa using h)
-
-theorem le_sum_div_length_of_min?_eq_some_int {xs : Array Int} (h : xs.min? = some x) :
-    x ≤ xs.sum / xs.size := by
-  rcases xs with ⟨l⟩
-  simpa [List.min?_toArray, List.sum_toArray] using
-    List.le_sum_div_length_of_min?_eq_some_int (by simpa using h)
-
-theorem sum_le_max_mul_length_int {xs : Array Int} (h : xs ≠ #[]) :
-    xs.sum ≤ xs.max h * xs.size := by
-  rcases xs with ⟨l⟩
-  simpa [List.max_toArray, List.sum_toArray] using List.sum_le_max_mul_length_int (by simpa using h)
-
-theorem sum_le_max_mul_length_of_max?_eq_some_int {xs : Array Int} (h : xs.max? = some x) :
-    xs.sum ≤ x * xs.size := by
-  rcases xs with ⟨l⟩
-  simpa [List.max?_toArray, List.sum_toArray] using
-    List.sum_le_max_mul_length_of_max?_eq_some_int (by simpa using h)
-
-theorem sum_div_length_le_max_int {xs : Array Int} (h : xs ≠ #[]) :
-    xs.sum / xs.size ≤ xs.max h := by
-  rcases xs with ⟨l⟩
-  simpa [List.max_toArray, List.sum_toArray] using List.sum_div_length_le_max_int (by simpa using h)
-
-theorem sum_div_length_le_max_of_max?_eq_some_int {xs : Array Int} (h : xs.max? = some x) :
-    xs.sum / xs.size ≤ x := by
-  rcases xs with ⟨l⟩
-  simpa [List.max?_toArray, List.sum_toArray] using
-    List.sum_div_length_le_max_of_max?_eq_some_int (by simpa using h)
-
-end Array

src/Init/Data/Array/Lemmas.lean

@@ -6,28 +6,14 @@ Authors: Mario Carneiro, Kim Morrison
 module
 
 prelude
+public import Init.Data.List.Nat.Basic
+public import Init.Data.Array.Mem
+public import Init.Data.Array.DecidableEq
+public import Init.Data.Range.Lemmas
 public import Init.Data.List.ToArray
 import all Init.Data.List.Control
 import all Init.Data.Array.Basic
 import all Init.Data.Array.Bootstrap
-public import Init.Data.Nat.Lemmas
-public import Init.Data.Nat.MinMax
-import Init.ByCases
-import Init.Data.Array.DecidableEq
-import Init.Data.Bool
-import Init.Data.Fin.Lemmas
-import Init.Data.List.Find
-import Init.Data.List.Nat.Basic
-import Init.Data.List.Nat.Modify
-import Init.Data.List.Nat.TakeDrop
-import Init.Data.List.Range
-import Init.Data.List.Zip
-import Init.Data.Nat.Linear
-import Init.Data.Nat.Simproc
-import Init.Data.Option.Lemmas
-import Init.Data.Prod
-import Init.Omega
-import Init.TacticsExtra
 
 public section
 
@@ -76,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
@@ -129,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 ..
@@ -496,18 +478,9 @@ theorem mem_iff_getElem {a} {xs : Array α} : a ∈ xs ↔ ∃ (i : Nat) (h : i
 theorem mem_iff_getElem? {a} {xs : Array α} : a ∈ xs ↔ ∃ i : Nat, xs[i]? = some a := by
   simp [getElem?_eq_some_iff, mem_iff_getElem]
 
-theorem exists_mem_iff_exists_getElem {P : α → Prop} {xs : Array α} :
-    (∃ x ∈ xs, P x) ↔ ∃ (i : Nat), ∃ (hi : i < xs.size), P (xs[i]) := by
-  cases xs; simp [List.exists_mem_iff_exists_getElem]
-
-theorem forall_mem_iff_forall_getElem {P : α → Prop} {xs : Array α} :
-    (∀ x ∈ xs, P x) ↔ ∀ (i : Nat) (hi : i < xs.size), P (xs[i]) := by
-  cases xs; simp [List.forall_mem_iff_forall_getElem]
-
-@[deprecated forall_mem_iff_forall_getElem (since := "2026-01-29")]
 theorem forall_getElem {xs : Array α} {p : α → Prop} :
     (∀ (i : Nat) h, p (xs[i]'h)) ↔ ∀ a, a ∈ xs → p a := by
-  exact forall_mem_iff_forall_getElem.symm
+  cases xs; simp [List.forall_getElem]
 
 /-! ### isEmpty -/
 
@@ -1785,6 +1758,11 @@ theorem toArray_append {xs : List α} {ys : Array α} :
 
 theorem singleton_eq_toArray_singleton {a : α} : #[a] = [a].toArray := rfl
 
+@[deprecated empty_append (since := "2025-05-26")]
+theorem empty_append_fun : ((#[] : Array α) ++ ·) = id := by
+  funext ⟨l⟩
+  simp
+
 @[simp, grind =] theorem mem_append {a : α} {xs ys : Array α} : a ∈ xs ++ ys ↔ a ∈ xs ∨ a ∈ ys := by
   simp only [mem_def, toList_append, List.mem_append]
 
@@ -1992,14 +1970,6 @@ theorem append_eq_append_iff {ws xs ys zs : Array α} :
     · left; exact ⟨as.toList, by simp⟩
     · right; exact ⟨cs.toList, by simp⟩
 
-theorem append_eq_append_iff_of_size_eq_left {ws xs ys zs : Array α} (h : ws.size = xs.size) :
-    ws ++ ys = xs ++ zs ↔ ws = xs ∧ ys = zs := by
-  simpa [← Array.toList_inj] using List.append_eq_append_iff_of_size_eq_left h
-
-theorem append_eq_append_iff_of_size_eq_right {ws xs ys zs : Array α} (h : ys.size = zs.size) :
-    ws ++ ys = xs ++ zs ↔ ws = xs ∧ ys = zs := by
-  simpa [← Array.toList_inj] using List.append_eq_append_iff_of_size_eq_right h
-
 @[grind =] theorem set_append {xs ys : Array α} {i : Nat} {x : α} (h : i < (xs ++ ys).size) :
     (xs ++ ys).set i x =
       if h' : i < xs.size then
@@ -2531,6 +2501,10 @@ theorem flatMap_replicate {f : α → Array β} : (replicate n a).flatMap f = (r
   rw [← List.toArray_replicate, List.isEmpty_toArray]
   simp
 
+@[simp] theorem sum_replicate_nat {n : Nat} {a : Nat} : (replicate n a).sum = n * a := by
+  rw [← List.toArray_replicate, List.sum_toArray]
+  simp
+
 /-! ### Preliminaries about `swap` needed for `reverse`. -/
 
 @[grind =]
@@ -3092,18 +3066,6 @@ theorem foldl_eq_foldlM {f : β → α → β} {b} {xs : Array α} {start stop :
 theorem foldr_eq_foldrM {f : α → β → β} {b} {xs : Array α} {start stop : Nat} :
     xs.foldr f b start stop = (xs.foldrM (m := Id) (pure <| f · ·) b start stop).run := rfl
 
-public theorem foldl_eq_foldl_extract {xs : Array α} {f : β → α → β} {init : β} :
-    xs.foldl (init := init) (start := start) (stop := stop) f =
-      (xs.extract start stop).foldl (init := init) f := by
-  simp only [foldl_eq_foldlM]
-  rw [foldlM_start_stop]
-
-public theorem foldr_eq_foldr_extract {xs : Array α} {f : α → β → β} {init : β} :
-    xs.foldr (init := init) (start := start) (stop := stop) f =
-      (xs.extract stop start).foldr (init := init) f := by
-  simp only [foldr_eq_foldrM]
-  rw [foldrM_start_stop]
-
 @[simp] theorem id_run_foldlM {f : β → α → Id β} {b} {xs : Array α} {start stop : Nat} :
     Id.run (xs.foldlM f b start stop) = xs.foldl (f · · |>.run) b start stop := rfl
 
@@ -3286,6 +3248,14 @@ rather than `(arr.push a).size` as the argument.
     l.foldl (fun xs x => xs.push x) xs = xs ++ l.toArray := by
   simpa using List.foldl_push_eq_append (f := id)
 
+@[deprecated _root_.List.foldl_push_eq_append' (since := "2025-05-18")]
+theorem _root_.List.foldl_push {l : List α} {as : Array α} : l.foldl Array.push as = as ++ l.toArray := by
+  induction l generalizing as <;> simp [*]
+
+@[deprecated _root_.List.foldr_push_eq_append' (since := "2025-05-18")]
+theorem _root_.List.foldr_push {l : List α} {as : Array α} : l.foldr (fun a bs => push bs a) as = as ++ l.reverse.toArray := by
+  rw [List.foldr_eq_foldl_reverse, List.foldl_push_eq_append']
+
 -- TODO: a multi-pattern is being selected there because E-matching does not go inside lambdas.
 @[simp, grind! ←] theorem foldr_append_eq_append {xs : Array α} {f : α → Array β} {ys : Array β} :
     xs.foldr (f · ++ ·) ys = (xs.map f).flatten ++ ys := by
@@ -4316,31 +4286,19 @@ theorem getElem?_range {n : Nat} {i : Nat} : (Array.range n)[i]? = if i < n then
 /-! ### sum -/
 
 @[simp, grind =] theorem sum_empty [Add α] [Zero α] : (#[] : Array α).sum = 0 := rfl
-theorem sum_eq_foldr [Add α] [Zero α] {xs : Array α} :
-    xs.sum = xs.foldr (init := 0) (· + ·) :=
-  rfl
 
 -- Without further algebraic hypotheses, there's no useful `sum_push` lemma.
 
 @[simp, grind =]
-theorem sum_toList [Add α] [Zero α] {as : Array α} : as.toList.sum = as.sum := by
+theorem sum_eq_sum_toList [Add α] [Zero α] {as : Array α} : as.toList.sum = as.sum := by
   cases as
   simp [Array.sum, List.sum]
 
-@[deprecated sum_toList (since := "2026-01-14")]
-def sum_eq_sum_toList := @sum_toList
-
 @[simp, grind =]
-theorem sum_append [Zero α] [Add α] [Std.Associative (α := α) (· + ·)]
-    [Std.LeftIdentity (α := α) (· + ·) 0] [Std.LawfulLeftIdentity (α := α) (· + ·) 0]
-    {as₁ as₂ : Array α} : (as₁ ++ as₂).sum = as₁.sum + as₂.sum := by
-  simp [← sum_toList, List.sum_append]
-
-@[simp, grind =]
-theorem sum_reverse [Zero α] [Add α] [Std.Associative (α := α) (· + ·)]
-    [Std.Commutative (α := α) (· + ·)]
-    [Std.LawfulLeftIdentity (α := α) (· + ·) 0] (xs : Array α) : xs.reverse.sum = xs.sum := by
-  simp [← sum_toList, List.sum_reverse]
+theorem sum_append_nat {as₁ as₂ : Array Nat} : (as₁ ++ as₂).sum = as₁.sum + as₂.sum := by
+  cases as₁
+  cases as₂
+  simp [List.sum_append_nat]
 
 theorem foldl_toList_eq_flatMap {l : List α} {acc : Array β}
     {F : Array β → α → Array β} {G : α → List β}
@@ -4376,6 +4334,11 @@ theorem getElem_eq_getD {xs : Array α} {i} {h : i < xs.size} (fallback : α) :
     xs[i]'h = xs.getD i fallback := by
   rw [getD_eq_getD_getElem?, getElem_eq_getElem?_get, Option.get_eq_getD]
 
+/-! # mem -/
+
+@[deprecated mem_toList_iff (since := "2025-05-26")]
+theorem mem_toList {a : α} {xs : Array α} : a ∈ xs.toList ↔ a ∈ xs := mem_def.symm
+
 /-! # get lemmas -/
 
 theorem lt_of_getElem {x : α} {xs : Array α} {i : Nat} {hidx : i < xs.size} (_ : xs[i] = x) :

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

@@ -6,10 +6,9 @@ Author: Kim Morrison
 module
 
 prelude
-public import Init.Data.Range.Polymorphic.RangeIterator
-import Init.Data.Range.Polymorphic.Iterators
-import Init.Data.Range.Polymorphic.Nat
-import Init.Omega
+public import Init.Data.Range.Polymorphic.Iterators
+public import Init.Data.Range.Polymorphic.Nat
+import Init.Data.Iterators.Consumers
 
 public section
 

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

@@ -8,13 +8,9 @@ module
 prelude
 import all Init.Data.Array.Lex.Basic
 public import Init.Data.Array.Lex.Basic
+public import Init.Data.Array.Lemmas
+public import Init.Data.List.Lex
 import Init.Data.Range.Polymorphic.NatLemmas
-public import Init.Data.BEq
-import Init.Data.Array.DecidableEq
-import Init.Data.Array.Lemmas
-import Init.Data.Bool
-import Init.Data.List.Lex
-import Init.Data.Range.Polymorphic.Lemmas
 
 public section
 
@@ -77,11 +73,19 @@ private theorem cons_lex_cons [BEq α] {lt : α → α → Bool} {a b : α} {xs
        (lt a b || a == b && xs.lex ys lt) := by
   simp only [lex, size_append, List.size_toArray, List.length_cons, List.length_nil, Nat.zero_add,
     Nat.add_min_add_left, Nat.add_lt_add_iff_left, Std.Rco.forIn'_eq_forIn'_toList]
-  rw [cons_lex_cons.forIn'_congr_aux (Nat.toList_rco_eq_cons (by omega)) rfl (fun _ _ _ => rfl)]
-  simp only [bind_pure_comp, map_pure, Nat.toList_rco_succ_succ, Nat.add_comm 1]
-  cases h : lt a b
-  · cases h' : a == b <;> simp [bne, *]
-  · simp [*]
+  conv =>
+    lhs; congr; congr
+    rw [cons_lex_cons.forIn'_congr_aux Std.Rco.toList_eq_if_roo rfl (fun _ _ _ => rfl)]
+    simp only [bind_pure_comp, map_pure]
+    rw [cons_lex_cons.forIn'_congr_aux (if_pos (by omega)) rfl (fun _ _ _ => rfl)]
+  simp only [Std.toList_roo_eq_toList_rco_of_isSome_succ? (lo := 0) (h := rfl),
+    Std.PRange.UpwardEnumerable.succ?, Nat.add_comm 1, Std.PRange.Nat.toList_rco_succ_succ,
+    Option.get_some, List.forIn'_cons, List.size_toArray, List.length_cons, List.length_nil,
+    Nat.lt_add_one, getElem_append_left, List.getElem_toArray, List.getElem_cons_zero]
+  cases lt a b
+  · rw [bne]
+    cases a == b <;> simp
+  · simp
 
 @[simp, grind =] theorem _root_.List.lex_toArray [BEq α] {lt : α → α → Bool} {l₁ l₂ : List α} :
     l₁.toArray.lex l₂.toArray lt = l₁.lex l₂ lt := by

src/Init/Data/Array/MapIdx.lean

@@ -7,9 +7,9 @@ module
 
 prelude
 import all Init.Data.Array.Basic
+public import Init.Data.Array.OfFn
 public import Init.Data.List.MapIdx
 import all Init.Data.List.MapIdx
-import Init.Data.Array.OfFn
 
 public section
 

src/Init/Data/Array/Mem.lean

@@ -6,11 +6,7 @@ Authors: Leonardo de Moura, Joachim Breitner
 module
 
 prelude
-public import Init.Data.Array.Basic
-public import Init.WFTactics
-import Init.Data.List.BasicAux
-import Init.Data.Nat.Linear
-meta import Init.MetaTypes
+public import Init.Data.List.BasicAux
 
 public section
 

src/Init/Data/Array/MinMax.lean

@@ -1,403 +0,0 @@
-/-
-Copyright (c) 2026 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.Array.Lemmas
-import Init.Data.List.MinMax
-public import Init.Data.Order.Classes
-import Init.Data.Array.Bootstrap
-import Init.Data.Array.DecidableEq
-import Init.Data.List.TakeDrop
-import Init.Data.Order.Lemmas
-
-namespace Array
-
-/-! ## Minima and maxima -/
-
-/-! ### min -/
-
-/--
-Returns the smallest element of a non-empty array.
-
-Examples:
-* `#[4].min (by decide) = 4`
-* `#[1, 4, 2, 10, 6].min (by decide) = 1`
--/
-public protected def min [Min α] (arr : Array α) (h : arr ≠ #[]) : α :=
-  haveI : arr.size > 0 := by simp [Array.size_pos_iff, h]
-  arr.foldl min arr[0] (start := 1)
-
-/-! ### min? -/
-
-/--
-Returns the smallest element of the array if it is not empty, or `none` if it is empty.
-
-Examples:
-* `#[].min? = none`
-* `#[4].min? = some 4`
-* `#[1, 4, 2, 10, 6].min? = some 1`
--/
-public protected def min? [Min α] (arr : Array α) : Option α :=
-  if h : arr ≠ #[] then
-    some (arr.min h)
-  else
-    none
-
-/-! ### max -/
-
-/--
-Returns the largest element of a non-empty array.
-
-Examples:
-* `#[4].max (by decide) = 4`
-* `#[1, 4, 2, 10, 6].max (by decide) = 10`
--/
-public protected def max [Max α] (arr : Array α) (h : arr ≠ #[]) : α :=
-  haveI : arr.size > 0 := by simp [Array.size_pos_iff, h]
-  arr.foldl max arr[0] (start := 1)
-
-/-! ### max? -/
-
-/--
-Returns the largest element of the array if it is not empty, or `none` if it is empty.
-
-Examples:
-* `#[].max? = none`
-* `#[4].max? = some 4`
-* `#[1, 4, 2, 10, 6].max? = some 10`
--/
-public protected def max? [Max α] (arr : Array α) : Option α :=
-  if h : arr ≠ #[] then
-    some (arr.max h)
-  else
-    none
-
-/-! ### Compatibility with `List` -/
-
-@[simp, grind =]
-public theorem _root_.List.min_toArray [Min α] {l : List α} {h} :
-    l.toArray.min h = l.min (by simpa [List.ne_nil_iff_length_pos] using h) := by
-  let h' : l ≠ [] := by simpa [List.ne_nil_iff_length_pos] using h
-  change l.toArray.min h = l.min h'
-  rw [Array.min]
-  · induction l
-    · contradiction
-    · rename_i x xs
-      simp only [List.getElem_toArray, List.getElem_cons_zero, List.size_toArray, List.length_cons]
-      rw [List.toArray_cons, foldl_eq_foldl_extract]
-      rw [← Array.foldl_toList, Array.toList_extract, List.extract_eq_drop_take]
-      simp [List.min]
-
-public theorem _root_.List.min_eq_min_toArray [Min α] {l : List α} {h} :
-    l.min h = l.toArray.min (by simpa [List.ne_nil_iff_length_pos] using h) := by
-  simp
-
-@[simp, grind =]
-public theorem min_toList [Min α] {xs : Array α} {h} :
-    xs.toList.min h = xs.min (by simpa [List.ne_nil_iff_length_pos] using h) := by
-  cases xs; simp
-
-public theorem min_eq_min_toList [Min α] {xs : Array α} {h} :
-    xs.min h = xs.toList.min (by simpa [List.ne_nil_iff_length_pos] using h) := by
-  simp
-
-@[simp, grind =]
-public theorem _root_.List.min?_toArray [Min α] {l : List α} :
-    l.toArray.min? = l.min? := by
-  rw [Array.min?]
-  split
-  · simp [List.min_toArray, List.min_eq_get_min?, - List.get_min?]
-  · simp_all
-
-@[simp, grind =]
-public theorem min?_toList [Min α] {xs : Array α} :
-    xs.toList.min? = xs.min? := by
-  cases xs; simp
-
-@[simp, grind =]
-public theorem _root_.List.max_toArray [Max α] {l : List α} {h} :
-    l.toArray.max h = l.max (by simpa [List.ne_nil_iff_length_pos] using h) := by
-  let h' : l ≠ [] := by simpa [List.ne_nil_iff_length_pos] using h
-  change l.toArray.max h = l.max h'
-  rw [Array.max]
-  · induction l
-    · contradiction
-    · rename_i x xs
-      simp only [List.getElem_toArray, List.getElem_cons_zero, List.size_toArray, List.length_cons]
-      rw [List.toArray_cons, foldl_eq_foldl_extract]
-      rw [← Array.foldl_toList, Array.toList_extract, List.extract_eq_drop_take]
-      simp [List.max]
-
-public theorem _root_.List.max_eq_max_toArray [Max α] {l : List α} {h} :
-    l.max h = l.toArray.max (by simpa [List.ne_nil_iff_length_pos] using h) := by
-  simp
-
-@[simp, grind =]
-public theorem max_toList [Max α] {xs : Array α} {h} :
-    xs.toList.max h = xs.max (by simpa [List.ne_nil_iff_length_pos] using h) := by
-  cases xs; simp
-
-public theorem max_eq_max_toList [Max α] {xs : Array α} {h} :
-    xs.max h = xs.toList.max (by simpa [List.ne_nil_iff_length_pos] using h) := by
-  simp
-
-@[simp, grind =]
-public theorem _root_.List.max?_toArray [Max α] {l : List α} :
-    l.toArray.max? = l.max? := by
-  rw [Array.max?]
-  split
-  · simp [List.max_toArray, List.max_eq_get_max?, - List.get_max?]
-  · simp_all
-
-@[simp, grind =]
-public theorem max?_toList [Max α] {xs : Array α} :
-    xs.toList.max? = xs.max? := by
-  cases xs; simp
-
-/-! ### Lemmas about `min?` -/
-
-@[simp, grind =]
-public theorem min?_empty [Min α] : (#[] : Array α).min? = none :=
-  (rfl)
-
-@[simp, grind =]
-public theorem min?_singleton [Min α] {x : α} : #[x].min? = some x :=
-  (rfl)
-
--- We don't put `@[simp]` on `min?_singleton_append'`,
--- because the definition in terms of `foldl` is not useful for proofs.
-public theorem min?_singleton_append' [Min α] {xs : Array α} :
-    (#[x] ++ xs).min? = some (xs.foldl min x) := by
-  simp [← min?_toList, toList_append, List.min?]
-
-@[simp]
-public theorem min?_singleton_append [Min α] [Std.Associative (min : α → α → α)] {xs : Array α} :
-    (#[x] ++ xs).min? = some (xs.min?.elim x (min x)) := by
-  simp [← min?_toList, toList_append, List.min?_cons]
-
-@[simp, grind =]
-public theorem min?_eq_none_iff {xs : Array α} [Min α] : xs.min? = none ↔ xs = #[] := by
-  rcases xs with ⟨l⟩
-  simp
-
-@[simp, grind =]
-public theorem isSome_min?_iff {xs : Array α} [Min α] : xs.min?.isSome ↔ xs ≠ #[] := by
-  rcases xs with ⟨l⟩
-  simp
-
-@[grind .]
-public theorem isSome_min?_of_mem {xs : Array α} [Min α] {a : α} (h : a ∈ xs) :
-    xs.min?.isSome := by
-  rw [← min?_toList]
-  apply List.isSome_min?_of_mem (a := a)
-  simpa
-
-public theorem isSome_min?_of_ne_empty [Min α] (xs : Array α) (h : xs ≠ #[]) : xs.min?.isSome := by
-  rw [← min?_toList]
-  apply List.isSome_min?_of_ne_nil
-  simpa
-
-public theorem min?_mem [Min α] [Std.MinEqOr α] (xs : Array α) (h : xs.min? = some a) : a ∈ xs := by
-  rw [← min?_toList] at h
-  simpa using List.min?_mem h
-
-public theorem le_min?_iff [Min α] [LE α] [Std.LawfulOrderInf α] :
-    {xs : Array α} → xs.min? = some a → ∀ {x}, x ≤ a ↔ ∀ b, b ∈ xs → x ≤ b := by
-  intro xs h x
-  simp only [← min?_toList] at h
-  simpa using List.le_min?_iff h
-
-public theorem min?_eq_some_iff [Min α] [LE α] {xs : Array α} [Std.IsLinearOrder α]
-    [Std.LawfulOrderMin α] : xs.min? = some a ↔ a ∈ xs ∧ ∀ b, b ∈ xs → a ≤ b := by
-  rcases xs with ⟨l⟩
-  simpa using List.min?_eq_some_iff
-
-public theorem min?_replicate [Min α] [Std.IdempotentOp (min : α → α → α)] {n : Nat} {a : α} :
-    (replicate n a).min? = if n = 0 then none else some a := by
-  rw [← List.toArray_replicate, List.min?_toArray, List.min?_replicate]
-
-@[simp, grind =]
-public theorem min?_replicate_of_pos [Min α] [Std.MinEqOr α] {n : Nat} {a : α} (h : 0 < n) :
-    (replicate n a).min? = some a := by
-  simp [min?_replicate, Nat.ne_of_gt h]
-
-public theorem foldl_min [Min α] [Std.IdempotentOp (min : α → α → α)]
-    [Std.Associative (min : α → α → α)] {xs : Array α} {a : α} :
-    xs.foldl (init := a) min = min a (xs.min?.getD a) := by
-  rcases xs with ⟨l⟩
-  simp [List.foldl_min]
-
-/-! ### Lemmas about `max?` -/
-
-@[simp, grind =]
-public theorem max?_empty [Max α] : (#[] : Array α).max? = none :=
-  (rfl)
-
-@[simp, grind =]
-public theorem max?_singleton [Max α] {x : α} : #[x].max? = some x :=
-  (rfl)
-
--- We don't put `@[simp]` on `max?_singleton_append'`,
--- because the definition in terms of `foldl` is not useful for proofs.
-public theorem max?_singleton_append' [Max α] {xs : Array α} : (#[x] ++ xs).max? = some (xs.foldl max x) := by
-  simp [← max?_toList, toList_append, List.max?]
-
-@[simp]
-public theorem max?_singleton_append [Max α] [Std.Associative (max : α → α → α)] {xs : Array α} :
-    (#[x] ++ xs).max? = some (xs.max?.elim x (max x)) := by
-  simp [← max?_toList, toList_append, List.max?_cons]
-
-@[simp, grind =]
-public theorem max?_eq_none_iff {xs : Array α} [Max α] : xs.max? = none ↔ xs = #[] := by
-  rcases xs with ⟨l⟩
-  simp
-
-@[simp, grind =]
-public theorem isSome_max?_iff {xs : Array α} [Max α] : xs.max?.isSome ↔ xs ≠ #[] := by
-  rcases xs with ⟨l⟩
-  simp
-
-@[grind .]
-public theorem isSome_max?_of_mem {xs : Array α} [Max α] {a : α} (h : a ∈ xs) :
-    xs.max?.isSome := by
-  rw [← max?_toList]
-  apply List.isSome_max?_of_mem (a := a)
-  simpa
-
-public theorem isSome_max?_of_ne_empty [Max α] (xs : Array α) (h : xs ≠ #[]) : xs.max?.isSome := by
-  rw [← max?_toList]
-  apply List.isSome_max?_of_ne_nil
-  simpa
-
-public theorem max?_mem [Max α] [Std.MaxEqOr α] (xs : Array α) (h : xs.max? = some a) : a ∈ xs := by
-  rw [← max?_toList] at h
-  simpa using List.max?_mem h
-
-public theorem max?_le_iff [Max α] [LE α] [Std.LawfulOrderSup α] :
-    {xs : Array α} → xs.max? = some a → ∀ {x}, a ≤ x ↔ ∀ b, b ∈ xs → b ≤ x := by
-  intro xs h x
-  simp only [← max?_toList] at h
-  simpa using List.max?_le_iff h
-
-public theorem max?_eq_some_iff [Max α] [LE α] {xs : Array α} [Std.IsLinearOrder α]
-    [Std.LawfulOrderMax α] : xs.max? = some a ↔ a ∈ xs ∧ ∀ b, b ∈ xs → b ≤ a := by
-  rcases xs with ⟨l⟩
-  simpa using List.max?_eq_some_iff
-
-public theorem max?_replicate [Max α] [Std.IdempotentOp (max : α → α → α)] {n : Nat} {a : α} :
-    (replicate n a).max? = if n = 0 then none else some a := by
-  rw [← List.toArray_replicate, List.max?_toArray, List.max?_replicate]
-
-@[simp, grind =]
-public theorem max?_replicate_of_pos [Max α] [Std.MaxEqOr α] {n : Nat} {a : α} (h : 0 < n) :
-    (replicate n a).max? = some a := by
-  simp [max?_replicate, Nat.ne_of_gt h]
-
-public theorem foldl_max [Max α] [Std.IdempotentOp (max : α → α → α)] [Std.Associative (max : α → α → α)]
-    {xs : Array α} {a : α} : xs.foldl (init := a) max = max a (xs.max?.getD a) := by
-  rcases xs with ⟨l⟩
-  simp [List.foldl_max]
-
-/-! ### Lemmas about `min` -/
-
-@[simp, grind =]
-theorem min_singleton [Min α] {x : α} :
-    #[x].min (ne_empty_of_size_eq_add_one rfl) = x := by
-  (rfl)
-
-public theorem min?_eq_some_min [Min α] : {xs : Array α} → (h : xs ≠ #[]) →
-    xs.min? = some (xs.min h)
-  | ⟨a::as⟩, _ => by simp [Array.min, Array.min?]
-
-public theorem min_eq_get_min? [Min α] : (xs : Array α) → (h : xs ≠ #[]) →
-    xs.min h = xs.min?.get (xs.isSome_min?_of_ne_empty h)
-  | ⟨a::as⟩, _ => by simp [Array.min, Array.min?]
-
-@[simp, grind =]
-public theorem get_min? [Min α] {xs : Array α} {h : xs.min?.isSome} :
-    xs.min?.get h = xs.min (isSome_min?_iff.mp h) := by
-  simp [min?_eq_some_min (isSome_min?_iff.mp h)]
-
-@[grind .]
-public theorem min_mem [Min α] [Std.MinEqOr α] {xs : Array α} (h : xs ≠ #[]) : xs.min h ∈ xs :=
-  xs.min?_mem (min?_eq_some_min h)
-
-@[grind .]
-public theorem min_le_of_mem [Min α] [LE α] [Std.IsLinearOrder α] [Std.LawfulOrderMin α]
-    {xs : Array α} {a : α} (ha : a ∈ xs) :
-    xs.min (ne_empty_of_mem ha) ≤ a :=
-  (Array.min?_eq_some_iff.mp (min?_eq_some_min (ne_empty_of_mem ha))).right a ha
-
-public protected theorem le_min_iff [Min α] [LE α] [Std.LawfulOrderInf α]
-    {xs : Array α} (h : xs ≠ #[]) : ∀ {x}, x ≤ xs.min h ↔ ∀ b, b ∈ xs → x ≤ b :=
-  le_min?_iff (min?_eq_some_min h)
-
-public theorem min_eq_iff [Min α] [LE α] {xs : Array α} [Std.IsLinearOrder α] [Std.LawfulOrderMin α]
-    (h : xs ≠ #[]) : xs.min h = a ↔ a ∈ xs ∧ ∀ b, b ∈ xs → a ≤ b := by
-  simpa [min?_eq_some_min h] using (min?_eq_some_iff (xs := xs))
-
-@[simp, grind =]
-public theorem min_replicate [Min α] [Std.MinEqOr α] {n : Nat} {a : α} (h : (replicate n a) ≠ #[]) :
-    (replicate n a).min h = a := by
-  have n_pos : 0 < n := by simpa [Nat.ne_zero_iff_zero_lt] using h
-  simpa [min?_eq_some_min h] using (min?_replicate_of_pos (a := a) n_pos)
-
-public theorem foldl_min_eq_min [Min α] [Std.IdempotentOp (min : α → α → α)]
-    [Std.Associative (min : α → α → α)] {xs : Array α} (h : xs ≠ #[]) {a : α} :
-    xs.foldl min a = min a (xs.min h) := by
-  simpa [min?_eq_some_min h] using foldl_min (xs := xs)
-
-/-! ### Lemmas about `max` -/
-
-@[simp, grind =]
-theorem max_singleton [Max α] {x : α} :
-    #[x].max (ne_empty_of_size_eq_add_one rfl) = x := by
-  (rfl)
-
-public theorem max?_eq_some_max [Max α] : {xs : Array α} → (h : xs ≠ #[]) →
-    xs.max? = some (xs.max h)
-  | ⟨a::as⟩, _ => by simp [Array.max, Array.max?]
-
-public theorem max_eq_get_max? [Max α] : (xs : Array α) → (h : xs ≠ #[]) →
-    xs.max h = xs.max?.get (xs.isSome_max?_of_ne_empty h)
-  | ⟨a::as⟩, _ => by simp [Array.max, Array.max?]
-
-@[simp, grind =]
-public theorem get_max? [Max α] {xs : Array α} {h : xs.max?.isSome} :
-    xs.max?.get h = xs.max (isSome_max?_iff.mp h) := by
-  simp [max?_eq_some_max (isSome_max?_iff.mp h)]
-
-@[grind .]
-public theorem max_mem [Max α] [Std.MaxEqOr α] {xs : Array α} (h : xs ≠ #[]) : xs.max h ∈ xs :=
-  xs.max?_mem (max?_eq_some_max h)
-
-public protected theorem max_le_iff [Max α] [LE α] [Std.LawfulOrderSup α]
-    {xs : Array α} (h : xs ≠ #[]) : ∀ {x}, xs.max h ≤ x ↔ ∀ b, b ∈ xs → b ≤ x :=
-  max?_le_iff (max?_eq_some_max h)
-
-public theorem max_eq_iff [Max α] [LE α] {xs : Array α} [Std.IsLinearOrder α] [Std.LawfulOrderMax α]
-    (h : xs ≠ #[]) : xs.max h = a ↔ a ∈ xs ∧ ∀ b, b ∈ xs → b ≤ a := by
-  simpa [max?_eq_some_max h] using (max?_eq_some_iff (xs := xs))
-
-@[grind .]
-public theorem le_max_of_mem [Max α] [LE α] [Std.IsLinearOrder α] [Std.LawfulOrderMax α]
-    {xs : Array α} {a : α} (ha : a ∈ xs) :
-    a ≤ xs.max (ne_empty_of_mem ha) :=
-  (Array.max?_eq_some_iff.mp (max?_eq_some_max (ne_empty_of_mem ha))).right a ha
-
-@[simp, grind =]
-public theorem max_replicate [Max α] [Std.MaxEqOr α] {n : Nat} {a : α} (h : (replicate n a) ≠ #[]) :
-    (replicate n a).max h = a := by
-  have n_pos : 0 < n := by simpa [Nat.ne_zero_iff_zero_lt] using h
-  simpa [max?_eq_some_max h] using (max?_replicate_of_pos (a := a) n_pos)
-
-public theorem foldl_max_eq_max [Max α] [Std.IdempotentOp (max : α → α → α)]
-    [Std.Associative (max : α → α → α)] {xs : Array α} (h : xs ≠ #[]) {a : α} :
-    xs.foldl max a = max a (xs.max h) := by
-  simpa [max?_eq_some_max h] using foldl_max (xs := xs)
-
-end Array

src/Init/Data/Array/Monadic.lean

@@ -9,7 +9,6 @@ prelude
 import all Init.Data.List.Control
 import all Init.Data.Array.Basic
 public import Init.Data.Array.Attach
-import Init.Data.Bool
 
 public section
 
@@ -40,6 +39,10 @@ theorem map_toList_inj [Monad m] [LawfulMonad m]
 @[simp, grind =] theorem idRun_mapM {xs : Array α} {f : α → Id β} : (xs.mapM f).run = xs.map (f · |>.run) :=
   mapM_pure
 
+@[deprecated idRun_mapM (since := "2025-05-21")]
+theorem mapM_id {xs : Array α} {f : α → Id β} : xs.mapM f = xs.map f :=
+  mapM_pure
+
 @[simp, grind =] theorem mapM_map [Monad m] [LawfulMonad m] {f : α → β} {g : β → m γ} {xs : Array α} :
     (xs.map f).mapM g = xs.mapM (g ∘ f) := by
   rcases xs with ⟨xs⟩
@@ -198,6 +201,13 @@ theorem idRun_forIn'_yield_eq_foldl
       xs.attach.foldl (fun b ⟨a, h⟩ => f a h b |>.run) init := by
   simp
 
+@[deprecated idRun_forIn'_yield_eq_foldl (since := "2025-05-21")]
+theorem forIn'_yield_eq_foldl
+    {xs : Array α} (f : (a : α) → a ∈ xs → β → β) (init : β) :
+    forIn' (m := Id) xs init (fun a m b => .yield (f a m b)) =
+      xs.attach.foldl (fun b ⟨a, h⟩ => f a h b) init :=
+  forIn'_pure_yield_eq_foldl _ _
+
 @[simp, grind =] theorem forIn'_map [Monad m] [LawfulMonad m]
     {xs : Array α} (g : α → β) (f : (b : β) → b ∈ xs.map g → γ → m (ForInStep γ)) :
     forIn' (xs.map g) init f = forIn' xs init fun a h y => f (g a) (mem_map_of_mem h) y := by
@@ -239,6 +249,13 @@ theorem idRun_forIn_yield_eq_foldl
       xs.foldl (fun b a => f a b |>.run) init := by
   simp
 
+@[deprecated idRun_forIn_yield_eq_foldl (since := "2025-05-21")]
+theorem forIn_yield_eq_foldl
+    {xs : Array α} (f : α → β → β) (init : β) :
+    forIn (m := Id) xs init (fun a b => .yield (f a b)) =
+      xs.foldl (fun b a => f a b) init :=
+  forIn_pure_yield_eq_foldl _ _
+
 @[simp, grind =] theorem forIn_map [Monad m] [LawfulMonad m]
     {xs : Array α} {g : α → β} {f : β → γ → m (ForInStep γ)} :
     forIn (xs.map g) init f = forIn xs init fun a y => f (g a) y := by

src/Init/Data/Array/Nat.lean

@@ -1,84 +0,0 @@
-/-
-Copyright (c) 2026 Lean FRO, LLC. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison, Sebastian Graf, Paul Reichert
--/
-module
-
-prelude
-public import Init.Data.Array.MinMax
-import Init.Data.List.Nat.Sum
-import Init.Data.Array.Lemmas
-
-public section
-
-set_option linter.listVariables true -- Enforce naming conventions for `List`/`Array`/`Vector` variables.
-set_option linter.indexVariables true -- Enforce naming conventions for index variables.
-
-namespace Array
-
-protected theorem sum_pos_iff_exists_pos_nat {xs : Array Nat} : 0 < xs.sum ↔ ∃ x ∈ xs, 0 < x := by
-  simp [← sum_toList, List.sum_pos_iff_exists_pos_nat]
-
-protected theorem sum_eq_zero_iff_forall_eq_nat {xs : Array Nat} :
-    xs.sum = 0 ↔ ∀ x ∈ xs, x = 0 := by
-  simp [← sum_toList, List.sum_eq_zero_iff_forall_eq_nat]
-
-@[simp] theorem sum_replicate_nat {n : Nat} {a : Nat} : (replicate n a).sum = n * a := by
-  rw [← List.toArray_replicate, List.sum_toArray]
-  simp
-
-theorem sum_append_nat {as₁ as₂ : Array Nat} : (as₁ ++ as₂).sum = as₁.sum + as₂.sum := by
-  simp [sum_append]
-
-theorem sum_reverse_nat (xs : Array Nat) : xs.reverse.sum = xs.sum := by
-  simp [sum_reverse]
-
-theorem sum_eq_foldl_nat {xs : Array Nat} : xs.sum = xs.foldl (init := 0) (· + ·) := by
-  simp only [foldl_eq_foldr_reverse, Nat.add_comm, ← sum_eq_foldr, sum_reverse_nat]
-
-theorem min_mul_length_le_sum_nat {xs : Array Nat} (h : xs ≠ #[]) :
-    xs.min h * xs.size ≤ xs.sum := by
-  rcases xs with ⟨l⟩
-  simpa [List.min_toArray, List.sum_toArray] using List.min_mul_length_le_sum_nat (by simpa using h)
-
-theorem mul_length_le_sum_of_min?_eq_some_nat {xs : Array Nat} (h : xs.min? = some x) :
-    x * xs.size ≤ xs.sum := by
-  rcases xs with ⟨l⟩
-  simpa [List.min?_toArray, List.sum_toArray] using
-    List.mul_length_le_sum_of_min?_eq_some_nat (by simpa using h)
-
-theorem min_le_sum_div_length_nat {xs : Array Nat} (h : xs ≠ #[]) :
-    xs.min h ≤ xs.sum / xs.size := by
-  rcases xs with ⟨l⟩
-  simpa [List.min_toArray, List.sum_toArray] using List.min_le_sum_div_length_nat (by simpa using h)
-
-theorem le_sum_div_length_of_min?_eq_some_nat {xs : Array Nat} (h : xs.min? = some x) :
-    x ≤ xs.sum / xs.size := by
-  rcases xs with ⟨l⟩
-  simpa [List.min?_toArray, List.sum_toArray] using
-    List.le_sum_div_length_of_min?_eq_some_nat (by simpa using h)
-
-theorem sum_le_max_mul_length_nat {xs : Array Nat} (h : xs ≠ #[]) :
-    xs.sum ≤ xs.max h * xs.size := by
-  rcases xs with ⟨l⟩
-  simpa [List.max_toArray, List.sum_toArray] using List.sum_le_max_mul_length_nat (by simpa using h)
-
-theorem sum_le_max_mul_length_of_max?_eq_some_nat {xs : Array Nat} (h : xs.max? = some x) :
-    xs.sum ≤ x * xs.size := by
-  rcases xs with ⟨l⟩
-  simpa [List.max?_toArray, List.sum_toArray] using
-    List.sum_le_max_mul_length_of_max?_eq_some_nat (by simpa using h)
-
-theorem sum_div_length_le_max_nat {xs : Array Nat} (h : xs ≠ #[]) :
-    xs.sum / xs.size ≤ xs.max h := by
-  rcases xs with ⟨l⟩
-  simpa [List.max_toArray, List.sum_toArray] using List.sum_div_length_le_max_nat (by simpa using h)
-
-theorem sum_div_length_le_max_of_max?_eq_some_nat {xs : Array Nat} (h : xs.max? = some x) :
-    xs.sum / xs.size ≤ x := by
-  rcases xs with ⟨l⟩
-  simpa [List.max?_toArray, List.sum_toArray] using
-    List.sum_div_length_le_max_of_max?_eq_some_nat (by simpa using h)
-
-end Array

src/Init/Data/Array/OfFn.lean

@@ -7,13 +7,8 @@ module
 
 prelude
 import all Init.Data.Array.Basic
-public import Init.Data.List.OfFn
-import Init.Data.Array.Bootstrap
-import Init.Data.Array.Monadic
-import Init.Data.Fin.Lemmas
-import Init.Data.List.FinRange
-import Init.Data.Option.Lemmas
-import Init.Omega
+public import Init.Data.Array.Monadic
+public import Init.Data.List.FinRange
 
 public section
 
@@ -58,11 +53,6 @@ theorem ofFn_succ' {f : Fin (n+1) → α} :
   apply Array.toList_inj.mp
   simp [List.ofFn_succ]
 
-@[simp]
-theorem ofFn_getElem {xs : Array α} :
-    Array.ofFn (fun i : Fin xs.size => xs[i.val]) = xs := by
-  ext <;> simp
-
 @[simp]
 theorem ofFn_eq_empty_iff {f : Fin n → α} : ofFn f = #[] ↔ n = 0 := by
   rw [← Array.toList_inj]
@@ -77,12 +67,6 @@ theorem mem_ofFn {n} {f : Fin n → α} {a : α} : a ∈ ofFn f ↔ ∃ i, f i =
   · rintro ⟨i, rfl⟩
     apply mem_of_getElem (i := i) <;> simp
 
-@[simp, grind =]
-theorem map_ofFn {f : Fin n → α} {g : α → β} :
-    (Array.ofFn f).map g = Array.ofFn (g ∘ f) := by
-  apply Array.ext_getElem?
-  simp [Array.getElem?_ofFn]
-
 /-! ### ofFnM -/
 
 /-- Construct (in a monadic context) an array by applying a monadic function to each index. -/

src/Init/Data/Array/Perm.lean

@@ -6,13 +6,9 @@ Authors: Kim Morrison
 module
 
 prelude
+public import Init.Data.List.Nat.Perm
 import all Init.Data.Array.Basic
-public import Init.Data.Array.Basic
-import Init.Data.Array.Lemmas
-import Init.Data.List.Nat.Perm
-import Init.Data.List.Nat.TakeDrop
-import Init.Data.List.Perm
-import Init.Omega
+public import Init.Data.Array.Lemmas
 
 public section
 

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

@@ -8,7 +8,6 @@ module
 prelude
 public import Init.Data.Vector.Basic
 public import Init.Data.Ord.Basic
-import Init.Omega
 
 public section
 

src/Init/Data/Array/Range.lean

@@ -8,16 +8,8 @@ module
 prelude
 import all Init.Data.Array.Basic
 import all Init.Data.Array.OfFn
-public import Init.BinderPredicates
-public import Init.Data.Nat.Lemmas
-public import Init.Ext
-import Init.ByCases
-import Init.Data.Array.Count
-import Init.Data.Array.MapIdx
-import Init.Data.Array.Zip
-import Init.Data.List.Find
-import Init.Data.List.Nat.Range
-import Init.Data.List.Range
+public import Init.Data.Array.MapIdx
+public import Init.Data.Array.Zip
 
 public section
 

src/Init/Data/Array/Subarray.lean

@@ -7,6 +7,7 @@ module
 
 prelude
 public import Init.Data.Array.Basic
+import Init.Data.Array.GetLit
 public import Init.Data.Slice.Basic
 
 public section
@@ -279,7 +280,7 @@ Checks whether any of the elements in a subarray satisfy a Boolean predicate.
 The elements are tested starting at the lowest index and moving up. The search terminates as soon as
 an element that satisfies the predicate is found.
 -/
-@[inline, suggest_for Subarray.some]
+@[inline]
 def any {α : Type u} (p : α → Bool) (as : Subarray α) : Bool :=
   Id.run <| as.anyM (pure <| p ·)
 
@@ -289,7 +290,7 @@ Checks whether all of the elements in a subarray satisfy a Boolean predicate.
 The elements are tested starting at the lowest index and moving up. The search terminates as soon as
 an element that does not satisfy the predicate is found.
 -/
-@[inline, suggest_for Subarray.every]
+@[inline]
 def all {α : Type u} (p : α → Bool) (as : Subarray α) : Bool :=
   Id.run <| as.allM (pure <| p ·)