chore: typo

.github/workflows/ci.yml

@@ -298,8 +298,8 @@ jobs:
         uses: msys2/setup-msys2@v2
         with:
           msystem: clang64
-          # `:` means do not prefix with msystem
-          pacboy: "make: python: cmake clang ccache gmp git: zip: unzip: diffutils: binutils: tree: zstd tar:"
+          # `:p` means prefix with appropriate msystem prefix
+          pacboy: "make python cmake:p clang:p ccache:p gmp:p git zip unzip diffutils binutils tree zstd:p tar"
         if: runner.os == 'Windows'
       - name: Install Brew Packages
         run: |
@@ -426,7 +426,7 @@ jobs:
         if: matrix.test-speedcenter
       - name: Check Stage 3
         run: |
-          make -C build -j$NPROC check-stage3
+          make -C build -j$NPROC stage3
         if: matrix.test-speedcenter
       - name: Test Speedcenter Benchmarks
         run: |
@@ -455,24 +455,12 @@ jobs:
     # mark as merely cancelled not failed if builds are cancelled
     if: ${{ !cancelled() }}
     steps:
-    - if: ${{ contains(needs.*.result, 'failure') && github.repository == 'leanprover/lean4' && github.ref_name == 'master' }}
-      uses: zulip/github-actions-zulip/send-message@v1
-      with:
-        api-key: ${{ secrets.ZULIP_BOT_KEY }}
-        email: "github-actions-bot@lean-fro.zulipchat.com"
-        organization-url: "https://lean-fro.zulipchat.com"
-        to: "infrastructure"
-        topic: "Github actions"
-        type: "stream"
-        content: |
-          A build of `${{ github.ref_name }}`, triggered by event `${{ github.event_name }}`, [failed](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}).
     - if: contains(needs.*.result, 'failure')
       uses: actions/github-script@v7
       with:
         script: |
             core.setFailed('Some jobs failed')
 
-
   # This job creates releases from tags
   # (whether they are "unofficial" releases for experiments, or official releases when the tag is "v" followed by a semver string.)
   # We do not attempt to automatically construct a changelog here:
@@ -545,8 +533,3 @@ jobs:
           gh workflow -R leanprover/release-index run update-index.yml
         env:
           GITHUB_TOKEN: ${{ secrets.RELEASE_INDEX_TOKEN }}
-      - name: Update toolchain on mathlib4's nightly-testing branch
-        run: |
-          gh workflow -R leanprover-community/mathlib4 run nightly_bump_toolchain.yml
-        env:
-          GITHUB_TOKEN: ${{ secrets.MATHLIB4_BOT }}

.github/workflows/jira.yml

@@ -1,34 +0,0 @@
-name: Jira sync
-
-on:
-  issues:
-    types: [closed]
-
-jobs:
-  jira-sync:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Move Jira issue to Done
-        env:
-          JIRA_API_TOKEN: ${{ secrets.JIRA_API_TOKEN }}
-          JIRA_USERNAME: ${{ secrets.JIRA_USERNAME }}
-          JIRA_BASE_URL: ${{ secrets.JIRA_BASE_URL }}
-        run: |
-          issue_number=${{ github.event.issue.number }}
-
-          jira_issue_key=$(curl -s -u "${JIRA_USERNAME}:${JIRA_API_TOKEN}" \
-            -X GET -H "Content-Type: application/json" \
-            "${JIRA_BASE_URL}/rest/api/2/search?jql=summary~\"${issue_number}\"" | \
-            jq -r '.issues[0].key')
-
-          if [ -z "$jira_issue_key" ]; then
-            exit
-          fi
-
-          curl -s -u "${JIRA_USERNAME}:${JIRA_API_TOKEN}" \
-            -X POST -H "Content-Type: application/json" \
-            --data "{\"transition\": {\"id\": \"41\"}}" \
-            "${JIRA_BASE_URL}/rest/api/2/issue/${jira_issue_key}/transitions"
-
-          echo "Moved Jira issue ${jira_issue_key} to Done"

.github/workflows/nix-ci.yml

@@ -103,7 +103,7 @@ jobs:
         continue-on-error: true
       - name: Build manual
         run: |
-          nix build $NIX_BUILD_ARGS --update-input lean --no-write-lock-file ./doc#{lean-mdbook,leanInk,alectryon,inked} -o push-doc
+          nix build $NIX_BUILD_ARGS --update-input lean --no-write-lock-file ./doc#{lean-mdbook,leanInk,alectryon,test,inked} -o push-doc
           nix build $NIX_BUILD_ARGS --update-input lean --no-write-lock-file ./doc
           # https://github.com/netlify/cli/issues/1809
           cp -r --dereference ./result ./dist
@@ -146,3 +146,5 @@ jobs:
       - name: Fixup CCache Cache
         run: |
           sudo chown -R $USER /nix/var/cache
+      - name: CCache stats
+        run: CCACHE_DIR=/nix/var/cache/ccache nix run .#nixpkgs.ccache -- -s

CONTRIBUTING.md

@@ -63,20 +63,6 @@ Because the change will be squashed, there is no need to polish the commit messa
 Reviews and Feedback:
 ----
 
-The lean4 repo is managed by the Lean FRO's *triage team* that aims to provide initial feedback on new bug reports, PRs, and RFCs weekly.
-This feedback generally consists of prioritizing the ticket using one of the following categories:
-* label `P-high`: We will work on this issue
-* label `P-medium`: We may work on this issue if we find the time
-* label `P-low`: We are not planning to work on this issue
-* *closed*: This issue is already fixed, it is not an issue, or is not sufficiently compatible with our roadmap for the project and we will not work on it nor accept external contributions on it
-
-For *bug reports*, the listed priority reflects our commitment to fixing the issue.
-It is generally indicative but not necessarily identical to the priority an external contribution addressing this bug would receive.
-For *PRs* and *RFCs*, the priority reflects our commitment to reviewing them and getting them to an acceptable state.
-Accepted RFCs are marked with the label `RFC accepted` and afterwards assigned a new "implementation" priority as with bug reports.
-
-General guidelines for interacting with reviews and feedback:
-
 **Be Patient**: Given the limited number of full-time maintainers and the volume of PRs, reviews may take some time.
 
 **Engage Constructively**: Always approach feedback positively and constructively. Remember, reviews are about ensuring the best quality for the project, not personal criticism.

RELEASES.md

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

doc/dev/debugging.md

@@ -5,7 +5,7 @@ Some notes on how to debug Lean, which may also be applicable to debugging Lean
 
 ## Tracing
 
-In `CoreM` and derived monads, we use `trace[traceCls] "msg with {interpolations}"` to fill the structured trace viewable with `set_option trace.traceCls true`.
+In `CoreM` and derived monads, we use `trace![traceCls] "msg with {interpolations}"` to fill the structured trace viewable with `set_option trace.traceCls true`.
 New trace classes have to be registered using `registerTraceClass` first.
 
 Notable trace classes:
@@ -22,9 +22,7 @@ Notable trace classes:
 
 In pure contexts or when execution is aborted before the messages are finally printed, one can instead use the term `dbg_trace "msg with {interpolations}"; val` (`;` can also be replaced by a newline), which will print the message to stderr before evaluating `val`. `dbgTraceVal val` can be used as a shorthand for `dbg_trace "{val}"; val`.
 Note that if the return value is not actually used, the trace code is silently dropped as well.
-
-By default, such stderr output is buffered and shown as messages after a command has been elaborated, which is necessary to ensure deterministic ordering of messages under parallelism.
-If Lean aborts the process before it can finish the command or takes too long to do that, using `-DstderrAsMessages=false` avoids this buffering and shows `dbg_trace` output (but not `trace`s or other diagnostics) immediately.
+In the language server, stderr output is buffered and shown as messages after a command has been elaborated, unless the option `server.stderrAsMessages` is deactivated.
 
 ## Debuggers
 

doc/dev/release_checklist.md

@@ -5,11 +5,8 @@ See below for the checklist for release candidates.
 
 We'll use `v4.6.0` as the intended release version as a running example.
 
-- One week before the planned release, ensure that
-  (1) someone has written the release notes and
-  (2) someone has written the first draft of the release blog post.
-  If there is any material in `./releases_drafts/` on the `releases/v4.6.0` branch, then the release notes are not done.
-  (See the section "Writing the release notes".)
+- One week before the planned release, ensure that (1) someone has written the release notes and (2) someone has written the first draft of the release blog post.
+  If there is any material in `./releases_drafts/`, then the release notes are not done. (See the section "Writing the release notes".)
 - `git checkout releases/v4.6.0`
   (This branch should already exist, from the release candidates.)
 - `git pull`
@@ -147,31 +144,33 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
   - You can monitor this at `https://github.com/leanprover/lean4/actions/workflows/ci.yml`, looking for the `v4.7.0-rc1` tag.
   - This step can take up to an hour.
 - (GitHub release notes) Once the release appears at https://github.com/leanprover/lean4/releases/
-  - Verify that the release is marked as a prerelease (this should have been done automatically by the CI release job).
-  - In the "previous tag" dropdown, select `v4.6.0`, and click "Generate release notes".
+  - Edit the release notes on Github to select the "Set as a pre-release box".
+  - If release notes have been written already, copy the section of `RELEASES.md` for this version into the Github release notes
+    and use the title "Changes since v4.6.0 (from RELEASES.md)".
+  - Otherwise, in the "previous tag" dropdown, select `v4.6.0`, and click "Generate release notes".
     This will add a list of all the commits since the last stable version.
+    - Delete anything already mentioned in the hand-written release notes above.
     - Delete "update stage0" commits, and anything with a completely inscrutable commit message.
+    - Briefly rearrange the remaining items by category (e.g. `simp`, `lake`, `bug fixes`),
+      but for minor items don't put any work in expanding on commit messages.
+  - (How we want to release notes to look is evolving: please update this section if it looks wrong!)
 - Next, we will move a curated list of downstream repos to the release candidate.
-  - This assumes that for each repository either:
-    * There is already a *reviewed* branch `bump/v4.7.0` containing the required adaptations.
-      The preparation of this branch is beyond the scope of this document.
-    * The repository does not need any changes to move to the new version.
+  - This assumes that there is already a *reviewed* branch `bump/v4.7.0` on each repository
+    containing the required adaptations (or no adaptations are required).
+    The preparation of this branch is beyond the scope of this document.
   - For each of the target repositories:
-    - If the repository does not need any changes (i.e. `bump/v4.7.0` does not exist) then create
-      a new PR updating `lean-toolchain` to `leanprover/lean4:v4.7.0-rc1` and running `lake update`.
-    - Otherwise:
-      - Checkout the `bump/v4.7.0` branch.
-      - Verify that the `lean-toolchain` is set to the nightly from which the release candidate was created.
-      - `git merge origin/master`
-      - Change the `lean-toolchain` to `leanprover/lean4:v4.7.0-rc1`
-      - In `lakefile.lean`, change any dependencies which were using `nightly-testing` or `bump/v4.7.0` branches
-        back to `master` or `main`, and run `lake update` for those dependencies.
-      - Run `lake build` to ensure that dependencies are found (but it's okay to stop it after a moment).
-      - `git commit`
-      - `git push`
-      - Open a PR from `bump/v4.7.0` to `master`, and either merge it yourself after CI, if appropriate,
-        or notify the maintainers that it is ready to go.
-    - Once the PR has been merged, tag `master` with `v4.7.0-rc1` and push this tag.
+    - Checkout the `bump/v4.7.0` branch.
+    - Verify that the `lean-toolchain` is set to the nightly from which the release candidate was created.
+    - `git merge origin/master`
+    - Change the `lean-toolchain` to `leanprover/lean4:v4.7.0-rc1`
+    - In `lakefile.lean`, change any dependencies which were using `nightly-testing` or `bump/v4.7.0` branches
+      back to `master` or `main`, and run `lake update` for those dependencies.
+    - Run `lake build` to ensure that dependencies are found (but it's okay to stop it after a moment).
+    - `git commit`
+    - `git push`
+    - Open a PR from `bump/v4.7.0` to `master`, and either merge it yourself after CI, if appropriate,
+      or notify the maintainers that it is ready to go.
+    - Once this PR has been merged, tag `master` with `v4.7.0-rc1` and push this tag.
   - We do this for the same list of repositories as for stable releases, see above.
     As above, there are dependencies between these, and so the process above is iterative.
     It greatly helps if you can merge the `bump/v4.7.0` PRs yourself!
@@ -188,8 +187,6 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
   Please also make sure that whoever is handling social media knows the release is out.
 - Begin the next development cycle (i.e. for `v4.8.0`) on the Lean repository, by making a PR that:
   - Updates `src/CMakeLists.txt` to say `set(LEAN_VERSION_MINOR 8)`
-  - Replaces the "release notes will be copied" text in the `v4.6.0` section of `RELEASES.md` with the
-    finalized release notes from the `releases/v4.6.0` branch.
   - Replaces the "development in progress" in the `v4.7.0` section of `RELEASES.md` with
     ```
     Release candidate, release notes will be copied from `branch releases/v4.7.0` once completed.
@@ -225,15 +222,12 @@ Please read https://leanprover-community.github.io/contribute/tags_and_branches.
   * This can either be done by the person managing this process directly,
     or by soliciting assistance from authors of files, or generally helpful people on Zulip!
 * Each repo has a `bump/v4.7.0` which accumulates reviewed changes adapting to new versions.
-* Once `nightly-testing` is working on a given nightly, say `nightly-2024-02-15`, we will create a PR to `bump/v4.7.0`.
-* For Mathlib, there is a script in `scripts/create-adaptation-pr.sh` that automates this process.
-* For Batteries and Aesop it is currently manual.
-* For all of these repositories, the process is the same:
+* Once `nightly-testing` is working on a given nightly, say `nightly-2024-02-15`, we:
   * Make sure `bump/v4.7.0` is up to date with `master` (by merging `master`, no PR necessary)
   * Create from `bump/v4.7.0` a `bump/nightly-2024-02-15` branch.
-  * In that branch, `git merge nightly-testing` to bring across changes from `nightly-testing`.
+  * In that branch, `git merge --squash nightly-testing` to bring across changes from `nightly-testing`.
   * Sanity check changes, commit, and make a PR to `bump/v4.7.0` from the `bump/nightly-2024-02-15` branch.
-  * Solicit review, merge the PR into `bump/v4.7.0`.
+  * Solicit review, merge the PR into `bump/v4,7,0`.
 * It is always okay to merge in the following directions:
   `master` -> `bump/v4.7.0` -> `bump/nightly-2024-02-15` -> `nightly-testing`.
   Please remember to push any merges you make to intermediate steps!
@@ -245,7 +239,7 @@ The exact steps are a work in progress.
 Here is the general idea:
 
 * The work is done right on the `releases/v4.6.0` branch sometime after it is created but before the stable release is made.
-  The release notes for `v4.6.0` will later be copied to `master` when we begin a new development cycle.
+  The release notes for `v4.6.0` will be copied to `master`.
 * There can be material for release notes entries in commit messages.
 * There can also be pre-written entries in `./releases_drafts`, which should be all incorporated in the release notes and then deleted from the branch.
   See `./releases_drafts/README.md` for more information.

doc/examples/interp.lean

@@ -149,4 +149,4 @@ def fact : Expr ctx (Ty.fn Ty.int Ty.int) :=
            (op (·*·) (delay fun _ => app fact (op (·-·) (var stop) (val 1))) (var stop)))
   decreasing_by sorry
 
-#eval! fact.interp Env.nil 10
+#eval fact.interp Env.nil 10

doc/flake.lock

@@ -18,15 +18,12 @@
       }
     },
     "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
       "locked": {
-        "lastModified": 1710146030,
-        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
+        "lastModified": 1656928814,
+        "narHash": "sha256-RIFfgBuKz6Hp89yRr7+NR5tzIAbn52h8vT6vXkYjZoM=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
+        "rev": "7e2a3b3dfd9af950a856d66b0a7d01e3c18aa249",
         "type": "github"
       },
       "original": {
@@ -38,12 +35,13 @@
     "lean": {
       "inputs": {
         "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs",
-        "nixpkgs-old": "nixpkgs-old"
+        "lean4-mode": "lean4-mode",
+        "nix": "nix",
+        "nixpkgs": "nixpkgs_2"
       },
       "locked": {
         "lastModified": 0,
-        "narHash": "sha256-saRAtQ6VautVXKDw1XH35qwP0KEBKTKZbg/TRa4N9Vw=",
+        "narHash": "sha256-YnYbmG0oou1Q/GE4JbMNb8/yqUVXBPIvcdQQJHBqtPk=",
         "path": "../.",
         "type": "path"
       },
@@ -52,6 +50,22 @@
         "type": "path"
       }
     },
+    "lean4-mode": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1659020985,
+        "narHash": "sha256-+dRaXB7uvN/weSZiKcfSKWhcdJVNg9Vg8k0pJkDNjpc=",
+        "owner": "leanprover",
+        "repo": "lean4-mode",
+        "rev": "37d5c99b7b29c80ab78321edd6773200deb0bca6",
+        "type": "github"
+      },
+      "original": {
+        "owner": "leanprover",
+        "repo": "lean4-mode",
+        "type": "github"
+      }
+    },
     "leanInk": {
       "flake": false,
       "locked": {
@@ -69,6 +83,22 @@
         "type": "github"
       }
     },
+    "lowdown-src": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1633514407,
+        "narHash": "sha256-Dw32tiMjdK9t3ETl5fzGrutQTzh2rufgZV4A/BbxuD4=",
+        "owner": "kristapsdz",
+        "repo": "lowdown",
+        "rev": "d2c2b44ff6c27b936ec27358a2653caaef8f73b8",
+        "type": "github"
+      },
+      "original": {
+        "owner": "kristapsdz",
+        "repo": "lowdown",
+        "type": "github"
+      }
+    },
     "mdBook": {
       "flake": false,
       "locked": {
@@ -85,13 +115,65 @@
         "type": "github"
       }
     },
+    "nix": {
+      "inputs": {
+        "lowdown-src": "lowdown-src",
+        "nixpkgs": "nixpkgs",
+        "nixpkgs-regression": "nixpkgs-regression"
+      },
+      "locked": {
+        "lastModified": 1657097207,
+        "narHash": "sha256-SmeGmjWM3fEed3kQjqIAO8VpGmkC2sL1aPE7kKpK650=",
+        "owner": "NixOS",
+        "repo": "nix",
+        "rev": "f6316b49a0c37172bca87ede6ea8144d7d89832f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nix",
+        "type": "github"
+      }
+    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1710889954,
-        "narHash": "sha256-Pr6F5Pmd7JnNEMHHmspZ0qVqIBVxyZ13ik1pJtm2QXk=",
+        "lastModified": 1653988320,
+        "narHash": "sha256-ZaqFFsSDipZ6KVqriwM34T739+KLYJvNmCWzErjAg7c=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "7872526e9c5332274ea5932a0c3270d6e4724f3b",
+        "rev": "2fa57ed190fd6c7c746319444f34b5917666e5c1",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-22.05-small",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-regression": {
+      "locked": {
+        "lastModified": 1643052045,
+        "narHash": "sha256-uGJ0VXIhWKGXxkeNnq4TvV3CIOkUJ3PAoLZ3HMzNVMw=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1657208011,
+        "narHash": "sha256-BlIFwopAykvdy1DYayEkj6ZZdkn+cVgPNX98QVLc0jM=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "2770cc0b1e8faa0e20eb2c6aea64c256a706d4f2",
         "type": "github"
       },
       "original": {
@@ -101,23 +183,6 @@
         "type": "github"
       }
     },
-    "nixpkgs-old": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1581379743,
-        "narHash": "sha256-i1XCn9rKuLjvCdu2UeXKzGLF6IuQePQKFt4hEKRU5oc=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "34c7eb7545d155cc5b6f499b23a7cb1c96ab4d59",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-19.03",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
     "root": {
       "inputs": {
         "alectryon": "alectryon",
@@ -129,21 +194,6 @@
         "leanInk": "leanInk",
         "mdBook": "mdBook"
       }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
     }
   },
   "root": "root",

doc/flake.nix

@@ -17,7 +17,7 @@
   };
 
   outputs = inputs@{ self, ... }: inputs.flake-utils.lib.eachDefaultSystem (system:
-    with inputs.lean.packages.${system}.deprecated; with nixpkgs;
+    with inputs.lean.packages.${system}; with nixpkgs;
     let
       doc-src = lib.sourceByRegex ../. ["doc.*" "tests(/lean(/beginEndAsMacro.lean)?)?"];
     in {
@@ -44,6 +44,21 @@
           mdbook build -d $out
         '';
       };
+      # We use a separate derivation instead of `checkPhase` so we can push it but not `doc` to the binary cache
+      test = stdenv.mkDerivation {
+        name ="lean-doc-test";
+        src = doc-src;
+        buildInputs = [ lean-mdbook stage1.Lean.lean-package strace ];
+        patchPhase = ''
+          cd doc
+          patchShebangs test
+        '';
+        buildPhase = ''
+          mdbook test
+          touch $out
+        '';
+        dontInstall = true;
+      };
       leanInk = (buildLeanPackage {
         name = "Main";
         src = inputs.leanInk;

doc/int.md

@@ -13,7 +13,7 @@ Recall that nonnegative numerals are considered to be a `Nat` if there are no ty
 
 The operator `/` for `Int` implements integer division.
 ```lean
-#eval -10 / 4 -- -3
+#eval -10 / 4 -- -2
 ```
 
 Similar to `Nat`, the internal representation of `Int` is optimized. Small integers are

doc/make/index.md

@@ -27,9 +27,9 @@ Setting up a basic parallelized release build:
 git clone https://github.com/leanprover/lean4
 cd lean4
 cmake --preset release
-make -C build/release -j$(nproc || sysctl -n hw.logicalcpu)
+make -C build/release -j$(nproc)  # see below for macOS
 ```
-You can replace `$(nproc || sysctl -n hw.logicalcpu)` with the desired parallelism amount.
+You can replace `$(nproc)`, which is not available on macOS and some alternative shells, with the desired parallelism amount.
 
 The above commands will compile the Lean library and binaries into the
 `stage1` subfolder; see below for details.

doc/quickstart.md

@@ -7,17 +7,12 @@ See [Setup](./setup.md) for supported platforms and other ways to set up Lean 4.
 
 1. Launch VS Code and install the `lean4` extension by clicking on the "Extensions" sidebar entry and searching for "lean4".
 
-   ![installing the vscode-lean4 extension](images/code-ext.png)
+    ![installing the vscode-lean4 extension](images/code-ext.png)
 
-1. Open the Lean 4 setup guide by creating a new text file using "File > New Text File" (`Ctrl+N` / `Cmd+N`), clicking on the ∀-symbol in the top right and selecting "Documentation… > Docs: Show Setup Guide".
+1. Open the Lean 4 setup guide by creating a new text file using "File > New Text File" (`Ctrl+N`), clicking on the ∀-symbol in the top right and selecting "Documentation… > Setup: Show Setup Guide".
 
-   ![show setup guide](images/show-setup-guide.png)
+    ![show setup guide](images/show-setup-guide.png)
 
-1. Follow the Lean 4 setup guide. It will:
+1. Follow the Lean 4 setup guide. It will walk you through learning resources for Lean 4, teach you how to set up Lean's dependencies on your platform, install Lean 4 for you at the click of a button and help you set up your first project.
 
-   - walk you through learning resources for Lean,
-   - teach you how to set up Lean's dependencies on your platform,
-   - install Lean 4 for you at the click of a button,
-   - help you set up your first project.
-
-   ![setup guide](images/setup_guide.png)
+    ![setup guide](images/setup_guide.png)

flake.lock

@@ -1,5 +1,21 @@
 {
   "nodes": {
+    "flake-compat": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1673956053,
+        "narHash": "sha256-4gtG9iQuiKITOjNQQeQIpoIB6b16fm+504Ch3sNKLd8=",
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "rev": "35bb57c0c8d8b62bbfd284272c928ceb64ddbde9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "edolstra",
+        "repo": "flake-compat",
+        "type": "github"
+      }
+    },
     "flake-utils": {
       "inputs": {
         "systems": "systems"
@@ -18,18 +34,71 @@
         "type": "github"
       }
     },
-    "nixpkgs": {
+    "lean4-mode": {
+      "flake": false,
       "locked": {
-        "lastModified": 1710889954,
-        "narHash": "sha256-Pr6F5Pmd7JnNEMHHmspZ0qVqIBVxyZ13ik1pJtm2QXk=",
+        "lastModified": 1709737301,
+        "narHash": "sha256-uT9JN2kLNKJK9c/S/WxLjiHmwijq49EgLb+gJUSDpz0=",
+        "owner": "leanprover",
+        "repo": "lean4-mode",
+        "rev": "f1f24c15134dee3754b82c9d9924866fe6bc6b9f",
+        "type": "github"
+      },
+      "original": {
+        "owner": "leanprover",
+        "repo": "lean4-mode",
+        "type": "github"
+      }
+    },
+    "libgit2": {
+      "flake": false,
+      "locked": {
+        "lastModified": 1697646580,
+        "narHash": "sha256-oX4Z3S9WtJlwvj0uH9HlYcWv+x1hqp8mhXl7HsLu2f0=",
+        "owner": "libgit2",
+        "repo": "libgit2",
+        "rev": "45fd9ed7ae1a9b74b957ef4f337bc3c8b3df01b5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "libgit2",
+        "repo": "libgit2",
+        "type": "github"
+      }
+    },
+    "nix": {
+      "inputs": {
+        "flake-compat": "flake-compat",
+        "libgit2": "libgit2",
+        "nixpkgs": "nixpkgs",
+        "nixpkgs-regression": "nixpkgs-regression"
+      },
+      "locked": {
+        "lastModified": 1711102798,
+        "narHash": "sha256-CXOIJr8byjolqG7eqCLa+Wfi7rah62VmLoqSXENaZnw=",
         "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "7872526e9c5332274ea5932a0c3270d6e4724f3b",
+        "repo": "nix",
+        "rev": "a22328066416650471c3545b0b138669ea212ab4",
         "type": "github"
       },
       "original": {
         "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
+        "repo": "nix",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1709083642,
+        "narHash": "sha256-7kkJQd4rZ+vFrzWu8sTRtta5D1kBG0LSRYAfhtmMlSo=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "b550fe4b4776908ac2a861124307045f8e717c8e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "release-23.11",
         "repo": "nixpkgs",
         "type": "github"
       }
@@ -51,10 +120,44 @@
         "type": "github"
       }
     },
+    "nixpkgs-regression": {
+      "locked": {
+        "lastModified": 1643052045,
+        "narHash": "sha256-uGJ0VXIhWKGXxkeNnq4TvV3CIOkUJ3PAoLZ3HMzNVMw=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "215d4d0fd80ca5163643b03a33fde804a29cc1e2",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1710889954,
+        "narHash": "sha256-Pr6F5Pmd7JnNEMHHmspZ0qVqIBVxyZ13ik1pJtm2QXk=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "7872526e9c5332274ea5932a0c3270d6e4724f3b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixpkgs-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
     "root": {
       "inputs": {
         "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs",
+        "lean4-mode": "lean4-mode",
+        "nix": "nix",
+        "nixpkgs": "nixpkgs_2",
         "nixpkgs-old": "nixpkgs-old"
       }
     },

flake.nix

@@ -1,21 +1,38 @@
 {
-  description = "Lean development flake. Not intended for end users.";
+  description = "Lean interactive theorem prover";
 
   inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
   # old nixpkgs used for portable release with older glibc (2.27)
   inputs.nixpkgs-old.url = "github:NixOS/nixpkgs/nixos-19.03";
   inputs.nixpkgs-old.flake = false;
   inputs.flake-utils.url = "github:numtide/flake-utils";
+  inputs.nix.url = "github:NixOS/nix";
+  inputs.lean4-mode = {
+    url = "github:leanprover/lean4-mode";
+    flake = false;
+  };
+  # used *only* by `stage0-from-input` below
+  #inputs.lean-stage0 = {
+  #  url = github:leanprover/lean4;
+  #  inputs.nixpkgs.follows = "nixpkgs";
+  #  inputs.flake-utils.follows = "flake-utils";
+  #  inputs.nix.follows = "nix";
+  #  inputs.lean4-mode.follows = "lean4-mode";
+  #};
 
-  outputs = { self, nixpkgs, nixpkgs-old, flake-utils, ... }@inputs: flake-utils.lib.eachDefaultSystem (system:
+  outputs = { self, nixpkgs, nixpkgs-old, flake-utils, nix, lean4-mode, ... }@inputs: flake-utils.lib.eachDefaultSystem (system:
     let
-      pkgs = import nixpkgs { inherit system; };
+      pkgs = import nixpkgs {
+        inherit system;
+        # for `vscode-with-extensions`
+        config.allowUnfree = true;
+      };
       # An old nixpkgs for creating releases with an old glibc
       pkgsDist-old = import nixpkgs-old { inherit system; };
       # An old nixpkgs for creating releases with an old glibc
       pkgsDist-old-aarch = import nixpkgs-old { localSystem.config = "aarch64-unknown-linux-gnu"; };
 
-      lean-packages = pkgs.callPackage (./nix/packages.nix) { src = ./.; };
+      lean-packages = pkgs.callPackage (./nix/packages.nix) { src = ./.; inherit nix lean4-mode; };
 
       devShellWithDist = pkgsDist: pkgs.mkShell.override {
           stdenv = pkgs.overrideCC pkgs.stdenv lean-packages.llvmPackages.clang;
@@ -41,15 +58,41 @@
           GDB = pkgsDist.gdb;
         });
     in {
-      packages = {
-        # to be removed when Nix CI is not needed anymore
-        inherit (lean-packages) cacheRoots test update-stage0-commit ciShell;
-        deprecated = lean-packages;
+      packages = lean-packages // rec {
+        debug = lean-packages.override { debug = true; };
+        stage0debug = lean-packages.override { stage0debug = true; };
+        asan = lean-packages.override { extraCMakeFlags = [ "-DLEAN_EXTRA_CXX_FLAGS=-fsanitize=address" "-DLEANC_EXTRA_FLAGS=-fsanitize=address" "-DSMALL_ALLOCATOR=OFF" "-DSYMBOLIC=OFF" ]; };
+        asandebug = asan.override { debug = true; };
+        tsan = lean-packages.override {
+          extraCMakeFlags = [ "-DLEAN_EXTRA_CXX_FLAGS=-fsanitize=thread" "-DLEANC_EXTRA_FLAGS=-fsanitize=thread" "-DCOMPRESSED_OBJECT_HEADER=OFF" ];
+          stage0 = (lean-packages.override {
+            # Compressed headers currently trigger data race reports in tsan.
+            # Turn them off for stage 0 as well so stage 1 can read its own stdlib.
+            extraCMakeFlags = [ "-DCOMPRESSED_OBJECT_HEADER=OFF" ];
+          }).stage1;
+        };
+        tsandebug = tsan.override { debug = true; };
+        stage0-from-input = lean-packages.override {
+          stage0 = pkgs.writeShellScriptBin "lean" ''
+            exec ${inputs.lean-stage0.packages.${system}.lean}/bin/lean -Dinterpreter.prefer_native=false "$@"
+          '';
+        };
+        inherit self;
       };
+      defaultPackage = lean-packages.lean-all;
 
       # The default development shell for working on lean itself
       devShells.default = devShellWithDist pkgs;
       devShells.oldGlibc = devShellWithDist pkgsDist-old;
       devShells.oldGlibcAArch = devShellWithDist pkgsDist-old-aarch;
-    });
+
+      checks.lean = lean-packages.test;
+    }) // rec {
+      templates.pkg = {
+        path = ./nix/templates/pkg;
+        description = "A custom Lean package";
+      };
+
+      defaultTemplate = templates.pkg;
+    };
 }

nix/bootstrap.nix

@@ -2,7 +2,7 @@
   stdenv, lib, cmake, gmp, git, gnumake, bash, buildLeanPackage, writeShellScriptBin, runCommand, symlinkJoin, lndir, perl, gnused, darwin, llvmPackages, linkFarmFromDrvs,
   ... } @ args:
 with builtins;
-lib.warn "The Nix-based build is deprecated" rec {
+rec {
   inherit stdenv;
   sourceByRegex = p: rs: lib.sourceByRegex p (map (r: "(/src/)?${r}") rs);
   buildCMake = args: stdenv.mkDerivation ({

nix/buildLeanPackage.nix

@@ -1,5 +1,5 @@
 { lean, lean-leanDeps ? lean, lean-final ? lean, leanc,
-  stdenv, lib, coreutils, gnused, writeShellScriptBin, bash, substituteAll, symlinkJoin, linkFarmFromDrvs,
+  stdenv, lib, coreutils, gnused, writeShellScriptBin, bash, lean-emacs, lean-vscode, nix, substituteAll, symlinkJoin, linkFarmFromDrvs,
   runCommand, darwin, mkShell, ... }:
 let lean-final' = lean-final; in
 lib.makeOverridable (
@@ -197,6 +197,19 @@ with builtins; let
              then map (m: m.module) header.imports
              else abort "errors while parsing imports of ${mod}:\n${lib.concatStringsSep "\n" header.errors}";
     in mkMod mod (map (dep: if modDepsMap ? ${dep} then modCandidates.${dep} else externalModMap.${dep}) deps)) modDepsMap;
+  makeEmacsWrapper = name: emacs: lean: writeShellScriptBin name ''
+    ${emacs} --eval "(progn (setq lean4-rootdir \"${lean}\"))" "$@"
+  '';
+  makeVSCodeWrapper = name: lean: writeShellScriptBin name ''
+    PATH=${lean}/bin:$PATH ${lean-vscode}/bin/code "$@"
+  '';
+  printPaths = deps: writeShellScriptBin "print-paths" ''
+    echo '${toJSON {
+      oleanPath = [(depRoot "print-paths" deps)];
+      srcPath = ["."] ++ map (dep: dep.src) allExternalDeps;
+      loadDynlibPaths = map pathOfSharedLib (loadDynlibsOfDeps deps);
+    }}'
+  '';
   expandGlob = g:
     if typeOf g == "string" then [g]
     else if g.glob == "one" then [g.mod]
@@ -244,4 +257,48 @@ in rec {
         -o $out/bin/${executableName} \
         ${lib.concatStringsSep " " allLinkFlags}
     '') {};
+
+  lean-package = writeShellScriptBin "lean" ''
+    LEAN_PATH=${modRoot}:$LEAN_PATH LEAN_SRC_PATH=$LEAN_SRC_PATH:${src} exec ${lean-final}/bin/lean "$@"
+  '';
+  emacs-package = makeEmacsWrapper "emacs-package" lean-package;
+  vscode-package = makeVSCodeWrapper "vscode-package" lean-package;
+
+  link-ilean = writeShellScriptBin "link-ilean" ''
+    dest=''${1:-.}
+    mkdir -p $dest/build/lib
+    ln -sf ${iTree}/* $dest/build/lib
+  '';
+
+  makePrintPathsFor = deps: mods: printPaths deps // mapAttrs (_: mod: makePrintPathsFor (deps ++ [mod]) mods) mods;
+  print-paths = makePrintPathsFor [] (mods' // externalModMap);
+  # `lean` wrapper that dynamically runs Nix for the actual `lean` executable so the same editor can be
+  # used for multiple projects/after upgrading the `lean` input/for editing both stage 1 and the tests
+  lean-bin-dev = substituteAll {
+    name = "lean";
+    dir = "bin";
+    src = ./lean-dev.in;
+    isExecutable = true;
+    srcRoot = fullSrc;  # use root flake.nix in case of Lean repo
+    inherit bash nix srcTarget srcArgs;
+  };
+  lake-dev = substituteAll {
+    name = "lake";
+    dir = "bin";
+    src = ./lake-dev.in;
+    isExecutable = true;
+    srcRoot = fullSrc;  # use root flake.nix in case of Lean repo
+    inherit bash nix srcTarget srcArgs;
+  };
+  lean-dev = symlinkJoin { name = "lean-dev"; paths = [ lean-bin-dev lake-dev ]; };
+  emacs-dev = makeEmacsWrapper "emacs-dev" "${lean-emacs}/bin/emacs" lean-dev;
+  emacs-path-dev = makeEmacsWrapper "emacs-path-dev" "emacs" lean-dev;
+  vscode-dev = makeVSCodeWrapper "vscode-dev" lean-dev;
+
+  devShell = mkShell {
+    buildInputs = [ nix ];
+    shellHook = ''
+      export LEAN_SRC_PATH="${srcPath}"
+    '';
+  };
 })

nix/packages.nix

@@ -1,6 +1,9 @@
-{ src, pkgs, ... } @ args:
+{ src, pkgs, nix, ... } @ args:
 with pkgs;
 let
+  nix-pinned = writeShellScriptBin "nix" ''
+    ${nix.packages.${system}.default}/bin/nix --experimental-features 'nix-command flakes' --extra-substituters https://lean4.cachix.org/ --option warn-dirty false "$@"
+  '';
   # https://github.com/NixOS/nixpkgs/issues/130963
   llvmPackages = if stdenv.isDarwin then llvmPackages_11 else llvmPackages_15;
   cc = (ccacheWrapper.override rec {
@@ -39,9 +42,40 @@ let
     inherit (lean) stdenv;
     lean = lean.stage1;
     inherit (lean.stage1) leanc;
+    inherit lean-emacs lean-vscode;
+    nix = nix-pinned;
   }));
+  lean4-mode = emacsPackages.melpaBuild {
+    pname = "lean4-mode";
+    version = "1";
+    commit = "1";
+    src = args.lean4-mode;
+    packageRequires = with pkgs.emacsPackages.melpaPackages; [ dash f flycheck magit-section lsp-mode s ];
+    recipe = pkgs.writeText "recipe" ''
+      (lean4-mode
+       :repo "leanprover/lean4-mode"
+       :fetcher github
+       :files ("*.el" "data"))
+    '';
+  };
+  lean-emacs = emacsWithPackages [ lean4-mode ];
+  # updating might be nicer by building from source from a flake input, but this is good enough for now
+  vscode-lean4 = vscode-utils.extensionFromVscodeMarketplace {
+      name = "lean4";
+      publisher = "leanprover";
+      version = "0.0.63";
+      sha256 = "sha256-kjEex7L0F2P4pMdXi4NIZ1y59ywJVubqDqsoYagZNkI=";
+  };
+  lean-vscode = vscode-with-extensions.override {
+    vscodeExtensions = [ vscode-lean4 ];
+  };
 in {
-  inherit cc buildLeanPackage llvmPackages;
+  inherit cc lean4-mode buildLeanPackage llvmPackages vscode-lean4;
+  lean = lean.stage1;
+  stage0print-paths = lean.stage1.Lean.print-paths;
+  HEAD-as-stage0 = (lean.stage1.Lean.overrideArgs { srcTarget = "..#stage0-from-input.stage0"; srcArgs = "(--override-input lean-stage0 ..\?rev=$(git rev-parse HEAD) -- -Dinterpreter.prefer_native=false \"$@\")"; });
+  HEAD-as-stage1 = (lean.stage1.Lean.overrideArgs { srcTarget = "..\?rev=$(git rev-parse HEAD)#stage0"; });
+  nix = nix-pinned;
   nixpkgs = pkgs;
   ciShell = writeShellScriptBin "ciShell" ''
     set -o pipefail
@@ -49,4 +83,5 @@ in {
     # prefix lines with cumulative and individual execution time
     "$@" |& ts -i "(%.S)]" | ts -s "[%M:%S"
   '';
-} // lean.stage1
+  vscode = lean-vscode;
+} // lean.stage1.Lean // lean.stage1 // lean

releases_drafts/mutualStructural.md

@@ -1,65 +0,0 @@
-* Structural recursion can now be explicitly requested using
-  ```
-  termination_by structural x
-  ```
-  in analogy to the existing `termination_by x` syntax that causes well-founded recursion to be used.
-  (#4542)
-
-* The `termination_by?` syntax no longer forces the use of well-founded recursion, and when structural
-  recursion is inferred, will print the result using the `termination_by` syntax.
-
-* Mutual structural recursion is supported now. This supports both mutual recursion over a non-mutual
-  data type, as well as recursion over mutual or nested data types:
-
-  ```lean
-  mutual
-  def Even : Nat → Prop
-    | 0 => True
-    | n+1 => Odd n
-
-  def Odd : Nat → Prop
-    | 0 => False
-    | n+1 => Even n
-  end
-
-  mutual
-  inductive A
-  | other : B → A
-  | empty
-  inductive B
-  | other : A → B
-  | empty
-  end
-
-  mutual
-  def A.size : A → Nat
-  | .other b => b.size + 1
-  | .empty => 0
-
-  def B.size : B → Nat
-  | .other a => a.size + 1
-  | .empty => 0
-  end
-
-  inductive Tree where | node : List Tree → Tree
-
-  mutual
-  def Tree.size : Tree → Nat
-  | node ts => Tree.list_size ts
-
-  def Tree.list_size : List Tree → Nat
-  | [] => 0
-  | t::ts => Tree.size t + Tree.list_size ts
-  end
-  ```
-
-  Functional induction principles are generated for these functions as well (`A.size.induct`, `A.size.mutual_induct`).
-
-  Nested structural recursion is still not supported.
-
-  PRs #4639, #4715, #4642, #4656, #4684, #4715, #4728, #4575, #4731, #4658, #4734, #4738, #4718,
-  #4733, #4787, #4788, #4789, #4807, #4772
-
-* A bugfix in the structural recursion code may in some cases break existing code, when a parameter
-  of the type of the recursive argument is bound behind indices of that type. This can usually be
-  fixed by reordering the parameters of the function (PR #4672)

releases_drafts/varCtorNameLint.md

@@ -0,0 +1,45 @@
+A new linter flags situations where a local variable's name is one of
+the argumentless constructors of its type. This can arise when a user either
+doesn't open a namespace or doesn't add a dot or leading qualifier, as
+in the following:
+
+````
+inductive Tree (α : Type) where
+  | leaf
+  | branch (left : Tree α) (val : α) (right : Tree α)
+
+def depth : Tree α → Nat
+  | leaf => 0
+````
+
+With this linter, the `leaf` pattern is highlighted as a local
+variable whose name overlaps with the constructor `Tree.leaf`.
+
+The linter can be disabled with `set_option linter.constructorNameAsVariable false`.
+
+Additionally, the error message that occurs when a name in a pattern that takes arguments isn't valid now suggests similar names that would be valid. This means that the following definition:
+
+```
+def length (list : List α) : Nat :=
+  match list with
+  | nil => 0
+  | cons x xs => length xs + 1
+```
+
+now results in the following warning:
+
+```
+warning: Local variable 'nil' resembles constructor 'List.nil' - write '.nil' (with a dot) or 'List.nil' to use the constructor.
+note: this linter can be disabled with `set_option linter.constructorNameAsVariable false`
+```
+
+and error:
+
+```
+invalid pattern, constructor or constant marked with '[match_pattern]' expected
+
+Suggestion: 'List.cons' is similar
+```
+
+
+#4301

src/CMakeLists.txt

@@ -1,6 +1,5 @@
 cmake_minimum_required(VERSION 3.10)
 cmake_policy(SET CMP0054 NEW)
-cmake_policy(SET CMP0110 NEW)
 if(NOT (${CMAKE_GENERATOR} MATCHES "Unix Makefiles"))
   message(FATAL_ERROR "The only supported CMake generator at the moment is 'Unix Makefiles'")
 endif()

src/Init/ByCases.lean

@@ -67,8 +67,12 @@ theorem ite_some_none_eq_none [Decidable P] :
 -- This is not marked as `simp` as it is already handled by `dite_eq_right_iff`.
 theorem dite_some_none_eq_none [Decidable P] {x : P → α} :
     (if h : P then some (x h) else none) = none ↔ ¬P := by
-  simp
+  simp only [dite_eq_right_iff]
+  rfl
 
 @[simp] theorem dite_some_none_eq_some [Decidable P] {x : P → α} {y : α} :
     (if h : P then some (x h) else none) = some y ↔ ∃ h : P, x h = y := by
-  by_cases h : P <;> simp [h]
+  by_cases h : P <;> simp only [h, dite_cond_eq_true, dite_cond_eq_false, Option.some.injEq,
+    false_iff, not_exists]
+  case pos => exact ⟨fun h_eq ↦ Exists.intro h h_eq, fun h_exists => h_exists.2⟩
+  case neg => exact fun h_false _ ↦ h_false

src/Init/Core.lean

@@ -474,8 +474,6 @@ class LawfulSingleton (α : Type u) (β : Type v) [EmptyCollection β] [Insert
   insert_emptyc_eq (x : α) : (insert x ∅ : β) = singleton x
 export LawfulSingleton (insert_emptyc_eq)
 
-attribute [simp] insert_emptyc_eq
-
 /-- Type class used to implement the notation `{ a ∈ c | p a }` -/
 class Sep (α : outParam <| Type u) (γ : Type v) where
   /-- Computes `{ a ∈ c | p a }`. -/
@@ -703,7 +701,7 @@ theorem Ne.elim (h : a ≠ b) : a = b → False := h
 
 theorem Ne.irrefl (h : a ≠ a) : False := h rfl
 
-@[symm] theorem Ne.symm (h : a ≠ b) : b ≠ a := fun h₁ => h (h₁.symm)
+theorem Ne.symm (h : a ≠ b) : b ≠ a := fun h₁ => h (h₁.symm)
 
 theorem ne_comm {α} {a b : α} : a ≠ b ↔ b ≠ a := ⟨Ne.symm, Ne.symm⟩
 
@@ -756,7 +754,7 @@ noncomputable def HEq.elim {α : Sort u} {a : α} {p : α → Sort v} {b : α} (
 theorem HEq.subst {p : (T : Sort u) → T → Prop} (h₁ : HEq a b) (h₂ : p α a) : p β b :=
   HEq.ndrecOn h₁ h₂
 
-@[symm] theorem HEq.symm (h : HEq a b) : HEq b a :=
+theorem HEq.symm (h : HEq a b) : HEq b a :=
   h.rec (HEq.refl a)
 
 theorem heq_of_eq (h : a = a') : HEq a a' :=
@@ -812,15 +810,15 @@ instance : Trans Iff Iff Iff where
 theorem Eq.comm {a b : α} : a = b ↔ b = a := Iff.intro Eq.symm Eq.symm
 theorem eq_comm {a b : α} : a = b ↔ b = a := Eq.comm
 
-@[symm] theorem Iff.symm (h : a ↔ b) : b ↔ a := Iff.intro h.mpr h.mp
+theorem Iff.symm (h : a ↔ b) : b ↔ a := Iff.intro h.mpr h.mp
 theorem Iff.comm: (a ↔ b) ↔ (b ↔ a) := Iff.intro Iff.symm Iff.symm
 theorem iff_comm : (a ↔ b) ↔ (b ↔ a) := Iff.comm
 
-@[symm] theorem And.symm : a ∧ b → b ∧ a := fun ⟨ha, hb⟩ => ⟨hb, ha⟩
+theorem And.symm : a ∧ b → b ∧ a := fun ⟨ha, hb⟩ => ⟨hb, ha⟩
 theorem And.comm : a ∧ b ↔ b ∧ a := Iff.intro And.symm And.symm
 theorem and_comm : a ∧ b ↔ b ∧ a := And.comm
 
-@[symm] theorem Or.symm : a ∨ b → b ∨ a := .rec .inr .inl
+theorem Or.symm : a ∨ b → b ∨ a := .rec .inr .inl
 theorem Or.comm : a ∨ b ↔ b ∨ a := Iff.intro Or.symm Or.symm
 theorem or_comm : a ∨ b ↔ b ∨ a := Or.comm
 
@@ -1107,7 +1105,6 @@ inductive Relation.TransGen {α : Sort u} (r : α → α → Prop) : α → α
 /-! # Subtype -/
 
 namespace Subtype
-
 theorem existsOfSubtype {α : Type u} {p : α → Prop} : { x // p x } → Exists (fun x => p x)
   | ⟨a, h⟩ => ⟨a, h⟩
 
@@ -1204,13 +1201,9 @@ def Prod.map {α₁ : Type u₁} {α₂ : Type u₂} {β₁ : Type v₁} {β₂
 
 /-! # Dependent products -/
 
-theorem Exists.of_psigma_prop {α : Sort u} {p : α → Prop} : (PSigma (fun x => p x)) → Exists (fun x => p x)
+theorem ex_of_PSigma {α : Type u} {p : α → Prop} : (PSigma (fun x => p x)) → Exists (fun x => p x)
   | ⟨x, hx⟩ => ⟨x, hx⟩
 
-@[deprecated Exists.of_psigma_prop (since := "2024-07-27")]
-theorem ex_of_PSigma {α : Type u} {p : α → Prop} : (PSigma (fun x => p x)) → Exists (fun x => p x) :=
-  Exists.of_psigma_prop
-
 protected theorem PSigma.eta {α : Sort u} {β : α → Sort v} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}
     (h₁ : a₁ = a₂) (h₂ : Eq.ndrec b₁ h₁ = b₂) : PSigma.mk a₁ b₁ = PSigma.mk a₂ b₂ := by
   subst h₁
@@ -1552,7 +1545,7 @@ protected abbrev rec
     (q : Quot r) : motive q :=
   Eq.ndrecOn (Quot.liftIndepPr1 f h q) ((lift (Quot.indep f) (Quot.indepCoherent f h) q).2)
 
-@[inherit_doc Quot.rec, elab_as_elim] protected abbrev recOn
+@[inherit_doc Quot.rec] protected abbrev recOn
     (q : Quot r)
     (f : (a : α) → motive (Quot.mk r a))
     (h : (a b : α) → (p : r a b) → Eq.ndrec (f a) (sound p) = f b)
@@ -1563,7 +1556,7 @@ protected abbrev rec
 Dependent induction principle for a quotient, when the target type is a `Subsingleton`.
 In this case the quotient's side condition is trivial so any function can be lifted.
 -/
-@[elab_as_elim] protected abbrev recOnSubsingleton
+protected abbrev recOnSubsingleton
     [h : (a : α) → Subsingleton (motive (Quot.mk r a))]
     (q : Quot r)
     (f : (a : α) → motive (Quot.mk r a))

src/Init/Data.lean

@@ -36,4 +36,3 @@ import Init.Data.Channel
 import Init.Data.Cast
 import Init.Data.Sum
 import Init.Data.BEq
-import Init.Data.Subtype

src/Init/Data/Array/Basic.lean

@@ -50,13 +50,6 @@ instance : Inhabited (Array α) where
 def singleton (v : α) : Array α :=
   mkArray 1 v
 
-/-- Low-level version of `size` that directly queries the C array object cached size.
-    While this is not provable, `usize` always returns the exact size of the array since
-    the implementation only supports arrays of size less than `USize.size`.
--/
-@[extern "lean_array_size", simp]
-def usize (a : @& Array α) : USize := a.size.toUSize
-
 /-- Low-level version of `fget` which is as fast as a C array read.
    `Fin` values are represented as tag pointers in the Lean runtime. Thus,
    `fget` may be slightly slower than `uget`. -/
@@ -108,7 +101,7 @@ def swap (a : Array α) (i j : @& Fin a.size) : Array α :=
   a'.set (size_set a i v₂ ▸ j) v₁
 
 /--
-Swaps two entries in an array, or returns the array unchanged if either index is out of bounds.
+Swaps two entries in an array, or panics if either index is out of bounds.
 
 This will perform the update destructively provided that `a` has a reference
 count of 1 when called.
@@ -181,7 +174,7 @@ def modifyOp (self : Array α) (idx : Nat) (f : α → α) : Array α :=
 
   This kind of low level trick can be removed with a little bit of compiler support. For example, if the compiler simplifies `as.size < usizeSz` to true. -/
 @[inline] unsafe def forInUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (as : Array α) (b : β) (f : α → β → m (ForInStep β)) : m β :=
-  let sz := as.usize
+  let sz := USize.ofNat as.size
   let rec @[specialize] loop (i : USize) (b : β) : m β := do
     if i < sz then
       let a := as.uget i lcProof
@@ -287,7 +280,7 @@ def foldrM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α
 /-- See comment at `forInUnsafe` -/
 @[inline]
 unsafe def mapMUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : α → m β) (as : Array α) : m (Array β) :=
-  let sz := as.usize
+  let sz := USize.ofNat as.size
   let rec @[specialize] map (i : USize) (r : Array NonScalar) : m (Array PNonScalar.{v}) := do
     if i < sz then
      let v    := r.uget i lcProof

src/Init/Data/Array/Lemmas.lean

@@ -6,8 +6,7 @@ Authors: Mario Carneiro
 prelude
 import Init.Data.Nat.MinMax
 import Init.Data.Nat.Lemmas
-import Init.Data.List.Monadic
-import Init.Data.List.Nat.Range
+import Init.Data.List.Lemmas
 import Init.Data.Fin.Basic
 import Init.Data.Array.Mem
 import Init.TacticsExtra
@@ -337,10 +336,6 @@ theorem not_mem_nil (a : α) : ¬ a ∈ #[] := nofun
 
 /-- # get lemmas -/
 
-theorem lt_of_getElem {x : α} {a : Array α} {idx : Nat} {hidx : idx < a.size} (_ : a[idx] = x) :
-    idx < a.size :=
-  hidx
-
 theorem getElem?_mem {l : Array α} {i : Fin l.size} : l[i] ∈ l := by
   erw [Array.mem_def, getElem_eq_data_getElem]
   apply List.get_mem
@@ -510,13 +505,6 @@ theorem size_eq_length_data (as : Array α) : as.size = as.data.length := rfl
     simp only [mkEmpty_eq, size_push] at *
     omega
 
-@[simp] theorem data_range (n : Nat) : (range n).data = List.range n := by
-  induction n <;> simp_all [range, Nat.fold, flip, List.range_succ]
-
-@[simp]
-theorem getElem_range {n : Nat} {x : Nat} (h : x < (Array.range n).size) : (Array.range n)[x] = x := by
-  simp [getElem_eq_data_getElem]
-
 set_option linter.deprecated false in
 @[simp] theorem reverse_data (a : Array α) : a.reverse.data = a.data.reverse := by
   let rec go (as : Array α) (i j hj)
@@ -719,22 +707,13 @@ theorem mapIdx_spec (as : Array α) (f : Fin as.size → α → β)
   unfold modify modifyM Id.run
   split <;> simp
 
-theorem getElem_modify {as : Array α} {x i} (h : i < as.size) :
-    (as.modify x f)[i]'(by simp [h]) = if x = i then f as[i] else as[i] := by
-  simp only [modify, modifyM, get_eq_getElem, Id.run, Id.pure_eq]
-  split
-  · simp only [Id.bind_eq, get_set _ _ _ h]; split <;> simp [*]
+theorem get_modify {arr : Array α} {x i} (h : i < arr.size) :
+    (arr.modify x f).get ⟨i, by simp [h]⟩ =
+    if x = i then f (arr.get ⟨i, h⟩) else arr.get ⟨i, h⟩ := by
+  simp [modify, modifyM, Id.run]; split
+  · simp [get_set _ _ _ h]; split <;> simp [*]
   · rw [if_neg (mt (by rintro rfl; exact h) ‹_›)]
 
-theorem getElem_modify_self {as : Array α} {i : Nat} (h : i < as.size) (f : α → α) :
-    (as.modify i f)[i]'(by simp [h]) = f as[i] := by
-  simp [getElem_modify h]
-
-theorem getElem_modify_of_ne {as : Array α} {i : Nat} (hj : j < as.size)
-    (f : α → α) (h : i ≠ j) :
-    (as.modify i f)[j]'(by rwa [size_modify]) = as[j] := by
-  simp [getElem_modify hj, h]
-
 /-! ### filter -/
 
 @[simp] theorem filter_data (p : α → Bool) (l : Array α) :

src/Init/Data/Array/TakeDrop.lean

@@ -5,7 +5,7 @@ Authors: Markus Himmel
 -/
 prelude
 import Init.Data.Array.Lemmas
-import Init.Data.List.Nat.TakeDrop
+import Init.Data.List.TakeDrop
 
 namespace Array
 

src/Init/Data/BitVec/Basic.lean

@@ -20,8 +20,6 @@ We define many of the bitvector operations from the
 of SMT-LIBv2.
 -/
 
-set_option linter.missingDocs true
-
 /--
 A bitvector of the specified width.
 
@@ -36,14 +34,14 @@ structure BitVec (w : Nat) where
   O(1), because we use `Fin` as the internal representation of a bitvector. -/
   toFin : Fin (2^w)
 
-/--
-Bitvectors have decidable equality. This should be used via the instance `DecidableEq (BitVec n)`.
--/
+@[deprecated (since := "2024-04-12")]
+protected abbrev Std.BitVec := _root_.BitVec
+
 -- We manually derive the `DecidableEq` instances for `BitVec` because
 -- we want to have builtin support for bit-vector literals, and we
 -- need a name for this function to implement `canUnfoldAtMatcher` at `WHNF.lean`.
-def BitVec.decEq (x y : BitVec n) : Decidable (x = y) :=
-  match x, y with
+def BitVec.decEq (a b : BitVec n) : Decidable (a = b) :=
+  match a, b with
   | ⟨n⟩, ⟨m⟩ =>
     if h : n = m then
       isTrue (h ▸ rfl)
@@ -69,9 +67,9 @@ protected def ofNat (n : Nat) (i : Nat) : BitVec n where
 instance instOfNat : OfNat (BitVec n) i where ofNat := .ofNat n i
 instance natCastInst : NatCast (BitVec w) := ⟨BitVec.ofNat w⟩
 
-/-- Given a bitvector `x`, return the underlying `Nat`. This is O(1) because `BitVec` is a
+/-- Given a bitvector `a`, return the underlying `Nat`. This is O(1) because `BitVec` is a
 (zero-cost) wrapper around a `Nat`. -/
-protected def toNat (x : BitVec n) : Nat := x.toFin.val
+protected def toNat (a : BitVec n) : Nat := a.toFin.val
 
 /-- Return the bound in terms of toNat. -/
 theorem isLt (x : BitVec w) : x.toNat < 2^w := x.toFin.isLt
@@ -123,18 +121,18 @@ section getXsb
 @[inline] def getMsb (x : BitVec w) (i : Nat) : Bool := i < w && getLsb x (w-1-i)
 
 /-- Return most-significant bit in bitvector. -/
-@[inline] protected def msb (x : BitVec n) : Bool := getMsb x 0
+@[inline] protected def msb (a : BitVec n) : Bool := getMsb a 0
 
 end getXsb
 
 section Int
 
 /-- Interpret the bitvector as an integer stored in two's complement form. -/
-protected def toInt (x : BitVec n) : Int :=
-  if 2 * x.toNat < 2^n then
-    x.toNat
+protected def toInt (a : BitVec n) : Int :=
+  if 2 * a.toNat < 2^n then
+    a.toNat
   else
-    (x.toNat : Int) - (2^n : Nat)
+    (a.toNat : Int) - (2^n : Nat)
 
 /-- The `BitVec` with value `(2^n + (i mod 2^n)) mod 2^n`.  -/
 protected def ofInt (n : Nat) (i : Int) : BitVec n := .ofNatLt (i % (Int.ofNat (2^n))).toNat (by
@@ -215,7 +213,7 @@ instance : Neg (BitVec n) := ⟨.neg⟩
 /--
 Return the absolute value of a signed bitvector.
 -/
-protected def abs (x : BitVec n) : BitVec n := if x.msb then .neg x else x
+protected def abs (s : BitVec n) : BitVec n := if s.msb then .neg s else s
 
 /--
 Multiplication for bit vectors. This can be interpreted as either signed or unsigned negation
@@ -262,12 +260,12 @@ sdiv 5#4 -2 = -2#4
 sdiv (-7#4) (-2) = 3#4
 ```
 -/
-def sdiv (x y : BitVec n) : BitVec n :=
-  match x.msb, y.msb with
-  | false, false => udiv x y
-  | false, true  => .neg (udiv x (.neg y))
-  | true,  false => .neg (udiv (.neg x) y)
-  | true,  true  => udiv (.neg x) (.neg y)
+def sdiv (s t : BitVec n) : BitVec n :=
+  match s.msb, t.msb with
+  | false, false => udiv s t
+  | false, true  => .neg (udiv s (.neg t))
+  | true,  false => .neg (udiv (.neg s) t)
+  | true,  true  => udiv (.neg s) (.neg t)
 
 /--
 Signed division for bit vectors using SMTLIB rules for division by zero.
@@ -276,40 +274,40 @@ Specifically, `smtSDiv x 0 = if x >= 0 then -1 else 1`
 
 SMT-Lib name: `bvsdiv`.
 -/
-def smtSDiv (x y : BitVec n) : BitVec n :=
-  match x.msb, y.msb with
-  | false, false => smtUDiv x y
-  | false, true  => .neg (smtUDiv x (.neg y))
-  | true,  false => .neg (smtUDiv (.neg x) y)
-  | true,  true  => smtUDiv (.neg x) (.neg y)
+def smtSDiv (s t : BitVec n) : BitVec n :=
+  match s.msb, t.msb with
+  | false, false => smtUDiv s t
+  | false, true  => .neg (smtUDiv s (.neg t))
+  | true,  false => .neg (smtUDiv (.neg s) t)
+  | true,  true  => smtUDiv (.neg s) (.neg t)
 
 /--
 Remainder for signed division rounding to zero.
 
 SMT_Lib name: `bvsrem`.
 -/
-def srem (x y : BitVec n) : BitVec n :=
-  match x.msb, y.msb with
-  | false, false => umod x y
-  | false, true  => umod x (.neg y)
-  | true,  false => .neg (umod (.neg x) y)
-  | true,  true  => .neg (umod (.neg x) (.neg y))
+def srem (s t : BitVec n) : BitVec n :=
+  match s.msb, t.msb with
+  | false, false => umod s t
+  | false, true  => umod s (.neg t)
+  | true,  false => .neg (umod (.neg s) t)
+  | true,  true  => .neg (umod (.neg s) (.neg t))
 
 /--
 Remainder for signed division rounded to negative infinity.
 
 SMT_Lib name: `bvsmod`.
 -/
-def smod (x y : BitVec m) : BitVec m :=
-  match x.msb, y.msb with
-  | false, false => umod x y
+def smod (s t : BitVec m) : BitVec m :=
+  match s.msb, t.msb with
+  | false, false => umod s t
   | false, true =>
-    let u := umod x (.neg y)
-    (if u = .zero m then u else .add u y)
+    let u := umod s (.neg t)
+    (if u = .zero m then u else .add u t)
   | true, false =>
-    let u := umod (.neg x) y
-    (if u = .zero m then u else .sub y u)
-  | true, true => .neg (umod (.neg x) (.neg y))
+    let u := umod (.neg s) t
+    (if u = .zero m then u else .sub t u)
+  | true, true => .neg (umod (.neg s) (.neg t))
 
 end arithmetic
 
@@ -373,8 +371,8 @@ end relations
 
 section cast
 
-/-- `cast eq x` embeds `x` into an equal `BitVec` type. -/
-@[inline] def cast (eq : n = m) (x : BitVec n) : BitVec m := .ofNatLt x.toNat (eq ▸ x.isLt)
+/-- `cast eq i` embeds `i` into an equal `BitVec` type. -/
+@[inline] def cast (eq : n = m) (i : BitVec n) : BitVec m := .ofNatLt i.toNat (eq ▸ i.isLt)
 
 @[simp] theorem cast_ofNat {n m : Nat} (h : n = m) (x : Nat) :
     cast h (BitVec.ofNat n x) = BitVec.ofNat m x := by
@@ -391,7 +389,7 @@ Extraction of bits `start` to `start + len - 1` from a bit vector of size `n` to
 new bitvector of size `len`. If `start + len > n`, then the vector will be zero-padded in the
 high bits.
 -/
-def extractLsb' (start len : Nat) (x : BitVec n) : BitVec len := .ofNat _ (x.toNat >>> start)
+def extractLsb' (start len : Nat) (a : BitVec n) : BitVec len := .ofNat _ (a.toNat >>> start)
 
 /--
 Extraction of bits `hi` (inclusive) down to `lo` (inclusive) from a bit vector of size `n` to
@@ -399,12 +397,12 @@ yield a new bitvector of size `hi - lo + 1`.
 
 SMT-Lib name: `extract`.
 -/
-def extractLsb (hi lo : Nat) (x : BitVec n) : BitVec (hi - lo + 1) := extractLsb' lo _ x
+def extractLsb (hi lo : Nat) (a : BitVec n) : BitVec (hi - lo + 1) := extractLsb' lo _ a
 
 /--
 A version of `zeroExtend` that requires a proof, but is a noop.
 -/
-def zeroExtend' {n w : Nat} (le : n ≤ w) (x : BitVec n) : BitVec w :=
+def zeroExtend' {n w : Nat} (le : n ≤ w) (x : BitVec n)  : BitVec w :=
   x.toNat#'(by
     apply Nat.lt_of_lt_of_le x.isLt
     exact Nat.pow_le_pow_of_le_right (by trivial) le)
@@ -413,8 +411,8 @@ def zeroExtend' {n w : Nat} (le : n ≤ w) (x : BitVec n) : BitVec w :=
 `shiftLeftZeroExtend x n` returns `zeroExtend (w+n) x <<< n` without
 needing to compute `x % 2^(2+n)`.
 -/
-def shiftLeftZeroExtend (msbs : BitVec w) (m : Nat) : BitVec (w + m) :=
-  let shiftLeftLt {x : Nat} (p : x < 2^w) (m : Nat) : x <<< m < 2^(w + m) := by
+def shiftLeftZeroExtend (msbs : BitVec w) (m : Nat) : BitVec (w+m) :=
+  let shiftLeftLt {x : Nat} (p : x < 2^w) (m : Nat) : x <<< m < 2^(w+m) := by
         simp [Nat.shiftLeft_eq, Nat.pow_add]
         apply Nat.mul_lt_mul_of_pos_right p
         exact (Nat.two_pow_pos m)
@@ -502,24 +500,24 @@ instance : Complement (BitVec w) := ⟨.not⟩
 
 /--
 Left shift for bit vectors. The low bits are filled with zeros. As a numeric operation, this is
-equivalent to `x * 2^s`, modulo `2^n`.
+equivalent to `a * 2^s`, modulo `2^n`.
 
 SMT-Lib name: `bvshl` except this operator uses a `Nat` shift value.
 -/
-protected def shiftLeft (x : BitVec n) (s : Nat) : BitVec n := BitVec.ofNat n (x.toNat <<< s)
+protected def shiftLeft (a : BitVec n) (s : Nat) : BitVec n := BitVec.ofNat n (a.toNat <<< s)
 instance : HShiftLeft (BitVec w) Nat (BitVec w) := ⟨.shiftLeft⟩
 
 /--
 (Logical) right shift for bit vectors. The high bits are filled with zeros.
-As a numeric operation, this is equivalent to `x / 2^s`, rounding down.
+As a numeric operation, this is equivalent to `a / 2^s`, rounding down.
 
 SMT-Lib name: `bvlshr` except this operator uses a `Nat` shift value.
 -/
-def ushiftRight (x : BitVec n) (s : Nat) : BitVec n :=
-  (x.toNat >>> s)#'(by
-  let ⟨x, lt⟩ := x
+def ushiftRight (a : BitVec n) (s : Nat) : BitVec n :=
+  (a.toNat >>> s)#'(by
+  let ⟨a, lt⟩ := a
   simp only [BitVec.toNat, Nat.shiftRight_eq_div_pow, Nat.div_lt_iff_lt_mul (Nat.two_pow_pos s)]
-  rw [←Nat.mul_one x]
+  rw [←Nat.mul_one a]
   exact Nat.mul_lt_mul_of_lt_of_le' lt (Nat.two_pow_pos s) (Nat.le_refl 1))
 
 instance : HShiftRight (BitVec w) Nat (BitVec w) := ⟨.ushiftRight⟩
@@ -527,24 +525,15 @@ instance : HShiftRight (BitVec w) Nat (BitVec w) := ⟨.ushiftRight⟩
 /--
 Arithmetic right shift for bit vectors. The high bits are filled with the
 most-significant bit.
-As a numeric operation, this is equivalent to `x.toInt >>> s`.
+As a numeric operation, this is equivalent to `a.toInt >>> s`.
 
 SMT-Lib name: `bvashr` except this operator uses a `Nat` shift value.
 -/
-def sshiftRight (x : BitVec n) (s : Nat) : BitVec n := .ofInt n (x.toInt >>> s)
+def sshiftRight (a : BitVec n) (s : Nat) : BitVec n := .ofInt n (a.toInt >>> s)
 
 instance {n} : HShiftLeft  (BitVec m) (BitVec n) (BitVec m) := ⟨fun x y => x <<< y.toNat⟩
 instance {n} : HShiftRight (BitVec m) (BitVec n) (BitVec m) := ⟨fun x y => x >>> y.toNat⟩
 
-/--
-Arithmetic right shift for bit vectors. The high bits are filled with the
-most-significant bit.
-As a numeric operation, this is equivalent to `a.toInt >>> s.toNat`.
-
-SMT-Lib name: `bvashr`.
--/
-def sshiftRight' (a : BitVec n) (s : BitVec m) : BitVec n := a.sshiftRight s.toNat
-
 /-- Auxiliary function for `rotateLeft`, which does not take into account the case where
 the rotation amount is greater than the bitvector width. -/
 def rotateLeftAux (x : BitVec w) (n : Nat) : BitVec w :=
@@ -594,9 +583,11 @@ instance : HAppend (BitVec w) (BitVec v) (BitVec (w + v)) := ⟨.append⟩
 -- TODO: write this using multiplication
 /-- `replicate i x` concatenates `i` copies of `x` into a new vector of length `w*i`. -/
 def replicate : (i : Nat) → BitVec w → BitVec (w*i)
-  | 0,   _ => 0#0
+  | 0,   _ => 0
   | n+1, x =>
-    (x ++ replicate n x).cast (by rw [Nat.mul_succ]; omega)
+    have hEq : w + w*n = w*(n + 1) := by
+      rw [Nat.mul_add, Nat.add_comm, Nat.mul_one]
+    hEq ▸ (x ++ replicate n x)
 
 /-!
 ### Cons and Concat

src/Init/Data/BitVec/Bitblast.lean

@@ -28,8 +28,6 @@ https://github.com/mhk119/lean-smt/blob/bitvec/Smt/Data/Bitwise.lean.
 
 -/
 
-set_option linter.missingDocs true
-
 open Nat Bool
 
 namespace Bool
@@ -100,37 +98,6 @@ theorem carry_succ (i : Nat) (x y : BitVec w) (c : Bool) :
     exact mod_two_pow_add_mod_two_pow_add_bool_lt_two_pow_succ ..
   cases x.toNat.testBit i <;> cases y.toNat.testBit i <;> (simp; omega)
 
-/--
-If `x &&& y = 0`, then the carry bit `(x + y + 0)` is always `false` for any index `i`.
-Intuitively, this is because a carry is only produced when at least two of `x`, `y`, and the
-previous carry are true. However, since `x &&& y = 0`, at most one of `x, y` can be true,
-and thus we never have a previous carry, which means that the sum cannot produce a carry.
--/
-theorem carry_of_and_eq_zero {x y : BitVec w} (h : x &&& y = 0#w) : carry i x y false = false := by
-  induction i with
-  | zero => simp
-  | succ i ih =>
-    replace h := congrArg (·.getLsb i) h
-    simp_all [carry_succ]
-
-/-- The final carry bit when computing `x + y + c` is `true` iff `x.toNat + y.toNat + c.toNat ≥ 2^w`. -/
-theorem carry_width {x y : BitVec w} :
-    carry w x y c = decide (x.toNat + y.toNat + c.toNat ≥ 2^w) := by
-  simp [carry]
-
-/--
-If `x &&& y = 0`, then addition does not overflow, and thus `(x + y).toNat = x.toNat + y.toNat`.
--/
-theorem toNat_add_of_and_eq_zero {x y : BitVec w} (h : x &&& y = 0#w) :
-    (x + y).toNat = x.toNat + y.toNat := by
-  rw [toNat_add]
-  apply Nat.mod_eq_of_lt
-  suffices ¬ decide (x.toNat + y.toNat + false.toNat ≥ 2^w) by
-    simp only [decide_eq_true_eq] at this
-    omega
-  rw [← carry_width]
-  simp [not_eq_true, carry_of_and_eq_zero h]
-
 /-- Carry function for bitwise addition. -/
 def adcb (x y c : Bool) : Bool × Bool := (atLeastTwo x y c, Bool.xor x (Bool.xor y c))
 
@@ -289,18 +256,18 @@ theorem sle_eq_carry (x y : BitVec w) :
 A recurrence that describes multiplication as repeated addition.
 Is useful for bitblasting multiplication.
 -/
-def mulRec (x y : BitVec w) (s : Nat) : BitVec w :=
-  let cur := if y.getLsb s then (x <<< s) else 0
+def mulRec (l r : BitVec w) (s : Nat) : BitVec w :=
+  let cur := if r.getLsb s then (l <<< s) else 0
   match s with
   | 0 => cur
-  | s + 1 => mulRec x y s + cur
+  | s + 1 => mulRec l r s + cur
 
-theorem mulRec_zero_eq (x y : BitVec w) :
-    mulRec x y 0 = if y.getLsb 0 then x else 0 := by
+theorem mulRec_zero_eq (l r : BitVec w) :
+    mulRec l r 0 = if r.getLsb 0 then l else 0 := by
   simp [mulRec]
 
-theorem mulRec_succ_eq (x y : BitVec w) (s : Nat) :
-    mulRec x y (s + 1) = mulRec x y s + if y.getLsb (s + 1) then (x <<< (s + 1)) else 0 := rfl
+theorem mulRec_succ_eq (l r : BitVec w) (s : Nat) :
+    mulRec l r (s + 1) = mulRec l r s + if r.getLsb (s + 1) then (l <<< (s + 1)) else 0 := rfl
 
 /--
 Recurrence lemma: truncating to `i+1` bits and then zero extending to `w`
@@ -323,32 +290,32 @@ theorem zeroExtend_truncate_succ_eq_zeroExtend_truncate_add_twoPow (x : BitVec w
         simp [hik', hik'']
   · ext k
     simp
-    by_cases hi : x.getLsb i <;> simp [hi] <;> omega
+    omega
 
 /--
-Recurrence lemma: multiplying `x` with the first `s` bits of `y` is the
-same as truncating `y` to `s` bits, then zero extending to the original length,
+Recurrence lemma: multiplying `l` with the first `s` bits of `r` is the
+same as truncating `r` to `s` bits, then zero extending to the original length,
 and performing the multplication. -/
-theorem mulRec_eq_mul_signExtend_truncate (x y : BitVec w) (s : Nat) :
-    mulRec x y s = x * ((y.truncate (s + 1)).zeroExtend w) := by
+theorem mulRec_eq_mul_signExtend_truncate (l r : BitVec w) (s : Nat) :
+    mulRec l r s = l * ((r.truncate (s + 1)).zeroExtend w) := by
   induction s
   case zero =>
     simp only [mulRec_zero_eq, ofNat_eq_ofNat, Nat.reduceAdd]
-    by_cases y.getLsb 0
-    case pos hy =>
-      simp only [hy, ↓reduceIte, truncate, zeroExtend_one_eq_ofBool_getLsb_zero,
-        ofBool_true, ofNat_eq_ofNat]
+    by_cases r.getLsb 0
+    case pos hr =>
+      simp only [hr, ↓reduceIte, truncate, zeroExtend_one_eq_ofBool_getLsb_zero,
+        hr, ofBool_true, ofNat_eq_ofNat]
       rw [zeroExtend_ofNat_one_eq_ofNat_one_of_lt (by omega)]
       simp
-    case neg hy =>
-      simp [hy, zeroExtend_one_eq_ofBool_getLsb_zero]
+    case neg hr =>
+      simp [hr, zeroExtend_one_eq_ofBool_getLsb_zero]
   case succ s' hs =>
     rw [mulRec_succ_eq, hs]
     have heq :
-      (if y.getLsb (s' + 1) = true then x <<< (s' + 1) else 0) =
-        (x * (y &&& (BitVec.twoPow w (s' + 1)))) := by
-      simp only [ofNat_eq_ofNat, and_twoPow]
-      by_cases hy : y.getLsb (s' + 1) <;> simp [hy]
+      (if r.getLsb (s' + 1) = true then l <<< (s' + 1) else 0) =
+        (l * (r &&& (BitVec.twoPow w (s' + 1)))) := by
+      simp only [ofNat_eq_ofNat, and_twoPow_eq]
+      by_cases hr : r.getLsb (s' + 1) <;> simp [hr]
     rw [heq, ← BitVec.mul_add, ← zeroExtend_truncate_succ_eq_zeroExtend_truncate_add_twoPow]
 
 theorem getLsb_mul (x y : BitVec w) (i : Nat) :
@@ -359,198 +326,4 @@ theorem getLsb_mul (x y : BitVec w) (i : Nat) :
   · simp
   · omega
 
-/-! ## shiftLeft recurrence for bitblasting -/
-
-/--
-`shiftLeftRec x y n` shifts `x` to the left by the first `n` bits of `y`.
-
-The theorem `shiftLeft_eq_shiftLeftRec` proves the equivalence of `(x <<< y)` and `shiftLeftRec`.
-
-Together with equations `shiftLeftRec_zero`, `shiftLeftRec_succ`,
-this allows us to unfold `shiftLeft` into a circuit for bitblasting.
- -/
-def shiftLeftRec (x : BitVec w₁) (y : BitVec w₂) (n : Nat) : BitVec w₁ :=
-  let shiftAmt := (y &&& (twoPow w₂ n))
-  match n with
-  | 0 => x <<< shiftAmt
-  | n + 1 => (shiftLeftRec x y n) <<< shiftAmt
-
-@[simp]
-theorem shiftLeftRec_zero {x : BitVec w₁} {y : BitVec w₂} :
-    shiftLeftRec x y 0 = x <<< (y &&& twoPow w₂ 0)  := by
-  simp [shiftLeftRec]
-
-@[simp]
-theorem shiftLeftRec_succ {x : BitVec w₁} {y : BitVec w₂} :
-    shiftLeftRec x y (n + 1) = (shiftLeftRec x y n) <<< (y &&& twoPow w₂ (n + 1)) := by
-  simp [shiftLeftRec]
-
-/--
-If `y &&& z = 0`, `x <<< (y ||| z) = x <<< y <<< z`.
-This follows as `y &&& z = 0` implies `y ||| z = y + z`,
-and thus `x <<< (y ||| z) = x <<< (y + z) = x <<< y <<< z`.
--/
-theorem shiftLeft_or_of_and_eq_zero {x : BitVec w₁} {y z : BitVec w₂}
-    (h : y &&& z = 0#w₂) :
-    x <<< (y ||| z) = x <<< y <<< z := by
-  rw [← add_eq_or_of_and_eq_zero _ _ h,
-    shiftLeft_eq', toNat_add_of_and_eq_zero h]
-  simp [shiftLeft_add]
-
-/--
-`shiftLeftRec x y n` shifts `x` to the left by the first `n` bits of `y`.
--/
-theorem shiftLeftRec_eq {x : BitVec w₁} {y : BitVec w₂} {n : Nat} :
-    shiftLeftRec x y n = x <<< (y.truncate (n + 1)).zeroExtend w₂ := by
-  induction n generalizing x y
-  case zero =>
-    ext i
-    simp only [shiftLeftRec_zero, twoPow_zero, Nat.reduceAdd, truncate_one,
-      and_one_eq_zeroExtend_ofBool_getLsb]
-  case succ n ih =>
-    simp only [shiftLeftRec_succ, and_twoPow]
-    rw [ih]
-    by_cases h : y.getLsb (n + 1)
-    · simp only [h, ↓reduceIte]
-      rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_or_twoPow_of_getLsb_true h,
-        shiftLeft_or_of_and_eq_zero]
-      simp
-    · simp only [h, false_eq_true, ↓reduceIte, shiftLeft_zero']
-      rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_of_getLsb_false (i := n + 1)]
-      simp [h]
-
-/--
-Show that `x <<< y` can be written in terms of `shiftLeftRec`.
-This can be unfolded in terms of `shiftLeftRec_zero`, `shiftLeftRec_succ` for bitblasting.
--/
-theorem shiftLeft_eq_shiftLeftRec (x : BitVec w₁) (y : BitVec w₂) :
-    x <<< y = shiftLeftRec x y (w₂ - 1) := by
-  rcases w₂ with rfl | w₂
-  · simp [of_length_zero]
-  · simp [shiftLeftRec_eq]
-
-/- ### Arithmetic shift right (sshiftRight) recurrence -/
-
-/--
-`sshiftRightRec x y n` shifts `x` arithmetically/signed to the right by the first `n` bits of `y`.
-The theorem `sshiftRight_eq_sshiftRightRec` proves the equivalence of `(x.sshiftRight y)` and `sshiftRightRec`.
-Together with equations `sshiftRightRec_zero`, `sshiftRightRec_succ`,
-this allows us to unfold `sshiftRight` into a circuit for bitblasting.
--/
-def sshiftRightRec (x : BitVec w₁) (y : BitVec w₂) (n : Nat) : BitVec w₁ :=
-  let shiftAmt := (y &&& (twoPow w₂ n))
-  match n with
-  | 0 => x.sshiftRight' shiftAmt
-  | n + 1 => (sshiftRightRec x y n).sshiftRight' shiftAmt
-
-@[simp]
-theorem sshiftRightRec_zero_eq (x : BitVec w₁) (y : BitVec w₂) :
-    sshiftRightRec x y 0 = x.sshiftRight' (y &&& 1#w₂) := by
-  simp only [sshiftRightRec, twoPow_zero]
-
-@[simp]
-theorem sshiftRightRec_succ_eq (x : BitVec w₁) (y : BitVec w₂) (n : Nat) :
-    sshiftRightRec x y (n + 1) = (sshiftRightRec x y n).sshiftRight' (y &&& twoPow w₂ (n + 1)) := by
-  simp [sshiftRightRec]
-
-/--
-If `y &&& z = 0`, `x.sshiftRight (y ||| z) = (x.sshiftRight y).sshiftRight z`.
-This follows as `y &&& z = 0` implies `y ||| z = y + z`,
-and thus `x.sshiftRight (y ||| z) = x.sshiftRight (y + z) = (x.sshiftRight y).sshiftRight z`.
--/
-theorem sshiftRight'_or_of_and_eq_zero {x : BitVec w₁} {y z : BitVec w₂}
-    (h : y &&& z = 0#w₂) :
-    x.sshiftRight' (y ||| z) = (x.sshiftRight' y).sshiftRight' z := by
-  simp [sshiftRight', ← add_eq_or_of_and_eq_zero _ _ h,
-    toNat_add_of_and_eq_zero h, sshiftRight_add]
-
-theorem sshiftRightRec_eq (x : BitVec w₁) (y : BitVec w₂) (n : Nat) :
-    sshiftRightRec x y n = x.sshiftRight' ((y.truncate (n + 1)).zeroExtend w₂) := by
-  induction n generalizing x y
-  case zero =>
-    ext i
-    simp [twoPow_zero, Nat.reduceAdd, and_one_eq_zeroExtend_ofBool_getLsb, truncate_one]
-  case succ n ih =>
-    simp only [sshiftRightRec_succ_eq, and_twoPow, ih]
-    by_cases h : y.getLsb (n + 1)
-    · rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_or_twoPow_of_getLsb_true h,
-        sshiftRight'_or_of_and_eq_zero (by simp), h]
-      simp
-    · rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_of_getLsb_false (i := n + 1)
-        (by simp [h])]
-      simp [h]
-
-/--
-Show that `x.sshiftRight y` can be written in terms of `sshiftRightRec`.
-This can be unfolded in terms of `sshiftRightRec_zero_eq`, `sshiftRightRec_succ_eq` for bitblasting.
--/
-theorem sshiftRight_eq_sshiftRightRec (x : BitVec w₁) (y : BitVec w₂) :
-    (x.sshiftRight' y).getLsb i = (sshiftRightRec x y (w₂ - 1)).getLsb i := by
-  rcases w₂ with rfl | w₂
-  · simp [of_length_zero]
-  · simp [sshiftRightRec_eq]
-
-/- ### Logical shift right (ushiftRight) recurrence for bitblasting -/
-
-/--
-`ushiftRightRec x y n` shifts `x` logically to the right by the first `n` bits of `y`.
-
-The theorem `shiftRight_eq_ushiftRightRec` proves the equivalence
-of `(x >>> y)` and `ushiftRightRec`.
-
-Together with equations `ushiftRightRec_zero`, `ushiftRightRec_succ`,
-this allows us to unfold `ushiftRight` into a circuit for bitblasting.
--/
-def ushiftRightRec (x : BitVec w₁) (y : BitVec w₂) (n : Nat) : BitVec w₁ :=
-  let shiftAmt := (y &&& (twoPow w₂ n))
-  match n with
-  | 0 => x >>> shiftAmt
-  | n + 1 => (ushiftRightRec x y n) >>> shiftAmt
-
-@[simp]
-theorem ushiftRightRec_zero (x : BitVec w₁) (y : BitVec w₂) :
-    ushiftRightRec x y 0 = x >>> (y &&& twoPow w₂ 0) := by
-  simp [ushiftRightRec]
-
-@[simp]
-theorem ushiftRightRec_succ (x : BitVec w₁) (y : BitVec w₂) :
-    ushiftRightRec x y (n + 1) = (ushiftRightRec x y n) >>> (y &&& twoPow w₂ (n + 1)) := by
-  simp [ushiftRightRec]
-
-/--
-If `y &&& z = 0`, `x >>> (y ||| z) = x >>> y >>> z`.
-This follows as `y &&& z = 0` implies `y ||| z = y + z`,
-and thus `x >>> (y ||| z) = x >>> (y + z) = x >>> y >>> z`.
--/
-theorem ushiftRight'_or_of_and_eq_zero {x : BitVec w₁} {y z : BitVec w₂}
-    (h : y &&& z = 0#w₂) :
-    x >>> (y ||| z) = x >>> y >>> z := by
-  simp [← add_eq_or_of_and_eq_zero _ _ h, toNat_add_of_and_eq_zero h, shiftRight_add]
-
-theorem ushiftRightRec_eq (x : BitVec w₁) (y : BitVec w₂) (n : Nat) :
-    ushiftRightRec x y n = x >>> (y.truncate (n + 1)).zeroExtend w₂ := by
-  induction n generalizing x y
-  case zero =>
-    ext i
-    simp only [ushiftRightRec_zero, twoPow_zero, Nat.reduceAdd,
-      and_one_eq_zeroExtend_ofBool_getLsb, truncate_one]
-  case succ n ih =>
-    simp only [ushiftRightRec_succ, and_twoPow]
-    rw [ih]
-    by_cases h : y.getLsb (n + 1) <;> simp only [h, ↓reduceIte]
-    · rw [zeroExtend_truncate_succ_eq_zeroExtend_truncate_or_twoPow_of_getLsb_true h,
-        ushiftRight'_or_of_and_eq_zero]
-      simp
-    · simp [zeroExtend_truncate_succ_eq_zeroExtend_truncate_of_getLsb_false, h]
-
-/--
-Show that `x >>> y` can be written in terms of `ushiftRightRec`.
-This can be unfolded in terms of `ushiftRightRec_zero`, `ushiftRightRec_succ` for bitblasting.
--/
-theorem shiftRight_eq_ushiftRightRec (x : BitVec w₁) (y : BitVec w₂) :
-    x >>> y = ushiftRightRec x y (w₂ - 1) := by
-  rcases w₂ with rfl | w₂
-  · simp [of_length_zero]
-  · simp [ushiftRightRec_eq]
-
 end BitVec

src/Init/Data/BitVec/Folds.lean

@@ -8,8 +8,6 @@ import Init.Data.BitVec.Lemmas
 import Init.Data.Nat.Lemmas
 import Init.Data.Fin.Iterate
 
-set_option linter.missingDocs true
-
 namespace BitVec
 
 /--

src/Init/Data/BitVec/Lemmas.lean

@@ -12,8 +12,6 @@ import Init.Data.Nat.Lemmas
 import Init.Data.Nat.Mod
 import Init.Data.Int.Bitwise.Lemmas
 
-set_option linter.missingDocs true
-
 namespace BitVec
 
 /--
@@ -23,7 +21,7 @@ theorem ofFin_eq_ofNat : @BitVec.ofFin w (Fin.mk x lt) = BitVec.ofNat w x := by
   simp only [BitVec.ofNat, Fin.ofNat', lt, Nat.mod_eq_of_lt]
 
 /-- Prove equality of bitvectors in terms of nat operations. -/
-theorem eq_of_toNat_eq {n} : ∀ {x y : BitVec n}, x.toNat = y.toNat → x = y
+theorem eq_of_toNat_eq {n} : ∀ {i j : BitVec n}, i.toNat = j.toNat → i = j
   | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl
 
 @[simp] theorem val_toFin (x : BitVec w) : x.toFin.val = x.toNat := rfl
@@ -228,12 +226,12 @@ theorem toNat_ge_of_msb_true {x : BitVec n} (p : BitVec.msb x = true) : x.toNat
 /-! ### toInt/ofInt -/
 
 /-- Prove equality of bitvectors in terms of nat operations. -/
-theorem toInt_eq_toNat_cond (x : BitVec n) :
-    x.toInt =
-      if 2*x.toNat < 2^n then
-        (x.toNat : Int)
+theorem toInt_eq_toNat_cond (i : BitVec n) :
+    i.toInt =
+      if 2*i.toNat < 2^n then
+        (i.toNat : Int)
       else
-        (x.toNat : Int) - (2^n : Nat) :=
+        (i.toNat : Int) - (2^n : Nat) :=
   rfl
 
 theorem msb_eq_false_iff_two_mul_lt (x : BitVec w) : x.msb = false ↔ 2 * x.toNat < 2^w := by
@@ -260,13 +258,13 @@ theorem toInt_eq_toNat_bmod (x : BitVec n) : x.toInt = Int.bmod x.toNat (2^n) :=
     omega
 
 /-- Prove equality of bitvectors in terms of nat operations. -/
-theorem eq_of_toInt_eq {x y : BitVec n} : x.toInt = y.toInt → x = y := by
+theorem eq_of_toInt_eq {i j : BitVec n} : i.toInt = j.toInt → i = j := by
   intro eq
   simp [toInt_eq_toNat_cond] at eq
   apply eq_of_toNat_eq
   revert eq
-  have _xlt := x.isLt
-  have _ylt := y.isLt
+  have _ilt := i.isLt
+  have _jlt := j.isLt
   split <;> split <;> omega
 
 theorem toInt_inj (x y : BitVec n) : x.toInt = y.toInt ↔ x = y :=
@@ -438,12 +436,6 @@ theorem zeroExtend_ofNat_one_eq_ofNat_one_of_lt {v w : Nat} (hv : 0 < v) :
   have hv := Nat.testBit_one_eq_true_iff_self_eq_zero.mp hi₁
   omega
 
-/-- Truncating to width 1 produces a bitvector equal to the least significant bit. -/
-theorem truncate_one {x : BitVec w} :
-    x.truncate 1 = ofBool (x.getLsb 0) := by
-  ext i
-  simp [show i = 0 by omega]
-
 /-! ## extractLsb -/
 
 @[simp]
@@ -507,13 +499,6 @@ theorem or_assoc (x y z : BitVec w) :
     x ||| y ||| z = x ||| (y ||| z) := by
   ext i
   simp [Bool.or_assoc]
-instance : Std.Associative (α := BitVec n) (· ||| ·) := ⟨BitVec.or_assoc⟩
-
-theorem or_comm (x y : BitVec w) :
-    x ||| y = y ||| x := by
-  ext i
-  simp [Bool.or_comm]
-instance : Std.Commutative (fun (x y : BitVec w) => x ||| y) := ⟨BitVec.or_comm⟩
 
 /-! ### and -/
 
@@ -545,13 +530,6 @@ theorem and_assoc (x y z : BitVec w) :
     x &&& y &&& z = x &&& (y &&& z) := by
   ext i
   simp [Bool.and_assoc]
-instance : Std.Associative (α := BitVec n) (· &&& ·) := ⟨BitVec.and_assoc⟩
-
-theorem and_comm (x y : BitVec w) :
-    x &&& y = y &&& x := by
-  ext i
-  simp [Bool.and_comm]
-instance : Std.Commutative (fun (x y : BitVec w) => x &&& y) := ⟨BitVec.and_comm⟩
 
 /-! ### xor -/
 
@@ -577,13 +555,6 @@ theorem xor_assoc (x y z : BitVec w) :
     x ^^^ y ^^^ z = x ^^^ (y ^^^ z) := by
   ext i
   simp [Bool.xor_assoc]
-instance : Std.Associative (fun (x y : BitVec w) => x ^^^ y) := ⟨BitVec.xor_assoc⟩
-
-theorem xor_comm (x y : BitVec w) :
-    x ^^^ y = y ^^^ x := by
-  ext i
-  simp [Bool.xor_comm]
-instance : Std.Commutative (fun (x y : BitVec w) => x ^^^ y) := ⟨BitVec.xor_comm⟩
 
 /-! ### not -/
 
@@ -655,10 +626,6 @@ theorem shiftLeft_zero_eq (x : BitVec w) : x <<< 0 = x := by
   apply eq_of_toNat_eq
   simp
 
-@[simp]
-theorem zero_shiftLeft (n : Nat) : 0#w <<< n = 0#w := by
-  simp [bv_toNat]
-
 @[simp] theorem getLsb_shiftLeft (x : BitVec m) (n) :
     getLsb (x <<< n) i = (decide (i < m) && !decide (i < n) && getLsb x (i - n)) := by
   rw [← testBit_toNat, getLsb]
@@ -724,22 +691,6 @@ theorem shiftLeft_shiftLeft {w : Nat} (x : BitVec w) (n m : Nat) :
     (x <<< n) <<< m = x <<< (n + m) := by
   rw [shiftLeft_add]
 
-/-! ### shiftLeft reductions from BitVec to Nat -/
-
-@[simp]
-theorem shiftLeft_eq' {x : BitVec w₁} {y : BitVec w₂} : x <<< y = x <<< y.toNat := by rfl
-
-@[simp]
-theorem shiftLeft_zero' {x : BitVec w₁} : x <<< 0#w₂ = x := by simp
-
-theorem shiftLeft_shiftLeft' {x : BitVec w₁} {y : BitVec w₂} {z : BitVec w₃} :
-    x <<< y <<< z = x <<< (y.toNat + z.toNat) := by
-  simp [shiftLeft_add]
-
-theorem getLsb_shiftLeft' {x : BitVec w₁} {y : BitVec w₂} {i : Nat} :
-    (x <<< y).getLsb i = (decide (i < w₁) && !decide (i < y.toNat) && x.getLsb (i - y.toNat)) := by
-  simp [shiftLeft_eq', getLsb_shiftLeft]
-
 /-! ### ushiftRight -/
 
 @[simp, bv_toNat] theorem toNat_ushiftRight (x : BitVec n) (i : Nat) :
@@ -749,31 +700,6 @@ theorem getLsb_shiftLeft' {x : BitVec w₁} {y : BitVec w₂} {i : Nat} :
     getLsb (x >>> i) j = getLsb x (i+j) := by
   unfold getLsb ; simp
 
-theorem ushiftRight_xor_distrib (x y : BitVec w) (n : Nat) :
-    (x ^^^ y) >>> n = (x >>> n) ^^^ (y >>> n) := by
-  ext
-  simp
-
-theorem ushiftRight_and_distrib (x y : BitVec w) (n : Nat) :
-    (x &&& y) >>> n = (x >>> n) &&& (y >>> n) := by
-  ext
-  simp
-
-theorem ushiftRight_or_distrib (x y : BitVec w)  (n : Nat) :
-    (x ||| y) >>> n = (x >>> n) ||| (y >>> n) := by
-  ext
-  simp
-
-@[simp]
-theorem ushiftRight_zero_eq (x : BitVec w) : x >>> 0 = x := by
-  simp [bv_toNat]
-
-/-! ### ushiftRight reductions from BitVec to Nat -/
-
-@[simp]
-theorem ushiftRight_eq' (x : BitVec w₁) (y : BitVec w₂) :
-    x >>> y = x >>> y.toNat := by rfl
-
 /-! ### sshiftRight -/
 
 theorem sshiftRight_eq {x : BitVec n} {i : Nat} :
@@ -817,7 +743,7 @@ theorem sshiftRight_eq_of_msb_true {x : BitVec w} {s : Nat} (h : x.msb = true) :
     · rw [Nat.shiftRight_eq_div_pow]
       apply Nat.lt_of_le_of_lt (Nat.div_le_self _ _) (by omega)
 
-@[simp] theorem getLsb_sshiftRight (x : BitVec w) (s i : Nat) :
+theorem getLsb_sshiftRight (x : BitVec w) (s i : Nat) :
     getLsb (x.sshiftRight s) i =
       (!decide (w ≤ i) && if s + i < w then x.getLsb (s + i) else x.msb) := by
   rcases hmsb : x.msb with rfl | rfl
@@ -838,41 +764,6 @@ theorem sshiftRight_eq_of_msb_true {x : BitVec w} {s : Nat} (h : x.msb = true) :
         Nat.not_lt, decide_eq_true_eq]
       omega
 
-/-- The msb after arithmetic shifting right equals the original msb. -/
-theorem sshiftRight_msb_eq_msb {n : Nat} {x : BitVec w} :
-    (x.sshiftRight n).msb = x.msb := by
-  rw [msb_eq_getLsb_last, getLsb_sshiftRight, msb_eq_getLsb_last]
-  by_cases hw₀ : w = 0
-  · simp [hw₀]
-  · simp only [show ¬(w ≤ w - 1) by omega, decide_False, Bool.not_false, Bool.true_and,
-      ite_eq_right_iff]
-    intros h
-    simp [show n = 0 by omega]
-
-@[simp] theorem sshiftRight_zero {x : BitVec w} : x.sshiftRight 0 = x := by
-  ext i
-  simp
-
-theorem sshiftRight_add {x : BitVec w} {m n : Nat} :
-    x.sshiftRight (m + n) = (x.sshiftRight m).sshiftRight n := by
-  ext i
-  simp only [getLsb_sshiftRight, Nat.add_assoc]
-  by_cases h₁ : w ≤ (i : Nat)
-  · simp [h₁]
-  · simp only [h₁, decide_False, Bool.not_false, Bool.true_and]
-    by_cases h₂ : n + ↑i < w
-    · simp [h₂]
-    · simp only [h₂, ↓reduceIte]
-      by_cases h₃ : m + (n + ↑i) < w
-      · simp [h₃]
-        omega
-      · simp [h₃, sshiftRight_msb_eq_msb]
-
-/-! ### sshiftRight reductions from BitVec to Nat -/
-
-@[simp]
-theorem sshiftRight_eq' (x : BitVec w) : x.sshiftRight' y = x.sshiftRight y.toNat := rfl
-
 /-! ### signExtend -/
 
 /-- Equation theorem for `Int.sub` when both arguments are `Int.ofNat` -/
@@ -935,15 +826,15 @@ theorem append_def (x : BitVec v) (y : BitVec w) :
     (x ++ y).toNat = x.toNat <<< n ||| y.toNat :=
   rfl
 
-@[simp] theorem getLsb_append {x : BitVec n} {y : BitVec m} :
-    getLsb (x ++ y) i = bif i < m then getLsb y i else getLsb x (i - m) := by
+@[simp] theorem getLsb_append {v : BitVec n} {w : BitVec m} :
+    getLsb (v ++ w) i = bif i < m then getLsb w i else getLsb v (i - m) := by
   simp only [append_def, getLsb_or, getLsb_shiftLeftZeroExtend, getLsb_zeroExtend']
   by_cases h : i < m
   · simp [h]
   · simp [h]; simp_all
 
-@[simp] theorem getMsb_append {x : BitVec n} {y : BitVec m} :
-    getMsb (x ++ y) i = bif n ≤ i then getMsb y (i - n) else getMsb x i := by
+@[simp] theorem getMsb_append {v : BitVec n} {w : BitVec m} :
+    getMsb (v ++ w) i = bif n ≤ i then getMsb w (i - n) else getMsb v i := by
   simp [append_def]
   by_cases h : n ≤ i
   · simp [h]
@@ -1561,18 +1452,12 @@ theorem getLsb_twoPow (i j : Nat) : (twoPow w i).getLsb j = ((i < w) && (i = j))
           simp at hi
         simp_all
 
-@[simp]
-theorem and_twoPow (x : BitVec w) (i : Nat) :
+theorem and_twoPow_eq (x : BitVec w) (i : Nat) :
     x &&& (twoPow w i) = if x.getLsb i then twoPow w i else 0#w := by
   ext j
   simp only [getLsb_and, getLsb_twoPow]
   by_cases hj : i = j <;> by_cases hx : x.getLsb i <;> simp_all
 
-@[simp]
-theorem twoPow_and (x : BitVec w) (i : Nat) :
-    (twoPow w i) &&& x = if x.getLsb i then twoPow w i else 0#w := by
-  rw [BitVec.and_comm, and_twoPow]
-
 @[simp]
 theorem mul_twoPow_eq_shiftLeft (x : BitVec w) (i : Nat) :
     x * (twoPow w i) = x <<< i := by
@@ -1586,14 +1471,6 @@ theorem mul_twoPow_eq_shiftLeft (x : BitVec w) (i : Nat) :
       apply Nat.pow_dvd_pow 2 (by omega)
     simp [Nat.mul_mod, hpow]
 
-theorem twoPow_zero {w : Nat} : twoPow w 0 = 1#w := by
-  apply eq_of_toNat_eq
-  simp
-
-@[simp]
-theorem getLsb_one {w i : Nat} : (1#w).getLsb i = (decide (0 < w) && decide (0 = i)) := by
-  rw [← twoPow_zero, getLsb_twoPow]
-
 /- ### zeroExtend, truncate, and bitwise operations -/
 
 /--
@@ -1627,54 +1504,4 @@ theorem zeroExtend_truncate_succ_eq_zeroExtend_truncate_or_twoPow_of_getLsb_true
     simp [hx]
   · by_cases hik' : k < i + 1 <;> simp [hik, hik'] <;> omega
 
-/-- Bitwise and of `(x : BitVec w)` with `1#w` equals zero extending `x.lsb` to `w`. -/
-theorem and_one_eq_zeroExtend_ofBool_getLsb {x : BitVec w} :
-    (x &&& 1#w) = zeroExtend w (ofBool (x.getLsb 0)) := by
-  ext i
-  simp only [getLsb_and, getLsb_one, getLsb_zeroExtend, Fin.is_lt, decide_True, getLsb_ofBool,
-    Bool.true_and]
-  by_cases h : (0 = (i : Nat)) <;> simp [h] <;> omega
-
-@[simp]
-theorem replicate_zero_eq {x : BitVec w} : x.replicate 0 = 0#0 := by
-  simp [replicate]
-
-@[simp]
-theorem replicate_succ_eq {x : BitVec w} :
-    x.replicate (n + 1) =
-    (x ++ replicate n x).cast (by rw [Nat.mul_succ]; omega) := by
-  simp [replicate]
-
-/--
-If a number `w * n ≤ i < w * (n + 1)`, then `i - w * n` equals `i % w`.
-This is true by subtracting `w * n` from the inequality, giving
-`0 ≤ i - w * n < w`, which uniquely identifies `i % w`.
--/
-private theorem Nat.sub_mul_eq_mod_of_lt_of_le (hlo : w * n ≤ i) (hhi : i < w * (n + 1)) :
-    i - w * n = i % w := by
-  rw [Nat.mod_def]
-  congr
-  symm
-  apply Nat.div_eq_of_lt_le
-    (by rw [Nat.mul_comm]; omega)
-    (by rw [Nat.mul_comm]; omega)
-
-@[simp]
-theorem getLsb_replicate {n w : Nat} (x : BitVec w) :
-    (x.replicate n).getLsb i =
-    (decide (i < w * n) && x.getLsb (i % w)) := by
-  induction n generalizing x
-  case zero => simp
-  case succ n ih =>
-    simp only [replicate_succ_eq, getLsb_cast, getLsb_append]
-    by_cases hi : i < w * (n + 1)
-    · simp only [hi, decide_True, Bool.true_and]
-      by_cases hi' : i < w * n
-      · simp [hi', ih]
-      · simp only [hi', decide_False, cond_false]
-        rw [Nat.sub_mul_eq_mod_of_lt_of_le] <;> omega
-    · rw [Nat.mul_succ] at hi ⊢
-      simp only [show ¬i < w * n by omega, decide_False, cond_false, hi, Bool.false_and]
-      apply BitVec.getLsb_ge (x := x) (i := i - w * n) (ge := by omega)
-
 end BitVec

src/Init/Data/Bool.lean

@@ -438,24 +438,6 @@ Added for confluence between `if_true_left` and `ite_false_same` on
 -/
 @[simp] theorem eq_true_imp_eq_false : ∀(b:Bool), (b = true → b = false) ↔ (b = false) := by decide
 
-/-! ### forall -/
-
-theorem forall_bool' {p : Bool → Prop} (b : Bool) : (∀ x, p x) ↔ p b ∧ p !b :=
-  ⟨fun h ↦ ⟨h _, h _⟩, fun ⟨h₁, h₂⟩ x ↦ by cases b <;> cases x <;> assumption⟩
-
-@[simp]
-theorem forall_bool {p : Bool → Prop} : (∀ b, p b) ↔ p false ∧ p true :=
-  forall_bool' false
-
-/-! ### exists -/
-
-theorem exists_bool' {p : Bool → Prop} (b : Bool) : (∃ x, p x) ↔ p b ∨ p !b :=
-  ⟨fun ⟨x, hx⟩ ↦ by cases x <;> cases b <;> first | exact .inl ‹_› | exact .inr ‹_›,
-    fun h ↦ by cases h <;> exact ⟨_, ‹_›⟩⟩
-
-@[simp]
-theorem exists_bool {p : Bool → Prop} : (∃ b, p b) ↔ p false ∨ p true :=
-  exists_bool' false
 
 /-! ### cond -/
 

src/Init/Data/ByteArray/Basic.lean

@@ -37,10 +37,6 @@ def push : ByteArray → UInt8 → ByteArray
 def size : (@& ByteArray) → Nat
   | ⟨bs⟩ => bs.size
 
-@[extern "lean_sarray_size", simp]
-def usize (a : @& ByteArray) : USize :=
-  a.size.toUSize
-
 @[extern "lean_byte_array_uget"]
 def uget : (a : @& ByteArray) → (i : USize) → i.toNat < a.size → UInt8
   | ⟨bs⟩, i, h => bs[i]
@@ -123,7 +119,7 @@ def toList (bs : ByteArray) : List UInt8 :=
   TODO: avoid code duplication in the future after we improve the compiler.
 -/
 @[inline] unsafe def forInUnsafe {β : Type v} {m : Type v → Type w} [Monad m] (as : ByteArray) (b : β) (f : UInt8 → β → m (ForInStep β)) : m β :=
-  let sz := as.usize
+  let sz := USize.ofNat as.size
   let rec @[specialize] loop (i : USize) (b : β) : m β := do
     if i < sz then
       let a := as.uget i lcProof
@@ -191,121 +187,6 @@ def foldlM {β : Type v} {m : Type v → Type w} [Monad m] (f : β → UInt8 →
 def foldl {β : Type v} (f : β → UInt8 → β) (init : β) (as : ByteArray) (start := 0) (stop := as.size) : β :=
   Id.run <| as.foldlM f init start stop
 
-/-- Iterator over the bytes (`UInt8`) of a `ByteArray`.
-
-Typically created by `arr.iter`, where `arr` is a `ByteArray`.
-
-An iterator is *valid* if the position `i` is *valid* for the array `arr`, meaning `0 ≤ i ≤ arr.size`
-
-Most operations on iterators return arbitrary values if the iterator is not valid. The functions in
-the `ByteArray.Iterator` API should rule out the creation of invalid iterators, with two exceptions:
-
-- `Iterator.next iter` is invalid if `iter` is already at the end of the array (`iter.atEnd` is
-  `true`)
-- `Iterator.forward iter n`/`Iterator.nextn iter n` is invalid if `n` is strictly greater than the
-  number of remaining bytes.
--/
-structure Iterator where
-  /-- The array the iterator is for. -/
-  array : ByteArray
-  /-- The current position.
-
-  This position is not necessarily valid for the array, for instance if one keeps calling
-  `Iterator.next` when `Iterator.atEnd` is true. If the position is not valid, then the
-  current byte is `(default : UInt8)`. -/
-  idx : Nat
-  deriving Inhabited
-
-/-- Creates an iterator at the beginning of an array. -/
-def mkIterator (arr : ByteArray) : Iterator :=
-  ⟨arr, 0⟩
-
-@[inherit_doc mkIterator]
-abbrev iter := mkIterator
-
-/-- The size of an array iterator is the number of bytes remaining. -/
-instance : SizeOf Iterator where
-  sizeOf i := i.array.size - i.idx
-
-theorem Iterator.sizeOf_eq (i : Iterator) : sizeOf i = i.array.size - i.idx :=
-  rfl
-
-namespace Iterator
-
-/-- Number of bytes remaining in the iterator. -/
-def remainingBytes : Iterator → Nat
-  | ⟨arr, i⟩ => arr.size - i
-
-@[inherit_doc Iterator.idx]
-def pos := Iterator.idx
-
-/-- The byte at the current position.
-
-On an invalid position, returns `(default : UInt8)`. -/
-@[inline]
-def curr : Iterator → UInt8
-  | ⟨arr, i⟩ =>
-    if h:i < arr.size then
-      arr[i]'h
-    else
-      default
-
-/-- Moves the iterator's position forward by one byte, unconditionally.
-
-It is only valid to call this function if the iterator is not at the end of the array, *i.e.*
-`Iterator.atEnd` is `false`; otherwise, the resulting iterator will be invalid. -/
-@[inline]
-def next : Iterator → Iterator
-  | ⟨arr, i⟩ => ⟨arr, i + 1⟩
-
-/-- Decreases the iterator's position.
-
-If the position is zero, this function is the identity. -/
-@[inline]
-def prev : Iterator → Iterator
-  | ⟨arr, i⟩ => ⟨arr, i - 1⟩
-
-/-- True if the iterator is past the array's last byte. -/
-@[inline]
-def atEnd : Iterator → Bool
-  | ⟨arr, i⟩ => i ≥ arr.size
-
-/-- True if the iterator is not past the array's last byte. -/
-@[inline]
-def hasNext : Iterator → Bool
-  | ⟨arr, i⟩ => i < arr.size
-
-/-- True if the position is not zero. -/
-@[inline]
-def hasPrev : Iterator → Bool
-  | ⟨_, i⟩ => i > 0
-
-/-- Moves the iterator's position to the end of the array.
-
-Note that `i.toEnd.atEnd` is always `true`. -/
-@[inline]
-def toEnd : Iterator → Iterator
-  | ⟨arr, _⟩ => ⟨arr, arr.size⟩
-
-/-- Moves the iterator's position several bytes forward.
-
-The resulting iterator is only valid if the number of bytes to skip is less than or equal to
-the number of bytes left in the iterator. -/
-@[inline]
-def forward : Iterator → Nat → Iterator
-  | ⟨arr, i⟩, f => ⟨arr, i + f⟩
-
-@[inherit_doc forward, inline]
-def nextn : Iterator → Nat → Iterator := forward
-
-/-- Moves the iterator's position several bytes back.
-
-If asked to go back more bytes than available, stops at the beginning of the array. -/
-@[inline]
-def prevn : Iterator → Nat → Iterator
-  | ⟨arr, i⟩, f => ⟨arr, i - f⟩
-
-end Iterator
 end ByteArray
 
 def List.toByteArray (bs : List UInt8) : ByteArray :=

src/Init/Data/FloatArray/Basic.lean

@@ -37,10 +37,6 @@ def push : FloatArray → Float → FloatArray
 def size : (@& FloatArray) → Nat
   | ⟨ds⟩ => ds.size
 
-@[extern "lean_sarray_size", simp]
-def usize (a : @& FloatArray) : USize :=
-  a.size.toUSize
-
 @[extern "lean_float_array_uget"]
 def uget : (a : @& FloatArray) → (i : USize) → i.toNat < a.size → Float
   | ⟨ds⟩, i, h => ds[i]
@@ -94,7 +90,7 @@ partial def toList (ds : FloatArray) : List Float :=
 -/
 -- TODO: avoid code duplication in the future after we improve the compiler.
 @[inline] unsafe def forInUnsafe {β : Type v} {m : Type v → Type w} [Monad m] (as : FloatArray) (b : β) (f : Float → β → m (ForInStep β)) : m β :=
-  let sz := as.usize
+  let sz := USize.ofNat as.size
   let rec @[specialize] loop (i : USize) (b : β) : m β := do
     if i < sz then
       let a := as.uget i lcProof

src/Init/Data/Int/Basic.lean

@@ -322,8 +322,8 @@ protected def pow (m : Int) : Nat → Int
   | 0      => 1
   | succ n => Int.pow m n * m
 
-instance : NatPow Int where
-  pow := Int.pow
+instance : HPow Int Nat Int where
+  hPow := Int.pow
 
 instance : LawfulBEq Int where
   eq_of_beq h := by simp [BEq.beq] at h; assumption

src/Init/Data/List.lean

@@ -4,20 +4,11 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Leonardo de Moura
 -/
 prelude
-import Init.Data.List.Attach
 import Init.Data.List.Basic
 import Init.Data.List.BasicAux
 import Init.Data.List.Control
-import Init.Data.List.Count
-import Init.Data.List.Erase
-import Init.Data.List.Find
-import Init.Data.List.Impl
 import Init.Data.List.Lemmas
-import Init.Data.List.MinMax
-import Init.Data.List.Monadic
-import Init.Data.List.Nat
-import Init.Data.List.Notation
-import Init.Data.List.Pairwise
-import Init.Data.List.Sublist
+import Init.Data.List.Attach
+import Init.Data.List.Impl
 import Init.Data.List.TakeDrop
-import Init.Data.List.Zip
+import Init.Data.List.Notation

src/Init/Data/List/Attach.lean

@@ -4,8 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
 -/
 prelude
-import Init.Data.List.Count
-import Init.Data.Subtype
+import Init.Data.List.Lemmas
 
 namespace List
 
@@ -45,155 +44,3 @@ Unsafe implementation of `attachWith`, taking advantage of the fact that the rep
   | nil, hL' => rfl
   | cons _ L', hL' => congrArg _ <| go L' fun _ hx => hL' (.tail _ hx)
   exact go L h'
-
-@[simp] theorem attach_nil : ([] : List α).attach = [] := rfl
-
-@[simp]
-theorem pmap_eq_map (p : α → Prop) (f : α → β) (l : List α) (H) :
-    @pmap _ _ p (fun a _ => f a) l H = map f l := by
-  induction l
-  · rfl
-  · simp only [*, pmap, map]
-
-theorem pmap_congr {p q : α → Prop} {f : ∀ a, p a → β} {g : ∀ a, q a → β} (l : List α) {H₁ H₂}
-    (h : ∀ a ∈ l, ∀ (h₁ h₂), f a h₁ = g a h₂) : pmap f l H₁ = pmap g l H₂ := by
-  induction l with
-  | nil => rfl
-  | cons x l ih => rw [pmap, pmap, h _ (mem_cons_self _ _), ih fun a ha => h a (mem_cons_of_mem _ ha)]
-
-theorem map_pmap {p : α → Prop} (g : β → γ) (f : ∀ a, p a → β) (l H) :
-    map g (pmap f l H) = pmap (fun a h => g (f a h)) l H := by
-  induction l
-  · rfl
-  · simp only [*, pmap, map]
-
-theorem pmap_map {p : β → Prop} (g : ∀ b, p b → γ) (f : α → β) (l H) :
-    pmap g (map f l) H = pmap (fun a h => g (f a) h) l fun a h => H _ (mem_map_of_mem _ h) := by
-  induction l
-  · rfl
-  · simp only [*, pmap, map]
-
-theorem pmap_eq_map_attach {p : α → Prop} (f : ∀ a, p a → β) (l H) :
-    pmap f l H = l.attach.map fun x => f x.1 (H _ x.2) := by
-  rw [attach, attachWith, map_pmap]; exact pmap_congr l fun _ _ _ _ => rfl
-
-theorem attach_map_coe (l : List α) (f : α → β) :
-    (l.attach.map fun (i : {i // i ∈ l}) => f i) = l.map f := by
-  rw [attach, attachWith, map_pmap]; exact pmap_eq_map _ _ _ _
-
-theorem attach_map_val (l : List α) (f : α → β) : (l.attach.map fun i => f i.val) = l.map f :=
-  attach_map_coe _ _
-
-@[simp]
-theorem attach_map_subtype_val (l : List α) : l.attach.map Subtype.val = l :=
-  (attach_map_coe _ _).trans l.map_id
-
-theorem countP_attach (l : List α) (p : α → Bool) : l.attach.countP (fun a : {x // x ∈ l} => p a) = l.countP p := by
-  simp only [← Function.comp_apply (g := Subtype.val), ← countP_map, attach_map_subtype_val]
-
-@[simp]
-theorem count_attach [DecidableEq α] (l : List α) (a : {x // x ∈ l}) : l.attach.count a = l.count ↑a :=
-  Eq.trans (countP_congr fun _ _ => by simp [Subtype.ext_iff]) <| countP_attach _ _
-
-@[simp]
-theorem mem_attach (l : List α) : ∀ x, x ∈ l.attach
-  | ⟨a, h⟩ => by
-    have := mem_map.1 (by rw [attach_map_subtype_val] <;> exact h)
-    rcases this with ⟨⟨_, _⟩, m, rfl⟩
-    exact m
-
-@[simp]
-theorem mem_pmap {p : α → Prop} {f : ∀ a, p a → β} {l H b} :
-    b ∈ pmap f l H ↔ ∃ (a : _) (h : a ∈ l), f a (H a h) = b := by
-  simp only [pmap_eq_map_attach, mem_map, mem_attach, true_and, Subtype.exists, eq_comm]
-
-@[simp]
-theorem length_pmap {p : α → Prop} {f : ∀ a, p a → β} {l H} : length (pmap f l H) = length l := by
-  induction l
-  · rfl
-  · simp only [*, pmap, length]
-
-@[simp]
-theorem length_attach (L : List α) : L.attach.length = L.length :=
-  length_pmap
-
-@[simp]
-theorem pmap_eq_nil {p : α → Prop} {f : ∀ a, p a → β} {l H} : pmap f l H = [] ↔ l = [] := by
-  rw [← length_eq_zero, length_pmap, length_eq_zero]
-
-@[simp]
-theorem attach_eq_nil (l : List α) : l.attach = [] ↔ l = [] :=
-  pmap_eq_nil
-
-theorem getLast_pmap (p : α → Prop) (f : ∀ a, p a → β) (l : List α)
-    (hl₁ : ∀ a ∈ l, p a) (hl₂ : l ≠ []) :
-    (l.pmap f hl₁).getLast (mt List.pmap_eq_nil.1 hl₂) =
-      f (l.getLast hl₂) (hl₁ _ (List.getLast_mem hl₂)) := by
-  induction l with
-  | nil => apply (hl₂ rfl).elim
-  | cons l_hd l_tl l_ih =>
-    by_cases hl_tl : l_tl = []
-    · simp [hl_tl]
-    · simp only [pmap]
-      rw [getLast_cons, l_ih _ hl_tl]
-      simp only [getLast_cons hl_tl]
-
-theorem getElem?_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h : ∀ a ∈ l, p a) (n : Nat) :
-    (pmap f l h)[n]? = Option.pmap f l[n]? fun x H => h x (getElem?_mem H) := by
-  induction l generalizing n with
-  | nil => simp
-  | cons hd tl hl =>
-    rcases n with ⟨n⟩
-    · simp only [Option.pmap]
-      split <;> simp_all
-    · simp only [hl, pmap, Option.pmap, getElem?_cons_succ]
-      split <;> rename_i h₁ _ <;> split <;> rename_i h₂ _
-      · simp_all
-      · simp at h₂
-        simp_all
-      · simp_all
-      · simp_all
-
-theorem get?_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h : ∀ a ∈ l, p a) (n : Nat) :
-    get? (pmap f l h) n = Option.pmap f (get? l n) fun x H => h x (get?_mem H) := by
-  simp only [get?_eq_getElem?]
-  simp [getElem?_pmap, h]
-
-theorem getElem_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h : ∀ a ∈ l, p a) {n : Nat}
-    (hn : n < (pmap f l h).length) :
-    (pmap f l h)[n] =
-      f (l[n]'(@length_pmap _ _ p f l h ▸ hn))
-        (h _ (getElem_mem l n (@length_pmap _ _ p f l h ▸ hn))) := by
-  induction l generalizing n with
-  | nil =>
-    simp only [length, pmap] at hn
-    exact absurd hn (Nat.not_lt_of_le n.zero_le)
-  | cons hd tl hl =>
-    cases n
-    · simp
-    · simp [hl]
-
-theorem get_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h : ∀ a ∈ l, p a) {n : Nat}
-    (hn : n < (pmap f l h).length) :
-    get (pmap f l h) ⟨n, hn⟩ =
-      f (get l ⟨n, @length_pmap _ _ p f l h ▸ hn⟩)
-        (h _ (get_mem l n (@length_pmap _ _ p f l h ▸ hn))) := by
-  simp only [get_eq_getElem]
-  simp [getElem_pmap]
-
-theorem pmap_append {p : ι → Prop} (f : ∀ a : ι, p a → α) (l₁ l₂ : List ι)
-    (h : ∀ a ∈ l₁ ++ l₂, p a) :
-    (l₁ ++ l₂).pmap f h =
-      (l₁.pmap f fun a ha => h a (mem_append_left l₂ ha)) ++
-        l₂.pmap f fun a ha => h a (mem_append_right l₁ ha) := by
-  induction l₁ with
-  | nil => rfl
-  | cons _ _ ih =>
-    dsimp only [pmap, cons_append]
-    rw [ih]
-
-theorem pmap_append' {p : α → Prop} (f : ∀ a : α, p a → β) (l₁ l₂ : List α)
-    (h₁ : ∀ a ∈ l₁, p a) (h₂ : ∀ a ∈ l₂, p a) :
-    ((l₁ ++ l₂).pmap f fun a ha => (List.mem_append.1 ha).elim (h₁ a) (h₂ a)) =
-      l₁.pmap f h₁ ++ l₂.pmap f h₂ :=
-  pmap_append f l₁ l₂ _

src/Init/Data/List/Basic.lean

@@ -27,32 +27,24 @@ Recall that `length`, `get`, `set`, `foldl`, and `concat` have already been defi
 The operations are organized as follow:
 * Equality: `beq`, `isEqv`.
 * Lexicographic ordering: `lt`, `le`, and instances.
-* Head and tail operators: `head`, `head?`, `headD?`, `tail`, `tail?`, `tailD`.
 * Basic operations:
-  `map`, `filter`, `filterMap`, `foldr`, `append`, `join`, `pure`, `bind`, `replicate`, and
-  `reverse`.
-* Additional functions defined in terms of these: `leftpad`, `rightPad`, and `reduceOption`.
+  `map`, `filter`, `filterMap`, `foldr`, `append`, `join`, `pure`, `bind`, `replicate`, and `reverse`.
 * List membership: `isEmpty`, `elem`, `contains`, `mem` (and the `∈` notation),
   and decidability for predicates quantifying over membership in a `List`.
 * Sublists: `take`, `drop`, `takeWhile`, `dropWhile`, `partition`, `dropLast`,
-  `isPrefixOf`, `isPrefixOf?`, `isSuffixOf`, `isSuffixOf?`, `Subset`, `Sublist`,
-  `rotateLeft` and `rotateRight`.
-* Manipulating elements: `replace`, `insert`, `erase`, `eraseP`, `eraseIdx`.
-* Finding elements: `find?`, `findSome?`, `findIdx`, `indexOf`, `findIdx?`, `indexOf?`,
- `countP`, `count`, and `lookup`.
+  `isPrefixOf`, `isPrefixOf?`, `isSuffixOf`, `isSuffixOf?`, `Subset`, `Sublist`, `rotateLeft` and `rotateRight`.
+* Manipulating elements: `replace`, `insert`, `erase`, `eraseP`, `eraseIdx`, `find?`, `findSome?`, and `lookup`.
 * Logic: `any`, `all`, `or`, and `and`.
 * Zippers: `zipWith`, `zip`, `zipWithAll`, and `unzip`.
 * Ranges and enumeration: `range`, `iota`, `enumFrom`, and `enum`.
 * Minima and maxima: `minimum?` and `maximum?`.
-* Other functions: `intersperse`, `intercalate`, `eraseDups`, `eraseReps`, `span`, `groupBy`,
-  `removeAll`
+* Other functions: `intersperse`, `intercalate`, `eraseDups`, `eraseReps`, `span`, `groupBy`, `removeAll`
   (currently these functions are mostly only used in meta code,
   and do not have API suitable for verification).
 
-Further operations are defined in `Init.Data.List.BasicAux`
-(because they use `Array` in their implementations), namely:
+Further operations are defined in `Init.Data.List.BasicAux` (because they use `Array` in their implementations), namely:
 * Variant getters: `get!`, `get?`, `getD`, `getLast`, `getLast!`, `getLast?`, and `getLastD`.
-* Head and tail: `head!`, `tail!`.
+* Head and tail: `head`, `head!`, `head?`, `headD`, `tail!`, `tail?`, and `tailD`.
 * Other operations on sublists: `partitionMap`, `rotateLeft`, and `rotateRight`.
 -/
 
@@ -323,16 +315,6 @@ def headD : (as : List α) → (fallback : α) → α
 @[simp 1100] theorem headD_nil : @headD α [] d = d := rfl
 @[simp 1100] theorem headD_cons : @headD α (a::l) d = a := rfl
 
-/-! ### tail -/
-
-/-- Get the tail of a nonempty list, or return `[]` for `[]`. -/
-def tail : List α → List α
-  | []    => []
-  | _::as => as
-
-@[simp] theorem tail_nil : @tail α [] = [] := rfl
-@[simp] theorem tail_cons : @tail α (a::as) = as := rfl
-
 /-! ### tail? -/
 
 /--
@@ -595,28 +577,6 @@ theorem replicate_succ (a : α) (n) : replicate (n+1) a = a :: replicate n a :=
   | zero => simp
   | succ n ih => simp only [ih, replicate_succ, length_cons, Nat.succ_eq_add_one]
 
-/-! ## Additional functions -/
-
-/-! ### leftpad and rightpad -/
-
-/--
-Pads `l : List α` on the left with repeated occurrences of `a : α` until it is of length `n`.
-If `l` is initially larger than `n`, just return `l`.
--/
-def leftpad (n : Nat) (a : α) (l : List α) : List α := replicate (n - length l) a ++ l
-
-/--
-Pads `l : List α` on the right with repeated occurrences of `a : α` until it is of length `n`.
-If `l` is initially larger than `n`, just return `l`.
--/
-def rightpad (n : Nat) (a : α) (l : List α) : List α := l ++ replicate (n - length l) a
-
-/-! ### reduceOption -/
-
-/-- Drop `none`s from a list, and replace each remaining `some a` with `a`. -/
-@[inline] def reduceOption {α} : List (Option α) → List α :=
-  List.filterMap id
-
 /-! ## List membership
 
 * `L.contains a : Bool` determines, using a `[BEq α]` instance, whether `L` contains an element `· == a`.
@@ -759,7 +719,7 @@ def take : Nat → List α → List α
 
 @[simp] theorem take_nil : ([] : List α).take i = [] := by cases i <;> rfl
 @[simp] theorem take_zero (l : List α) : l.take 0 = [] := rfl
-@[simp] theorem take_succ_cons : (a::as).take (i+1) = a :: as.take i := rfl
+@[simp] theorem take_cons_succ : (a::as).take (i+1) = a :: as.take i := rfl
 
 /-! ### drop -/
 
@@ -866,6 +826,46 @@ def dropLast {α} : List α → List α
     have ih := length_dropLast_cons b bs
     simp [dropLast, ih]
 
+/-! ### isPrefixOf -/
+
+/--  `isPrefixOf l₁ l₂` returns `true` Iff `l₁` is a prefix of `l₂`.
+That is, there exists a `t` such that `l₂ == l₁ ++ t`. -/
+def isPrefixOf [BEq α] : List α → List α → Bool
+  | [],    _     => true
+  | _,     []    => false
+  | a::as, b::bs => a == b && isPrefixOf as bs
+
+@[simp] theorem isPrefixOf_nil_left [BEq α] : isPrefixOf ([] : List α) l = true := by
+  simp [isPrefixOf]
+@[simp] theorem isPrefixOf_cons_nil [BEq α] : isPrefixOf (a::as) ([] : List α) = false := rfl
+theorem isPrefixOf_cons₂ [BEq α] {a : α} :
+    isPrefixOf (a::as) (b::bs) = (a == b && isPrefixOf as bs) := rfl
+
+/-! ### isPrefixOf? -/
+
+/-- `isPrefixOf? l₁ l₂` returns `some t` when `l₂ == l₁ ++ t`. -/
+def isPrefixOf? [BEq α] : List α → List α → Option (List α)
+  | [], l₂ => some l₂
+  | _, [] => none
+  | (x₁ :: l₁), (x₂ :: l₂) =>
+    if x₁ == x₂ then isPrefixOf? l₁ l₂ else none
+
+/-! ### isSuffixOf -/
+
+/--  `isSuffixOf l₁ l₂` returns `true` Iff `l₁` is a suffix of `l₂`.
+That is, there exists a `t` such that `l₂ == t ++ l₁`. -/
+def isSuffixOf [BEq α] (l₁ l₂ : List α) : Bool :=
+  isPrefixOf l₁.reverse l₂.reverse
+
+@[simp] theorem isSuffixOf_nil_left [BEq α] : isSuffixOf ([] : List α) l = true := by
+  simp [isSuffixOf]
+
+/-! ### isSuffixOf? -/
+
+/-- `isSuffixOf? l₁ l₂` returns `some t` when `l₂ == t ++ l₁`.-/
+def isSuffixOf? [BEq α] (l₁ l₂ : List α) : Option (List α) :=
+  Option.map List.reverse <| isPrefixOf? l₁.reverse l₂.reverse
+
 /-! ### Subset -/
 
 /--
@@ -900,68 +900,6 @@ def isSublist [BEq α] : List α → List α → Bool
     then tl₁.isSublist tl₂
     else l₁.isSublist tl₂
 
-/-! ### IsPrefix / isPrefixOf / isPrefixOf? -/
-
-/--
-`IsPrefix l₁ l₂`, or `l₁ <+: l₂`, means that `l₁` is a prefix of `l₂`,
-that is, `l₂` has the form `l₁ ++ t` for some `t`.
--/
-def IsPrefix (l₁ : List α) (l₂ : List α) : Prop := Exists fun t => l₁ ++ t = l₂
-
-@[inherit_doc] infixl:50 " <+: " => IsPrefix
-
-/--  `isPrefixOf l₁ l₂` returns `true` Iff `l₁` is a prefix of `l₂`.
-That is, there exists a `t` such that `l₂ == l₁ ++ t`. -/
-def isPrefixOf [BEq α] : List α → List α → Bool
-  | [],    _     => true
-  | _,     []    => false
-  | a::as, b::bs => a == b && isPrefixOf as bs
-
-@[simp] theorem isPrefixOf_nil_left [BEq α] : isPrefixOf ([] : List α) l = true := by
-  simp [isPrefixOf]
-@[simp] theorem isPrefixOf_cons_nil [BEq α] : isPrefixOf (a::as) ([] : List α) = false := rfl
-theorem isPrefixOf_cons₂ [BEq α] {a : α} :
-    isPrefixOf (a::as) (b::bs) = (a == b && isPrefixOf as bs) := rfl
-
-/-- `isPrefixOf? l₁ l₂` returns `some t` when `l₂ == l₁ ++ t`. -/
-def isPrefixOf? [BEq α] : List α → List α → Option (List α)
-  | [], l₂ => some l₂
-  | _, [] => none
-  | (x₁ :: l₁), (x₂ :: l₂) =>
-    if x₁ == x₂ then isPrefixOf? l₁ l₂ else none
-
-/-! ### IsSuffix / isSuffixOf / isSuffixOf? -/
-
-/--  `isSuffixOf l₁ l₂` returns `true` Iff `l₁` is a suffix of `l₂`.
-That is, there exists a `t` such that `l₂ == t ++ l₁`. -/
-def isSuffixOf [BEq α] (l₁ l₂ : List α) : Bool :=
-  isPrefixOf l₁.reverse l₂.reverse
-
-@[simp] theorem isSuffixOf_nil_left [BEq α] : isSuffixOf ([] : List α) l = true := by
-  simp [isSuffixOf]
-
-/-- `isSuffixOf? l₁ l₂` returns `some t` when `l₂ == t ++ l₁`.-/
-def isSuffixOf? [BEq α] (l₁ l₂ : List α) : Option (List α) :=
-  Option.map List.reverse <| isPrefixOf? l₁.reverse l₂.reverse
-
-/--
-`IsSuffix l₁ l₂`, or `l₁ <:+ l₂`, means that `l₁` is a suffix of `l₂`,
-that is, `l₂` has the form `t ++ l₁` for some `t`.
--/
-def IsSuffix (l₁ : List α) (l₂ : List α) : Prop := Exists fun t => t ++ l₁ = l₂
-
-@[inherit_doc] infixl:50 " <:+ " => IsSuffix
-
-/-! ### IsInfix -/
-
-/--
-`IsInfix l₁ l₂`, or `l₁ <:+: l₂`, means that `l₁` is a contiguous
-substring of `l₂`, that is, `l₂` has the form `s ++ l₁ ++ t` for some `s, t`.
--/
-def IsInfix (l₁ : List α) (l₂ : List α) : Prop := Exists fun s => Exists fun t => s ++ l₁ ++ t = l₂
-
-@[inherit_doc] infixl:50 " <:+: " => IsInfix
-
 /-! ### rotateLeft -/
 
 /--
@@ -1120,8 +1058,6 @@ def eraseIdx : List α → Nat → List α
 @[simp] theorem eraseIdx_cons_zero : (a::as).eraseIdx 0 = as := rfl
 @[simp] theorem eraseIdx_cons_succ : (a::as).eraseIdx (i+1) = a :: as.eraseIdx i := rfl
 
-/-! Finding elements -/
-
 /-! ### find? -/
 
 /--
@@ -1159,50 +1095,6 @@ theorem findSome?_cons {f : α → Option β} :
     (a::as).findSome? f = match f a with | some b => some b | none => as.findSome? f :=
   rfl
 
-/-! ### findIdx -/
-
-/-- Returns the index of the first element satisfying `p`, or the length of the list otherwise. -/
-@[inline] def findIdx (p : α → Bool) (l : List α) : Nat := go l 0 where
-  /-- Auxiliary for `findIdx`: `findIdx.go p l n = findIdx p l + n` -/
-  @[specialize] go : List α → Nat → Nat
-  | [], n => n
-  | a :: l, n => bif p a then n else go l (n + 1)
-
-@[simp] theorem findIdx_nil {α : Type _} (p : α → Bool) : [].findIdx p = 0 := rfl
-
-/-! ### indexOf -/
-
-/-- Returns the index of the first element equal to `a`, or the length of the list otherwise. -/
-def indexOf [BEq α] (a : α) : List α → Nat := findIdx (· == a)
-
-@[simp] theorem indexOf_nil [BEq α] : ([] : List α).indexOf x = 0 := rfl
-
-/-! ### findIdx? -/
-
-/-- Return the index of the first occurrence of an element satisfying `p`. -/
-def findIdx? (p : α → Bool) : List α → (start : Nat := 0) → Option Nat
-| [], _ => none
-| a :: l, i => if p a then some i else findIdx? p l (i + 1)
-
-/-! ### indexOf? -/
-
-/-- Return the index of the first occurrence of `a` in the list. -/
-@[inline] def indexOf? [BEq α] (a : α) : List α → Option Nat := findIdx? (· == a)
-
-/-! ### countP -/
-
-/-- `countP p l` is the number of elements of `l` that satisfy `p`. -/
-@[inline] def countP (p : α → Bool) (l : List α) : Nat := go l 0 where
-  /-- Auxiliary for `countP`: `countP.go p l acc = countP p l + acc`. -/
-  @[specialize] go : List α → Nat → Nat
-  | [], acc => acc
-  | x :: xs, acc => bif p x then go xs (acc + 1) else go xs acc
-
-/-! ### count -/
-
-/-- `count a l` is the number of occurrences of `a` in `l`. -/
-@[inline] def count [BEq α] (a : α) : List α → Nat := countP (· == a)
-
 /-! ### lookup -/
 
 /--
@@ -1344,14 +1236,6 @@ def unzip : List (α × β) → List α × List β
 
 /-! ## Ranges and enumeration -/
 
-/-- Sum of a list of natural numbers. -/
--- This is not in the `List` namespace as later `List.sum` will be defined polymorphically.
-protected def _root_.Nat.sum (l : List Nat) : Nat := l.foldr (·+·) 0
-
-@[simp] theorem _root_.Nat.sum_nil : Nat.sum ([] : List Nat) = 0 := rfl
-@[simp] theorem _root_.Nat.sum_cons (a : Nat) (l : List Nat) :
-    Nat.sum (a::l) = a + Nat.sum l := rfl
-
 /-! ### range -/
 
 /--
@@ -1367,14 +1251,6 @@ where
 
 @[simp] theorem range_zero : range 0 = [] := rfl
 
-/-! ### range' -/
-
-/-- `range' start len step` is the list of numbers `[start, start+step, ..., start+(len-1)*step]`.
-  It is intended mainly for proving properties of `range` and `iota`. -/
-def range' : (start len : Nat) → (step : Nat := 1) → List Nat
-  | _, 0, _ => []
-  | s, n+1, step => s :: range' (s+step) n step
-
 /-! ### iota -/
 
 /--

src/Init/Data/List/Control.lean

@@ -127,12 +127,12 @@ results `y` for which `f x` returns `some y`.
 @[inline]
 def filterMapM {m : Type u → Type v} [Monad m] {α β : Type u} (f : α → m (Option β)) (as : List α) : m (List β) :=
   let rec @[specialize] loop
-    | [],     bs => pure bs.reverse
+    | [],     bs => pure bs
     | a :: as, bs => do
       match (← f a) with
       | none   => loop as bs
       | some b => loop as (b::bs)
-  loop as []
+  loop as.reverse []
 
 /--
 Folds a monadic function over a list from left to right:
@@ -227,8 +227,6 @@ def findSomeM? {m : Type u → Type v} [Monad m] {α : Type w} {β : Type u} (f
 instance : ForIn m (List α) α where
   forIn := List.forIn
 
-@[simp] theorem forIn_eq_forIn [Monad m] : @List.forIn α β m _ = forIn := rfl
-
 @[simp] theorem forIn_nil [Monad m] (f : α → β → m (ForInStep β)) (b : β) : forIn [] b f = pure b :=
   rfl
 

src/Init/Data/List/Count.lean

@@ -1,242 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.Sublist
-
-/-!
-# Lemmas about `List.countP` and `List.count`.
--/
-
-namespace List
-
-open Nat
-
-/-! ### countP -/
-section countP
-
-variable (p q : α → Bool)
-
-@[simp] theorem countP_nil : countP p [] = 0 := rfl
-
-protected theorem countP_go_eq_add (l) : countP.go p l n = n + countP.go p l 0 := by
-  induction l generalizing n with
-  | nil => rfl
-  | cons head tail ih =>
-    unfold countP.go
-    rw [ih (n := n + 1), ih (n := n), ih (n := 1)]
-    if h : p head then simp [h, Nat.add_assoc] else simp [h]
-
-@[simp] theorem countP_cons_of_pos (l) (pa : p a) : countP p (a :: l) = countP p l + 1 := by
-  have : countP.go p (a :: l) 0 = countP.go p l 1 := show cond .. = _ by rw [pa]; rfl
-  unfold countP
-  rw [this, Nat.add_comm, List.countP_go_eq_add]
-
-@[simp] theorem countP_cons_of_neg (l) (pa : ¬p a) : countP p (a :: l) = countP p l := by
-  simp [countP, countP.go, pa]
-
-theorem countP_cons (a : α) (l) : countP p (a :: l) = countP p l + if p a then 1 else 0 := by
-  by_cases h : p a <;> simp [h]
-
-theorem length_eq_countP_add_countP (l) : length l = countP p l + countP (fun a => ¬p a) l := by
-  induction l with
-  | nil => rfl
-  | cons x h ih =>
-    if h : p x then
-      rw [countP_cons_of_pos _ _ h, countP_cons_of_neg _ _ _, length, ih]
-      · rw [Nat.add_assoc, Nat.add_comm _ 1, Nat.add_assoc]
-      · simp only [h, not_true_eq_false, decide_False, not_false_eq_true]
-    else
-      rw [countP_cons_of_pos (fun a => ¬p a) _ _, countP_cons_of_neg _ _ h, length, ih]
-      · rfl
-      · simp only [h, not_false_eq_true, decide_True]
-
-theorem countP_eq_length_filter (l) : countP p l = length (filter p l) := by
-  induction l with
-  | nil => rfl
-  | cons x l ih =>
-    if h : p x
-    then rw [countP_cons_of_pos p l h, ih, filter_cons_of_pos h, length]
-    else rw [countP_cons_of_neg p l h, ih, filter_cons_of_neg h]
-
-theorem countP_le_length : countP p l ≤ l.length := by
-  simp only [countP_eq_length_filter]
-  apply length_filter_le
-
-@[simp] theorem countP_append (l₁ l₂) : countP p (l₁ ++ l₂) = countP p l₁ + countP p l₂ := by
-  simp only [countP_eq_length_filter, filter_append, length_append]
-
-theorem countP_pos : 0 < countP p l ↔ ∃ a ∈ l, p a := by
-  simp only [countP_eq_length_filter, length_pos_iff_exists_mem, mem_filter, exists_prop]
-
-theorem countP_eq_zero : countP p l = 0 ↔ ∀ a ∈ l, ¬p a := by
-  simp only [countP_eq_length_filter, length_eq_zero, filter_eq_nil]
-
-theorem countP_eq_length : countP p l = l.length ↔ ∀ a ∈ l, p a := by
-  rw [countP_eq_length_filter, filter_length_eq_length]
-
-theorem Sublist.countP_le (s : l₁ <+ l₂) : countP p l₁ ≤ countP p l₂ := by
-  simp only [countP_eq_length_filter]
-  apply s.filter _ |>.length_le
-
-theorem countP_filter (l : List α) :
-    countP p (filter q l) = countP (fun a => p a ∧ q a) l := by
-  simp only [countP_eq_length_filter, filter_filter]
-
-@[simp] theorem countP_true {l : List α} : (l.countP fun _ => true) = l.length := by
-  rw [countP_eq_length]
-  simp
-
-@[simp] theorem countP_false {l : List α} : (l.countP fun _ => false) = 0 := by
-  rw [countP_eq_zero]
-  simp
-
-@[simp] theorem countP_map (p : β → Bool) (f : α → β) :
-    ∀ l, countP p (map f l) = countP (p ∘ f) l
-  | [] => rfl
-  | a :: l => by rw [map_cons, countP_cons, countP_cons, countP_map p f l]; rfl
-
-variable {p q}
-
-theorem countP_mono_left (h : ∀ x ∈ l, p x → q x) : countP p l ≤ countP q l := by
-  induction l with
-  | nil => apply Nat.le_refl
-  | cons a l ihl =>
-    rw [forall_mem_cons] at h
-    have ⟨ha, hl⟩ := h
-    simp [countP_cons]
-    cases h : p a
-    · simp only [Bool.false_eq_true, ↓reduceIte, Nat.add_zero]
-      apply Nat.le_trans ?_ (Nat.le_add_right _ _)
-      apply ihl hl
-    · simp only [↓reduceIte, ha h, succ_le_succ_iff]
-      apply ihl hl
-
-theorem countP_congr (h : ∀ x ∈ l, p x ↔ q x) : countP p l = countP q l :=
-  Nat.le_antisymm
-    (countP_mono_left fun x hx => (h x hx).1)
-    (countP_mono_left fun x hx => (h x hx).2)
-
-end countP
-
-/-! ### count -/
-section count
-
-variable [BEq α]
-
-@[simp] theorem count_nil (a : α) : count a [] = 0 := rfl
-
-theorem count_cons (a b : α) (l : List α) :
-    count a (b :: l) = count a l + if b == a then 1 else 0 := by
-  simp [count, countP_cons]
-
-theorem count_tail : ∀ (l : List α) (a : α) (h : l ≠ []),
-      l.tail.count a = l.count a - if l.head h == a then 1 else 0
-  | head :: tail, a, _ => by simp [count_cons]
-
-theorem count_le_length (a : α) (l : List α) : count a l ≤ l.length := countP_le_length _
-
-theorem Sublist.count_le (h : l₁ <+ l₂) (a : α) : count a l₁ ≤ count a l₂ := h.countP_le _
-
-theorem count_le_count_cons (a b : α) (l : List α) : count a l ≤ count a (b :: l) :=
-  (sublist_cons_self _ _).count_le _
-
-theorem count_singleton (a b : α) : count a [b] = if b == a then 1 else 0 := by
-  simp [count_cons]
-
-@[simp] theorem count_append (a : α) : ∀ l₁ l₂, count a (l₁ ++ l₂) = count a l₁ + count a l₂ :=
-  countP_append _
-
-variable [LawfulBEq α]
-
-@[simp] theorem count_cons_self (a : α) (l : List α) : count a (a :: l) = count a l + 1 := by
-  simp [count_cons]
-
-@[simp] theorem count_cons_of_ne (h : a ≠ b) (l : List α) : count a (b :: l) = count a l := by
-  simp only [count_cons, cond_eq_if, beq_iff_eq]
-  split <;> simp_all
-
-theorem count_singleton_self (a : α) : count a [a] = 1 := by simp
-
-theorem count_concat_self (a : α) (l : List α) :
-    count a (concat l a) = (count a l) + 1 := by simp
-
-@[simp]
-theorem count_pos_iff_mem {a : α} {l : List α} : 0 < count a l ↔ a ∈ l := by
-  simp only [count, countP_pos, beq_iff_eq, exists_eq_right]
-
-theorem count_eq_zero_of_not_mem {a : α} {l : List α} (h : a ∉ l) : count a l = 0 :=
-  Decidable.byContradiction fun h' => h <| count_pos_iff_mem.1 (Nat.pos_of_ne_zero h')
-
-theorem not_mem_of_count_eq_zero {a : α} {l : List α} (h : count a l = 0) : a ∉ l :=
-  fun h' => Nat.ne_of_lt (count_pos_iff_mem.2 h') h.symm
-
-theorem count_eq_zero {l : List α} : count a l = 0 ↔ a ∉ l :=
-  ⟨not_mem_of_count_eq_zero, count_eq_zero_of_not_mem⟩
-
-theorem count_eq_length {l : List α} : count a l = l.length ↔ ∀ b ∈ l, a = b := by
-  rw [count, countP_eq_length]
-  refine ⟨fun h b hb => Eq.symm ?_, fun h b hb => ?_⟩
-  · simpa using h b hb
-  · rw [h b hb, beq_self_eq_true]
-
-@[simp] theorem count_replicate_self (a : α) (n : Nat) : count a (replicate n a) = n :=
-  (count_eq_length.2 <| fun _ h => (eq_of_mem_replicate h).symm).trans (length_replicate ..)
-
-theorem count_replicate (a b : α) (n : Nat) : count a (replicate n b) = if b == a then n else 0 := by
-  split <;> (rename_i h; simp only [beq_iff_eq] at h)
-  · exact ‹b = a› ▸ count_replicate_self ..
-  · exact count_eq_zero.2 <| mt eq_of_mem_replicate (Ne.symm h)
-
-theorem filter_beq (l : List α) (a : α) : l.filter (· == a) = replicate (count a l) a := by
-  simp only [count, countP_eq_length_filter, eq_replicate, mem_filter, beq_iff_eq]
-  exact ⟨trivial, fun _ h => h.2⟩
-
-theorem filter_eq {α} [DecidableEq α] (l : List α) (a : α) : l.filter (· = a) = replicate (count a l) a :=
-  filter_beq l a
-
-theorem le_count_iff_replicate_sublist {l : List α} : n ≤ count a l ↔ replicate n a <+ l := by
-  refine ⟨fun h => ?_, fun h => ?_⟩
-  · exact ((replicate_sublist_replicate a).2 h).trans <| filter_beq l a ▸ filter_sublist _
-  · simpa only [count_replicate_self] using h.count_le a
-
-theorem replicate_count_eq_of_count_eq_length {l : List α} (h : count a l = length l) :
-    replicate (count a l) a = l :=
-  (le_count_iff_replicate_sublist.mp (Nat.le_refl _)).eq_of_length <|
-    (length_replicate (count a l) a).trans h
-
-@[simp] theorem count_filter {l : List α} (h : p a) : count a (filter p l) = count a l := by
-  rw [count, countP_filter]; congr; funext b
-  simp; rintro rfl; exact h
-
-theorem count_le_count_map [DecidableEq β] (l : List α) (f : α → β) (x : α) :
-    count x l ≤ count (f x) (map f l) := by
-  rw [count, count, countP_map]
-  apply countP_mono_left; simp (config := { contextual := true })
-
-theorem count_erase (a b : α) :
-    ∀ l : List α, count a (l.erase b) = count a l - if b == a then 1 else 0
-  | [] => by simp
-  | c :: l => by
-    rw [erase_cons]
-    if hc : c = b then
-      have hc_beq := (beq_iff_eq _ _).mpr hc
-      rw [if_pos hc_beq, hc, count_cons, Nat.add_sub_cancel]
-    else
-      have hc_beq := beq_false_of_ne hc
-      simp only [hc_beq, if_false, count_cons, count_cons, count_erase a b l]
-      if ha : b = a then
-        rw [ha, eq_comm] at hc
-        rw [if_pos ((beq_iff_eq _ _).2 ha), if_neg (by simpa using Ne.symm hc), Nat.add_zero, Nat.add_zero]
-      else
-        rw [if_neg (by simpa using ha), Nat.sub_zero, Nat.sub_zero]
-
-@[simp] theorem count_erase_self (a : α) (l : List α) :
-    count a (List.erase l a) = count a l - 1 := by rw [count_erase, if_pos (by simp)]
-
-@[simp] theorem count_erase_of_ne (ab : a ≠ b) (l : List α) : count a (l.erase b) = count a l := by
-  rw [count_erase, if_neg (by simpa using ab.symm), Nat.sub_zero]
-
-end count

src/Init/Data/List/Erase.lean

@@ -1,445 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro,
-  Yury Kudryashov
--/
-prelude
-import Init.Data.List.Pairwise
-
-/-!
-# Lemmas about `List.eraseP` and `List.erase`.
--/
-
-namespace List
-
-open Nat
-
-/-! ### eraseP -/
-
-@[simp] theorem eraseP_nil : [].eraseP p = [] := rfl
-
-theorem eraseP_cons (a : α) (l : List α) :
-    (a :: l).eraseP p = bif p a then l else a :: l.eraseP p := rfl
-
-@[simp] theorem eraseP_cons_of_pos {l : List α} {p} (h : p a) : (a :: l).eraseP p = l := by
-  simp [eraseP_cons, h]
-
-@[simp] theorem eraseP_cons_of_neg {l : List α} {p} (h : ¬p a) :
-    (a :: l).eraseP p = a :: l.eraseP p := by simp [eraseP_cons, h]
-
-theorem eraseP_of_forall_not {l : List α} (h : ∀ a, a ∈ l → ¬p a) : l.eraseP p = l := by
-  induction l with
-  | nil => rfl
-  | cons _ _ ih => simp [h _ (.head ..), ih (forall_mem_cons.1 h).2]
-
-theorem exists_of_eraseP : ∀ {l : List α} {a} (al : a ∈ l) (pa : p a),
-    ∃ a l₁ l₂, (∀ b ∈ l₁, ¬p b) ∧ p a ∧ l = l₁ ++ a :: l₂ ∧ l.eraseP p = l₁ ++ l₂
-  | b :: l, a, al, pa =>
-    if pb : p b then
-      ⟨b, [], l, forall_mem_nil _, pb, by simp [pb]⟩
-    else
-      match al with
-      | .head .. => nomatch pb pa
-      | .tail _ al =>
-        let ⟨c, l₁, l₂, h₁, h₂, h₃, h₄⟩ := exists_of_eraseP al pa
-        ⟨c, b::l₁, l₂, (forall_mem_cons ..).2 ⟨pb, h₁⟩,
-          h₂, by rw [h₃, cons_append], by simp [pb, h₄]⟩
-
-theorem exists_or_eq_self_of_eraseP (p) (l : List α) :
-    l.eraseP p = l ∨
-    ∃ a l₁ l₂, (∀ b ∈ l₁, ¬p b) ∧ p a ∧ l = l₁ ++ a :: l₂ ∧ l.eraseP p = l₁ ++ l₂ :=
-  if h : ∃ a ∈ l, p a then
-    let ⟨_, ha, pa⟩ := h
-    .inr (exists_of_eraseP ha pa)
-  else
-    .inl (eraseP_of_forall_not (h ⟨·, ·, ·⟩))
-
-@[simp] theorem length_eraseP_of_mem (al : a ∈ l) (pa : p a) :
-    length (l.eraseP p) = length l - 1 := by
-  let ⟨_, l₁, l₂, _, _, e₁, e₂⟩ := exists_of_eraseP al pa
-  rw [e₂]; simp [length_append, e₁]; rfl
-
-theorem length_eraseP {l : List α} : (l.eraseP p).length = if l.any p then l.length - 1 else l.length := by
-  split <;> rename_i h
-  · simp only [any_eq_true] at h
-    obtain ⟨x, m, h⟩ := h
-    simp [length_eraseP_of_mem m h]
-  · simp only [any_eq_true] at h
-    rw [eraseP_of_forall_not]
-    simp_all
-
-theorem eraseP_sublist (l : List α) : l.eraseP p <+ l := by
-  match exists_or_eq_self_of_eraseP p l with
-  | .inl h => rw [h]; apply Sublist.refl
-  | .inr ⟨c, l₁, l₂, _, _, h₃, h₄⟩ => rw [h₄, h₃]; simp
-
-theorem eraseP_subset (l : List α) : l.eraseP p ⊆ l := (eraseP_sublist l).subset
-
-protected theorem Sublist.eraseP : l₁ <+ l₂ → l₁.eraseP p <+ l₂.eraseP p
-  | .slnil => Sublist.refl _
-  | .cons a s => by
-    by_cases h : p a
-    · simpa [h] using s.eraseP.trans (eraseP_sublist _)
-    · simpa [h] using s.eraseP.cons _
-  | .cons₂ a s => by
-    by_cases h : p a
-    · simpa [h] using s
-    · simpa [h] using s.eraseP
-
-theorem length_eraseP_le (l : List α) : (l.eraseP p).length ≤ l.length :=
-  l.eraseP_sublist.length_le
-
-theorem mem_of_mem_eraseP {l : List α} : a ∈ l.eraseP p → a ∈ l := (eraseP_subset _ ·)
-
-@[simp] theorem mem_eraseP_of_neg {l : List α} (pa : ¬p a) : a ∈ l.eraseP p ↔ a ∈ l := by
-  refine ⟨mem_of_mem_eraseP, fun al => ?_⟩
-  match exists_or_eq_self_of_eraseP p l with
-  | .inl h => rw [h]; assumption
-  | .inr ⟨c, l₁, l₂, h₁, h₂, h₃, h₄⟩ =>
-    rw [h₄]; rw [h₃] at al
-    have : a ≠ c := fun h => (h ▸ pa).elim h₂
-    simp [this] at al; simp [al]
-
-@[simp] theorem eraseP_eq_self_iff {p} {l : List α} : l.eraseP p = l ↔ ∀ a ∈ l, ¬ p a := by
-  rw [← Sublist.length_eq (eraseP_sublist l), length_eraseP]
-  split <;> rename_i h
-  · simp only [any_eq_true, length_eq_zero] at h
-    constructor
-    · intro; simp_all [Nat.sub_one_eq_self]
-    · intro; obtain ⟨x, m, h⟩ := h; simp_all
-  · simp_all
-
-theorem eraseP_map (f : β → α) : ∀ (l : List β), (map f l).eraseP p = map f (l.eraseP (p ∘ f))
-  | [] => rfl
-  | b::l => by by_cases h : p (f b) <;> simp [h, eraseP_map f l, eraseP_cons_of_pos]
-
-theorem eraseP_filterMap (f : α → Option β) : ∀ (l : List α),
-    (filterMap f l).eraseP p = filterMap f (l.eraseP (fun x => match f x with | some y => p y | none => false))
-  | [] => rfl
-  | a::l => by
-    rw [filterMap_cons, eraseP_cons]
-    split <;> rename_i h
-    · simp [h, eraseP_filterMap]
-    · rename_i b
-      rw [h, eraseP_cons]
-      by_cases w : p b
-      · simp [w]
-      · simp only [w, cond_false]
-        rw [filterMap_cons_some h, eraseP_filterMap]
-
-theorem eraseP_filter (f : α → Bool) (l : List α) :
-    (filter f l).eraseP p = filter f (l.eraseP (fun x => p x && f x)) := by
-  rw [← filterMap_eq_filter, eraseP_filterMap]
-  congr
-  ext x
-  simp only [Option.guard]
-  split <;> split at * <;> simp_all
-
-theorem eraseP_append_left {a : α} (pa : p a) :
-    ∀ {l₁ : List α} l₂, a ∈ l₁ → (l₁++l₂).eraseP p = l₁.eraseP p ++ l₂
-  | x :: xs, l₂, h => by
-    by_cases h' : p x <;> simp [h']
-    rw [eraseP_append_left pa l₂ ((mem_cons.1 h).resolve_left (mt _ h'))]
-    intro | rfl => exact pa
-
-theorem eraseP_append_right :
-    ∀ {l₁ : List α} l₂, (∀ b ∈ l₁, ¬p b) → eraseP p (l₁++l₂) = l₁ ++ l₂.eraseP p
-  | [],      l₂, _ => rfl
-  | x :: xs, l₂, h => by
-    simp [(forall_mem_cons.1 h).1, eraseP_append_right _ (forall_mem_cons.1 h).2]
-
-theorem eraseP_append (l₁ l₂ : List α) :
-    (l₁ ++ l₂).eraseP p = if l₁.any p then l₁.eraseP p ++ l₂ else l₁ ++ l₂.eraseP p := by
-  split <;> rename_i h
-  · simp only [any_eq_true] at h
-    obtain ⟨x, m, h⟩ := h
-    rw [eraseP_append_left h _ m]
-  · simp only [any_eq_true] at h
-    rw [eraseP_append_right _]
-    simp_all
-
-theorem eraseP_eq_iff {p} {l : List α} :
-    l.eraseP p = l' ↔
-      ((∀ a ∈ l, ¬ p a) ∧ l = l') ∨
-        ∃ a l₁ l₂, (∀ b ∈ l₁, ¬ p b) ∧ p a ∧ l = l₁ ++ a :: l₂ ∧ l' = l₁ ++ l₂ := by
-  cases exists_or_eq_self_of_eraseP p l with
-  | inl h =>
-    constructor
-    · intro h'
-      left
-      exact ⟨eraseP_eq_self_iff.1 h, by simp_all⟩
-    · rintro (⟨-, rfl⟩ | ⟨a, l₁, l₂, h₁, h₂, rfl, rfl⟩)
-      · assumption
-      · rw [eraseP_append_right _ h₁, eraseP_cons_of_pos h₂]
-  | inr h =>
-    obtain ⟨a, l₁, l₂, h₁, h₂, w₁, w₂⟩ := h
-    rw [w₂]
-    subst w₁
-    constructor
-    · rintro rfl
-      right
-      refine ⟨a, l₁, l₂, ?_⟩
-      simp_all
-    · rintro (h | h)
-      · simp_all
-      · obtain ⟨a', l₁', l₂', h₁', h₂', h, rfl⟩ := h
-        have p : l₁ = l₁' := by
-          have q : l₁ = takeWhile (fun x => !p x) (l₁ ++ a :: l₂) := by
-            rw [takeWhile_append_of_pos (by simp_all),
-              takeWhile_cons_of_neg (by simp [h₂]), append_nil]
-          have q' : l₁' = takeWhile (fun x => !p x) (l₁' ++ a' :: l₂') := by
-            rw [takeWhile_append_of_pos (by simpa using h₁'),
-              takeWhile_cons_of_neg (by simp [h₂']), append_nil]
-          simp [h] at q
-          rw [q', q]
-        subst p
-        simp_all
-
-@[simp] theorem eraseP_replicate_of_pos {n : Nat} {a : α} (h : p a) :
-    (replicate n a).eraseP p = replicate (n - 1) a := by
-  cases n <;> simp [replicate_succ, h]
-
-@[simp] theorem eraseP_replicate_of_neg {n : Nat} {a : α} (h : ¬p a) :
-    (replicate n a).eraseP p = replicate n a := by
-  rw [eraseP_of_forall_not (by simp_all)]
-
-theorem Nodup.eraseP (p) : Nodup l → Nodup (l.eraseP p) :=
-  Nodup.sublist <| eraseP_sublist _
-
-theorem eraseP_comm {l : List α} (h : ∀ a ∈ l, ¬ p a ∨ ¬ q a) :
-    (l.eraseP p).eraseP q = (l.eraseP q).eraseP p := by
-  induction l with
-  | nil => rfl
-  | cons a l ih =>
-    simp only [eraseP_cons]
-    by_cases h₁ : p a
-    · by_cases h₂ : q a
-      · simp_all
-      · simp [h₁, h₂, ih (fun b m => h b (mem_cons_of_mem _ m))]
-    · by_cases h₂ : q a
-      · simp [h₁, h₂, ih (fun b m => h b (mem_cons_of_mem _ m))]
-      · simp [h₁, h₂, ih (fun b m => h b (mem_cons_of_mem _ m))]
-
-/-! ### erase -/
-section erase
-variable [BEq α]
-
-@[simp] theorem erase_cons_head [LawfulBEq α] (a : α) (l : List α) : (a :: l).erase a = l := by
-  simp [erase_cons]
-
-@[simp] theorem erase_cons_tail {a b : α} {l : List α} (h : ¬(b == a)) :
-    (b :: l).erase a = b :: l.erase a := by simp only [erase_cons, if_neg h]
-
-theorem erase_of_not_mem [LawfulBEq α] {a : α} : ∀ {l : List α}, a ∉ l → l.erase a = l
-  | [], _ => rfl
-  | b :: l, h => by
-    rw [mem_cons, not_or] at h
-    simp only [erase_cons, if_neg, erase_of_not_mem h.2, beq_iff_eq, Ne.symm h.1, not_false_eq_true]
-
-theorem erase_eq_eraseP' (a : α) (l : List α) : l.erase a = l.eraseP (· == a) := by
-  induction l
-  · simp
-  · next b t ih =>
-    rw [erase_cons, eraseP_cons, ih]
-    if h : b == a then simp [h] else simp [h]
-
-theorem erase_eq_eraseP [LawfulBEq α] (a : α) : ∀ l : List α,  l.erase a = l.eraseP (a == ·)
-  | [] => rfl
-  | b :: l => by
-    if h : a = b then simp [h] else simp [h, Ne.symm h, erase_eq_eraseP a l]
-
-theorem exists_erase_eq [LawfulBEq α] {a : α} {l : List α} (h : a ∈ l) :
-    ∃ l₁ l₂, a ∉ l₁ ∧ l = l₁ ++ a :: l₂ ∧ l.erase a = l₁ ++ l₂ := by
-  let ⟨_, l₁, l₂, h₁, e, h₂, h₃⟩ := exists_of_eraseP h (beq_self_eq_true _)
-  rw [erase_eq_eraseP]; exact ⟨l₁, l₂, fun h => h₁ _ h (beq_self_eq_true _), eq_of_beq e ▸ h₂, h₃⟩
-
-@[simp] theorem length_erase_of_mem [LawfulBEq α] {a : α} {l : List α} (h : a ∈ l) :
-    length (l.erase a) = length l - 1 := by
-  rw [erase_eq_eraseP]; exact length_eraseP_of_mem h (beq_self_eq_true a)
-
-theorem length_erase [LawfulBEq α] (a : α) (l : List α) :
-    length (l.erase a) = if a ∈ l then length l - 1 else length l := by
-  rw [erase_eq_eraseP, length_eraseP]
-  split <;> split <;> simp_all
-
-theorem erase_sublist (a : α) (l : List α) : l.erase a <+ l :=
-  erase_eq_eraseP' a l ▸ eraseP_sublist ..
-
-theorem erase_subset (a : α) (l : List α) : l.erase a ⊆ l := (erase_sublist a l).subset
-
-theorem Sublist.erase (a : α) {l₁ l₂ : List α} (h : l₁ <+ l₂) : l₁.erase a <+ l₂.erase a := by
-  simp only [erase_eq_eraseP']; exact h.eraseP
-
-theorem length_erase_le (a : α) (l : List α) : (l.erase a).length ≤ l.length :=
-  (erase_sublist a l).length_le
-
-theorem mem_of_mem_erase {a b : α} {l : List α} (h : a ∈ l.erase b) : a ∈ l := erase_subset _ _ h
-
-@[simp] theorem mem_erase_of_ne [LawfulBEq α] {a b : α} {l : List α} (ab : a ≠ b) :
-    a ∈ l.erase b ↔ a ∈ l :=
-  erase_eq_eraseP b l ▸ mem_eraseP_of_neg (mt eq_of_beq ab.symm)
-
-@[simp] theorem erase_eq_self_iff [LawfulBEq α] {l : List α} : l.erase a = l ↔ a ∉ l := by
-  rw [erase_eq_eraseP', eraseP_eq_self_iff]
-  simp
-
-theorem erase_filter [LawfulBEq α] (f : α → Bool) (l : List α) :
-    (filter f l).erase a = filter f (l.erase a) := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    by_cases h : a = x
-    · rw [erase_cons]
-      simp only [h, beq_self_eq_true, ↓reduceIte]
-      rw [filter_cons]
-      split
-      · rw [erase_cons_head]
-      · rw [erase_of_not_mem]
-        simp_all [mem_filter]
-    · rw [erase_cons_tail (by simpa using Ne.symm h), filter_cons, filter_cons]
-      split
-      · rw [erase_cons_tail (by simpa using Ne.symm h), ih]
-      · rw [ih]
-
-theorem erase_append_left [LawfulBEq α] {l₁ : List α} (l₂) (h : a ∈ l₁) :
-    (l₁ ++ l₂).erase a = l₁.erase a ++ l₂ := by
-  simp [erase_eq_eraseP]; exact eraseP_append_left (beq_self_eq_true a) l₂ h
-
-theorem erase_append_right [LawfulBEq α] {a : α} {l₁ : List α} (l₂ : List α) (h : a ∉ l₁) :
-    (l₁ ++ l₂).erase a = (l₁ ++ l₂.erase a) := by
-  rw [erase_eq_eraseP, erase_eq_eraseP, eraseP_append_right]
-  intros b h' h''; rw [eq_of_beq h''] at h; exact h h'
-
-theorem erase_append [LawfulBEq α] {a : α} {l₁ l₂ : List α} :
-    (l₁ ++ l₂).erase a = if a ∈ l₁ then l₁.erase a ++ l₂ else l₁ ++ l₂.erase a := by
-  simp [erase_eq_eraseP, eraseP_append]
-
-theorem erase_comm [LawfulBEq α] (a b : α) (l : List α) :
-    (l.erase a).erase b = (l.erase b).erase a := by
-  if ab : a == b then rw [eq_of_beq ab] else ?_
-  if ha : a ∈ l then ?_ else
-    simp only [erase_of_not_mem ha, erase_of_not_mem (mt mem_of_mem_erase ha)]
-  if hb : b ∈ l then ?_ else
-    simp only [erase_of_not_mem hb, erase_of_not_mem (mt mem_of_mem_erase hb)]
-  match l, l.erase a, exists_erase_eq ha with
-  | _, _, ⟨l₁, l₂, ha', rfl, rfl⟩ =>
-    if h₁ : b ∈ l₁ then
-      rw [erase_append_left _ h₁, erase_append_left _ h₁,
-          erase_append_right _ (mt mem_of_mem_erase ha'), erase_cons_head]
-    else
-      rw [erase_append_right _ h₁, erase_append_right _ h₁, erase_append_right _ ha',
-          erase_cons_tail ab, erase_cons_head]
-
-theorem erase_eq_iff [LawfulBEq α] {a : α} {l : List α} :
-    l.erase a = l' ↔
-      (a ∉ l ∧ l = l') ∨
-        ∃ l₁ l₂, a ∉ l₁ ∧ l = l₁ ++ a :: l₂ ∧ l' = l₁ ++ l₂ := by
-  rw [erase_eq_eraseP', eraseP_eq_iff]
-  simp only [beq_iff_eq, forall_mem_ne', exists_and_left]
-  constructor
-  · rintro (⟨h, rfl⟩ | ⟨a', l', h, rfl, x, rfl, rfl⟩)
-    · left; simp_all
-    · right; refine ⟨l', h, x, by simp⟩
-  · rintro (⟨h, rfl⟩ | ⟨l₁, h, x, rfl, rfl⟩)
-    · left; simp_all
-    · right; refine ⟨a, l₁, h, by simp⟩
-
-@[simp] theorem erase_replicate_self [LawfulBEq α] {a : α} :
-    (replicate n a).erase a = replicate (n - 1) a := by
-  cases n <;> simp [replicate_succ]
-
-@[simp] theorem erase_replicate_ne [LawfulBEq α] {a b : α} (h : !b == a) :
-    (replicate n a).erase b = replicate n a := by
-  rw [erase_of_not_mem]
-  simp_all
-
-theorem Nodup.erase_eq_filter [LawfulBEq α] {l} (d : Nodup l) (a : α) : l.erase a = l.filter (· != a) := by
-  induction d with
-  | nil => rfl
-  | cons m _n ih =>
-    rename_i b l
-    by_cases h : b = a
-    · subst h
-      rw [erase_cons_head, filter_cons_of_neg (by simp)]
-      apply Eq.symm
-      rw [filter_eq_self]
-      simpa [@eq_comm α] using m
-    · simp [beq_false_of_ne h, ih, h]
-
-theorem Nodup.mem_erase_iff [LawfulBEq α] {a : α} (d : Nodup l) : a ∈ l.erase b ↔ a ≠ b ∧ a ∈ l := by
-  rw [Nodup.erase_eq_filter d, mem_filter, and_comm, bne_iff_ne]
-
-theorem Nodup.not_mem_erase [LawfulBEq α] {a : α} (h : Nodup l) : a ∉ l.erase a := fun H => by
-  simpa using ((Nodup.mem_erase_iff h).mp H).left
-
-theorem Nodup.erase [LawfulBEq α] (a : α) : Nodup l → Nodup (l.erase a) :=
-  Nodup.sublist <| erase_sublist _ _
-
-end erase
-
-/-! ### eraseIdx -/
-
-theorem length_eraseIdx : ∀ {l i}, i < length l → length (@eraseIdx α l i) = length l - 1
-  | [], _, _ => rfl
-  | _::_, 0, _ => by simp [eraseIdx]
-  | x::xs, i+1, h => by
-    have : i < length xs := Nat.lt_of_succ_lt_succ h
-    simp [eraseIdx, ← Nat.add_one]
-    rw [length_eraseIdx this, Nat.sub_add_cancel (Nat.lt_of_le_of_lt (Nat.zero_le _) this)]
-
-@[simp] theorem eraseIdx_zero (l : List α) : eraseIdx l 0 = tail l := by cases l <;> rfl
-
-theorem eraseIdx_eq_take_drop_succ :
-    ∀ (l : List α) (i : Nat), l.eraseIdx i = l.take i ++ l.drop (i + 1)
-  | nil, _ => by simp
-  | a::l, 0 => by simp
-  | a::l, i + 1 => by simp [eraseIdx_eq_take_drop_succ l i]
-
-theorem eraseIdx_sublist : ∀ (l : List α) (k : Nat), eraseIdx l k <+ l
-  | [], _ => by simp
-  | a::l, 0 => by simp
-  | a::l, k + 1 => by simp [eraseIdx_sublist l k]
-
-theorem eraseIdx_subset (l : List α) (k : Nat) : eraseIdx l k ⊆ l := (eraseIdx_sublist l k).subset
-
-@[simp]
-theorem eraseIdx_eq_self : ∀ {l : List α} {k : Nat}, eraseIdx l k = l ↔ length l ≤ k
-  | [], _ => by simp
-  | a::l, 0 => by simp [(cons_ne_self _ _).symm]
-  | a::l, k + 1 => by simp [eraseIdx_eq_self]
-
-theorem eraseIdx_of_length_le {l : List α} {k : Nat} (h : length l ≤ k) : eraseIdx l k = l := by
-  rw [eraseIdx_eq_self.2 h]
-
-theorem eraseIdx_append_of_lt_length {l : List α} {k : Nat} (hk : k < length l) (l' : List α) :
-    eraseIdx (l ++ l') k = eraseIdx l k ++ l' := by
-  induction l generalizing k with
-  | nil => simp_all
-  | cons x l ih =>
-    cases k with
-    | zero => rfl
-    | succ k => simp_all [eraseIdx_cons_succ, Nat.succ_lt_succ_iff]
-
-theorem eraseIdx_append_of_length_le {l : List α} {k : Nat} (hk : length l ≤ k) (l' : List α) :
-    eraseIdx (l ++ l') k = l ++ eraseIdx l' (k - length l) := by
-  induction l generalizing k with
-  | nil => simp_all
-  | cons x l ih =>
-    cases k with
-    | zero => simp_all
-    | succ k => simp_all [eraseIdx_cons_succ, Nat.succ_sub_succ]
-
-protected theorem IsPrefix.eraseIdx {l l' : List α} (h : l <+: l') (k : Nat) :
-    eraseIdx l k <+: eraseIdx l' k := by
-  rcases h with ⟨t, rfl⟩
-  if hkl : k < length l then
-    simp [eraseIdx_append_of_lt_length hkl]
-  else
-    rw [Nat.not_lt] at hkl
-    simp [eraseIdx_append_of_length_le hkl, eraseIdx_of_length_le hkl]
-
--- See also `mem_eraseIdx_iff_getElem` and `mem_eraseIdx_iff_getElem?` in
--- `Init/Data/List/Nat/Basic.lean`.
-
-end List

src/Init/Data/List/Find.lean

@@ -1,229 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.Lemmas
-
-/-!
-# Lemmas about `List.find?`, `List.findSome?`, `List.findIdx`, `List.findIdx?`, and `List.indexOf`.
--/
-
-namespace List
-
-open Nat
-
-/-! ### find? -/
-
-@[simp] theorem find?_cons_of_pos (l) (h : p a) : find? p (a :: l) = some a := by
-  simp [find?, h]
-
-@[simp] theorem find?_cons_of_neg (l) (h : ¬p a) : find? p (a :: l) = find? p l := by
-  simp [find?, h]
-
-@[simp] theorem find?_eq_none : find? p l = none ↔ ∀ x ∈ l, ¬ p x := by
-  induction l <;> simp [find?_cons]; split <;> simp [*]
-
-theorem find?_some : ∀ {l}, find? p l = some a → p a
-  | b :: l, H => by
-    by_cases h : p b <;> simp [find?, h] at H
-    · exact H ▸ h
-    · exact find?_some H
-
-@[simp] theorem mem_of_find?_eq_some : ∀ {l}, find? p l = some a → a ∈ l
-  | b :: l, H => by
-    by_cases h : p b <;> simp [find?, h] at H
-    · exact H ▸ .head _
-    · exact .tail _ (mem_of_find?_eq_some H)
-
-@[simp] theorem find?_map (f : β → α) (l : List β) : find? p (l.map f) = (l.find? (p ∘ f)).map f := by
-  induction l with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [map_cons, find?]
-    by_cases h : p (f x) <;> simp [h, ih]
-
-theorem find?_replicate : find? p (replicate n a) = if n = 0 then none else if p a then some a else none := by
-  cases n
-  · simp
-  · by_cases p a <;> simp_all [replicate_succ]
-
-@[simp] theorem find?_replicate_of_length_pos (h : 0 < n) : find? p (replicate n a) = if p a then some a else none := by
-  simp [find?_replicate, Nat.ne_of_gt h]
-
-@[simp] theorem find?_replicate_of_pos (h : p a) : find? p (replicate n a) = if n = 0 then none else some a := by
-  simp [find?_replicate, h]
-
-@[simp] theorem find?_replicate_of_neg (h : ¬ p a) : find? p (replicate n a) = none := by
-  simp [find?_replicate, h]
-
-theorem find?_isSome_of_sublist {l₁ l₂ : List α} (h : l₁ <+ l₂) : (l₁.find? p).isSome → (l₂.find? p).isSome := by
-  induction h with
-  | slnil => simp
-  | cons a h ih
-  | cons₂ a h ih =>
-    simp only [find?]
-    split <;> simp_all
-
-/-! ### findSome? -/
-
-@[simp] theorem findSome?_cons_of_isSome (l) (h : (f a).isSome) : findSome? f (a :: l) = f a := by
-  simp only [findSome?]
-  split <;> simp_all
-
-@[simp] theorem findSome?_cons_of_isNone (l) (h : (f a).isNone) : findSome? f (a :: l) = findSome? f l := by
-  simp only [findSome?]
-  split <;> simp_all
-
-theorem exists_of_findSome?_eq_some {l : List α} {f : α → Option β} (w : l.findSome? f = some b) :
-    ∃ a, a ∈ l ∧ f a = b := by
-  induction l with
-  | nil => simp_all
-  | cons h l ih =>
-    simp_all only [findSome?_cons, mem_cons, exists_eq_or_imp]
-    split at w <;> simp_all
-
-@[simp] theorem findSome?_map (f : β → γ) (l : List β) : findSome? p (l.map f) = l.findSome? (p ∘ f) := by
-  induction l with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [map_cons, findSome?]
-    split <;> simp_all
-
-theorem findSome?_replicate : findSome? f (replicate n a) = if n = 0 then none else f a := by
-  induction n with
-  | zero => simp
-  | succ n ih =>
-    simp only [replicate_succ, findSome?_cons]
-    split <;> simp_all
-
-@[simp] theorem findSome?_replicate_of_pos (h : 0 < n) : findSome? f (replicate n a) = f a := by
-  simp [findSome?_replicate, Nat.ne_of_gt h]
-
--- Argument is unused, but used to decide whether `simp` should unfold.
-@[simp] theorem find?_replicate_of_isSome (_ : (f a).isSome) : findSome? f (replicate n a) = if n = 0 then none else f a := by
-  simp [findSome?_replicate]
-
-@[simp] theorem find?_replicate_of_isNone (h : (f a).isNone) : findSome? f (replicate n a) = none := by
-  rw [Option.isNone_iff_eq_none] at h
-  simp [findSome?_replicate, h]
-
-theorem findSome?_isSome_of_sublist {l₁ l₂ : List α} (h : l₁ <+ l₂) :
-    (l₁.findSome? f).isSome → (l₂.findSome? f).isSome := by
-  induction h with
-  | slnil => simp
-  | cons a h ih
-  | cons₂ a h ih =>
-    simp only [findSome?]
-    split <;> simp_all
-
-/-! ### findIdx -/
-
-theorem findIdx_cons (p : α → Bool) (b : α) (l : List α) :
-    (b :: l).findIdx p = bif p b then 0 else (l.findIdx p) + 1 := by
-  cases H : p b with
-  | true => simp [H, findIdx, findIdx.go]
-  | false => simp [H, findIdx, findIdx.go, findIdx_go_succ]
-where
-  findIdx_go_succ (p : α → Bool) (l : List α) (n : Nat) :
-      List.findIdx.go p l (n + 1) = (findIdx.go p l n) + 1 := by
-    cases l with
-    | nil => unfold findIdx.go; exact Nat.succ_eq_add_one n
-    | cons head tail =>
-      unfold findIdx.go
-      cases p head <;> simp only [cond_false, cond_true]
-      exact findIdx_go_succ p tail (n + 1)
-
-theorem findIdx_of_get?_eq_some {xs : List α} (w : xs.get? (xs.findIdx p) = some y) : p y := by
-  induction xs with
-  | nil => simp_all
-  | cons x xs ih => by_cases h : p x <;> simp_all [findIdx_cons]
-
-theorem findIdx_get {xs : List α} {w : xs.findIdx p < xs.length} :
-    p (xs.get ⟨xs.findIdx p, w⟩) :=
-  xs.findIdx_of_get?_eq_some (get?_eq_get w)
-
-theorem findIdx_lt_length_of_exists {xs : List α} (h : ∃ x ∈ xs, p x) :
-    xs.findIdx p < xs.length := by
-  induction xs with
-  | nil => simp_all
-  | cons x xs ih =>
-    by_cases p x
-    · simp_all only [forall_exists_index, and_imp, mem_cons, exists_eq_or_imp, true_or,
-        findIdx_cons, cond_true, length_cons]
-      apply Nat.succ_pos
-    · simp_all [findIdx_cons]
-      refine Nat.succ_lt_succ ?_
-      obtain ⟨x', m', h'⟩ := h
-      exact ih x' m' h'
-
-theorem findIdx_get?_eq_get_of_exists {xs : List α} (h : ∃ x ∈ xs, p x) :
-    xs.get? (xs.findIdx p) = some (xs.get ⟨xs.findIdx p, xs.findIdx_lt_length_of_exists h⟩) :=
-  get?_eq_get (findIdx_lt_length_of_exists h)
-
-  /-! ### findIdx? -/
-
-@[simp] theorem findIdx?_nil : ([] : List α).findIdx? p i = none := rfl
-
-@[simp] theorem findIdx?_cons :
-    (x :: xs).findIdx? p i = if p x then some i else findIdx? p xs (i + 1) := rfl
-
-@[simp] theorem findIdx?_succ :
-    (xs : List α).findIdx? p (i+1) = (xs.findIdx? p i).map fun i => i + 1 := by
-  induction xs generalizing i with simp
-  | cons _ _ _ => split <;> simp_all
-
-theorem findIdx?_eq_some_iff (xs : List α) (p : α → Bool) :
-    xs.findIdx? p = some i ↔ (xs.take (i + 1)).map p = replicate i false ++ [true] := by
-  induction xs generalizing i with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [findIdx?_cons, Nat.zero_add, findIdx?_succ, take_succ_cons, map_cons]
-    split <;> cases i <;> simp_all [replicate_succ, succ_inj']
-
-theorem findIdx?_of_eq_some {xs : List α} {p : α → Bool} (w : xs.findIdx? p = some i) :
-    match xs.get? i with | some a => p a | none => false := by
-  induction xs generalizing i with
-  | nil => simp_all
-  | cons x xs ih =>
-    simp_all only [findIdx?_cons, Nat.zero_add, findIdx?_succ]
-    split at w <;> cases i <;> simp_all [succ_inj']
-
-theorem findIdx?_of_eq_none {xs : List α} {p : α → Bool} (w : xs.findIdx? p = none) :
-    ∀ i, match xs.get? i with | some a => ¬ p a | none => true := by
-  intro i
-  induction xs generalizing i with
-  | nil => simp_all
-  | cons x xs ih =>
-    simp_all only [Bool.not_eq_true, findIdx?_cons, Nat.zero_add, findIdx?_succ]
-    cases i with
-    | zero =>
-      split at w <;> simp_all
-    | succ i =>
-      simp only [get?_cons_succ]
-      apply ih
-      split at w <;> simp_all
-
-@[simp] theorem findIdx?_append :
-    (xs ++ ys : List α).findIdx? p =
-      (xs.findIdx? p <|> (ys.findIdx? p).map fun i => i + xs.length) := by
-  induction xs with simp
-  | cons _ _ _ => split <;> simp_all [Option.map_orElse, Option.map_map]; rfl
-
-@[simp] theorem findIdx?_replicate :
-    (replicate n a).findIdx? p = if 0 < n ∧ p a then some 0 else none := by
-  induction n with
-  | zero => simp
-  | succ n ih =>
-    simp only [replicate, findIdx?_cons, Nat.zero_add, findIdx?_succ, Nat.zero_lt_succ, true_and]
-    split <;> simp_all
-
-/-! ### indexOf -/
-
-theorem indexOf_cons [BEq α] :
-    (x :: xs : List α).indexOf y = bif x == y then 0 else xs.indexOf y + 1 := by
-  dsimp [indexOf]
-  simp [findIdx_cons]
-
-end List

src/Init/Data/List/Impl.lean

@@ -193,17 +193,6 @@ theorem replicateTR_loop_eq : ∀ n, replicateTR.loop a n acc = replicate n a ++
   apply funext; intro α; apply funext; intro n; apply funext; intro a
   exact (replicateTR_loop_replicate_eq _ 0 n).symm
 
-/-! ## Additional functions -/
-
-/-! ### leftpad -/
-
-/-- Optimized version of `leftpad`. -/
-@[inline] def leftpadTR (n : Nat) (a : α) (l : List α) : List α :=
-  replicateTR.loop a (n - length l) l
-
-@[csimp] theorem leftpad_eq_leftpadTR : @leftpad = @leftpadTR := by
-  funext α n a l; simp [leftpad, leftpadTR, replicateTR_loop_eq]
-
 /-! ## Sublists -/
 
 /-! ### take -/
@@ -377,26 +366,6 @@ def unzipTR (l : List (α × β)) : List α × List β :=
 
 /-! ## Ranges and enumeration -/
 
-/-! ### range' -/
-
-/-- Optimized version of `range'`. -/
-@[inline] def range'TR (s n : Nat) (step : Nat := 1) : List Nat := go n (s + step * n) [] where
-  /-- Auxiliary for `range'TR`: `range'TR.go n e = [e-n, ..., e-1] ++ acc`. -/
-  go : Nat → Nat → List Nat → List Nat
-  | 0, _, acc => acc
-  | n+1, e, acc => go n (e-step) ((e-step) :: acc)
-
-@[csimp] theorem range'_eq_range'TR : @range' = @range'TR := by
-  funext s n step
-  let rec go (s) : ∀ n m,
-    range'TR.go step n (s + step * n) (range' (s + step * n) m step) = range' s (n + m) step
-  | 0, m => by simp [range'TR.go]
-  | n+1, m => by
-    simp [range'TR.go]
-    rw [Nat.mul_succ, ← Nat.add_assoc, Nat.add_sub_cancel, Nat.add_right_comm n]
-    exact go s n (m + 1)
-  exact (go s n 0).symm
-
 /-! ### iota -/
 
 /-- Tail-recursive version of `List.iota`. -/

src/Init/Data/List/MinMax.lean

@@ -1,153 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.Lemmas
-
-/-!
-# Lemmas about `List.minimum?` and `List.maximum?.
--/
-
-namespace List
-
-open Nat
-
-/-! ## Minima and maxima -/
-
-/-! ### minimum? -/
-
-@[simp] theorem minimum?_nil [Min α] : ([] : List α).minimum? = none := rfl
-
--- We don't put `@[simp]` on `minimum?_cons`,
--- because the definition in terms of `foldl` is not useful for proofs.
-theorem minimum?_cons [Min α] {xs : List α} : (x :: xs).minimum? = foldl min x xs := rfl
-
-@[simp] theorem minimum?_eq_none_iff {xs : List α} [Min α] : xs.minimum? = none ↔ xs = [] := by
-  cases xs <;> simp [minimum?]
-
-theorem minimum?_mem [Min α] (min_eq_or : ∀ a b : α, min a b = a ∨ min a b = b) :
-    {xs : List α} → xs.minimum? = some a → a ∈ xs := by
-  intro xs
-  match xs with
-  | nil => simp
-  | x :: xs =>
-    simp only [minimum?_cons, Option.some.injEq, List.mem_cons]
-    intro eq
-    induction xs generalizing x with
-    | nil =>
-      simp at eq
-      simp [eq]
-    | cons y xs ind =>
-      simp at eq
-      have p := ind _ eq
-      cases p with
-      | inl p =>
-        cases min_eq_or x y with | _ q => simp [p, q]
-      | inr p => simp [p, mem_cons]
-
--- See also `Init.Data.List.Nat.Basic` for specialisations of the next two results to `Nat`.
-
-theorem le_minimum?_iff [Min α] [LE α]
-    (le_min_iff : ∀ a b c : α, a ≤ min b c ↔ a ≤ b ∧ a ≤ c) :
-    {xs : List α} → xs.minimum? = some a → ∀ x, x ≤ a ↔ ∀ b, b ∈ xs → x ≤ b
-  | nil => by simp
-  | cons x xs => by
-    rw [minimum?]
-    intro eq y
-    simp only [Option.some.injEq] at eq
-    induction xs generalizing x with
-    | nil =>
-      simp at eq
-      simp [eq]
-    | cons z xs ih =>
-      simp at eq
-      simp [ih _ eq, le_min_iff, and_assoc]
-
--- This could be refactored by designing appropriate typeclasses to replace `le_refl`, `min_eq_or`,
--- and `le_min_iff`.
-theorem minimum?_eq_some_iff [Min α] [LE α] [anti : Antisymm ((· : α) ≤ ·)]
-    (le_refl : ∀ a : α, a ≤ a)
-    (min_eq_or : ∀ a b : α, min a b = a ∨ min a b = b)
-    (le_min_iff : ∀ a b c : α, a ≤ min b c ↔ a ≤ b ∧ a ≤ c) {xs : List α} :
-    xs.minimum? = some a ↔ a ∈ xs ∧ ∀ b, b ∈ xs → a ≤ b := by
-  refine ⟨fun h => ⟨minimum?_mem min_eq_or h, (le_minimum?_iff le_min_iff h _).1 (le_refl _)⟩, ?_⟩
-  intro ⟨h₁, h₂⟩
-  cases xs with
-  | nil => simp at h₁
-  | cons x xs =>
-    exact congrArg some <| anti.1
-      ((le_minimum?_iff le_min_iff (xs := x::xs) rfl _).1 (le_refl _) _ h₁)
-      (h₂ _ (minimum?_mem min_eq_or (xs := x::xs) rfl))
-
-theorem minimum?_replicate [Min α] {n : Nat} {a : α} (w : min a a = a) :
-    (replicate n a).minimum? = if n = 0 then none else some a := by
-  induction n with
-  | zero => rfl
-  | succ n ih => cases n <;> simp_all [replicate_succ, minimum?_cons]
-
-@[simp] theorem minimum?_replicate_of_pos [Min α] {n : Nat} {a : α} (w : min a a = a) (h : 0 < n) :
-    (replicate n a).minimum? = some a := by
-  simp [minimum?_replicate, Nat.ne_of_gt h, w]
-
-/-! ### maximum? -/
-
-@[simp] theorem maximum?_nil [Max α] : ([] : List α).maximum? = none := rfl
-
--- We don't put `@[simp]` on `maximum?_cons`,
--- because the definition in terms of `foldl` is not useful for proofs.
-theorem maximum?_cons [Max α] {xs : List α} : (x :: xs).maximum? = foldl max x xs := rfl
-
-@[simp] theorem maximum?_eq_none_iff {xs : List α} [Max α] : xs.maximum? = none ↔ xs = [] := by
-  cases xs <;> simp [maximum?]
-
-theorem maximum?_mem [Max α] (min_eq_or : ∀ a b : α, max a b = a ∨ max a b = b) :
-    {xs : List α} → xs.maximum? = some a → a ∈ xs
-  | nil => by simp
-  | cons x xs => by
-    rw [maximum?]; rintro ⟨⟩
-    induction xs generalizing x with simp at *
-    | cons y xs ih =>
-      rcases ih (max x y) with h | h <;> simp [h]
-      simp [← or_assoc, min_eq_or x y]
-
--- See also `Init.Data.List.Nat.Basic` for specialisations of the next two results to `Nat`.
-
-theorem maximum?_le_iff [Max α] [LE α]
-    (max_le_iff : ∀ a b c : α, max b c ≤ a ↔ b ≤ a ∧ c ≤ a) :
-    {xs : List α} → xs.maximum? = some a → ∀ x, a ≤ x ↔ ∀ b ∈ xs, b ≤ x
-  | nil => by simp
-  | cons x xs => by
-    rw [maximum?]; rintro ⟨⟩ y
-    induction xs generalizing x with
-    | nil => simp
-    | cons y xs ih => simp [ih, max_le_iff, and_assoc]
-
--- This could be refactored by designing appropriate typeclasses to replace `le_refl`, `max_eq_or`,
--- and `le_min_iff`.
-theorem maximum?_eq_some_iff [Max α] [LE α] [anti : Antisymm ((· : α) ≤ ·)]
-    (le_refl : ∀ a : α, a ≤ a)
-    (max_eq_or : ∀ a b : α, max a b = a ∨ max a b = b)
-    (max_le_iff : ∀ a b c : α, max b c ≤ a ↔ b ≤ a ∧ c ≤ a) {xs : List α} :
-    xs.maximum? = some a ↔ a ∈ xs ∧ ∀ b ∈ xs, b ≤ a := by
-  refine ⟨fun h => ⟨maximum?_mem max_eq_or h, (maximum?_le_iff max_le_iff h _).1 (le_refl _)⟩, ?_⟩
-  intro ⟨h₁, h₂⟩
-  cases xs with
-  | nil => simp at h₁
-  | cons x xs =>
-    exact congrArg some <| anti.1
-      (h₂ _ (maximum?_mem max_eq_or (xs := x::xs) rfl))
-      ((maximum?_le_iff max_le_iff (xs := x::xs) rfl _).1 (le_refl _) _ h₁)
-
-theorem maximum?_replicate [Max α] {n : Nat} {a : α} (w : max a a = a) :
-    (replicate n a).maximum? = if n = 0 then none else some a := by
-  induction n with
-  | zero => rfl
-  | succ n ih => cases n <;> simp_all [replicate_succ, maximum?_cons]
-
-@[simp] theorem maximum?_replicate_of_pos [Max α] {n : Nat} {a : α} (w : max a a = a) (h : 0 < n) :
-    (replicate n a).maximum? = some a := by
-  simp [maximum?_replicate, Nat.ne_of_gt h, w]
-
-end List

src/Init/Data/List/Monadic.lean

@@ -1,69 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.TakeDrop
-
-/-!
-# Lemmas about `List.mapM` and `List.forM`.
--/
-
-namespace List
-
-open Nat
-
-/-! ## Monadic operations -/
-
--- We may want to replace these `simp` attributes with explicit equational lemmas,
--- as we already have for all the non-monadic functions.
-attribute [simp] mapA forA filterAuxM firstM anyM allM findM? findSomeM?
-
--- Previously `mapM.loop`, `filterMapM.loop`, `forIn.loop`, `forIn'.loop`
--- had attribute `@[simp]`.
--- We don't currently provide simp lemmas,
--- as this is an internal implementation and they don't seem to be needed.
-
-/-! ### mapM -/
-
-/-- Alternate (non-tail-recursive) form of mapM for proofs. -/
-def mapM' [Monad m] (f : α → m β) : List α → m (List β)
-  | [] => pure []
-  | a :: l => return (← f a) :: (← l.mapM' f)
-
-@[simp] theorem mapM'_nil [Monad m] {f : α → m β} : mapM' f [] = pure [] := rfl
-@[simp] theorem mapM'_cons [Monad m] {f : α → m β} :
-    mapM' f (a :: l) = return ((← f a) :: (← l.mapM' f)) :=
-  rfl
-
-theorem mapM'_eq_mapM [Monad m] [LawfulMonad m] (f : α → m β) (l : List α) :
-    mapM' f l = mapM f l := by simp [go, mapM] where
-  go : ∀ l acc, mapM.loop f l acc = return acc.reverse ++ (← mapM' f l)
-    | [], acc => by simp [mapM.loop, mapM']
-    | a::l, acc => by simp [go l, mapM.loop, mapM']
-
-@[simp] theorem mapM_nil [Monad m] (f : α → m β) : [].mapM f = pure [] := rfl
-
-@[simp] theorem mapM_cons [Monad m] [LawfulMonad m] (f : α → m β) :
-    (a :: l).mapM f = (return (← f a) :: (← l.mapM f)) := by simp [← mapM'_eq_mapM, mapM']
-
-@[simp] theorem mapM_append [Monad m] [LawfulMonad m] (f : α → m β) {l₁ l₂ : List α} :
-    (l₁ ++ l₂).mapM f = (return (← l₁.mapM f) ++ (← l₂.mapM f)) := by induction l₁ <;> simp [*]
-
-/-! ### forM -/
-
--- We use `List.forM` as the simp normal form, rather that `ForM.forM`.
--- As such we need to replace `List.forM_nil` and `List.forM_cons`:
-
-@[simp] theorem forM_nil' [Monad m] : ([] : List α).forM f = (pure .unit : m PUnit) := rfl
-
-@[simp] theorem forM_cons' [Monad m] :
-    (a::as).forM f = (f a >>= fun _ => as.forM f : m PUnit) :=
-  List.forM_cons _ _ _
-
-@[simp] theorem forM_append [Monad m] [LawfulMonad m] (l₁ l₂ : List α) (f : α → m PUnit) :
-    (l₁ ++ l₂).forM f = (do l₁.forM f; l₂.forM f) := by
-  induction l₁ <;> simp [*]
-
-end List

src/Init/Data/List/Nat.lean

@@ -1,10 +0,0 @@
-/-
-Copyright (c) 2024 Lean FRO. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Kim Morrison
--/
-prelude
-import Init.Data.List.Nat.Basic
-import Init.Data.List.Nat.Pairwise
-import Init.Data.List.Nat.Range
-import Init.Data.List.Nat.TakeDrop

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

@@ -1,125 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.Count
-import Init.Data.List.MinMax
-import Init.Data.Nat.Lemmas
-
-/-!
-# Miscellaneous `List` lemmas, that require more `Nat` lemmas than are available in `Init.Data.List.Lemmas`.
-
-In particular, `omega` is available here.
--/
-
-open Nat
-
-namespace List
-
-/-! ### filter -/
-
-theorem length_filter_lt_length_iff_exists (l) :
-    length (filter p l) < length l ↔ ∃ x ∈ l, ¬p x := by
-  simpa [length_eq_countP_add_countP p l, countP_eq_length_filter] using
-  countP_pos (fun x => ¬p x) (l := l)
-
-/-! ### leftpad -/
-
-/-- The length of the List returned by `List.leftpad n a l` is equal
-  to the larger of `n` and `l.length` -/
-@[simp]
-theorem leftpad_length (n : Nat) (a : α) (l : List α) :
-    (leftpad n a l).length = max n l.length := by
-  simp only [leftpad, length_append, length_replicate, Nat.sub_add_eq_max]
-
-/-! ### eraseIdx -/
-
-theorem mem_eraseIdx_iff_getElem {x : α} :
-    ∀ {l} {k}, x ∈ eraseIdx l k ↔ ∃ i h, i ≠ k ∧ l[i]'h = x
-  | [], _ => by
-    simp only [eraseIdx, not_mem_nil, false_iff]
-    rintro ⟨i, h, -⟩
-    exact Nat.not_lt_zero _ h
-  | a::l, 0 => by simp [mem_iff_getElem, Nat.succ_lt_succ_iff]
-  | a::l, k+1 => by
-    rw [← Nat.or_exists_add_one]
-    simp [mem_eraseIdx_iff_getElem, @eq_comm _ a, succ_inj', Nat.succ_lt_succ_iff]
-
-theorem mem_eraseIdx_iff_getElem? {x : α} {l} {k} : x ∈ eraseIdx l k ↔ ∃ i ≠ k, l[i]? = some x := by
-  simp only [mem_eraseIdx_iff_getElem, getElem_eq_iff, exists_and_left]
-  refine exists_congr fun i => and_congr_right' ?_
-  constructor
-  · rintro ⟨_, h⟩; exact h
-  · rintro h;
-    obtain ⟨h', -⟩ := getElem?_eq_some.1 h
-    exact ⟨h', h⟩
-
-/-! ### minimum? -/
-
--- A specialization of `minimum?_eq_some_iff` to Nat.
-theorem minimum?_eq_some_iff' {xs : List Nat} :
-    xs.minimum? = some a ↔ (a ∈ xs ∧ ∀ b ∈ xs, a ≤ b) :=
-  minimum?_eq_some_iff
-    (le_refl := Nat.le_refl)
-    (min_eq_or := fun _ _ => by omega)
-    (le_min_iff := fun _ _ _ => by omega)
-
--- This could be generalized,
--- but will first require further work on order typeclasses in the core repository.
-theorem minimum?_cons' {a : Nat} {l : List Nat} :
-    (a :: l).minimum? = some (match l.minimum? with
-    | none => a
-    | some m => min a m) := by
-  rw [minimum?_eq_some_iff']
-  split <;> rename_i h m
-  · simp_all
-  · rw [minimum?_eq_some_iff'] at m
-    obtain ⟨m, le⟩ := m
-    rw [Nat.min_def]
-    constructor
-    · split
-      · exact mem_cons_self a l
-      · exact mem_cons_of_mem a m
-    · intro b m
-      cases List.mem_cons.1 m with
-      | inl => split <;> omega
-      | inr h =>
-        specialize le b h
-        split <;> omega
-
-/-! ### maximum? -/
-
--- A specialization of `maximum?_eq_some_iff` to Nat.
-theorem maximum?_eq_some_iff' {xs : List Nat} :
-    xs.maximum? = some a ↔ (a ∈ xs ∧ ∀ b ∈ xs, b ≤ a) :=
-  maximum?_eq_some_iff
-    (le_refl := Nat.le_refl)
-    (max_eq_or := fun _ _ => by omega)
-    (max_le_iff := fun _ _ _ => by omega)
-
--- This could be generalized,
--- but will first require further work on order typeclasses in the core repository.
-theorem maximum?_cons' {a : Nat} {l : List Nat} :
-    (a :: l).maximum? = some (match l.maximum? with
-    | none => a
-    | some m => max a m) := by
-  rw [maximum?_eq_some_iff']
-  split <;> rename_i h m
-  · simp_all
-  · rw [maximum?_eq_some_iff'] at m
-    obtain ⟨m, le⟩ := m
-    rw [Nat.max_def]
-    constructor
-    · split
-      · exact mem_cons_of_mem a m
-      · exact mem_cons_self a l
-    · intro b m
-      cases List.mem_cons.1 m with
-      | inl => split <;> omega
-      | inr h =>
-        specialize le b h
-        split <;> omega
-
-end List

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

@@ -1,73 +0,0 @@
-/-
-Copyright (c) 2018 Mario Carneiro. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Mario Carneiro, James Gallicchio
--/
-prelude
-import Init.Data.Fin.Lemmas
-import Init.Data.List.Nat.TakeDrop
-import Init.Data.List.Pairwise
-
-/-!
-# Lemmas about `List.Pairwise`
--/
-
-namespace List
-
-/-- Given a list `is` of monotonically increasing indices into `l`, getting each index
-  produces a sublist of `l`.  -/
-theorem map_getElem_sublist {l : List α} {is : List (Fin l.length)} (h : is.Pairwise (· < ·)) :
-    is.map (l[·]) <+ l := by
-  suffices ∀ n l', l' = l.drop n → (∀ i ∈ is, n ≤ i) → map (l[·]) is <+ l'
-    from this 0 l (by simp) (by simp)
-  rintro n l' rfl his
-  induction is generalizing n with
-  | nil => simp
-  | cons hd tl IH =>
-    simp only [Fin.getElem_fin, map_cons]
-    have := IH h.of_cons (hd+1) (pairwise_cons.mp h).1
-    specialize his hd (.head _)
-    have := (drop_eq_getElem_cons ..).symm ▸ this.cons₂ (get l hd)
-    have := Sublist.append (nil_sublist (take hd l |>.drop n)) this
-    rwa [nil_append, ← (drop_append_of_le_length ?_), take_append_drop] at this
-    simp [Nat.min_eq_left (Nat.le_of_lt hd.isLt), his]
-
-@[deprecated map_getElem_sublist (since := "2024-07-30")]
-theorem map_get_sublist {l : List α} {is : List (Fin l.length)} (h : is.Pairwise (·.val < ·.val)) :
-    is.map (get l) <+ l := by
-  simpa using map_getElem_sublist h
-
-/-- Given a sublist `l' <+ l`, there exists an increasing list of indices `is` such that
-  `l' = is.map fun i => l[i]`. -/
-theorem sublist_eq_map_getElem {l l' : List α} (h : l' <+ l) : ∃ is : List (Fin l.length),
-    l' = is.map (l[·]) ∧ is.Pairwise (· < ·) := by
-  induction h with
-  | slnil => exact ⟨[], by simp⟩
-  | cons _ _ IH =>
-    let ⟨is, IH⟩ := IH
-    refine ⟨is.map (·.succ), ?_⟩
-    simpa [Function.comp_def, pairwise_map]
-  | cons₂ _ _ IH =>
-    rcases IH with ⟨is,IH⟩
-    refine ⟨⟨0, by simp [Nat.zero_lt_succ]⟩ :: is.map (·.succ), ?_⟩
-    simp [Function.comp_def, pairwise_map, IH, ← get_eq_getElem]
-
-@[deprecated sublist_eq_map_getElem (since := "2024-07-30")]
-theorem sublist_eq_map_get (h : l' <+ l) : ∃ is : List (Fin l.length),
-    l' = map (get l) is ∧ is.Pairwise (· < ·) := by
-  simpa using sublist_eq_map_getElem h
-
-theorem pairwise_iff_getElem : Pairwise R l ↔
-    ∀ (i j : Nat) (_hi : i < l.length) (_hj : j < l.length) (_hij : i < j), R l[i] l[j] := by
-  rw [pairwise_iff_forall_sublist]
-  constructor <;> intro h
-  · intros i j hi hj h'
-    apply h
-    simpa [h'] using map_getElem_sublist (is := [⟨i, hi⟩, ⟨j, hj⟩])
-  · intros a b h'
-    have ⟨is, h', hij⟩ := sublist_eq_map_getElem h'
-    rcases is with ⟨⟩ | ⟨a', ⟨⟩ | ⟨b', ⟨⟩⟩⟩ <;> simp at h'
-    rcases h' with ⟨rfl, rfl⟩
-    apply h; simpa using hij
-
-end List

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

@@ -1,387 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.Nat.TakeDrop
-import Init.Data.List.Pairwise
-
-/-!
-# Lemmas about `List.range` and `List.enum`
--/
-
-namespace List
-
-open Nat
-
-/-! ## Ranges and enumeration -/
-
-/-! ### range' -/
-
-theorem range'_succ (s n step) : range' s (n + 1) step = s :: range' (s + step) n step := by
-  simp [range', Nat.add_succ, Nat.mul_succ]
-
-@[simp] theorem range'_one {s step : Nat} : range' s 1 step = [s] := rfl
-
-@[simp] theorem length_range' (s step) : ∀ n : Nat, length (range' s n step) = n
-  | 0 => rfl
-  | _ + 1 => congrArg succ (length_range' _ _ _)
-
-@[simp] theorem range'_eq_nil : range' s n step = [] ↔ n = 0 := by
-  rw [← length_eq_zero, length_range']
-
-theorem mem_range' : ∀{n}, m ∈ range' s n step ↔ ∃ i < n, m = s + step * i
-  | 0 => by simp [range', Nat.not_lt_zero]
-  | n + 1 => by
-    have h (i) : i ≤ n ↔ i = 0 ∨ ∃ j, i = succ j ∧ j < n := by
-      cases i <;> simp [Nat.succ_le, Nat.succ_inj']
-    simp [range', mem_range', Nat.lt_succ, h]; simp only [← exists_and_right, and_assoc]
-    rw [exists_comm]; simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
-
-@[simp] theorem mem_range'_1 : m ∈ range' s n ↔ s ≤ m ∧ m < s + n := by
-  simp [mem_range']; exact ⟨
-    fun ⟨i, h, e⟩ => e ▸ ⟨Nat.le_add_right .., Nat.add_lt_add_left h _⟩,
-    fun ⟨h₁, h₂⟩ => ⟨m - s, Nat.sub_lt_left_of_lt_add h₁ h₂, (Nat.add_sub_cancel' h₁).symm⟩⟩
-
-theorem pairwise_lt_range' s n (step := 1) (pos : 0 < step := by simp) :
-    Pairwise (· < ·) (range' s n step) :=
-  match s, n, step, pos with
-  | _, 0, _, _ => Pairwise.nil
-  | s, n + 1, step, pos => by
-    simp only [range'_succ, pairwise_cons]
-    constructor
-    · intros n m
-      rw [mem_range'] at m
-      omega
-    · exact pairwise_lt_range' (s + step) n step pos
-
-theorem pairwise_le_range' s n (step := 1) :
-    Pairwise (· ≤ ·) (range' s n step) :=
-  match s, n, step with
-  | _, 0, _ => Pairwise.nil
-  | s, n + 1, step => by
-    simp only [range'_succ, pairwise_cons]
-    constructor
-    · intros n m
-      rw [mem_range'] at m
-      omega
-    · exact pairwise_le_range' (s + step) n step
-
-theorem nodup_range' (s n : Nat) (step := 1) (h : 0 < step := by simp) : Nodup (range' s n step) :=
-  (pairwise_lt_range' s n step h).imp Nat.ne_of_lt
-
-@[simp]
-theorem map_add_range' (a) : ∀ s n step, map (a + ·) (range' s n step) = range' (a + s) n step
-  | _, 0, _ => rfl
-  | s, n + 1, step => by simp [range', map_add_range' _ (s + step) n step, Nat.add_assoc]
-
-theorem map_sub_range' (a s n : Nat) (h : a ≤ s) :
-    map (· - a) (range' s n step) = range' (s - a) n step := by
-  conv => lhs; rw [← Nat.add_sub_cancel' h]
-  rw [← map_add_range', map_map, (?_ : _∘_ = _), map_id]
-  funext x; apply Nat.add_sub_cancel_left
-
-theorem range'_append : ∀ s m n step : Nat,
-    range' s m step ++ range' (s + step * m) n step = range' s (n + m) step
-  | s, 0, n, step => rfl
-  | s, m + 1, n, step => by
-    simpa [range', Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
-      using range'_append (s + step) m n step
-
-@[simp] theorem range'_append_1 (s m n : Nat) :
-    range' s m ++ range' (s + m) n = range' s (n + m) := by simpa using range'_append s m n 1
-
-theorem range'_sublist_right {s m n : Nat} : range' s m step <+ range' s n step ↔ m ≤ n :=
-  ⟨fun h => by simpa only [length_range'] using h.length_le,
-   fun h => by rw [← Nat.sub_add_cancel h, ← range'_append]; apply sublist_append_left⟩
-
-theorem range'_subset_right {s m n : Nat} (step0 : 0 < step) :
-    range' s m step ⊆ range' s n step ↔ m ≤ n := by
-  refine ⟨fun h => Nat.le_of_not_lt fun hn => ?_, fun h => (range'_sublist_right.2 h).subset⟩
-  have ⟨i, h', e⟩ := mem_range'.1 <| h <| mem_range'.2 ⟨_, hn, rfl⟩
-  exact Nat.ne_of_gt h' (Nat.eq_of_mul_eq_mul_left step0 (Nat.add_left_cancel e))
-
-theorem range'_subset_right_1 {s m n : Nat} : range' s m ⊆ range' s n ↔ m ≤ n :=
-  range'_subset_right (by decide)
-
-theorem getElem?_range' (s step) :
-    ∀ {m n : Nat}, m < n → (range' s n step)[m]? = some (s + step * m)
-  | 0, n + 1, _ => by simp [range'_succ]
-  | m + 1, n + 1, h => by
-    simp only [range'_succ, getElem?_cons_succ]
-    exact (getElem?_range' (s + step) step (Nat.lt_of_add_lt_add_right h)).trans <| by
-      simp [Nat.mul_succ, Nat.add_assoc, Nat.add_comm]
-
-@[simp] theorem getElem_range' {n m step} (i) (H : i < (range' n m step).length) :
-    (range' n m step)[i] = n + step * i :=
-  (getElem?_eq_some.1 <| getElem?_range' n step (by simpa using H)).2
-
-theorem range'_concat (s n : Nat) : range' s (n + 1) step = range' s n step ++ [s + step * n] := by
-  rw [Nat.add_comm n 1]; exact (range'_append s n 1 step).symm
-
-theorem range'_1_concat (s n : Nat) : range' s (n + 1) = range' s n ++ [s + n] := by
-  simp [range'_concat]
-
-/-! ### range -/
-
-theorem range_loop_range' : ∀ s n : Nat, range.loop s (range' s n) = range' 0 (n + s)
-  | 0, n => rfl
-  | s + 1, n => by rw [← Nat.add_assoc, Nat.add_right_comm n s 1]; exact range_loop_range' s (n + 1)
-
-theorem range_eq_range' (n : Nat) : range n = range' 0 n :=
-  (range_loop_range' n 0).trans <| by rw [Nat.zero_add]
-
-theorem range_succ_eq_map (n : Nat) : range (n + 1) = 0 :: map succ (range n) := by
-  rw [range_eq_range', range_eq_range', range', Nat.add_comm, ← map_add_range']
-  congr; exact funext (Nat.add_comm 1)
-
-theorem reverse_range' : ∀ s n : Nat, reverse (range' s n) = map (s + n - 1 - ·) (range n)
-  | s, 0 => rfl
-  | s, n + 1 => by
-    rw [range'_1_concat, reverse_append, range_succ_eq_map,
-      show s + (n + 1) - 1 = s + n from rfl, map, map_map]
-    simp [reverse_range', Nat.sub_right_comm, Nat.sub_sub]
-
-theorem range'_eq_map_range (s n : Nat) : range' s n = map (s + ·) (range n) := by
-  rw [range_eq_range', map_add_range']; rfl
-
-@[simp] theorem length_range (n : Nat) : length (range n) = n := by
-  simp only [range_eq_range', length_range']
-
-@[simp] theorem range_eq_nil {n : Nat} : range n = [] ↔ n = 0 := by
-  rw [← length_eq_zero, length_range]
-
-@[simp]
-theorem range_sublist {m n : Nat} : range m <+ range n ↔ m ≤ n := by
-  simp only [range_eq_range', range'_sublist_right]
-
-@[simp]
-theorem range_subset {m n : Nat} : range m ⊆ range n ↔ m ≤ n := by
-  simp only [range_eq_range', range'_subset_right, lt_succ_self]
-
-@[simp]
-theorem mem_range {m n : Nat} : m ∈ range n ↔ m < n := by
-  simp only [range_eq_range', mem_range'_1, Nat.zero_le, true_and, Nat.zero_add]
-
-theorem not_mem_range_self {n : Nat} : n ∉ range n := by simp
-
-theorem self_mem_range_succ (n : Nat) : n ∈ range (n + 1) := by simp
-
-theorem pairwise_lt_range (n : Nat) : Pairwise (· < ·) (range n) := by
-  simp (config := {decide := true}) only [range_eq_range', pairwise_lt_range']
-
-theorem pairwise_le_range (n : Nat) : Pairwise (· ≤ ·) (range n) :=
-  Pairwise.imp Nat.le_of_lt (pairwise_lt_range _)
-
-theorem getElem?_range {m n : Nat} (h : m < n) : (range n)[m]? = some m := by
-  simp [range_eq_range', getElem?_range' _ _ h]
-
-@[simp] theorem getElem_range {n : Nat} (m) (h : m < (range n).length) : (range n)[m] = m := by
-  simp [range_eq_range']
-
-theorem range_succ (n : Nat) : range (succ n) = range n ++ [n] := by
-  simp only [range_eq_range', range'_1_concat, Nat.zero_add]
-
-theorem range_add (a b : Nat) : range (a + b) = range a ++ (range b).map (a + ·) := by
-  rw [← range'_eq_map_range]
-  simpa [range_eq_range', Nat.add_comm] using (range'_append_1 0 a b).symm
-
-theorem take_range (m n : Nat) : take m (range n) = range (min m n) := by
-  apply List.ext_getElem
-  · simp
-  · simp (config := { contextual := true }) [← getElem_take, Nat.lt_min]
-
-theorem nodup_range (n : Nat) : Nodup (range n) := by
-  simp (config := {decide := true}) only [range_eq_range', nodup_range']
-
-/-! ### iota -/
-
-theorem iota_eq_reverse_range' : ∀ n : Nat, iota n = reverse (range' 1 n)
-  | 0 => rfl
-  | n + 1 => by simp [iota, range'_concat, iota_eq_reverse_range' n, reverse_append, Nat.add_comm]
-
-@[simp] theorem length_iota (n : Nat) : length (iota n) = n := by simp [iota_eq_reverse_range']
-
-@[simp]
-theorem mem_iota {m n : Nat} : m ∈ iota n ↔ 1 ≤ m ∧ m ≤ n := by
-  simp [iota_eq_reverse_range', Nat.add_comm, Nat.lt_succ]
-
-theorem pairwise_gt_iota (n : Nat) : Pairwise (· > ·) (iota n) := by
-  simpa only [iota_eq_reverse_range', pairwise_reverse] using pairwise_lt_range' 1 n
-
-theorem nodup_iota (n : Nat) : Nodup (iota n) :=
-  (pairwise_gt_iota n).imp Nat.ne_of_gt
-
-/-! ### enumFrom -/
-
-@[simp]
-theorem enumFrom_singleton (x : α) (n : Nat) : enumFrom n [x] = [(n, x)] :=
-  rfl
-
-@[simp]
-theorem enumFrom_eq_nil {n : Nat} {l : List α} : List.enumFrom n l = [] ↔ l = [] := by
-  cases l <;> simp
-
-@[simp] theorem enumFrom_length : ∀ {n} {l : List α}, (enumFrom n l).length = l.length
-  | _, [] => rfl
-  | _, _ :: _ => congrArg Nat.succ enumFrom_length
-
-@[simp]
-theorem getElem?_enumFrom :
-    ∀ n (l : List α) m, (enumFrom n l)[m]? = l[m]?.map fun a => (n + m, a)
-  | n, [], m => rfl
-  | n, a :: l, 0 => by simp
-  | n, a :: l, m + 1 => by
-    simp only [enumFrom_cons, getElem?_cons_succ]
-    exact (getElem?_enumFrom (n + 1) l m).trans <| by rw [Nat.add_right_comm]; rfl
-
-@[simp]
-theorem getElem_enumFrom (l : List α) (n) (i : Nat) (h : i < (l.enumFrom n).length) :
-    (l.enumFrom n)[i] = (n + i, l[i]'(by simpa [enumFrom_length] using h)) := by
-  simp only [enumFrom_length] at h
-  rw [getElem_eq_getElem?]
-  simp only [getElem?_enumFrom, getElem?_eq_getElem h]
-  simp
-
-theorem mk_add_mem_enumFrom_iff_getElem? {n i : Nat} {x : α} {l : List α} :
-    (n + i, x) ∈ enumFrom n l ↔ l[i]? = some x := by
-  simp [mem_iff_get?]
-
-theorem mk_mem_enumFrom_iff_le_and_getElem?_sub {n i : Nat} {x : α} {l : List α} :
-    (i, x) ∈ enumFrom n l ↔ n ≤ i ∧ l[i - n]? = x := by
-  if h : n ≤ i then
-    rcases Nat.exists_eq_add_of_le h with ⟨i, rfl⟩
-    simp [mk_add_mem_enumFrom_iff_getElem?, Nat.add_sub_cancel_left]
-  else
-    have : ∀ k, n + k ≠ i := by rintro k rfl; simp at h
-    simp [h, mem_iff_get?, this]
-
-theorem le_fst_of_mem_enumFrom {x : Nat × α} {n : Nat} {l : List α} (h : x ∈ enumFrom n l) :
-    n ≤ x.1 :=
-  (mk_mem_enumFrom_iff_le_and_getElem?_sub.1 h).1
-
-theorem fst_lt_add_of_mem_enumFrom {x : Nat × α} {n : Nat} {l : List α} (h : x ∈ enumFrom n l) :
-    x.1 < n + length l := by
-  rcases mem_iff_get.1 h with ⟨i, rfl⟩
-  simpa using i.isLt
-
-theorem map_enumFrom (f : α → β) (n : Nat) (l : List α) :
-    map (Prod.map id f) (enumFrom n l) = enumFrom n (map f l) := by
-  induction l generalizing n <;> simp_all
-
-@[simp]
-theorem enumFrom_map_fst (n) :
-    ∀ (l : List α), map Prod.fst (enumFrom n l) = range' n l.length
-  | [] => rfl
-  | _ :: _ => congrArg (cons _) (enumFrom_map_fst _ _)
-
-@[simp]
-theorem enumFrom_map_snd : ∀ (n) (l : List α), map Prod.snd (enumFrom n l) = l
-  | _, [] => rfl
-  | _, _ :: _ => congrArg (cons _) (enumFrom_map_snd _ _)
-
-theorem snd_mem_of_mem_enumFrom {x : Nat × α} {n : Nat} {l : List α} (h : x ∈ enumFrom n l) : x.2 ∈ l :=
-  enumFrom_map_snd n l ▸ mem_map_of_mem _ h
-
-theorem mem_enumFrom {x : α} {i j : Nat} (xs : List α) (h : (i, x) ∈ xs.enumFrom j) :
-    j ≤ i ∧ i < j + xs.length ∧ x ∈ xs :=
-  ⟨le_fst_of_mem_enumFrom h, fst_lt_add_of_mem_enumFrom h, snd_mem_of_mem_enumFrom h⟩
-
-theorem map_fst_add_enumFrom_eq_enumFrom (l : List α) (n k : Nat) :
-    map (Prod.map (· + n) id) (enumFrom k l) = enumFrom (n + k) l :=
-  ext_getElem? fun i ↦ by simp [(· ∘ ·), Nat.add_comm, Nat.add_left_comm]; rfl
-
-theorem map_fst_add_enum_eq_enumFrom (l : List α) (n : Nat) :
-    map (Prod.map (· + n) id) (enum l) = enumFrom n l :=
-  map_fst_add_enumFrom_eq_enumFrom l _ _
-
-theorem enumFrom_cons' (n : Nat) (x : α) (xs : List α) :
-    enumFrom n (x :: xs) = (n, x) :: (enumFrom n xs).map (Prod.map (· + 1) id) := by
-  rw [enumFrom_cons, Nat.add_comm, ← map_fst_add_enumFrom_eq_enumFrom]
-
-theorem enumFrom_map (n : Nat) (l : List α) (f : α → β) :
-    enumFrom n (l.map f) = (enumFrom n l).map (Prod.map id f) := by
-  induction l with
-  | nil => rfl
-  | cons hd tl IH =>
-    rw [map_cons, enumFrom_cons', enumFrom_cons', map_cons, map_map, IH, map_map]
-    rfl
-
-theorem enumFrom_append (xs ys : List α) (n : Nat) :
-    enumFrom n (xs ++ ys) = enumFrom n xs ++ enumFrom (n + xs.length) ys := by
-  induction xs generalizing ys n with
-  | nil => simp
-  | cons x xs IH =>
-    rw [cons_append, enumFrom_cons, IH, ← cons_append, ← enumFrom_cons, length, Nat.add_right_comm,
-      Nat.add_assoc]
-
-theorem enumFrom_eq_zip_range' (l : List α) {n : Nat} : l.enumFrom n = (range' n l.length).zip l :=
-  zip_of_prod (enumFrom_map_fst _ _) (enumFrom_map_snd _ _)
-
-@[simp]
-theorem unzip_enumFrom_eq_prod (l : List α) {n : Nat} :
-    (l.enumFrom n).unzip = (range' n l.length, l) := by
-  simp only [enumFrom_eq_zip_range', unzip_zip, length_range']
-
-/-! ### enum -/
-
-theorem enum_cons : (a::as).enum = (0, a) :: as.enumFrom 1 := rfl
-
-theorem enum_cons' (x : α) (xs : List α) :
-    enum (x :: xs) = (0, x) :: (enum xs).map (Prod.map (· + 1) id) :=
-  enumFrom_cons' _ _ _
-
-@[simp]
-theorem enum_eq_nil {l : List α} : List.enum l = [] ↔ l = [] := enumFrom_eq_nil
-
-@[simp] theorem enum_singleton (x : α) : enum [x] = [(0, x)] := rfl
-
-@[simp] theorem enum_length : (enum l).length = l.length :=
-  enumFrom_length
-
-@[simp]
-theorem getElem?_enum (l : List α) (n : Nat) : (enum l)[n]? = l[n]?.map fun a => (n, a) := by
-  rw [enum, getElem?_enumFrom, Nat.zero_add]
-
-@[simp]
-theorem getElem_enum (l : List α) (i : Nat) (h : i < l.enum.length) :
-    l.enum[i] = (i, l[i]'(by simpa [enum_length] using h)) := by
-  simp [enum]
-
-theorem mk_mem_enum_iff_getElem? {i : Nat} {x : α} {l : List α} : (i, x) ∈ enum l ↔ l[i]? = x := by
-  simp [enum, mk_mem_enumFrom_iff_le_and_getElem?_sub]
-
-theorem mem_enum_iff_getElem? {x : Nat × α} {l : List α} : x ∈ enum l ↔ l[x.1]? = some x.2 :=
-  mk_mem_enum_iff_getElem?
-
-theorem fst_lt_of_mem_enum {x : Nat × α} {l : List α} (h : x ∈ enum l) : x.1 < length l := by
-  simpa using fst_lt_add_of_mem_enumFrom h
-
-theorem snd_mem_of_mem_enum {x : Nat × α} {l : List α} (h : x ∈ enum l) : x.2 ∈ l :=
-  snd_mem_of_mem_enumFrom h
-
-theorem map_enum (f : α → β) (l : List α) : map (Prod.map id f) (enum l) = enum (map f l) :=
-  map_enumFrom f 0 l
-
-@[simp] theorem enum_map_fst (l : List α) : map Prod.fst (enum l) = range l.length := by
-  simp only [enum, enumFrom_map_fst, range_eq_range']
-
-@[simp]
-theorem enum_map_snd (l : List α) : map Prod.snd (enum l) = l :=
-  enumFrom_map_snd _ _
-
-theorem enum_map (l : List α) (f : α → β) : (l.map f).enum = l.enum.map (Prod.map id f) :=
-  enumFrom_map _ _ _
-
-theorem enum_append (xs ys : List α) : enum (xs ++ ys) = enum xs ++ enumFrom xs.length ys := by
-  simp [enum, enumFrom_append]
-
-theorem enum_eq_zip_range (l : List α) : l.enum = (range l.length).zip l :=
-  zip_of_prod (enum_map_fst _) (enum_map_snd _)
-
-@[simp]
-theorem unzip_enum_eq_prod (l : List α) : l.enum.unzip = (range l.length, l) := by
-  simp only [enum_eq_zip_range, unzip_zip, length_range]
-
-end List

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

@@ -1,503 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.Zip
-import Init.Data.Nat.Lemmas
-
-/-!
-# Further lemmas about `List.take`, `List.drop`, `List.zip` and `List.zipWith`.
-
-These are in a separate file from most of the list lemmas
-as they required importing more lemmas about natural numbers, and use `omega`.
--/
-
-namespace List
-
-open Nat
-
-/-! ### take -/
-
-@[simp] theorem length_take : ∀ (i : Nat) (l : List α), length (take i l) = min i (length l)
-  | 0, l => by simp [Nat.zero_min]
-  | succ n, [] => by simp [Nat.min_zero]
-  | succ n, _ :: l => by simp [Nat.succ_min_succ, length_take]
-
-theorem length_take_le (n) (l : List α) : length (take n l) ≤ n := by simp [Nat.min_le_left]
-
-theorem length_take_le' (n) (l : List α) : length (take n l) ≤ l.length :=
-  by simp [Nat.min_le_right]
-
-theorem length_take_of_le (h : n ≤ length l) : length (take n l) = n := by simp [Nat.min_eq_left h]
-
-/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
-length `> i`. Version designed to rewrite from the big list to the small list. -/
-theorem getElem_take (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
-    L[i] = (L.take j)[i]'(length_take .. ▸ Nat.lt_min.mpr ⟨hj, hi⟩) :=
-  getElem_of_eq (take_append_drop j L).symm _ ▸ getElem_append ..
-
-/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
-length `> i`. Version designed to rewrite from the small list to the big list. -/
-theorem getElem_take' (L : List α) {j i : Nat} {h : i < (L.take j).length} :
-    (L.take j)[i] =
-    L[i]'(Nat.lt_of_lt_of_le h (length_take_le' _ _)) := by
-  rw [length_take, Nat.lt_min] at h; rw [getElem_take L _ h.1]
-
-/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
-length `> i`. Version designed to rewrite from the big list to the small list. -/
-@[deprecated getElem_take (since := "2024-06-12")]
-theorem get_take (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
-    get L ⟨i, hi⟩ = get (L.take j) ⟨i, length_take .. ▸ Nat.lt_min.mpr ⟨hj, hi⟩⟩ := by
-  simp [getElem_take _ hi hj]
-
-/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
-length `> i`. Version designed to rewrite from the small list to the big list. -/
-@[deprecated getElem_take (since := "2024-06-12")]
-theorem get_take' (L : List α) {j i} :
-    get (L.take j) i =
-    get L ⟨i.1, Nat.lt_of_lt_of_le i.2 (length_take_le' _ _)⟩ := by
-  simp [getElem_take']
-
-theorem getElem?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
-    (l.take n)[m]? = none :=
-  getElem?_eq_none <| Nat.le_trans (length_take_le _ _) h
-
-@[deprecated getElem?_take_eq_none (since := "2024-06-12")]
-theorem get?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
-    (l.take n).get? m = none := by
-  simp [getElem?_take_eq_none h]
-
-theorem getElem?_take_eq_if {l : List α} {n m : Nat} :
-    (l.take n)[m]? = if m < n then l[m]? else none := by
-  split
-  · next h => exact getElem?_take h
-  · next h => exact getElem?_take_eq_none (Nat.le_of_not_lt h)
-
-@[deprecated getElem?_take_eq_if (since := "2024-06-12")]
-theorem get?_take_eq_if {l : List α} {n m : Nat} :
-    (l.take n).get? m = if m < n then l.get? m else none := by
-  simp [getElem?_take_eq_if]
-
-theorem head?_take {l : List α} {n : Nat} :
-    (l.take n).head? = if n = 0 then none else l.head? := by
-  simp [head?_eq_getElem?, getElem?_take_eq_if]
-  split
-  · rw [if_neg (by omega)]
-  · rw [if_pos (by omega)]
-
-theorem head_take {l : List α} {n : Nat} (h : l.take n ≠ []) :
-    (l.take n).head h = l.head (by simp_all) := by
-  apply Option.some_inj.1
-  rw [← head?_eq_head, ← head?_eq_head, head?_take, if_neg]
-  simp_all
-
-theorem getLast?_take {l : List α} : (l.take n).getLast? = if n = 0 then none else l[n - 1]?.or l.getLast? := by
-  rw [getLast?_eq_getElem?, getElem?_take_eq_if, length_take]
-  split
-  · rw [if_neg (by omega)]
-    rw [Nat.min_def]
-    split
-    · rw [getElem?_eq_getElem (by omega)]
-      simp
-    · rw [← getLast?_eq_getElem?, getElem?_eq_none (by omega)]
-      simp
-  · rw [if_pos]
-    omega
-
-theorem getLast_take {l : List α} (h : l.take n ≠ []) :
-    (l.take n).getLast h = l[n - 1]?.getD (l.getLast (by simp_all)) := by
-  rw [getLast_eq_getElem, getElem_take']
-  simp [length_take, Nat.min_def]
-  simp at h
-  split
-  · rw [getElem?_eq_getElem (by omega)]
-    simp
-  · rw [getElem?_eq_none (by omega), getLast_eq_getElem]
-    simp
-
-theorem take_take : ∀ (n m) (l : List α), take n (take m l) = take (min n m) l
-  | n, 0, l => by rw [Nat.min_zero, take_zero, take_nil]
-  | 0, m, l => by rw [Nat.zero_min, take_zero, take_zero]
-  | succ n, succ m, nil => by simp only [take_nil]
-  | succ n, succ m, a :: l => by
-    simp only [take, succ_min_succ, take_take n m l]
-
-theorem take_set_of_lt (a : α) {n m : Nat} (l : List α) (h : m < n) :
-    (l.set n a).take m = l.take m :=
-  List.ext_getElem? fun i => by
-    rw [getElem?_take_eq_if, getElem?_take_eq_if]
-    split
-    · next h' => rw [getElem?_set_ne (by omega)]
-    · rfl
-
-@[simp] theorem take_replicate (a : α) : ∀ n m : Nat, take n (replicate m a) = replicate (min n m) a
-  | n, 0 => by simp [Nat.min_zero]
-  | 0, m => by simp [Nat.zero_min]
-  | succ n, succ m => by simp [replicate_succ, succ_min_succ, take_replicate]
-
-@[simp] theorem drop_replicate (a : α) : ∀ n m : Nat, drop n (replicate m a) = replicate (m - n) a
-  | n, 0 => by simp
-  | 0, m => by simp
-  | succ n, succ m => by simp [replicate_succ, succ_sub_succ, drop_replicate]
-
-/-- Taking the first `n` elements in `l₁ ++ l₂` is the same as appending the first `n` elements
-of `l₁` to the first `n - l₁.length` elements of `l₂`. -/
-theorem take_append_eq_append_take {l₁ l₂ : List α} {n : Nat} :
-    take n (l₁ ++ l₂) = take n l₁ ++ take (n - l₁.length) l₂ := by
-  induction l₁ generalizing n
-  · simp
-  · cases n
-    · simp [*]
-    · simp only [cons_append, take_succ_cons, length_cons, succ_eq_add_one, cons.injEq,
-        append_cancel_left_eq, true_and, *]
-      congr 1
-      omega
-
-theorem take_append_of_le_length {l₁ l₂ : List α} {n : Nat} (h : n ≤ l₁.length) :
-    (l₁ ++ l₂).take n = l₁.take n := by
-  simp [take_append_eq_append_take, Nat.sub_eq_zero_of_le h]
-
-/-- Taking the first `l₁.length + i` elements in `l₁ ++ l₂` is the same as appending the first
-`i` elements of `l₂` to `l₁`. -/
-theorem take_append {l₁ l₂ : List α} (i : Nat) :
-    take (l₁.length + i) (l₁ ++ l₂) = l₁ ++ take i l₂ := by
-  rw [take_append_eq_append_take, take_of_length_le (Nat.le_add_right _ _), Nat.add_sub_cancel_left]
-
-@[simp]
-theorem take_eq_take :
-    ∀ {l : List α} {m n : Nat}, l.take m = l.take n ↔ min m l.length = min n l.length
-  | [], m, n => by simp [Nat.min_zero]
-  | _ :: xs, 0, 0 => by simp
-  | x :: xs, m + 1, 0 => by simp [Nat.zero_min, succ_min_succ]
-  | x :: xs, 0, n + 1 => by simp [Nat.zero_min, succ_min_succ]
-  | x :: xs, m + 1, n + 1 => by simp [succ_min_succ, take_eq_take]
-
-theorem take_add (l : List α) (m n : Nat) : l.take (m + n) = l.take m ++ (l.drop m).take n := by
-  suffices take (m + n) (take m l ++ drop m l) = take m l ++ take n (drop m l) by
-    rw [take_append_drop] at this
-    assumption
-  rw [take_append_eq_append_take, take_of_length_le, append_right_inj]
-  · simp only [take_eq_take, length_take, length_drop]
-    omega
-  apply Nat.le_trans (m := m)
-  · apply length_take_le
-  · apply Nat.le_add_right
-
-theorem dropLast_take {n : Nat} {l : List α} (h : n < l.length) :
-    (l.take n).dropLast = l.take (n - 1) := by
-  simp only [dropLast_eq_take, length_take, Nat.le_of_lt h, Nat.min_eq_left, take_take, sub_le]
-
-theorem map_eq_append_split {f : α → β} {l : List α} {s₁ s₂ : List β}
-    (h : map f l = s₁ ++ s₂) : ∃ l₁ l₂, l = l₁ ++ l₂ ∧ map f l₁ = s₁ ∧ map f l₂ = s₂ := by
-  have := h
-  rw [← take_append_drop (length s₁) l] at this ⊢
-  rw [map_append] at this
-  refine ⟨_, _, rfl, append_inj this ?_⟩
-  rw [length_map, length_take, Nat.min_eq_left]
-  rw [← length_map l f, h, length_append]
-  apply Nat.le_add_right
-
-/-! ### drop -/
-
-theorem lt_length_drop (L : List α) {i j : Nat} (h : i + j < L.length) : j < (L.drop i).length := by
-  have A : i < L.length := Nat.lt_of_le_of_lt (Nat.le.intro rfl) h
-  rw [(take_append_drop i L).symm] at h
-  simpa only [Nat.le_of_lt A, Nat.min_eq_left, Nat.add_lt_add_iff_left, length_take,
-    length_append] using h
-
-/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
-dropping the first `i` elements. Version designed to rewrite from the big list to the small list. -/
-theorem getElem_drop (L : List α) {i j : Nat} (h : i + j < L.length) :
-    L[i + j] = (L.drop i)[j]'(lt_length_drop L h) := by
-  have : i ≤ L.length := Nat.le_trans (Nat.le_add_right _ _) (Nat.le_of_lt h)
-  rw [getElem_of_eq (take_append_drop i L).symm h, getElem_append_right'] <;>
-    simp [Nat.min_eq_left this, Nat.add_sub_cancel_left, Nat.le_add_right]
-
-/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
-dropping the first `i` elements. Version designed to rewrite from the big list to the small list. -/
-@[deprecated getElem_drop (since := "2024-06-12")]
-theorem get_drop (L : List α) {i j : Nat} (h : i + j < L.length) :
-    get L ⟨i + j, h⟩ = get (L.drop i) ⟨j, lt_length_drop L h⟩ := by
-  simp [getElem_drop]
-
-/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
-dropping the first `i` elements. Version designed to rewrite from the small list to the big list. -/
-theorem getElem_drop' (L : List α) {i : Nat} {j : Nat} {h : j < (L.drop i).length} :
-    (L.drop i)[j] = L[i + j]'(by
-      rw [Nat.add_comm]
-      exact Nat.add_lt_of_lt_sub (length_drop i L ▸ h)) := by
-  rw [getElem_drop]
-
-/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
-dropping the first `i` elements. Version designed to rewrite from the small list to the big list. -/
-@[deprecated getElem_drop' (since := "2024-06-12")]
-theorem get_drop' (L : List α) {i j} :
-    get (L.drop i) j = get L ⟨i + j, by
-      rw [Nat.add_comm]
-      exact Nat.add_lt_of_lt_sub (length_drop i L ▸ j.2)⟩ := by
-  simp [getElem_drop']
-
-@[simp]
-theorem getElem?_drop (L : List α) (i j : Nat) : (L.drop i)[j]? = L[i + j]? := by
-  ext
-  simp only [getElem?_eq_some, getElem_drop', Option.mem_def]
-  constructor <;> intro ⟨h, ha⟩
-  · exact ⟨_, ha⟩
-  · refine ⟨?_, ha⟩
-    rw [length_drop]
-    rw [Nat.add_comm] at h
-    apply Nat.lt_sub_of_add_lt h
-
-@[deprecated getElem?_drop (since := "2024-06-12")]
-theorem get?_drop (L : List α) (i j : Nat) : get? (L.drop i) j = get? L (i + j) := by
-  simp
-
-theorem head?_drop (l : List α) (n : Nat) :
-    (l.drop n).head? = l[n]? := by
-  rw [head?_eq_getElem?, getElem?_drop, Nat.add_zero]
-
-theorem head_drop {l : List α} {n : Nat} (h : l.drop n ≠ []) :
-    (l.drop n).head h = l[n]'(by simp_all) := by
-  have w : n < l.length := length_lt_of_drop_ne_nil h
-  simpa [head?_eq_head, getElem?_eq_getElem, h, w] using head?_drop l n
-
-theorem getLast?_drop {l : List α} : (l.drop n).getLast? = if l.length ≤ n then none else l.getLast? := by
-  rw [getLast?_eq_getElem?, getElem?_drop]
-  rw [length_drop]
-  split
-  · rw [getElem?_eq_none (by omega)]
-  · rw [getLast?_eq_getElem?]
-    congr
-    omega
-
-theorem getLast_drop {l : List α} (h : l.drop n ≠ []) :
-    (l.drop n).getLast h = l.getLast (ne_nil_of_length_pos (by simp at h; omega)) := by
-  simp only [ne_eq, drop_eq_nil_iff_le] at h
-  apply Option.some_inj.1
-  simp only [← getLast?_eq_getLast, getLast?_drop, ite_eq_right_iff]
-  omega
-
-theorem drop_length_cons {l : List α} (h : l ≠ []) (a : α) :
-    (a :: l).drop l.length = [l.getLast h] := by
-  induction l generalizing a with
-  | nil =>
-    cases h rfl
-  | cons y l ih =>
-    simp only [drop, length]
-    by_cases h₁ : l = []
-    · simp [h₁]
-    rw [getLast_cons h₁]
-    exact ih h₁ y
-
-/-- Dropping the elements up to `n` in `l₁ ++ l₂` is the same as dropping the elements up to `n`
-in `l₁`, dropping the elements up to `n - l₁.length` in `l₂`, and appending them. -/
-theorem drop_append_eq_append_drop {l₁ l₂ : List α} {n : Nat} :
-    drop n (l₁ ++ l₂) = drop n l₁ ++ drop (n - l₁.length) l₂ := by
-  induction l₁ generalizing n
-  · simp
-  · cases n
-    · simp [*]
-    · simp only [cons_append, drop_succ_cons, length_cons, succ_eq_add_one, append_cancel_left_eq, *]
-      congr 1
-      omega
-
-theorem drop_append_of_le_length {l₁ l₂ : List α} {n : Nat} (h : n ≤ l₁.length) :
-    (l₁ ++ l₂).drop n = l₁.drop n ++ l₂ := by
-  simp [drop_append_eq_append_drop, Nat.sub_eq_zero_of_le h]
-
-/-- Dropping the elements up to `l₁.length + i` in `l₁ + l₂` is the same as dropping the elements
-up to `i` in `l₂`. -/
-@[simp]
-theorem drop_append {l₁ l₂ : List α} (i : Nat) : drop (l₁.length + i) (l₁ ++ l₂) = drop i l₂ := by
-  rw [drop_append_eq_append_drop, drop_eq_nil_of_le] <;>
-    simp [Nat.add_sub_cancel_left, Nat.le_add_right]
-
-theorem set_eq_take_append_cons_drop {l : List α} {n : Nat} {a : α} :
-    l.set n a = if n < l.length then l.take n ++ a :: l.drop (n + 1) else l := by
-  split <;> rename_i h
-  · ext1 m
-    by_cases h' : m < n
-    · rw [getElem?_append (by simp [length_take]; omega), getElem?_set_ne (by omega),
-        getElem?_take h']
-    · by_cases h'' : m = n
-      · subst h''
-        rw [getElem?_set_eq ‹_›, getElem?_append_right, length_take,
-          Nat.min_eq_left (by omega), Nat.sub_self, getElem?_cons_zero]
-        rw [length_take]
-        exact Nat.min_le_left m l.length
-      · have h''' : n < m := by omega
-        rw [getElem?_set_ne (by omega), getElem?_append_right, length_take,
-          Nat.min_eq_left (by omega)]
-        · obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_lt h'''
-          have p : n + k + 1 - n = k + 1 := by omega
-          rw [p]
-          rw [getElem?_cons_succ, getElem?_drop]
-          congr 1
-          omega
-        · rw [length_take]
-          exact Nat.le_trans (Nat.min_le_left _ _) (by omega)
-  · rw [set_eq_of_length_le]
-    omega
-
-theorem exists_of_set {n : Nat} {a' : α} {l : List α} (h : n < l.length) :
-    ∃ l₁ l₂, l = l₁ ++ l[n] :: l₂ ∧ l₁.length = n ∧ l.set n a' = l₁ ++ a' :: l₂ := by
-  refine ⟨l.take n, l.drop (n + 1), ⟨by simp, ⟨length_take_of_le (Nat.le_of_lt h), ?_⟩⟩⟩
-  simp [set_eq_take_append_cons_drop, h]
-
-theorem drop_set_of_lt (a : α) {n m : Nat} (l : List α)
-    (hnm : n < m) : drop m (l.set n a) = l.drop m :=
-  ext_getElem? fun k => by simpa only [getElem?_drop] using getElem?_set_ne (by omega)
-
-theorem drop_take : ∀ (m n : Nat) (l : List α), drop n (take m l) = take (m - n) (drop n l)
-  | 0, _, _ => by simp
-  | _, 0, _ => by simp
-  | _, _, [] => by simp
-  | m+1, n+1, h :: t => by
-    simp [take_succ_cons, drop_succ_cons, drop_take m n t]
-    congr 1
-    omega
-
-theorem take_reverse {α} {xs : List α} {n : Nat} (h : n ≤ xs.length) :
-    xs.reverse.take n = (xs.drop (xs.length - n)).reverse := by
-  induction xs generalizing n <;>
-    simp only [reverse_cons, drop, reverse_nil, Nat.zero_sub, length, take_nil]
-  next xs_hd xs_tl xs_ih =>
-  cases Nat.lt_or_eq_of_le h with
-  | inl h' =>
-    have h' := Nat.le_of_succ_le_succ h'
-    rw [take_append_of_le_length, xs_ih h']
-    rw [show xs_tl.length + 1 - n = succ (xs_tl.length - n) from _, drop]
-    · rwa [succ_eq_add_one, Nat.sub_add_comm]
-    · rwa [length_reverse]
-  | inr h' =>
-    subst h'
-    rw [length, Nat.sub_self, drop]
-    suffices xs_tl.length + 1 = (xs_tl.reverse ++ [xs_hd]).length by
-      rw [this, take_length, reverse_cons]
-    rw [length_append, length_reverse]
-    rfl
-
-@[deprecated (since := "2024-06-15")] abbrev reverse_take := @take_reverse
-
-theorem drop_reverse {α} {xs : List α} {n : Nat} (h : n ≤ xs.length) :
-    xs.reverse.drop n = (xs.take (xs.length - n)).reverse := by
-  conv =>
-    rhs
-    rw [← reverse_reverse xs]
-  rw [← reverse_reverse xs] at h
-  generalize xs.reverse = xs' at h ⊢
-  rw [take_reverse]
-  · simp only [length_reverse, reverse_reverse] at *
-    congr
-    omega
-  · simp only [length_reverse, sub_le]
-
-/-! ### rotateLeft -/
-
-@[simp] theorem rotateLeft_replicate (n) (a : α) : rotateLeft (replicate m a) n = replicate m a := by
-  cases n with
-  | zero => simp
-  | succ n =>
-    suffices 1 < m → m - (n + 1) % m + min ((n + 1) % m) m = m by
-      simpa [rotateLeft]
-    intro h
-    rw [Nat.min_eq_left (Nat.le_of_lt (Nat.mod_lt _ (by omega)))]
-    have : (n + 1) % m < m := Nat.mod_lt _ (by omega)
-    omega
-
-/-! ### rotateRight -/
-
-@[simp] theorem rotateRight_replicate (n) (a : α) : rotateRight (replicate m a) n = replicate m a := by
-  cases n with
-  | zero => simp
-  | succ n =>
-    suffices 1 < m → m - (m - (n + 1) % m) + min (m - (n + 1) % m) m = m by
-      simpa [rotateRight]
-    intro h
-    have : (n + 1) % m < m := Nat.mod_lt _ (by omega)
-    rw [Nat.min_eq_left (by omega)]
-    omega
-
-/-! ### zipWith -/
-
-@[simp] theorem length_zipWith (f : α → β → γ) (l₁ l₂) :
-    length (zipWith f l₁ l₂) = min (length l₁) (length l₂) := by
-  induction l₁ generalizing l₂ <;> cases l₂ <;>
-    simp_all [succ_min_succ, Nat.zero_min, Nat.min_zero]
-
-theorem lt_length_left_of_zipWith {f : α → β → γ} {i : Nat} {l : List α} {l' : List β}
-    (h : i < (zipWith f l l').length) : i < l.length := by rw [length_zipWith] at h; omega
-
-theorem lt_length_right_of_zipWith {f : α → β → γ} {i : Nat} {l : List α} {l' : List β}
-    (h : i < (zipWith f l l').length) : i < l'.length := by rw [length_zipWith] at h; omega
-
-@[simp]
-theorem getElem_zipWith {f : α → β → γ} {l : List α} {l' : List β}
-    {i : Nat} {h : i < (zipWith f l l').length} :
-    (zipWith f l l')[i] =
-      f (l[i]'(lt_length_left_of_zipWith h))
-        (l'[i]'(lt_length_right_of_zipWith h)) := by
-  rw [← Option.some_inj, ← getElem?_eq_getElem, getElem?_zipWith_eq_some]
-  exact
-    ⟨l[i]'(lt_length_left_of_zipWith h), l'[i]'(lt_length_right_of_zipWith h),
-      by rw [getElem?_eq_getElem], by rw [getElem?_eq_getElem]; exact ⟨rfl, rfl⟩⟩
-
-theorem zipWith_eq_zipWith_take_min : ∀ (l₁ : List α) (l₂ : List β),
-    zipWith f l₁ l₂ = zipWith f (l₁.take (min l₁.length l₂.length)) (l₂.take (min l₁.length l₂.length))
-  | [], _ => by simp
-  | _, [] => by simp
-  | a :: l₁, b :: l₂ => by simp [succ_min_succ, zipWith_eq_zipWith_take_min l₁ l₂]
-
-theorem reverse_zipWith (h : l.length = l'.length) :
-    (zipWith f l l').reverse = zipWith f l.reverse l'.reverse := by
-  induction l generalizing l' with
-  | nil => simp
-  | cons hd tl hl =>
-    cases l' with
-    | nil => simp
-    | cons hd' tl' =>
-      simp only [Nat.add_right_cancel_iff, length] at h
-      have : tl.reverse.length = tl'.reverse.length := by simp [h]
-      simp [hl h, zipWith_append _ _ _ _ _ this]
-
-@[deprecated reverse_zipWith (since := "2024-07-28")] abbrev zipWith_distrib_reverse := @reverse_zipWith
-
-@[simp] theorem zipWith_replicate {a : α} {b : β} {m n : Nat} :
-    zipWith f (replicate m a) (replicate n b) = replicate (min m n) (f a b) := by
-  rw [zipWith_eq_zipWith_take_min]
-  simp
-
-/-! ### zip -/
-
-@[simp] theorem length_zip (l₁ : List α) (l₂ : List β) :
-    length (zip l₁ l₂) = min (length l₁) (length l₂) := by
-  simp [zip]
-
-theorem lt_length_left_of_zip {i : Nat} {l : List α} {l' : List β} (h : i < (zip l l').length) :
-    i < l.length :=
-  lt_length_left_of_zipWith h
-
-theorem lt_length_right_of_zip {i : Nat} {l : List α} {l' : List β} (h : i < (zip l l').length) :
-    i < l'.length :=
-  lt_length_right_of_zipWith h
-
-@[simp]
-theorem getElem_zip {l : List α} {l' : List β} {i : Nat} {h : i < (zip l l').length} :
-    (zip l l')[i] =
-      (l[i]'(lt_length_left_of_zip h), l'[i]'(lt_length_right_of_zip h)) :=
-  getElem_zipWith (h := h)
-
-theorem zip_eq_zip_take_min : ∀ (l₁ : List α) (l₂ : List β),
-    zip l₁ l₂ = zip (l₁.take (min l₁.length l₂.length)) (l₂.take (min l₁.length l₂.length))
-  | [], _ => by simp
-  | _, [] => by simp
-  | a :: l₁, b :: l₂ => by simp [succ_min_succ, zip_eq_zip_take_min l₁ l₂]
-
-@[simp] theorem zip_replicate {a : α} {b : β} {m n : Nat} :
-    zip (replicate m a) (replicate n b) = replicate (min m n) (a, b) := by
-  rw [zip_eq_zip_take_min]
-  simp
-
-end List

src/Init/Data/List/Pairwise.lean

@@ -1,269 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.Sublist
-
-/-!
-# Lemmas about `List.Pairwise` and `List.Nodup`.
--/
-
-namespace List
-
-open Nat
-
-/-! ## Pairwise and Nodup -/
-
-/-! ### Pairwise -/
-
-theorem Pairwise.sublist : l₁ <+ l₂ → l₂.Pairwise R → l₁.Pairwise R
-  | .slnil, h => h
-  | .cons _ s, .cons _ h₂ => h₂.sublist s
-  | .cons₂ _ s, .cons h₁ h₂ => (h₂.sublist s).cons fun _ h => h₁ _ (s.subset h)
-
-theorem Pairwise.imp {α R S} (H : ∀ {a b}, R a b → S a b) :
-    ∀ {l : List α}, l.Pairwise R → l.Pairwise S
-  | _, .nil => .nil
-  | _, .cons h₁ h₂ => .cons (H ∘ h₁ ·) (h₂.imp H)
-
-theorem rel_of_pairwise_cons (p : (a :: l).Pairwise R) : ∀ {a'}, a' ∈ l → R a a' :=
-  (pairwise_cons.1 p).1 _
-
-theorem Pairwise.of_cons (p : (a :: l).Pairwise R) : Pairwise R l :=
-  (pairwise_cons.1 p).2
-
-theorem Pairwise.tail : ∀ {l : List α} (_p : Pairwise R l), Pairwise R l.tail
-  | [], h => h
-  | _ :: _, h => h.of_cons
-
-theorem Pairwise.imp_of_mem {S : α → α → Prop}
-    (H : ∀ {a b}, a ∈ l → b ∈ l → R a b → S a b) (p : Pairwise R l) : Pairwise S l := by
-  induction p with
-  | nil => constructor
-  | @cons a l r _ ih =>
-    constructor
-    · exact fun x h => H (mem_cons_self ..) (mem_cons_of_mem _ h) <| r x h
-    · exact ih fun m m' => H (mem_cons_of_mem _ m) (mem_cons_of_mem _ m')
-
-theorem Pairwise.and (hR : Pairwise R l) (hS : Pairwise S l) :
-    l.Pairwise fun a b => R a b ∧ S a b := by
-  induction hR with
-  | nil => simp only [Pairwise.nil]
-  | cons R1 _ IH =>
-    simp only [Pairwise.nil, pairwise_cons] at hS ⊢
-    exact ⟨fun b bl => ⟨R1 b bl, hS.1 b bl⟩, IH hS.2⟩
-
-theorem pairwise_and_iff : l.Pairwise (fun a b => R a b ∧ S a b) ↔ Pairwise R l ∧ Pairwise S l :=
-  ⟨fun h => ⟨h.imp fun h => h.1, h.imp fun h => h.2⟩, fun ⟨hR, hS⟩ => hR.and hS⟩
-
-theorem Pairwise.imp₂ (H : ∀ a b, R a b → S a b → T a b)
-    (hR : Pairwise R l) (hS : l.Pairwise S) : l.Pairwise T :=
-  (hR.and hS).imp fun ⟨h₁, h₂⟩ => H _ _ h₁ h₂
-
-theorem Pairwise.iff_of_mem {S : α → α → Prop} {l : List α}
-    (H : ∀ {a b}, a ∈ l → b ∈ l → (R a b ↔ S a b)) : Pairwise R l ↔ Pairwise S l :=
-  ⟨Pairwise.imp_of_mem fun m m' => (H m m').1, Pairwise.imp_of_mem fun m m' => (H m m').2⟩
-
-theorem Pairwise.iff {S : α → α → Prop} (H : ∀ a b, R a b ↔ S a b) {l : List α} :
-    Pairwise R l ↔ Pairwise S l :=
-  Pairwise.iff_of_mem fun _ _ => H ..
-
-theorem pairwise_of_forall {l : List α} (H : ∀ x y, R x y) : Pairwise R l := by
-  induction l <;> simp [*]
-
-theorem Pairwise.and_mem {l : List α} :
-    Pairwise R l ↔ Pairwise (fun x y => x ∈ l ∧ y ∈ l ∧ R x y) l :=
-  Pairwise.iff_of_mem <| by simp (config := { contextual := true })
-
-theorem Pairwise.imp_mem {l : List α} :
-    Pairwise R l ↔ Pairwise (fun x y => x ∈ l → y ∈ l → R x y) l :=
-  Pairwise.iff_of_mem <| by simp (config := { contextual := true })
-
-theorem Pairwise.forall_of_forall_of_flip (h₁ : ∀ x ∈ l, R x x) (h₂ : Pairwise R l)
-    (h₃ : l.Pairwise (flip R)) : ∀ ⦃x⦄, x ∈ l → ∀ ⦃y⦄, y ∈ l → R x y := by
-  induction l with
-  | nil => exact forall_mem_nil _
-  | cons a l ih =>
-    rw [pairwise_cons] at h₂ h₃
-    simp only [mem_cons]
-    rintro x (rfl | hx) y (rfl | hy)
-    · exact h₁ _ (l.mem_cons_self _)
-    · exact h₂.1 _ hy
-    · exact h₃.1 _ hx
-    · exact ih (fun x hx => h₁ _ <| mem_cons_of_mem _ hx) h₂.2 h₃.2 hx hy
-
-theorem pairwise_singleton (R) (a : α) : Pairwise R [a] := by simp
-
-theorem pairwise_pair {a b : α} : Pairwise R [a, b] ↔ R a b := by simp
-
-theorem pairwise_map {l : List α} :
-    (l.map f).Pairwise R ↔ l.Pairwise fun a b => R (f a) (f b) := by
-  induction l
-  · simp
-  · simp only [map, pairwise_cons, forall_mem_map, *]
-
-theorem Pairwise.of_map {S : β → β → Prop} (f : α → β) (H : ∀ a b : α, S (f a) (f b) → R a b)
-    (p : Pairwise S (map f l)) : Pairwise R l :=
-  (pairwise_map.1 p).imp (H _ _)
-
-theorem Pairwise.map {S : β → β → Prop} (f : α → β) (H : ∀ a b : α, R a b → S (f a) (f b))
-    (p : Pairwise R l) : Pairwise S (map f l) :=
-  pairwise_map.2 <| p.imp (H _ _)
-
-theorem pairwise_filterMap (f : β → Option α) {l : List β} :
-    Pairwise R (filterMap f l) ↔ Pairwise (fun a a' : β => ∀ b ∈ f a, ∀ b' ∈ f a', R b b') l := by
-  let _S (a a' : β) := ∀ b ∈ f a, ∀ b' ∈ f a', R b b'
-  simp only [Option.mem_def]
-  induction l with
-  | nil => simp only [filterMap, Pairwise.nil]
-  | cons a l IH => ?_
-  match e : f a with
-  | none =>
-    rw [filterMap_cons_none e, pairwise_cons]
-    simp only [e, false_implies, implies_true, true_and, IH]
-  | some b =>
-    rw [filterMap_cons_some e]
-    simpa [IH, e] using fun _ =>
-      ⟨fun h a ha b hab => h _ _ ha hab, fun h a b ha hab => h _ ha _ hab⟩
-
-theorem Pairwise.filterMap {S : β → β → Prop} (f : α → Option β)
-    (H : ∀ a a' : α, R a a' → ∀ b ∈ f a, ∀ b' ∈ f a', S b b') {l : List α} (p : Pairwise R l) :
-    Pairwise S (filterMap f l) :=
-  (pairwise_filterMap _).2 <| p.imp (H _ _)
-
-@[deprecated Pairwise.filterMap (since := "2024-07-29")] abbrev Pairwise.filter_map := @Pairwise.filterMap
-
-theorem pairwise_filter (p : α → Prop) [DecidablePred p] {l : List α} :
-    Pairwise R (filter p l) ↔ Pairwise (fun x y => p x → p y → R x y) l := by
-  rw [← filterMap_eq_filter, pairwise_filterMap]
-  simp
-
-theorem Pairwise.filter (p : α → Bool) : Pairwise R l → Pairwise R (filter p l) :=
-  Pairwise.sublist (filter_sublist _)
-
-theorem pairwise_append {l₁ l₂ : List α} :
-    (l₁ ++ l₂).Pairwise R ↔ l₁.Pairwise R ∧ l₂.Pairwise R ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b := by
-  induction l₁ <;> simp [*, or_imp, forall_and, and_assoc, and_left_comm]
-
-theorem pairwise_append_comm {R : α → α → Prop} (s : ∀ {x y}, R x y → R y x) {l₁ l₂ : List α} :
-    Pairwise R (l₁ ++ l₂) ↔ Pairwise R (l₂ ++ l₁) := by
-  have (l₁ l₂ : List α) (H : ∀ x : α, x ∈ l₁ → ∀ y : α, y ∈ l₂ → R x y)
-    (x : α) (xm : x ∈ l₂) (y : α) (ym : y ∈ l₁) : R x y := s (H y ym x xm)
-  simp only [pairwise_append, and_left_comm]; rw [Iff.intro (this l₁ l₂) (this l₂ l₁)]
-
-theorem pairwise_middle {R : α → α → Prop} (s : ∀ {x y}, R x y → R y x) {a : α} {l₁ l₂ : List α} :
-    Pairwise R (l₁ ++ a :: l₂) ↔ Pairwise R (a :: (l₁ ++ l₂)) := by
-  show Pairwise R (l₁ ++ ([a] ++ l₂)) ↔ Pairwise R ([a] ++ l₁ ++ l₂)
-  rw [← append_assoc, pairwise_append, @pairwise_append _ _ ([a] ++ l₁), pairwise_append_comm s]
-  simp only [mem_append, or_comm]
-
-theorem pairwise_join {L : List (List α)} :
-    Pairwise R (join L) ↔
-      (∀ l ∈ L, Pairwise R l) ∧ Pairwise (fun l₁ l₂ => ∀ x ∈ l₁, ∀ y ∈ l₂, R x y) L := by
-  induction L with
-  | nil => simp
-  | cons l L IH =>
-    simp only [join, pairwise_append, IH, mem_join, exists_imp, and_imp, forall_mem_cons,
-      pairwise_cons, and_assoc, and_congr_right_iff]
-    rw [and_comm, and_congr_left_iff]
-    intros; exact ⟨fun h a b c d e => h c d e a b, fun h c d e a b => h a b c d e⟩
-
-theorem pairwise_bind {R : β → β → Prop} {l : List α} {f : α → List β} :
-    List.Pairwise R (l.bind f) ↔
-      (∀ a ∈ l, Pairwise R (f a)) ∧ Pairwise (fun a₁ a₂ => ∀ x ∈ f a₁, ∀ y ∈ f a₂, R x y) l := by
-  simp [List.bind, pairwise_join, pairwise_map]
-
-theorem pairwise_reverse {l : List α} :
-    l.reverse.Pairwise R ↔ l.Pairwise (fun a b => R b a) := by
-  induction l <;> simp [*, pairwise_append, and_comm]
-
-@[simp] theorem pairwise_replicate {n : Nat} {a : α} :
-    (replicate n a).Pairwise R ↔ n ≤ 1 ∨ R a a := by
-  induction n with
-  | zero => simp
-  | succ n ih =>
-    simp only [replicate_succ, pairwise_cons, mem_replicate, ne_eq, and_imp,
-      forall_eq_apply_imp_iff, ih]
-    constructor
-    · rintro ⟨h, h' | h'⟩
-      · by_cases w : n = 0
-        · left
-          subst w
-          simp
-        · right
-          exact h w
-      · right
-        exact h'
-    · rintro (h | h)
-      · obtain rfl := eq_zero_of_le_zero (le_of_lt_succ h)
-        simp
-      · exact ⟨fun _ => h, Or.inr h⟩
-
-theorem Pairwise.drop {l : List α} {n : Nat} (h : List.Pairwise R l) : List.Pairwise R (l.drop n) :=
-  h.sublist (drop_sublist _ _)
-
-theorem Pairwise.take {l : List α} {n : Nat} (h : List.Pairwise R l) : List.Pairwise R (l.take n) :=
-  h.sublist (take_sublist _ _)
-
-theorem pairwise_iff_forall_sublist : l.Pairwise R ↔ (∀ {a b}, [a,b] <+ l → R a b) := by
-  induction l with
-  | nil => simp
-  | cons hd tl IH =>
-    rw [List.pairwise_cons]
-    constructor <;> intro h
-    · intro
-      | a, b, .cons _ hab => exact IH.mp h.2 hab
-      | _, b, .cons₂ _ hab => refine h.1 _ (hab.subset ?_); simp
-    · constructor
-      · intro x hx
-        apply h
-        rw [List.cons_sublist_cons, List.singleton_sublist]
-        exact hx
-      · apply IH.mpr
-        intro a b hab
-        apply h; exact hab.cons _
-
-/-! ### Nodup -/
-
-@[simp]
-theorem nodup_nil : @Nodup α [] :=
-  Pairwise.nil
-
-@[simp]
-theorem nodup_cons {a : α} {l : List α} : Nodup (a :: l) ↔ a ∉ l ∧ Nodup l := by
-  simp only [Nodup, pairwise_cons, forall_mem_ne]
-
-theorem Nodup.sublist : l₁ <+ l₂ → Nodup l₂ → Nodup l₁ :=
-  Pairwise.sublist
-
-theorem Sublist.nodup : l₁ <+ l₂ → Nodup l₂ → Nodup l₁ :=
-  Nodup.sublist
-
-theorem getElem?_inj {xs : List α}
-    (h₀ : i < xs.length) (h₁ : Nodup xs) (h₂ : xs[i]? = xs[j]?) : i = j := by
-  induction xs generalizing i j with
-  | nil => cases h₀
-  | cons x xs ih =>
-    match i, j with
-    | 0, 0 => rfl
-    | i+1, j+1 =>
-      cases h₁ with
-      | cons ha h₁ =>
-        simp only [getElem?_cons_succ] at h₂
-        exact congrArg (· + 1) (ih (Nat.lt_of_succ_lt_succ h₀) h₁ h₂)
-    | i+1, 0 => ?_
-    | 0, j+1 => ?_
-    all_goals
-      simp only [get?_eq_getElem?, getElem?_cons_zero, getElem?_cons_succ] at h₂
-      cases h₁; rename_i h' h
-      have := h x ?_ rfl; cases this
-      rw [mem_iff_get?]
-      simp only [get?_eq_getElem?]
-    exact ⟨_, h₂⟩; exact ⟨_ , h₂.symm⟩
-
-@[simp] theorem nodup_replicate {n : Nat} {a : α} :
-    (replicate n a).Nodup ↔ n ≤ 1 := by simp [Nodup]
-
-end List

src/Init/Data/List/Sublist.lean

@@ -1,754 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.TakeDrop
-
-/-!
-# Lemmas about `List.Subset`, `List.Sublist`, `List.IsPrefix`, `List.IsSuffix`, and `List.IsInfix`.
--/
-
-namespace List
-
-open Nat
-
-/-! ### isPrefixOf -/
-section isPrefixOf
-variable [BEq α]
-
-@[simp] theorem isPrefixOf_cons₂_self [LawfulBEq α] {a : α} :
-    isPrefixOf (a::as) (a::bs) = isPrefixOf as bs := by simp [isPrefixOf_cons₂]
-
-@[simp] theorem isPrefixOf_length_pos_nil {L : List α} (h : 0 < L.length) : isPrefixOf L [] = false := by
-  cases L <;> simp_all [isPrefixOf]
-
-@[simp] theorem isPrefixOf_replicate {a : α} :
-    isPrefixOf l (replicate n a) = (decide (l.length ≤ n) && l.all (· == a)) := by
-  induction l generalizing n with
-  | nil => simp
-  | cons h t ih =>
-    cases n
-    · simp
-    · simp [replicate_succ, isPrefixOf_cons₂, ih, Nat.succ_le_succ_iff, Bool.and_left_comm]
-
-end isPrefixOf
-
-/-! ### isSuffixOf -/
-section isSuffixOf
-variable [BEq α]
-
-@[simp] theorem isSuffixOf_cons_nil : isSuffixOf (a::as) ([] : List α) = false := by
-  simp [isSuffixOf]
-
-@[simp] theorem isSuffixOf_replicate {a : α} :
-    isSuffixOf l (replicate n a) = (decide (l.length ≤ n) && l.all (· == a)) := by
-  simp [isSuffixOf, all_eq]
-
-end isSuffixOf
-
-/-! ### Subset -/
-
-/-! ### List subset -/
-
-theorem subset_def {l₁ l₂ : List α} : l₁ ⊆ l₂ ↔ ∀ {a : α}, a ∈ l₁ → a ∈ l₂ := .rfl
-
-@[simp] theorem nil_subset (l : List α) : [] ⊆ l := nofun
-
-@[simp] theorem Subset.refl (l : List α) : l ⊆ l := fun _ i => i
-
-theorem Subset.trans {l₁ l₂ l₃ : List α} (h₁ : l₁ ⊆ l₂) (h₂ : l₂ ⊆ l₃) : l₁ ⊆ l₃ :=
-  fun _ i => h₂ (h₁ i)
-
-instance : Trans (Membership.mem : α → List α → Prop) Subset Membership.mem :=
-  ⟨fun h₁ h₂ => h₂ h₁⟩
-
-instance : Trans (Subset : List α → List α → Prop) Subset Subset :=
-  ⟨Subset.trans⟩
-
-@[simp] theorem subset_cons_self (a : α) (l : List α) : l ⊆ a :: l := fun _ => Mem.tail _
-
-theorem subset_of_cons_subset {a : α} {l₁ l₂ : List α} : a :: l₁ ⊆ l₂ → l₁ ⊆ l₂ :=
-  fun s _ i => s (mem_cons_of_mem _ i)
-
-theorem subset_cons_of_subset (a : α) {l₁ l₂ : List α} : l₁ ⊆ l₂ → l₁ ⊆ a :: l₂ :=
-  fun s _ i => .tail _ (s i)
-
-theorem cons_subset_cons {l₁ l₂ : List α} (a : α) (s : l₁ ⊆ l₂) : a :: l₁ ⊆ a :: l₂ :=
-  fun _ => by simp only [mem_cons]; exact Or.imp_right (@s _)
-
-@[simp] theorem cons_subset : a :: l ⊆ m ↔ a ∈ m ∧ l ⊆ m := by
-  simp only [subset_def, mem_cons, or_imp, forall_and, forall_eq]
-
-@[simp] theorem subset_nil {l : List α} : l ⊆ [] ↔ l = [] :=
-  ⟨fun h => match l with | [] => rfl | _::_ => (nomatch h (.head ..)), fun | rfl => Subset.refl _⟩
-
-theorem map_subset {l₁ l₂ : List α} (f : α → β) (h : l₁ ⊆ l₂) : map f l₁ ⊆ map f l₂ :=
-  fun x => by simp only [mem_map]; exact .imp fun a => .imp_left (@h _)
-
-theorem filter_subset {l₁ l₂ : List α} (p : α → Bool) (H : l₁ ⊆ l₂) : filter p l₁ ⊆ filter p l₂ :=
-  fun x => by simp_all [mem_filter, subset_def.1 H]
-
-theorem filterMap_subset {l₁ l₂ : List α} (f : α → Option β) (H : l₁ ⊆ l₂) :
-    filterMap f l₁ ⊆ filterMap f l₂ := by
-  intro x
-  simp only [mem_filterMap]
-  rintro ⟨a, h, w⟩
-  exact ⟨a, H h, w⟩
-
-@[simp] theorem subset_append_left (l₁ l₂ : List α) : l₁ ⊆ l₁ ++ l₂ := fun _ => mem_append_left _
-
-@[simp] theorem subset_append_right (l₁ l₂ : List α) : l₂ ⊆ l₁ ++ l₂ := fun _ => mem_append_right _
-
-theorem subset_append_of_subset_left (l₂ : List α) : l ⊆ l₁ → l ⊆ l₁ ++ l₂ :=
-fun s => Subset.trans s <| subset_append_left _ _
-
-theorem subset_append_of_subset_right (l₁ : List α) : l ⊆ l₂ → l ⊆ l₁ ++ l₂ :=
-fun s => Subset.trans s <| subset_append_right _ _
-
-@[simp] theorem append_subset {l₁ l₂ l : List α} :
-    l₁ ++ l₂ ⊆ l ↔ l₁ ⊆ l ∧ l₂ ⊆ l := by simp [subset_def, or_imp, forall_and]
-
-theorem replicate_subset {n : Nat} {a : α} {l : List α} : replicate n a ⊆ l ↔ n = 0 ∨ a ∈ l := by
-  induction n with
-  | zero => simp
-  | succ n ih => simp (config := {contextual := true}) [replicate_succ, ih, cons_subset]
-
-theorem subset_replicate {n : Nat} {a : α} {l : List α} (h : n ≠ 0) : l ⊆ replicate n a ↔ ∀ x ∈ l, x = a := by
-  induction l with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [cons_subset, mem_replicate, ne_eq, ih, mem_cons, forall_eq_or_imp,
-      and_congr_left_iff, and_iff_right_iff_imp]
-    solve_by_elim
-
-@[simp] theorem reverse_subset {l₁ l₂ : List α} : reverse l₁ ⊆ l₂ ↔ l₁ ⊆ l₂ := by
-  simp [subset_def]
-
-@[simp] theorem subset_reverse {l₁ l₂ : List α} : l₁ ⊆ reverse l₂ ↔ l₁ ⊆ l₂ := by
-  simp [subset_def]
-
-/-! ### Sublist and isSublist -/
-
-@[simp] theorem nil_sublist : ∀ l : List α, [] <+ l
-  | [] => .slnil
-  | a :: l => (nil_sublist l).cons a
-
-@[simp] theorem Sublist.refl : ∀ l : List α, l <+ l
-  | [] => .slnil
-  | a :: l => (Sublist.refl l).cons₂ a
-
-theorem Sublist.trans {l₁ l₂ l₃ : List α} (h₁ : l₁ <+ l₂) (h₂ : l₂ <+ l₃) : l₁ <+ l₃ := by
-  induction h₂ generalizing l₁ with
-  | slnil => exact h₁
-  | cons _ _ IH => exact (IH h₁).cons _
-  | @cons₂ l₂ _ a _ IH =>
-    generalize e : a :: l₂ = l₂'
-    match e ▸ h₁ with
-    | .slnil => apply nil_sublist
-    | .cons a' h₁' => cases e; apply (IH h₁').cons
-    | .cons₂ a' h₁' => cases e; apply (IH h₁').cons₂
-
-instance : Trans (@Sublist α) Sublist Sublist := ⟨Sublist.trans⟩
-
-@[simp] theorem sublist_cons_self (a : α) (l : List α) : l <+ a :: l := (Sublist.refl l).cons _
-
-theorem sublist_of_cons_sublist : a :: l₁ <+ l₂ → l₁ <+ l₂ :=
-  (sublist_cons_self a l₁).trans
-
-@[simp]
-theorem cons_sublist_cons : a :: l₁ <+ a :: l₂ ↔ l₁ <+ l₂ :=
-  ⟨fun | .cons _ s => sublist_of_cons_sublist s | .cons₂ _ s => s, .cons₂ _⟩
-
-theorem sublist_or_mem_of_sublist (h : l <+ l₁ ++ a :: l₂) : l <+ l₁ ++ l₂ ∨ a ∈ l := by
-  induction l₁ generalizing l with
-  | nil => match h with
-    | .cons _ h => exact .inl h
-    | .cons₂ _ h => exact .inr (.head ..)
-  | cons b l₁ IH =>
-    match h with
-    | .cons _ h => exact (IH h).imp_left (Sublist.cons _)
-    | .cons₂ _ h => exact (IH h).imp (Sublist.cons₂ _) (.tail _)
-
-theorem Sublist.subset : l₁ <+ l₂ → l₁ ⊆ l₂
-  | .slnil, _, h => h
-  | .cons _ s, _, h => .tail _ (s.subset h)
-  | .cons₂ .., _, .head .. => .head ..
-  | .cons₂ _ s, _, .tail _ h => .tail _ (s.subset h)
-
-instance : Trans (@Sublist α) Subset Subset :=
-  ⟨fun h₁ h₂ => trans h₁.subset h₂⟩
-
-instance : Trans Subset (@Sublist α) Subset :=
-  ⟨fun h₁ h₂ => trans h₁ h₂.subset⟩
-
-instance : Trans (Membership.mem : α → List α → Prop) Sublist Membership.mem :=
-  ⟨fun h₁ h₂ => h₂.subset h₁⟩
-
-theorem mem_of_cons_sublist {a : α} {l₁ l₂ : List α} (s : a :: l₁ <+ l₂) : a ∈ l₂ :=
-  (cons_subset.1 s.subset).1
-
-@[simp] theorem sublist_nil {l : List α} : l <+ [] ↔ l = [] :=
-  ⟨fun s => subset_nil.1 s.subset, fun H => H ▸ Sublist.refl _⟩
-
-theorem Sublist.length_le : l₁ <+ l₂ → length l₁ ≤ length l₂
-  | .slnil => Nat.le_refl 0
-  | .cons _l s => le_succ_of_le (length_le s)
-  | .cons₂ _ s => succ_le_succ (length_le s)
-
-theorem Sublist.eq_of_length : l₁ <+ l₂ → length l₁ = length l₂ → l₁ = l₂
-  | .slnil, _ => rfl
-  | .cons a s, h => nomatch Nat.not_lt.2 s.length_le (h ▸ lt_succ_self _)
-  | .cons₂ a s, h => by rw [s.eq_of_length (succ.inj h)]
-
-theorem Sublist.eq_of_length_le (s : l₁ <+ l₂) (h : length l₂ ≤ length l₁) : l₁ = l₂ :=
-  s.eq_of_length <| Nat.le_antisymm s.length_le h
-
-theorem Sublist.length_eq (s : l₁ <+ l₂) : length l₁ = length l₂ ↔ l₁ = l₂ :=
-  ⟨s.eq_of_length, congrArg _⟩
-
-protected theorem Sublist.map (f : α → β) {l₁ l₂} (s : l₁ <+ l₂) : map f l₁ <+ map f l₂ := by
-  induction s with
-  | slnil => simp
-  | cons a s ih =>
-    simpa using cons (f a) ih
-  | cons₂ a s ih =>
-    simpa using cons₂ (f a) ih
-
-protected theorem Sublist.filterMap (f : α → Option β) (s : l₁ <+ l₂) :
-    filterMap f l₁ <+ filterMap f l₂ := by
-  induction s <;> simp [filterMap_cons] <;> split <;> simp [*, cons, cons₂]
-
-protected theorem Sublist.filter (p : α → Bool) {l₁ l₂} (s : l₁ <+ l₂) : filter p l₁ <+ filter p l₂ := by
-  rw [← filterMap_eq_filter]; apply s.filterMap
-
-theorem sublist_filterMap_iff {l₁ : List β} {f : α → Option β} :
-    l₁ <+ l₂.filterMap f ↔ ∃ l', l' <+ l₂ ∧ l₁ = l'.filterMap f := by
-  induction l₂ generalizing l₁ with
-  | nil => simp
-  | cons a l₂ ih =>
-    simp only [filterMap_cons]
-    split
-    · simp only [ih]
-      constructor
-      · rintro ⟨l', h, rfl⟩
-        exact ⟨l', Sublist.cons a h, rfl⟩
-      · rintro ⟨l', h, rfl⟩
-        cases h with
-        | cons _ h =>
-          exact ⟨l', h, rfl⟩
-        | cons₂ _ h =>
-          rename_i l'
-          exact ⟨l', h, by simp_all⟩
-    · constructor
-      · intro w
-        cases w with
-        | cons _ h =>
-          obtain ⟨l', s, rfl⟩ := ih.1 h
-          exact ⟨l', Sublist.cons a s, rfl⟩
-        | cons₂ _ h =>
-          rename_i l'
-          obtain ⟨l', s, rfl⟩ := ih.1 h
-          refine ⟨a :: l', Sublist.cons₂ a s, ?_⟩
-          rwa [filterMap_cons_some]
-      · rintro ⟨l', h, rfl⟩
-        replace h := h.filterMap f
-        rwa [filterMap_cons_some] at h
-        assumption
-
-theorem sublist_map_iff {l₁ : List β} {f : α → β} :
-    l₁ <+ l₂.map f ↔ ∃ l', l' <+ l₂ ∧ l₁ = l'.map f := by
-  simp only [← filterMap_eq_map, sublist_filterMap_iff]
-
-theorem sublist_filter_iff {l₁ : List α} {p : α → Bool} :
-    l₁ <+ l₂.filter p ↔ ∃ l', l' <+ l₂ ∧ l₁ = l'.filter p := by
-  simp only [← filterMap_eq_filter, sublist_filterMap_iff]
-
-@[simp] theorem sublist_append_left : ∀ l₁ l₂ : List α, l₁ <+ l₁ ++ l₂
-  | [], _ => nil_sublist _
-  | _ :: l₁, l₂ => (sublist_append_left l₁ l₂).cons₂ _
-
-@[simp] theorem sublist_append_right : ∀ l₁ l₂ : List α, l₂ <+ l₁ ++ l₂
-  | [], _ => Sublist.refl _
-  | _ :: l₁, l₂ => (sublist_append_right l₁ l₂).cons _
-
-@[simp] theorem singleton_sublist {a : α} {l} : [a] <+ l ↔ a ∈ l := by
-  refine ⟨fun h => h.subset (mem_singleton_self _), fun h => ?_⟩
-  obtain ⟨_, _, rfl⟩ := append_of_mem h
-  exact ((nil_sublist _).cons₂ _).trans (sublist_append_right ..)
-
-theorem sublist_append_of_sublist_left (s : l <+ l₁) : l <+ l₁ ++ l₂ :=
-  s.trans <| sublist_append_left ..
-
-theorem sublist_append_of_sublist_right (s : l <+ l₂) : l <+ l₁ ++ l₂ :=
-  s.trans <| sublist_append_right ..
-
-@[simp] theorem append_sublist_append_left : ∀ l, l ++ l₁ <+ l ++ l₂ ↔ l₁ <+ l₂
-  | [] => Iff.rfl
-  | _ :: l => cons_sublist_cons.trans (append_sublist_append_left l)
-
-theorem Sublist.append_left : l₁ <+ l₂ → ∀ l, l ++ l₁ <+ l ++ l₂ :=
-  fun h l => (append_sublist_append_left l).mpr h
-
-theorem Sublist.append_right : l₁ <+ l₂ → ∀ l, l₁ ++ l <+ l₂ ++ l
-  | .slnil, _ => Sublist.refl _
-  | .cons _ h, _ => (h.append_right _).cons _
-  | .cons₂ _ h, _ => (h.append_right _).cons₂ _
-
-theorem Sublist.append (hl : l₁ <+ l₂) (hr : r₁ <+ r₂) : l₁ ++ r₁ <+ l₂ ++ r₂ :=
-  (hl.append_right _).trans ((append_sublist_append_left _).2 hr)
-
-theorem sublist_cons_iff {a : α} {l l'} :
-    l <+ a :: l' ↔ l <+ l' ∨ ∃ r, l = a :: r ∧ r <+ l' := by
-  constructor
-  · intro h
-    cases h with
-    | cons _ h => exact Or.inl h
-    | cons₂ _ h => exact Or.inr ⟨_, rfl, h⟩
-  · rintro (h | ⟨r, rfl, h⟩)
-    · exact h.cons _
-    · exact h.cons₂ _
-
-theorem cons_sublist_iff {a : α} {l l'} :
-    a :: l <+ l' ↔ ∃ r₁ r₂, l' = r₁ ++ r₂ ∧ a ∈ r₁ ∧ l <+ r₂ := by
-  induction l' with
-  | nil => simp
-  | cons a' l' ih =>
-    constructor
-    · intro w
-      cases w with
-      | cons _ w =>
-        obtain ⟨r₁, r₂, rfl, h₁, h₂⟩ := ih.1 w
-        exact ⟨a' :: r₁, r₂, by simp, mem_cons_of_mem a' h₁, h₂⟩
-      | cons₂ _ w =>
-        exact ⟨[a], l', by simp, mem_singleton_self _, w⟩
-    · rintro ⟨r₁, r₂, w, h₁, h₂⟩
-      rw [w, ← singleton_append]
-      exact Sublist.append (by simpa) h₂
-
-theorem sublist_append_iff {l : List α} :
-    l <+ r₁ ++ r₂ ↔ ∃ l₁ l₂, l = l₁ ++ l₂ ∧ l₁ <+ r₁ ∧ l₂ <+ r₂ := by
-  induction r₁ generalizing l with
-  | nil =>
-    constructor
-    · intro w
-      refine ⟨[], l, by simp_all⟩
-    · rintro ⟨l₁, l₂, rfl, w₁, w₂⟩
-      simp_all
-  | cons r r₁ ih =>
-    constructor
-    · intro w
-      simp only [cons_append] at w
-      cases w with
-      | cons _ w =>
-        obtain ⟨l₁, l₂, rfl, w₁, w₂⟩ := ih.1 w
-        exact ⟨l₁, l₂, rfl, Sublist.cons r w₁, w₂⟩
-      | cons₂ _ w =>
-        rename_i l
-        obtain ⟨l₁, l₂, rfl, w₁, w₂⟩ := ih.1 w
-        refine ⟨r :: l₁, l₂, by simp, cons_sublist_cons.mpr w₁, w₂⟩
-    · rintro ⟨l₁, l₂, rfl, w₁, w₂⟩
-      cases w₁ with
-      | cons _ w₁ =>
-        exact Sublist.cons _ (Sublist.append w₁ w₂)
-      | cons₂ _ w₁ =>
-        rename_i l
-        exact Sublist.cons₂ _ (Sublist.append w₁ w₂)
-
-theorem append_sublist_iff {l₁ l₂ : List α} :
-    l₁ ++ l₂ <+ r ↔ ∃ r₁ r₂, r = r₁ ++ r₂ ∧ l₁ <+ r₁ ∧ l₂ <+ r₂ := by
-  induction l₁ generalizing r with
-  | nil =>
-    constructor
-    · intro w
-      refine ⟨[], r, by simp_all⟩
-    · rintro ⟨r₁, r₂, rfl, -, w₂⟩
-      simp only [nil_append]
-      exact sublist_append_of_sublist_right w₂
-  | cons a l₁ ih =>
-    constructor
-    · rw [cons_append, cons_sublist_iff]
-      rintro ⟨r₁, r₂, rfl, h₁, h₂⟩
-      obtain ⟨s₁, s₂, rfl, t₁, t₂⟩ := ih.1 h₂
-      refine ⟨r₁ ++ s₁, s₂, by simp, ?_, t₂⟩
-      rw [← singleton_append]
-      exact Sublist.append (by simpa) t₁
-    · rintro ⟨r₁, r₂, rfl, h₁, h₂⟩
-      exact Sublist.append h₁ h₂
-
-theorem Sublist.reverse : l₁ <+ l₂ → l₁.reverse <+ l₂.reverse
-  | .slnil => Sublist.refl _
-  | .cons _ h => by rw [reverse_cons]; exact sublist_append_of_sublist_left h.reverse
-  | .cons₂ _ h => by rw [reverse_cons, reverse_cons]; exact h.reverse.append_right _
-
-@[simp] theorem reverse_sublist : l₁.reverse <+ l₂.reverse ↔ l₁ <+ l₂ :=
-  ⟨fun h => l₁.reverse_reverse ▸ l₂.reverse_reverse ▸ h.reverse, Sublist.reverse⟩
-
-theorem sublist_reverse_iff : l₁ <+ l₂.reverse ↔ l₁.reverse <+ l₂ :=
-  by rw [← reverse_sublist, reverse_reverse]
-
-@[simp] theorem append_sublist_append_right (l) : l₁ ++ l <+ l₂ ++ l ↔ l₁ <+ l₂ :=
-  ⟨fun h => by
-    have := h.reverse
-    simp only [reverse_append, append_sublist_append_left, reverse_sublist] at this
-    exact this,
-   fun h => h.append_right l⟩
-
-@[simp] theorem replicate_sublist_replicate {m n} (a : α) :
-    replicate m a <+ replicate n a ↔ m ≤ n := by
-  refine ⟨fun h => ?_, fun h => ?_⟩
-  · have := h.length_le; simp only [length_replicate] at this ⊢; exact this
-  · induction h with
-    | refl => apply Sublist.refl
-    | step => simp [*, replicate, Sublist.cons]
-
-theorem sublist_replicate_iff : l <+ replicate m a ↔ ∃ n, n ≤ m ∧ l = replicate n a := by
-  induction l generalizing m with
-  | nil =>
-    simp only [nil_sublist, true_iff]
-    exact ⟨0, zero_le m, by simp⟩
-  | cons b l ih =>
-    constructor
-    · intro w
-      cases m with
-      | zero => simp at w
-      | succ m =>
-        simp [replicate_succ] at w
-        cases w with
-        | cons _ w =>
-          obtain ⟨n, le, rfl⟩ := ih.1 (sublist_of_cons_sublist w)
-          obtain rfl := (mem_replicate.1 (mem_of_cons_sublist w)).2
-          exact ⟨n+1, Nat.add_le_add_right le 1, rfl⟩
-        | cons₂ _ w =>
-          obtain ⟨n, le, rfl⟩ := ih.1 w
-          refine ⟨n+1, Nat.add_le_add_right le 1, by simp [replicate_succ]⟩
-    · rintro ⟨n, le, w⟩
-      rw [w]
-      exact (replicate_sublist_replicate a).2 le
-
-theorem sublist_join_of_mem {L : List (List α)} {l} (h : l ∈ L) : l <+ L.join := by
-  induction L with
-  | nil => cases h
-  | cons l' L ih =>
-    rcases mem_cons.1 h with (rfl | h)
-    · simp [h]
-    · simp [ih h, join_cons, sublist_append_of_sublist_right]
-
-theorem sublist_join_iff {L : List (List α)} {l} :
-    l <+ L.join ↔
-      ∃ L' : List (List α), l = L'.join ∧ ∀ i (_ : i < L'.length), L'[i] <+ L[i]?.getD [] := by
-  induction L generalizing l with
-  | nil =>
-    constructor
-    · intro w
-      simp only [join_nil, sublist_nil] at w
-      subst w
-      exact ⟨[], by simp, fun i x => by cases x⟩
-    · rintro ⟨L', rfl, h⟩
-      simp only [join_nil, sublist_nil, join_eq_nil_iff]
-      simp only [getElem?_nil, Option.getD_none, sublist_nil] at h
-      exact (forall_getElem L' (· = [])).1 h
-  | cons l' L ih =>
-    simp only [join_cons, sublist_append_iff, ih]
-    constructor
-    · rintro ⟨l₁, l₂, rfl, s, L', rfl, h⟩
-      refine ⟨l₁ :: L', by simp, ?_⟩
-      intro i lt
-      cases i <;> simp_all
-    · rintro ⟨L', rfl, h⟩
-      cases L' with
-      | nil =>
-        exact ⟨[], [], by simp, by simp, [], by simp, fun i x => by cases x⟩
-      | cons l₁ L' =>
-        exact ⟨l₁, L'.join, by simp, by simpa using h 0 (by simp), L', rfl,
-          fun i lt => by simpa using h (i+1) (Nat.add_lt_add_right lt 1)⟩
-
-theorem join_sublist_iff {L : List (List α)} {l} :
-    L.join <+ l ↔
-      ∃ L' : List (List α), l = L'.join ∧ ∀ i (_ : i < L.length), L[i] <+ L'[i]?.getD [] := by
-  induction L generalizing l with
-  | nil =>
-    constructor
-    · intro _
-      exact ⟨[l], by simp, fun i x => by cases x⟩
-    · rintro ⟨L', rfl, _⟩
-      simp only [join_nil, nil_sublist]
-  | cons l' L ih =>
-    simp only [join_cons, append_sublist_iff, ih]
-    constructor
-    · rintro ⟨l₁, l₂, rfl, s, L', rfl, h⟩
-      refine ⟨l₁ :: L', by simp, ?_⟩
-      intro i lt
-      cases i <;> simp_all
-    · rintro ⟨L', rfl, h⟩
-      cases L' with
-      | nil =>
-        exact ⟨[], [], by simp, by simpa using h 0 (by simp), [], by simp,
-          fun i x => by simpa using h (i+1) (Nat.add_lt_add_right x 1)⟩
-      | cons l₁ L' =>
-        exact ⟨l₁, L'.join, by simp, by simpa using h 0 (by simp), L', rfl,
-          fun i lt => by simpa using h (i+1) (Nat.add_lt_add_right lt 1)⟩
-
-@[simp] theorem isSublist_iff_sublist [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
-    l₁.isSublist l₂ ↔ l₁ <+ l₂ := by
-  cases l₁ <;> cases l₂ <;> simp [isSublist]
-  case cons.cons hd₁ tl₁ hd₂ tl₂ =>
-    if h_eq : hd₁ = hd₂ then
-      simp [h_eq, cons_sublist_cons, isSublist_iff_sublist]
-    else
-      simp only [beq_iff_eq, h_eq]
-      constructor
-      · intro h_sub
-        apply Sublist.cons
-        exact isSublist_iff_sublist.mp h_sub
-      · intro h_sub
-        cases h_sub
-        case cons h_sub =>
-          exact isSublist_iff_sublist.mpr h_sub
-        case cons₂ =>
-          contradiction
-
-instance [DecidableEq α] (l₁ l₂ : List α) : Decidable (l₁ <+ l₂) :=
-  decidable_of_iff (l₁.isSublist l₂) isSublist_iff_sublist
-
-/-! ### IsPrefix / IsSuffix / IsInfix -/
-
-@[simp] theorem prefix_append (l₁ l₂ : List α) : l₁ <+: l₁ ++ l₂ := ⟨l₂, rfl⟩
-
-@[simp] theorem suffix_append (l₁ l₂ : List α) : l₂ <:+ l₁ ++ l₂ := ⟨l₁, rfl⟩
-
-theorem infix_append (l₁ l₂ l₃ : List α) : l₂ <:+: l₁ ++ l₂ ++ l₃ := ⟨l₁, l₃, rfl⟩
-
-@[simp] theorem infix_append' (l₁ l₂ l₃ : List α) : l₂ <:+: l₁ ++ (l₂ ++ l₃) := by
-  rw [← List.append_assoc]; apply infix_append
-
-theorem IsPrefix.isInfix : l₁ <+: l₂ → l₁ <:+: l₂ := fun ⟨t, h⟩ => ⟨[], t, h⟩
-
-theorem IsSuffix.isInfix : l₁ <:+ l₂ → l₁ <:+: l₂ := fun ⟨t, h⟩ => ⟨t, [], by rw [h, append_nil]⟩
-
-@[simp] theorem nil_prefix (l : List α) : [] <+: l := ⟨l, rfl⟩
-
-@[simp] theorem nil_suffix (l : List α) : [] <:+ l := ⟨l, append_nil _⟩
-
-@[simp] theorem nil_infix (l : List α) : [] <:+: l := (nil_prefix _).isInfix
-
-@[simp] theorem prefix_refl (l : List α) : l <+: l := ⟨[], append_nil _⟩
-
-@[simp] theorem suffix_refl (l : List α) : l <:+ l := ⟨[], rfl⟩
-
-@[simp] theorem infix_refl (l : List α) : l <:+: l := (prefix_refl l).isInfix
-
-@[simp] theorem suffix_cons (a : α) : ∀ l, l <:+ a :: l := suffix_append [a]
-
-theorem infix_cons : l₁ <:+: l₂ → l₁ <:+: a :: l₂ := fun ⟨L₁, L₂, h⟩ => ⟨a :: L₁, L₂, h ▸ rfl⟩
-
-theorem infix_concat : l₁ <:+: l₂ → l₁ <:+: concat l₂ a := fun ⟨L₁, L₂, h⟩ =>
-  ⟨L₁, concat L₂ a, by simp [← h, concat_eq_append, append_assoc]⟩
-
-theorem IsPrefix.trans : ∀ {l₁ l₂ l₃ : List α}, l₁ <+: l₂ → l₂ <+: l₃ → l₁ <+: l₃
-  | _, _, _, ⟨r₁, rfl⟩, ⟨r₂, rfl⟩ => ⟨r₁ ++ r₂, (append_assoc _ _ _).symm⟩
-
-theorem IsSuffix.trans : ∀ {l₁ l₂ l₃ : List α}, l₁ <:+ l₂ → l₂ <:+ l₃ → l₁ <:+ l₃
-  | _, _, _, ⟨l₁, rfl⟩, ⟨l₂, rfl⟩ => ⟨l₂ ++ l₁, append_assoc _ _ _⟩
-
-theorem IsInfix.trans : ∀ {l₁ l₂ l₃ : List α}, l₁ <:+: l₂ → l₂ <:+: l₃ → l₁ <:+: l₃
-  | l, _, _, ⟨l₁, r₁, rfl⟩, ⟨l₂, r₂, rfl⟩ => ⟨l₂ ++ l₁, r₁ ++ r₂, by simp only [append_assoc]⟩
-
-protected theorem IsInfix.sublist : l₁ <:+: l₂ → l₁ <+ l₂
-  | ⟨_, _, h⟩ => h ▸ (sublist_append_right ..).trans (sublist_append_left ..)
-
-protected theorem IsInfix.subset (hl : l₁ <:+: l₂) : l₁ ⊆ l₂ :=
-  hl.sublist.subset
-
-protected theorem IsPrefix.sublist (h : l₁ <+: l₂) : l₁ <+ l₂ :=
-  h.isInfix.sublist
-
-protected theorem IsPrefix.subset (hl : l₁ <+: l₂) : l₁ ⊆ l₂ :=
-  hl.sublist.subset
-
-protected theorem IsSuffix.sublist (h : l₁ <:+ l₂) : l₁ <+ l₂ :=
-  h.isInfix.sublist
-
-protected theorem IsSuffix.subset (hl : l₁ <:+ l₂) : l₁ ⊆ l₂ :=
-  hl.sublist.subset
-
-@[simp] theorem reverse_suffix : reverse l₁ <:+ reverse l₂ ↔ l₁ <+: l₂ :=
-  ⟨fun ⟨r, e⟩ => ⟨reverse r, by rw [← reverse_reverse l₁, ← reverse_append, e, reverse_reverse]⟩,
-   fun ⟨r, e⟩ => ⟨reverse r, by rw [← reverse_append, e]⟩⟩
-
-@[simp] theorem reverse_prefix : reverse l₁ <+: reverse l₂ ↔ l₁ <:+ l₂ := by
-  rw [← reverse_suffix]; simp only [reverse_reverse]
-
-@[simp] theorem reverse_infix : reverse l₁ <:+: reverse l₂ ↔ l₁ <:+: l₂ := by
-  refine ⟨fun ⟨s, t, e⟩ => ⟨reverse t, reverse s, ?_⟩, fun ⟨s, t, e⟩ => ⟨reverse t, reverse s, ?_⟩⟩
-  · rw [← reverse_reverse l₁, append_assoc, ← reverse_append, ← reverse_append, e,
-      reverse_reverse]
-  · rw [append_assoc, ← reverse_append, ← reverse_append, e]
-
-theorem IsInfix.length_le (h : l₁ <:+: l₂) : l₁.length ≤ l₂.length :=
-  h.sublist.length_le
-
-theorem IsPrefix.length_le (h : l₁ <+: l₂) : l₁.length ≤ l₂.length :=
-  h.sublist.length_le
-
-theorem IsSuffix.length_le (h : l₁ <:+ l₂) : l₁.length ≤ l₂.length :=
-  h.sublist.length_le
-
-@[simp] theorem infix_nil : l <:+: [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ infix_refl _)⟩
-
-@[simp] theorem prefix_nil : l <+: [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ prefix_refl _)⟩
-
-@[simp] theorem suffix_nil : l <:+ [] ↔ l = [] := ⟨(sublist_nil.1 ·.sublist), (· ▸ suffix_refl _)⟩
-
-theorem infix_iff_prefix_suffix (l₁ l₂ : List α) : l₁ <:+: l₂ ↔ ∃ t, l₁ <+: t ∧ t <:+ l₂ :=
-  ⟨fun ⟨_, t, e⟩ => ⟨l₁ ++ t, ⟨_, rfl⟩, e ▸ append_assoc .. ▸ ⟨_, rfl⟩⟩,
-    fun ⟨_, ⟨t, rfl⟩, s, e⟩ => ⟨s, t, append_assoc .. ▸ e⟩⟩
-
-theorem IsInfix.eq_of_length (h : l₁ <:+: l₂) : l₁.length = l₂.length → l₁ = l₂ :=
-  h.sublist.eq_of_length
-
-theorem IsPrefix.eq_of_length (h : l₁ <+: l₂) : l₁.length = l₂.length → l₁ = l₂ :=
-  h.sublist.eq_of_length
-
-theorem IsSuffix.eq_of_length (h : l₁ <:+ l₂) : l₁.length = l₂.length → l₁ = l₂ :=
-  h.sublist.eq_of_length
-
-theorem prefix_of_prefix_length_le :
-    ∀ {l₁ l₂ l₃ : List α}, l₁ <+: l₃ → l₂ <+: l₃ → length l₁ ≤ length l₂ → l₁ <+: l₂
-  | [], l₂, _, _, _, _ => nil_prefix _
-  | a :: l₁, b :: l₂, _, ⟨r₁, rfl⟩, ⟨r₂, e⟩, ll => by
-    injection e with _ e'; subst b
-    rcases prefix_of_prefix_length_le ⟨_, rfl⟩ ⟨_, e'⟩ (le_of_succ_le_succ ll) with ⟨r₃, rfl⟩
-    exact ⟨r₃, rfl⟩
-
-theorem prefix_or_prefix_of_prefix (h₁ : l₁ <+: l₃) (h₂ : l₂ <+: l₃) : l₁ <+: l₂ ∨ l₂ <+: l₁ :=
-  (Nat.le_total (length l₁) (length l₂)).imp (prefix_of_prefix_length_le h₁ h₂)
-    (prefix_of_prefix_length_le h₂ h₁)
-
-theorem suffix_of_suffix_length_le
-    (h₁ : l₁ <:+ l₃) (h₂ : l₂ <:+ l₃) (ll : length l₁ ≤ length l₂) : l₁ <:+ l₂ :=
-  reverse_prefix.1 <|
-    prefix_of_prefix_length_le (reverse_prefix.2 h₁) (reverse_prefix.2 h₂) (by simp [ll])
-
-theorem suffix_or_suffix_of_suffix (h₁ : l₁ <:+ l₃) (h₂ : l₂ <:+ l₃) : l₁ <:+ l₂ ∨ l₂ <:+ l₁ :=
-  (prefix_or_prefix_of_prefix (reverse_prefix.2 h₁) (reverse_prefix.2 h₂)).imp reverse_prefix.1
-    reverse_prefix.1
-
-theorem prefix_cons_iff : l₁ <+: a :: l₂ ↔ l₁ = [] ∨ ∃ t, l₁ = a :: t ∧ t <+: l₂ := by
-  cases l₁ with
-  | nil => simp
-  | cons a' l₁ =>
-    constructor
-    · rintro ⟨t, h⟩
-      simp at h
-      obtain ⟨rfl, rfl⟩ := h
-      exact Or.inr ⟨l₁, rfl, prefix_append l₁ t⟩
-    · rintro (h | ⟨t, w, ⟨s, h'⟩⟩)
-      · simp [h]
-      · simp only [w]
-        refine ⟨s, by simp [h']⟩
-
-@[simp] theorem cons_prefix_cons : a :: l₁ <+: b :: l₂ ↔ a = b ∧ l₁ <+: l₂ := by
-  simp only [prefix_cons_iff, cons.injEq, false_or]
-  constructor
-  · rintro ⟨t, ⟨rfl, rfl⟩, h⟩
-    exact ⟨rfl, h⟩
-  · rintro ⟨rfl, h⟩
-    exact ⟨l₁, ⟨rfl, rfl⟩, h⟩
-
-theorem suffix_cons_iff : l₁ <:+ a :: l₂ ↔ l₁ = a :: l₂ ∨ l₁ <:+ l₂ := by
-  constructor
-  · rintro ⟨⟨hd, tl⟩, hl₃⟩
-    · exact Or.inl hl₃
-    · simp only [cons_append] at hl₃
-      injection hl₃ with _ hl₄
-      exact Or.inr ⟨_, hl₄⟩
-  · rintro (rfl | hl₁)
-    · exact (a :: l₂).suffix_refl
-    · exact hl₁.trans (l₂.suffix_cons _)
-
-theorem infix_cons_iff : l₁ <:+: a :: l₂ ↔ l₁ <+: a :: l₂ ∨ l₁ <:+: l₂ := by
-  constructor
-  · rintro ⟨⟨hd, tl⟩, t, hl₃⟩
-    · exact Or.inl ⟨t, hl₃⟩
-    · simp only [cons_append] at hl₃
-      injection hl₃ with _ hl₄
-      exact Or.inr ⟨_, t, hl₄⟩
-  · rintro (h | hl₁)
-    · exact h.isInfix
-    · exact infix_cons hl₁
-
-theorem infix_of_mem_join : ∀ {L : List (List α)}, l ∈ L → l <:+: join L
-  | l' :: _, h =>
-    match h with
-    | List.Mem.head .. => infix_append [] _ _
-    | List.Mem.tail _ hlMemL =>
-      IsInfix.trans (infix_of_mem_join hlMemL) <| (suffix_append _ _).isInfix
-
-theorem prefix_append_right_inj (l) : l ++ l₁ <+: l ++ l₂ ↔ l₁ <+: l₂ :=
-  exists_congr fun r => by rw [append_assoc, append_right_inj]
-
-@[simp]
-theorem prefix_cons_inj (a) : a :: l₁ <+: a :: l₂ ↔ l₁ <+: l₂ :=
-  prefix_append_right_inj [a]
-
-theorem take_prefix (n) (l : List α) : take n l <+: l :=
-  ⟨_, take_append_drop _ _⟩
-
-theorem drop_suffix (n) (l : List α) : drop n l <:+ l :=
-  ⟨_, take_append_drop _ _⟩
-
-theorem take_sublist (n) (l : List α) : take n l <+ l :=
-  (take_prefix n l).sublist
-
-theorem drop_sublist (n) (l : List α) : drop n l <+ l :=
-  (drop_suffix n l).sublist
-
-theorem take_subset (n) (l : List α) : take n l ⊆ l :=
-  (take_sublist n l).subset
-
-theorem drop_subset (n) (l : List α) : drop n l ⊆ l :=
-  (drop_sublist n l).subset
-
-theorem mem_of_mem_take {l : List α} (h : a ∈ l.take n) : a ∈ l :=
-  take_subset n l h
-
-theorem mem_of_mem_drop {n} {l : List α} (h : a ∈ l.drop n) : a ∈ l :=
-  drop_subset _ _ h
-
-theorem IsPrefix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <+: l₂) :
-    l₁.filter p <+: l₂.filter p := by
-  obtain ⟨xs, rfl⟩ := h
-  rw [filter_append]; apply prefix_append
-
-theorem IsSuffix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+ l₂) :
-    l₁.filter p <:+ l₂.filter p := by
-  obtain ⟨xs, rfl⟩ := h
-  rw [filter_append]; apply suffix_append
-
-theorem IsInfix.filter (p : α → Bool) ⦃l₁ l₂ : List α⦄ (h : l₁ <:+: l₂) :
-    l₁.filter p <:+: l₂.filter p := by
-  obtain ⟨xs, ys, rfl⟩ := h
-  rw [filter_append, filter_append]; apply infix_append _
-
-@[simp] theorem isPrefixOf_iff_prefix [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
-    l₁.isPrefixOf l₂ ↔ l₁ <+: l₂ := by
-  induction l₁ generalizing l₂ with
-  | nil => simp
-  | cons a l₁ ih =>
-    cases l₂ with
-    | nil => simp
-    | cons a' l₂ => simp [isPrefixOf, ih]
-
-instance [DecidableEq α] (l₁ l₂ : List α) : Decidable (l₁ <+: l₂) :=
-  decidable_of_iff (l₁.isPrefixOf l₂) isPrefixOf_iff_prefix
-
-@[simp] theorem isSuffixOf_iff_suffix [BEq α] [LawfulBEq α] {l₁ l₂ : List α} :
-    l₁.isSuffixOf l₂ ↔ l₁ <:+ l₂ := by
-  simp [isSuffixOf]
-
-instance [DecidableEq α] (l₁ l₂ : List α) : Decidable (l₁ <:+ l₂) :=
-  decidable_of_iff (l₁.isSuffixOf l₂) isSuffixOf_iff_suffix
-
-end List

src/Init/Data/List/TakeDrop.lean

@@ -5,443 +5,500 @@ Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, M
 -/
 prelude
 import Init.Data.List.Lemmas
+import Init.Data.Nat.Lemmas
 
 /-!
-# Lemmas about `List.zip`, `List.zipWith`, `List.zipWithAll`, and `List.unzip`.
+# Further lemmas about `List.take`, `List.drop`, `List.zip` and `List.zipWith`.
+
+These are in a separate file from most of the list lemmas
+as they required importing more lemmas about natural numbers, and use `omega`.
 -/
 
 namespace List
 
 open Nat
 
-/-! ### take and drop
+/-! ### take -/
 
-Further results on `List.take` and `List.drop`, which rely on stronger automation in `Nat`,
-are given in `Init.Data.List.TakeDrop`.
--/
+@[simp] theorem length_take : ∀ (i : Nat) (l : List α), length (take i l) = min i (length l)
+  | 0, l => by simp [Nat.zero_min]
+  | succ n, [] => by simp [Nat.min_zero]
+  | succ n, _ :: l => by simp [Nat.succ_min_succ, length_take]
+
+theorem length_take_le (n) (l : List α) : length (take n l) ≤ n := by simp [Nat.min_le_left]
+
+theorem length_take_le' (n) (l : List α) : length (take n l) ≤ l.length :=
+  by simp [Nat.min_le_right]
+
+theorem length_take_of_le (h : n ≤ length l) : length (take n l) = n := by simp [Nat.min_eq_left h]
+
+theorem take_take : ∀ (n m) (l : List α), take n (take m l) = take (min n m) l
+  | n, 0, l => by rw [Nat.min_zero, take_zero, take_nil]
+  | 0, m, l => by rw [Nat.zero_min, take_zero, take_zero]
+  | succ n, succ m, nil => by simp only [take_nil]
+  | succ n, succ m, a :: l => by
+    simp only [take, succ_min_succ, take_take n m l]
+
+@[simp] theorem take_replicate (a : α) : ∀ n m : Nat, take n (replicate m a) = replicate (min n m) a
+  | n, 0 => by simp [Nat.min_zero]
+  | 0, m => by simp [Nat.zero_min]
+  | succ n, succ m => by simp [replicate_succ, succ_min_succ, take_replicate]
+
+@[simp] theorem drop_replicate (a : α) : ∀ n m : Nat, drop n (replicate m a) = replicate (m - n) a
+  | n, 0 => by simp
+  | 0, m => by simp
+  | succ n, succ m => by simp [replicate_succ, succ_sub_succ, drop_replicate]
+
+/-- Taking the first `n` elements in `l₁ ++ l₂` is the same as appending the first `n` elements
+of `l₁` to the first `n - l₁.length` elements of `l₂`. -/
+theorem take_append_eq_append_take {l₁ l₂ : List α} {n : Nat} :
+    take n (l₁ ++ l₂) = take n l₁ ++ take (n - l₁.length) l₂ := by
+  induction l₁ generalizing n
+  · simp
+  · cases n
+    · simp [*]
+    · simp only [cons_append, take_cons_succ, length_cons, succ_eq_add_one, cons.injEq,
+        append_cancel_left_eq, true_and, *]
+      congr 1
+      omega
+
+theorem take_append_of_le_length {l₁ l₂ : List α} {n : Nat} (h : n ≤ l₁.length) :
+    (l₁ ++ l₂).take n = l₁.take n := by
+  simp [take_append_eq_append_take, Nat.sub_eq_zero_of_le h]
+
+/-- Taking the first `l₁.length + i` elements in `l₁ ++ l₂` is the same as appending the first
+`i` elements of `l₂` to `l₁`. -/
+theorem take_append {l₁ l₂ : List α} (i : Nat) :
+    take (l₁.length + i) (l₁ ++ l₂) = l₁ ++ take i l₂ := by
+  rw [take_append_eq_append_take, take_all_of_le (Nat.le_add_right _ _), Nat.add_sub_cancel_left]
+
+/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
+length `> i`. Version designed to rewrite from the big list to the small list. -/
+theorem getElem_take (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
+    L[i] = (L.take j)[i]'(length_take .. ▸ Nat.lt_min.mpr ⟨hj, hi⟩) :=
+  getElem_of_eq (take_append_drop j L).symm _ ▸ getElem_append ..
+
+/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
+length `> i`. Version designed to rewrite from the small list to the big list. -/
+theorem getElem_take' (L : List α) {j i : Nat} {h : i < (L.take j).length} :
+    (L.take j)[i] =
+    L[i]'(Nat.lt_of_lt_of_le h (length_take_le' _ _)) := by
+  rw [length_take, Nat.lt_min] at h; rw [getElem_take L _ h.1]
+
+/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
+length `> i`. Version designed to rewrite from the big list to the small list. -/
+@[deprecated getElem_take (since := "2024-06-12")]
+theorem get_take (L : List α) {i j : Nat} (hi : i < L.length) (hj : i < j) :
+    get L ⟨i, hi⟩ = get (L.take j) ⟨i, length_take .. ▸ Nat.lt_min.mpr ⟨hj, hi⟩⟩ := by
+  simp [getElem_take _ hi hj]
+
+/-- The `i`-th element of a list coincides with the `i`-th element of any of its prefixes of
+length `> i`. Version designed to rewrite from the small list to the big list. -/
+@[deprecated getElem_take (since := "2024-06-12")]
+theorem get_take' (L : List α) {j i} :
+    get (L.take j) i =
+    get L ⟨i.1, Nat.lt_of_lt_of_le i.2 (length_take_le' _ _)⟩ := by
+  simp [getElem_take']
+
+theorem getElem?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
+    (l.take n)[m]? = none :=
+  getElem?_eq_none <| Nat.le_trans (length_take_le _ _) h
+
+@[deprecated getElem?_take_eq_none (since := "2024-06-12")]
+theorem get?_take_eq_none {l : List α} {n m : Nat} (h : n ≤ m) :
+    (l.take n).get? m = none := by
+  simp [getElem?_take_eq_none h]
+
+theorem getElem?_take_eq_if {l : List α} {n m : Nat} :
+    (l.take n)[m]? = if m < n then l[m]? else none := by
+  split
+  · next h => exact getElem?_take h
+  · next h => exact getElem?_take_eq_none (Nat.le_of_not_lt h)
+
+@[deprecated getElem?_take_eq_if (since := "2024-06-12")]
+theorem get?_take_eq_if {l : List α} {n m : Nat} :
+    (l.take n).get? m = if m < n then l.get? m else none := by
+  simp [getElem?_take_eq_if]
+
+theorem head?_take {l : List α} {n : Nat} :
+    (l.take n).head? = if n = 0 then none else l.head? := by
+  simp [head?_eq_getElem?, getElem?_take_eq_if]
+  split
+  · rw [if_neg (by omega)]
+  · rw [if_pos (by omega)]
+
+theorem head_take {l : List α} {n : Nat} (h : l.take n ≠ []) :
+    (l.take n).head h = l.head (by simp_all) := by
+  apply Option.some_inj.1
+  rw [← head?_eq_head, ← head?_eq_head, head?_take, if_neg]
+  simp_all
+
+theorem getLast?_take {l : List α} : (l.take n).getLast? = if n = 0 then none else l[n - 1]?.or l.getLast? := by
+  rw [getLast?_eq_getElem?, getElem?_take_eq_if, length_take]
+  split
+  · rw [if_neg (by omega)]
+    rw [Nat.min_def]
+    split
+    · rw [getElem?_eq_getElem (by omega)]
+      simp
+    · rw [← getLast?_eq_getElem?, getElem?_eq_none (by omega)]
+      simp
+  · rw [if_pos]
+    omega
+
+theorem getLast_take {l : List α} (h : l.take n ≠ []) :
+    (l.take n).getLast h = l[n - 1]?.getD (l.getLast (by simp_all)) := by
+  rw [getLast_eq_getElem, getElem_take']
+  simp [length_take, Nat.min_def]
+  simp at h
+  split
+  · rw [getElem?_eq_getElem (by omega)]
+    simp
+  · rw [getElem?_eq_none (by omega), getLast_eq_getElem]
+    simp
 
 @[simp]
-theorem drop_one : ∀ l : List α, drop 1 l = tail l
-  | [] | _ :: _ => rfl
+theorem take_eq_take :
+    ∀ {l : List α} {m n : Nat}, l.take m = l.take n ↔ min m l.length = min n l.length
+  | [], m, n => by simp [Nat.min_zero]
+  | _ :: xs, 0, 0 => by simp
+  | x :: xs, m + 1, 0 => by simp [Nat.zero_min, succ_min_succ]
+  | x :: xs, 0, n + 1 => by simp [Nat.zero_min, succ_min_succ]
+  | x :: xs, m + 1, n + 1 => by simp [succ_min_succ, take_eq_take]; omega
 
-@[simp] theorem take_append_drop : ∀ (n : Nat) (l : List α), take n l ++ drop n l = l
-  | 0, _ => rfl
-  | _+1, [] => rfl
-  | n+1, x :: xs => congrArg (cons x) <| take_append_drop n xs
+theorem take_add (l : List α) (m n : Nat) : l.take (m + n) = l.take m ++ (l.drop m).take n := by
+  suffices take (m + n) (take m l ++ drop m l) = take m l ++ take n (drop m l) by
+    rw [take_append_drop] at this
+    assumption
+  rw [take_append_eq_append_take, take_all_of_le, append_right_inj]
+  · simp only [take_eq_take, length_take, length_drop]
+    omega
+  apply Nat.le_trans (m := m)
+  · apply length_take_le
+  · apply Nat.le_add_right
 
-@[simp] theorem length_drop : ∀ (i : Nat) (l : List α), length (drop i l) = length l - i
-  | 0, _ => rfl
-  | succ i, [] => Eq.symm (Nat.zero_sub (succ i))
-  | succ i, x :: l => calc
-    length (drop (succ i) (x :: l)) = length l - i := length_drop i l
-    _ = succ (length l) - succ i := (Nat.succ_sub_succ_eq_sub (length l) i).symm
+theorem dropLast_take {n : Nat} {l : List α} (h : n < l.length) :
+    (l.take n).dropLast = l.take n.pred := by
+  simp only [dropLast_eq_take, length_take, Nat.le_of_lt h, take_take, pred_le, Nat.min_eq_left]
 
-theorem drop_of_length_le {l : List α} (h : l.length ≤ i) : drop i l = [] :=
-  length_eq_zero.1 (length_drop .. ▸ Nat.sub_eq_zero_of_le h)
+theorem map_eq_append_split {f : α → β} {l : List α} {s₁ s₂ : List β}
+    (h : map f l = s₁ ++ s₂) : ∃ l₁ l₂, l = l₁ ++ l₂ ∧ map f l₁ = s₁ ∧ map f l₂ = s₂ := by
+  have := h
+  rw [← take_append_drop (length s₁) l] at this ⊢
+  rw [map_append] at this
+  refine ⟨_, _, rfl, append_inj this ?_⟩
+  rw [length_map, length_take, Nat.min_eq_left]
+  rw [← length_map l f, h, length_append]
+  apply Nat.le_add_right
 
-theorem length_lt_of_drop_ne_nil {l : List α} {n} (h : drop n l ≠ []) : n < l.length :=
-  gt_of_not_le (mt drop_of_length_le h)
+/-! ### drop -/
 
-theorem take_of_length_le {l : List α} (h : l.length ≤ i) : take i l = l := by
-  have := take_append_drop i l
-  rw [drop_of_length_le h, append_nil] at this; exact this
+theorem drop_length_cons {l : List α} (h : l ≠ []) (a : α) :
+    (a :: l).drop l.length = [l.getLast h] := by
+  induction l generalizing a with
+  | nil =>
+    cases h rfl
+  | cons y l ih =>
+    simp only [drop, length]
+    by_cases h₁ : l = []
+    · simp [h₁]
+    rw [getLast_cons' _ h₁]
+    exact ih h₁ y
 
-theorem lt_length_of_take_ne_self {l : List α} {n} (h : l.take n ≠ l) : n < l.length :=
-  gt_of_not_le (mt take_of_length_le h)
+/-- Dropping the elements up to `n` in `l₁ ++ l₂` is the same as dropping the elements up to `n`
+in `l₁`, dropping the elements up to `n - l₁.length` in `l₂`, and appending them. -/
+theorem drop_append_eq_append_drop {l₁ l₂ : List α} {n : Nat} :
+    drop n (l₁ ++ l₂) = drop n l₁ ++ drop (n - l₁.length) l₂ := by
+  induction l₁ generalizing n
+  · simp
+  · cases n
+    · simp [*]
+    · simp only [cons_append, drop_succ_cons, length_cons, succ_eq_add_one, append_cancel_left_eq, *]
+      congr 1
+      omega
 
-@[deprecated drop_of_length_le (since := "2024-07-07")] abbrev drop_length_le := @drop_of_length_le
-@[deprecated take_of_length_le (since := "2024-07-07")] abbrev take_length_le := @take_of_length_le
+theorem drop_append_of_le_length {l₁ l₂ : List α} {n : Nat} (h : n ≤ l₁.length) :
+    (l₁ ++ l₂).drop n = l₁.drop n ++ l₂ := by
+  simp [drop_append_eq_append_drop, Nat.sub_eq_zero_of_le h]
 
-@[simp] theorem drop_length (l : List α) : drop l.length l = [] := drop_of_length_le (Nat.le_refl _)
 
-@[simp] theorem take_length (l : List α) : take l.length l = l := take_of_length_le (Nat.le_refl _)
+/-- Dropping the elements up to `l₁.length + i` in `l₁ + l₂` is the same as dropping the elements
+up to `i` in `l₂`. -/
+@[simp]
+theorem drop_append {l₁ l₂ : List α} (i : Nat) : drop (l₁.length + i) (l₁ ++ l₂) = drop i l₂ := by
+  rw [drop_append_eq_append_drop, drop_eq_nil_of_le] <;>
+    simp [Nat.add_sub_cancel_left, Nat.le_add_right]
+
+theorem lt_length_drop (L : List α) {i j : Nat} (h : i + j < L.length) : j < (L.drop i).length := by
+  have A : i < L.length := Nat.lt_of_le_of_lt (Nat.le.intro rfl) h
+  rw [(take_append_drop i L).symm] at h
+  simpa only [Nat.le_of_lt A, Nat.min_eq_left, Nat.add_lt_add_iff_left, length_take,
+    length_append] using h
+
+/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
+dropping the first `i` elements. Version designed to rewrite from the big list to the small list. -/
+theorem getElem_drop (L : List α) {i j : Nat} (h : i + j < L.length) :
+    L[i + j] = (L.drop i)[j]'(lt_length_drop L h) := by
+  have : i ≤ L.length := Nat.le_trans (Nat.le_add_right _ _) (Nat.le_of_lt h)
+  rw [getElem_of_eq (take_append_drop i L).symm h, getElem_append_right'] <;>
+    simp [Nat.min_eq_left this, Nat.add_sub_cancel_left, Nat.le_add_right]
+
+/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
+dropping the first `i` elements. Version designed to rewrite from the big list to the small list. -/
+@[deprecated getElem_drop (since := "2024-06-12")]
+theorem get_drop (L : List α) {i j : Nat} (h : i + j < L.length) :
+    get L ⟨i + j, h⟩ = get (L.drop i) ⟨j, lt_length_drop L h⟩ := by
+  simp [getElem_drop]
+
+/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
+dropping the first `i` elements. Version designed to rewrite from the small list to the big list. -/
+theorem getElem_drop' (L : List α) {i : Nat} {j : Nat} {h : j < (L.drop i).length} :
+    (L.drop i)[j] = L[i + j]'(by
+      rw [Nat.add_comm]
+      exact Nat.add_lt_of_lt_sub (length_drop i L ▸ h)) := by
+  rw [getElem_drop]
+
+/-- The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
+dropping the first `i` elements. Version designed to rewrite from the small list to the big list. -/
+@[deprecated getElem_drop' (since := "2024-06-12")]
+theorem get_drop' (L : List α) {i j} :
+    get (L.drop i) j = get L ⟨i + j, by
+      rw [Nat.add_comm]
+      exact Nat.add_lt_of_lt_sub (length_drop i L ▸ j.2)⟩ := by
+  simp [getElem_drop']
 
 @[simp]
-theorem getElem_cons_drop : ∀ (l : List α) (i : Nat) (h : i < l.length),
-    l[i] :: drop (i + 1) l = drop i l
-  | _::_, 0, _ => rfl
-  | _::_, i+1, _ => getElem_cons_drop _ i _
+theorem getElem?_drop (L : List α) (i j : Nat) : (L.drop i)[j]? = L[i + j]? := by
+  ext
+  simp only [getElem?_eq_some, getElem_drop', Option.mem_def]
+  constructor <;> intro ⟨h, ha⟩
+  · exact ⟨_, ha⟩
+  · refine ⟨?_, ha⟩
+    rw [length_drop]
+    rw [Nat.add_comm] at h
+    apply Nat.lt_sub_of_add_lt h
 
-@[deprecated getElem_cons_drop (since := "2024-06-12")]
-theorem get_cons_drop (l : List α) (i) : get l i :: drop (i + 1) l = drop i l := by
+@[deprecated getElem?_drop (since := "2024-06-12")]
+theorem get?_drop (L : List α) (i j : Nat) : get? (L.drop i) j = get? L (i + j) := by
   simp
 
-theorem drop_eq_getElem_cons {n} {l : List α} (h) : drop n l = l[n] :: drop (n + 1) l :=
-  (getElem_cons_drop _ n h).symm
+theorem head?_drop (l : List α) (n : Nat) :
+    (l.drop n).head? = l[n]? := by
+  rw [head?_eq_getElem?, getElem?_drop, Nat.add_zero]
 
-@[deprecated drop_eq_getElem_cons (since := "2024-06-12")]
-theorem drop_eq_get_cons {n} {l : List α} (h) : drop n l = get l ⟨n, h⟩ :: drop (n + 1) l := by
-  simp [drop_eq_getElem_cons]
+theorem head_drop {l : List α} {n : Nat} (h : l.drop n ≠ []) :
+    (l.drop n).head h = l[n]'(by simp_all) := by
+  have w : n < l.length := length_lt_of_drop_ne_nil h
+  simpa [head?_eq_head, getElem?_eq_getElem, h, w] using head?_drop l n
 
-@[simp]
-theorem getElem?_take {l : List α} {n m : Nat} (h : m < n) : (l.take n)[m]? = l[m]? := by
-  induction n generalizing l m with
-  | zero =>
-    exact absurd h (Nat.not_lt_of_le m.zero_le)
-  | succ _ hn =>
-    cases l with
-    | nil => simp only [take_nil]
-    | cons hd tl =>
-      cases m
-      · simp
-      · simpa using hn (Nat.lt_of_succ_lt_succ h)
+theorem getLast?_drop {l : List α} : (l.drop n).getLast? = if l.length ≤ n then none else l.getLast? := by
+  rw [getLast?_eq_getElem?, getElem?_drop]
+  rw [length_drop]
+  split
+  · rw [getElem?_eq_none (by omega)]
+  · rw [getLast?_eq_getElem?]
+    congr
+    omega
 
-@[deprecated getElem?_take (since := "2024-06-12")]
-theorem get?_take {l : List α} {n m : Nat} (h : m < n) : (l.take n).get? m = l.get? m := by
-  simp [getElem?_take, h]
+theorem getLast_drop {l : List α} (h : l.drop n ≠ []) :
+    (l.drop n).getLast h = l.getLast (ne_nil_of_length_pos (by simp at h; omega)) := by
+  simp only [ne_eq, drop_eq_nil_iff_le] at h
+  apply Option.some_inj.1
+  simp only [← getLast?_eq_getLast, getLast?_drop, ite_eq_right_iff]
+  omega
 
-@[simp]
-theorem getElem?_take_of_succ {l : List α} {n : Nat} : (l.take (n + 1))[n]? = l[n]? :=
-  getElem?_take (Nat.lt_succ_self n)
+theorem set_eq_take_append_cons_drop {l : List α} {n : Nat} {a : α} :
+    l.set n a = if n < l.length then l.take n ++ a :: l.drop (n + 1) else l := by
+  split <;> rename_i h
+  · ext1 m
+    by_cases h' : m < n
+    · rw [getElem?_append (by simp [length_take]; omega), getElem?_set_ne (by omega),
+        getElem?_take h']
+    · by_cases h'' : m = n
+      · subst h''
+        rw [getElem?_set_eq (by simp; omega), getElem?_append_right, length_take,
+          Nat.min_eq_left (by omega), Nat.sub_self, getElem?_cons_zero]
+        rw [length_take]
+        exact Nat.min_le_left m l.length
+      · have h''' : n < m := by omega
+        rw [getElem?_set_ne (by omega), getElem?_append_right, length_take,
+          Nat.min_eq_left (by omega)]
+        · obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_lt h'''
+          have p : n + k + 1 - n = k + 1 := by omega
+          rw [p]
+          rw [getElem?_cons_succ, getElem?_drop]
+          congr 1
+          omega
+        · rw [length_take]
+          exact Nat.le_trans (Nat.min_le_left _ _) (by omega)
+  · rw [set_eq_of_length_le]
+    omega
 
-theorem tail_drop (l : List α) (n : Nat) : (l.drop n).tail = l.drop (n + 1) := by
-  induction l generalizing n with
-  | nil => simp
-  | cons hd tl hl =>
-    cases n
-    · simp
-    · simp [hl]
+theorem exists_of_set {n : Nat} {a' : α} {l : List α} (h : n < l.length) :
+    ∃ l₁ l₂, l = l₁ ++ l[n] :: l₂ ∧ l₁.length = n ∧ l.set n a' = l₁ ++ a' :: l₂ := by
+  refine ⟨l.take n, l.drop (n + 1), ⟨by simp, ⟨length_take_of_le (Nat.le_of_lt h), ?_⟩⟩⟩
+  simp [set_eq_take_append_cons_drop, h]
 
-@[simp]
-theorem drop_eq_nil_iff_le {l : List α} {k : Nat} : l.drop k = [] ↔ l.length ≤ k := by
-  refine' ⟨fun h => _, drop_eq_nil_of_le⟩
-  induction k generalizing l with
-  | zero =>
-    simp only [drop] at h
-    simp [h]
-  | succ k hk =>
-    cases l
-    · simp
-    · simp only [drop] at h
-      simpa [Nat.succ_le_succ_iff] using hk h
+theorem drop_set_of_lt (a : α) {n m : Nat} (l : List α)
+    (hnm : n < m) : drop m (l.set n a) = l.drop m :=
+  ext_getElem? fun k => by simpa only [getElem?_drop] using getElem?_set_ne (by omega)
 
-@[simp]
-theorem take_eq_nil_iff {l : List α} {k : Nat} : l.take k = [] ↔ k = 0 ∨ l = [] := by
-  cases l <;> cases k <;> simp [Nat.succ_ne_zero]
-
-theorem drop_eq_nil_of_eq_nil : ∀ {as : List α} {i}, as = [] → as.drop i = []
-  | _, _, rfl => drop_nil
-
-theorem ne_nil_of_drop_ne_nil {as : List α} {i : Nat} (h: as.drop i ≠ []) : as ≠ [] :=
-  mt drop_eq_nil_of_eq_nil h
-
-theorem take_eq_nil_of_eq_nil : ∀ {as : List α} {i}, as = [] → as.take i = []
-  | _, _, rfl => take_nil
-
-theorem ne_nil_of_take_ne_nil {as : List α} {i : Nat} (h : as.take i ≠ []) : as ≠ [] :=
-  mt take_eq_nil_of_eq_nil h
-
-theorem set_take {l : List α} {n m : Nat} {a : α} :
-    (l.set m a).take n = (l.take n).set m a := by
-  induction n generalizing l m with
-  | zero => simp
-  | succ _ hn =>
-    cases l with
-    | nil => simp
-    | cons hd tl => cases m <;> simp_all
-
-theorem drop_set {l : List α} {n m : Nat} {a : α} :
-    (l.set m a).drop n = if m < n then l.drop n else (l.drop n).set (m - n) a := by
-  induction n generalizing l m with
-  | zero => simp
-  | succ _ hn =>
-    cases l with
-    | nil => simp
-    | cons hd tl =>
-      cases m
-      · simp_all
-      · simp only [hn, set_cons_succ, drop_succ_cons, succ_lt_succ_iff]
-        congr 2
-        exact (Nat.add_sub_add_right ..).symm
-
-theorem set_drop {l : List α} {n m : Nat} {a : α} :
-    (l.drop n).set m a = (l.set (n + m) a).drop n := by
-  rw [drop_set, if_neg, add_sub_self_left n m]
-  exact (Nat.not_lt).2 (le_add_right n m)
-
-theorem take_concat_get (l : List α) (i : Nat) (h : i < l.length) :
-    (l.take i).concat l[i] = l.take (i+1) :=
-  Eq.symm <| (append_left_inj _).1 <| (take_append_drop (i+1) l).trans <| by
-    rw [concat_eq_append, append_assoc, singleton_append, get_drop_eq_drop, take_append_drop]
-
-@[deprecated take_succ_cons (since := "2024-07-25")]
-theorem take_cons_succ : (a::as).take (i+1) = a :: as.take i := rfl
-
-@[deprecated take_of_length_le (since := "2024-07-25")]
-theorem take_all_of_le {n} {l : List α} (h : length l ≤ n) : take n l = l :=
-  take_of_length_le h
-
-theorem drop_left : ∀ l₁ l₂ : List α, drop (length l₁) (l₁ ++ l₂) = l₂
-  | [], _ => rfl
-  | _ :: l₁, l₂ => drop_left l₁ l₂
-
-@[simp]
-theorem drop_left' {l₁ l₂ : List α} {n} (h : length l₁ = n) : drop n (l₁ ++ l₂) = l₂ := by
-  rw [← h]; apply drop_left
-
-theorem take_left : ∀ l₁ l₂ : List α, take (length l₁) (l₁ ++ l₂) = l₁
-  | [], _ => rfl
-  | a :: l₁, l₂ => congrArg (cons a) (take_left l₁ l₂)
-
-@[simp]
-theorem take_left' {l₁ l₂ : List α} {n} (h : length l₁ = n) : take n (l₁ ++ l₂) = l₁ := by
-  rw [← h]; apply take_left
-
-theorem take_succ {l : List α} {n : Nat} : l.take (n + 1) = l.take n ++ l[n]?.toList := by
-  induction l generalizing n with
-  | nil =>
-    simp only [take_nil, Option.toList, getElem?_nil, append_nil]
-  | cons hd tl hl =>
-    cases n
-    · simp only [take, Option.toList, getElem?_cons_zero, nil_append]
-    · simp only [take, hl, getElem?_cons_succ, cons_append]
-
-@[deprecated (since := "2024-07-25")]
-theorem drop_sizeOf_le [SizeOf α] (l : List α) (n : Nat) : sizeOf (l.drop n) ≤ sizeOf l := by
-  induction l generalizing n with
-  | nil => rw [drop_nil]; apply Nat.le_refl
-  | cons _ _ lih =>
-    induction n with
-    | zero => apply Nat.le_refl
-    | succ n =>
-      exact Trans.trans (lih _) (Nat.le_add_left _ _)
-
-theorem dropLast_eq_take (l : List α) : l.dropLast = l.take (l.length - 1) := by
-  cases l with
-  | nil => simp [dropLast]
-  | cons x l =>
-    induction l generalizing x <;> simp_all [dropLast]
-
-@[simp] theorem map_take (f : α → β) :
-    ∀ (L : List α) (i : Nat), (L.take i).map f = (L.map f).take i
-  | [], i => by simp
-  | _, 0 => by simp
-  | h :: t, n + 1 => by dsimp; rw [map_take f t n]
-
-@[simp] theorem map_drop (f : α → β) :
-    ∀ (L : List α) (i : Nat), (L.drop i).map f = (L.map f).drop i
-  | [], i => by simp
-  | L, 0 => by simp
-  | h :: t, n + 1 => by
-    dsimp
-    rw [map_drop f t]
-
-@[simp] theorem drop_drop (n : Nat) : ∀ (m) (l : List α), drop n (drop m l) = drop (n + m) l
-  | m, [] => by simp
-  | 0, l => by simp
-  | m + 1, a :: l =>
-    calc
-      drop n (drop (m + 1) (a :: l)) = drop n (drop m l) := rfl
-      _ = drop (n + m) l := drop_drop n m l
-      _ = drop (n + (m + 1)) (a :: l) := rfl
-
-theorem take_drop : ∀ (m n : Nat) (l : List α), take n (drop m l) = drop m (take (m + n) l)
+theorem drop_take : ∀ (m n : Nat) (l : List α), drop n (take m l) = take (m - n) (drop n l)
   | 0, _, _ => by simp
+  | _, 0, _ => by simp
   | _, _, [] => by simp
-  | _+1, _, _ :: _ => by simpa [Nat.succ_add, take_succ_cons, drop_succ_cons] using take_drop ..
+  | m+1, n+1, h :: t => by
+    simp [take_succ_cons, drop_succ_cons, drop_take m n t]
+    congr 1
+    omega
 
-@[deprecated drop_drop (since := "2024-06-15")]
-theorem drop_add (m n) (l : List α) : drop (m + n) l = drop m (drop n l) := by
-  simp [drop_drop]
+theorem take_reverse {α} {xs : List α} (n : Nat) (h : n ≤ xs.length) :
+    xs.reverse.take n = (xs.drop (xs.length - n)).reverse := by
+  induction xs generalizing n <;>
+    simp only [reverse_cons, drop, reverse_nil, Nat.zero_sub, length, take_nil]
+  next xs_hd xs_tl xs_ih =>
+  cases Nat.lt_or_eq_of_le h with
+  | inl h' =>
+    have h' := Nat.le_of_succ_le_succ h'
+    rw [take_append_of_le_length, xs_ih _ h']
+    rw [show xs_tl.length + 1 - n = succ (xs_tl.length - n) from _, drop]
+    · rwa [succ_eq_add_one, Nat.sub_add_comm]
+    · rwa [length_reverse]
+  | inr h' =>
+    subst h'
+    rw [length, Nat.sub_self, drop]
+    suffices xs_tl.length + 1 = (xs_tl.reverse ++ [xs_hd]).length by
+      rw [this, take_length, reverse_cons]
+    rw [length_append, length_reverse]
+    rfl
 
-/-! ### takeWhile and dropWhile -/
-
-theorem takeWhile_cons (p : α → Bool) (a : α) (l : List α) :
-    (a :: l).takeWhile p = if p a then a :: l.takeWhile p else [] := by
-  simp only [takeWhile]
-  by_cases h: p a <;> simp [h]
-
-@[simp] theorem takeWhile_cons_of_pos {p : α → Bool} {a : α} {l : List α} (h : p a) :
-    (a :: l).takeWhile p = a :: l.takeWhile p := by
-  simp [takeWhile_cons, h]
-
-@[simp] theorem takeWhile_cons_of_neg {p : α → Bool} {a : α} {l : List α} (h : ¬ p a) :
-    (a :: l).takeWhile p = [] := by
-  simp [takeWhile_cons, h]
-
-theorem dropWhile_cons :
-    (x :: xs : List α).dropWhile p = if p x then xs.dropWhile p else x :: xs := by
-  split <;> simp_all [dropWhile]
-
-@[simp] theorem dropWhile_cons_of_pos {a : α} {l : List α} (h : p a) :
-    (a :: l).dropWhile p = l.dropWhile p := by
-  simp [dropWhile_cons, h]
-
-@[simp] theorem dropWhile_cons_of_neg {a : α} {l : List α} (h : ¬ p a) :
-    (a :: l).dropWhile p = a :: l := by
-  simp [dropWhile_cons, h]
-
-theorem head?_takeWhile (p : α → Bool) (l : List α) : (l.takeWhile p).head? = l.head?.filter p := by
-  cases l with
-  | nil => rfl
-  | cons x xs =>
-    simp only [takeWhile_cons, head?_cons, Option.filter_some]
-    split <;> simp
-
-theorem head_takeWhile (p : α → Bool) (l : List α) (w) :
-    (l.takeWhile p).head w = l.head (by rintro rfl; simp_all) := by
-  cases l with
-  | nil => rfl
-  | cons x xs =>
-    simp only [takeWhile_cons, head_cons]
-    simp only [takeWhile_cons] at w
-    split <;> simp_all
-
-theorem head?_dropWhile_not (p : α → Bool) (l : List α) :
-    match (l.dropWhile p).head? with | some x => p x = false | none => True := by
-  induction l with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [dropWhile_cons]
-    split <;> rename_i h <;> split at h <;> simp_all
-
-theorem head_dropWhile_not (p : α → Bool) (l : List α) (w) :
-    p ((l.dropWhile p).head w) = false := by
-  simpa [head?_eq_head, w] using head?_dropWhile_not p l
-
-theorem takeWhile_map (f : α → β) (p : β → Bool) (l : List α) :
-    (l.map f).takeWhile p = (l.takeWhile (p ∘ f)).map f := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [map_cons, takeWhile_cons]
-    split <;> simp_all
-
-theorem dropWhile_map (f : α → β) (p : β → Bool) (l : List α) :
-    (l.map f).dropWhile p = (l.dropWhile (p ∘ f)).map f := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [map_cons, dropWhile_cons]
-    split <;> simp_all
-
-theorem takeWhile_filterMap (f : α → Option β) (p : β → Bool) (l : List α) :
-    (l.filterMap f).takeWhile p = (l.takeWhile fun a => (f a).all p).filterMap f := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [filterMap_cons]
-    split <;> rename_i h
-    · simp only [takeWhile_cons, h]
-      split <;> simp_all
-    · simp [takeWhile_cons, h, ih]
-      split <;> simp_all [filterMap_cons]
-
-theorem dropWhile_filterMap (f : α → Option β) (p : β → Bool) (l : List α) :
-    (l.filterMap f).dropWhile p = (l.dropWhile fun a => (f a).all p).filterMap f := by
-  induction l with
-  | nil => rfl
-  | cons x xs ih =>
-    simp only [filterMap_cons]
-    split <;> rename_i h
-    · simp only [dropWhile_cons, h]
-      split <;> simp_all
-    · simp [dropWhile_cons, h, ih]
-      split <;> simp_all [filterMap_cons]
-
-theorem takeWhile_filter (p q : α → Bool) (l : List α) :
-    (l.filter p).takeWhile q = (l.takeWhile fun a => !p a || q a).filter p := by
-  simp [← filterMap_eq_filter, takeWhile_filterMap]
-
-theorem dropWhile_filter (p q : α → Bool) (l : List α) :
-    (l.filter p).dropWhile q = (l.dropWhile fun a => !p a || q a).filter p := by
-  simp [← filterMap_eq_filter, dropWhile_filterMap]
-
-@[simp] theorem takeWhile_append_dropWhile (p : α → Bool) :
-    ∀ (l : List α), takeWhile p l ++ dropWhile p l = l
-  | [] => rfl
-  | x :: xs => by simp [takeWhile, dropWhile]; cases p x <;> simp [takeWhile_append_dropWhile p xs]
-
-theorem takeWhile_append {xs ys : List α} :
-    (xs ++ ys).takeWhile p =
-      if (xs.takeWhile p).length = xs.length then xs ++ ys.takeWhile p else xs.takeWhile p := by
-  induction xs with
-  | nil => simp
-  | cons x xs ih =>
-    simp only [cons_append, takeWhile_cons]
-    split
-    · simp_all only [length_cons, add_one_inj]
-      split <;> rfl
-    · simp_all
-
-@[simp] theorem takeWhile_append_of_pos {p : α → Bool} {l₁ l₂ : List α} (h : ∀ a ∈ l₁, p a) :
-    (l₁ ++ l₂).takeWhile p = l₁ ++ l₂.takeWhile p := by
-  induction l₁ with
-  | nil => simp
-  | cons x xs ih => simp_all [takeWhile_cons]
-
-theorem dropWhile_append {xs ys : List α} :
-    (xs ++ ys).dropWhile p =
-      if (xs.dropWhile p).isEmpty then ys.dropWhile p else xs.dropWhile p ++ ys := by
-  induction xs with
-  | nil => simp
-  | cons h t ih =>
-    simp only [cons_append, dropWhile_cons]
-    split <;> simp_all
-
-@[simp] theorem dropWhile_append_of_pos {p : α → Bool} {l₁ l₂ : List α} (h : ∀ a ∈ l₁, p a) :
-    (l₁ ++ l₂).dropWhile p = l₂.dropWhile p := by
-  induction l₁ with
-  | nil => simp
-  | cons x xs ih => simp_all [dropWhile_cons]
-
-@[simp] theorem takeWhile_replicate_eq_filter (p : α → Bool) :
-    (replicate n a).takeWhile p = (replicate n a).filter p := by
-  induction n with
-  | zero => simp
-  | succ n ih =>
-    simp only [replicate_succ, takeWhile_cons]
-    split <;> simp_all
-
-theorem takeWhile_replicate (p : α → Bool) :
-    (replicate n a).takeWhile p = if p a then replicate n a else [] := by
-  rw [takeWhile_replicate_eq_filter, filter_replicate]
-
-@[simp] theorem dropWhile_replicate_eq_filter_not (p : α → Bool) :
-    (replicate n a).dropWhile p = (replicate n a).filter (fun a => !p a) := by
-  induction n with
-  | zero => simp
-  | succ n ih =>
-    simp only [replicate_succ, dropWhile_cons]
-    split <;> simp_all
-
-theorem dropWhile_replicate (p : α → Bool) :
-    (replicate n a).dropWhile p = if p a then [] else replicate n a := by
-  simp only [dropWhile_replicate_eq_filter_not, filter_replicate]
-  split <;> simp_all
-
-theorem take_takeWhile {l : List α} (p : α → Bool) n :
-    (l.takeWhile p).take n = (l.take n).takeWhile p := by
-  induction l generalizing n with
-  | nil => simp
-  | cons x xs ih =>
-    by_cases h : p x <;> cases n <;> simp [takeWhile_cons, h, ih, take_succ_cons]
-
-@[simp] theorem all_takeWhile {l : List α} : (l.takeWhile p).all p = true := by
-  induction l with
-  | nil => rfl
-  | cons h t ih => by_cases p h <;> simp_all
-
-@[simp] theorem any_dropWhile {l : List α} :
-    (l.dropWhile p).any (fun x => !p x) = !l.all p := by
-  induction l with
-  | nil => rfl
-  | cons h t ih => by_cases p h <;> simp_all
+@[deprecated (since := "2024-06-15")] abbrev reverse_take := @take_reverse
 
 /-! ### rotateLeft -/
 
-@[simp] theorem rotateLeft_zero (l : List α) : rotateLeft l 0 = l := by
-  simp [rotateLeft]
-
--- TODO Batteries defines its own `getElem?_rotate`, which we need to adapt.
--- TODO Prove `map_rotateLeft`, using `ext` and `getElem?_rotateLeft`.
+@[simp] theorem rotateLeft_replicate (n) (a : α) : rotateLeft (replicate m a) n = replicate m a := by
+  cases n with
+  | zero => simp
+  | succ n =>
+    suffices 1 < m → m - (n + 1) % m + min ((n + 1) % m) m = m by
+      simpa [rotateLeft]
+    intro h
+    rw [Nat.min_eq_left (Nat.le_of_lt (Nat.mod_lt _ (by omega)))]
+    have : (n + 1) % m < m := Nat.mod_lt _ (by omega)
+    omega
 
 /-! ### rotateRight -/
 
-@[simp] theorem rotateRight_zero (l : List α) : rotateRight l 0 = l := by
-  simp [rotateRight]
+@[simp] theorem rotateRight_replicate (n) (a : α) : rotateRight (replicate m a) n = replicate m a := by
+  cases n with
+  | zero => simp
+  | succ n =>
+    suffices 1 < m → m - (m - (n + 1) % m) + min (m - (n + 1) % m) m = m by
+      simpa [rotateRight]
+    intro h
+    have : (n + 1) % m < m := Nat.mod_lt _ (by omega)
+    rw [Nat.min_eq_left (by omega)]
+    omega
 
--- TODO Batteries defines its own `getElem?_rotate`, which we need to adapt.
--- TODO Prove `map_rotateRight`, using `ext` and `getElem?_rotateRight`.
+/-! ### zipWith -/
+
+@[simp] theorem length_zipWith (f : α → β → γ) (l₁ l₂) :
+    length (zipWith f l₁ l₂) = min (length l₁) (length l₂) := by
+  induction l₁ generalizing l₂ <;> cases l₂ <;>
+    simp_all [succ_min_succ, Nat.zero_min, Nat.min_zero]
+
+theorem zipWith_eq_zipWith_take_min : ∀ (l₁ : List α) (l₂ : List β),
+    zipWith f l₁ l₂ = zipWith f (l₁.take (min l₁.length l₂.length)) (l₂.take (min l₁.length l₂.length))
+  | [], _ => by simp
+  | _, [] => by simp
+  | a :: l₁, b :: l₂ => by simp [succ_min_succ, zipWith_eq_zipWith_take_min l₁ l₂]
+
+@[simp] theorem zipWith_replicate {a : α} {b : β} {m n : Nat} :
+    zipWith f (replicate m a) (replicate n b) = replicate (min m n) (f a b) := by
+  rw [zipWith_eq_zipWith_take_min]
+  simp
+
+/-! ### zip -/
+
+@[simp] theorem length_zip (l₁ : List α) (l₂ : List β) :
+    length (zip l₁ l₂) = min (length l₁) (length l₂) := by
+  simp [zip]
+
+theorem zip_eq_zip_take_min : ∀ (l₁ : List α) (l₂ : List β),
+    zip l₁ l₂ = zip (l₁.take (min l₁.length l₂.length)) (l₂.take (min l₁.length l₂.length))
+  | [], _ => by simp
+  | _, [] => by simp
+  | a :: l₁, b :: l₂ => by simp [succ_min_succ, zip_eq_zip_take_min l₁ l₂]
+
+@[simp] theorem zip_replicate {a : α} {b : β} {m n : Nat} :
+    zip (replicate m a) (replicate n b) = replicate (min m n) (a, b) := by
+  rw [zip_eq_zip_take_min]
+  simp
+
+/-! ### minimum? -/
+
+-- A specialization of `minimum?_eq_some_iff` to Nat.
+theorem minimum?_eq_some_iff' {xs : List Nat} :
+    xs.minimum? = some a ↔ (a ∈ xs ∧ ∀ b ∈ xs, a ≤ b) :=
+  minimum?_eq_some_iff
+    (le_refl := Nat.le_refl)
+    (min_eq_or := fun _ _ => by omega)
+    (le_min_iff := fun _ _ _ => by omega)
+
+-- This could be generalized,
+-- but will first require further work on order typeclasses in the core repository.
+theorem minimum?_cons' {a : Nat} {l : List Nat} :
+    (a :: l).minimum? = some (match l.minimum? with
+    | none => a
+    | some m => min a m) := by
+  rw [minimum?_eq_some_iff']
+  split <;> rename_i h m
+  · simp_all
+  · rw [minimum?_eq_some_iff'] at m
+    obtain ⟨m, le⟩ := m
+    rw [Nat.min_def]
+    constructor
+    · split
+      · exact mem_cons_self a l
+      · exact mem_cons_of_mem a m
+    · intro b m
+      cases List.mem_cons.1 m with
+      | inl => split <;> omega
+      | inr h =>
+        specialize le b h
+        split <;> omega
+
+/-! ### maximum? -/
+
+-- A specialization of `maximum?_eq_some_iff` to Nat.
+theorem maximum?_eq_some_iff' {xs : List Nat} :
+    xs.maximum? = some a ↔ (a ∈ xs ∧ ∀ b ∈ xs, b ≤ a) :=
+  maximum?_eq_some_iff
+    (le_refl := Nat.le_refl)
+    (max_eq_or := fun _ _ => by omega)
+    (max_le_iff := fun _ _ _ => by omega)
+
+-- This could be generalized,
+-- but will first require further work on order typeclasses in the core repository.
+theorem maximum?_cons' {a : Nat} {l : List Nat} :
+    (a :: l).maximum? = some (match l.maximum? with
+    | none => a
+    | some m => max a m) := by
+  rw [maximum?_eq_some_iff']
+  split <;> rename_i h m
+  · simp_all
+  · rw [maximum?_eq_some_iff'] at m
+    obtain ⟨m, le⟩ := m
+    rw [Nat.max_def]
+    constructor
+    · split
+      · exact mem_cons_of_mem a m
+      · exact mem_cons_self a l
+    · intro b m
+      cases List.mem_cons.1 m with
+      | inl => split <;> omega
+      | inr h =>
+        specialize le b h
+        split <;> omega
 
 end List

src/Init/Data/List/Zip.lean

@@ -1,363 +0,0 @@
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro
--/
-prelude
-import Init.Data.List.TakeDrop
-
-/-!
-# Lemmas about `List.zip`, `List.zipWith`, `List.zipWithAll`, and `List.unzip`.
--/
-
-namespace List
-
-open Nat
-
-/-! ## Zippers -/
-
-/-! ### zip -/
-
-theorem zip_map (f : α → γ) (g : β → δ) :
-    ∀ (l₁ : List α) (l₂ : List β), zip (l₁.map f) (l₂.map g) = (zip l₁ l₂).map (Prod.map f g)
-  | [], l₂ => rfl
-  | l₁, [] => by simp only [map, zip_nil_right]
-  | a :: l₁, b :: l₂ => by
-    simp only [map, zip_cons_cons, zip_map, Prod.map]; constructor
-
-theorem zip_map_left (f : α → γ) (l₁ : List α) (l₂ : List β) :
-    zip (l₁.map f) l₂ = (zip l₁ l₂).map (Prod.map f id) := by rw [← zip_map, map_id]
-
-theorem zip_map_right (f : β → γ) (l₁ : List α) (l₂ : List β) :
-    zip l₁ (l₂.map f) = (zip l₁ l₂).map (Prod.map id f) := by rw [← zip_map, map_id]
-
-theorem zip_append :
-    ∀ {l₁ r₁ : List α} {l₂ r₂ : List β} (_h : length l₁ = length l₂),
-      zip (l₁ ++ r₁) (l₂ ++ r₂) = zip l₁ l₂ ++ zip r₁ r₂
-  | [], r₁, l₂, r₂, h => by simp only [eq_nil_of_length_eq_zero h.symm]; rfl
-  | l₁, r₁, [], r₂, h => by simp only [eq_nil_of_length_eq_zero h]; rfl
-  | a :: l₁, r₁, b :: l₂, r₂, h => by
-    simp only [cons_append, zip_cons_cons, zip_append (Nat.succ.inj h)]
-
-theorem zip_map' (f : α → β) (g : α → γ) :
-    ∀ l : List α, zip (l.map f) (l.map g) = l.map fun a => (f a, g a)
-  | [] => rfl
-  | a :: l => by simp only [map, zip_cons_cons, zip_map']
-
-theorem of_mem_zip {a b} : ∀ {l₁ : List α} {l₂ : List β}, (a, b) ∈ zip l₁ l₂ → a ∈ l₁ ∧ b ∈ l₂
-  | _ :: l₁, _ :: l₂, h => by
-    cases h
-    case head => simp
-    case tail h =>
-    · have := of_mem_zip h
-      exact ⟨Mem.tail _ this.1, Mem.tail _ this.2⟩
-
-@[deprecated of_mem_zip (since := "2024-07-28")] abbrev mem_zip := @of_mem_zip
-
-theorem map_fst_zip :
-    ∀ (l₁ : List α) (l₂ : List β), l₁.length ≤ l₂.length → map Prod.fst (zip l₁ l₂) = l₁
-  | [], bs, _ => rfl
-  | _ :: as, _ :: bs, h => by
-    simp [Nat.succ_le_succ_iff] at h
-    show _ :: map Prod.fst (zip as bs) = _ :: as
-    rw [map_fst_zip as bs h]
-  | a :: as, [], h => by simp at h
-
-theorem map_snd_zip :
-    ∀ (l₁ : List α) (l₂ : List β), l₂.length ≤ l₁.length → map Prod.snd (zip l₁ l₂) = l₂
-  | _, [], _ => by
-    rw [zip_nil_right]
-    rfl
-  | [], b :: bs, h => by simp at h
-  | a :: as, b :: bs, h => by
-    simp [Nat.succ_le_succ_iff] at h
-    show _ :: map Prod.snd (zip as bs) = _ :: bs
-    rw [map_snd_zip as bs h]
-
-theorem map_prod_left_eq_zip {l : List α} (f : α → β) :
-    (l.map fun x => (x, f x)) = l.zip (l.map f) := by
-  rw [← zip_map']
-  congr
-  exact map_id _
-
-theorem map_prod_right_eq_zip {l : List α} (f : α → β) :
-    (l.map fun x => (f x, x)) = (l.map f).zip l := by
-  rw [← zip_map']
-  congr
-  exact map_id _
-
-/-- See also `List.zip_replicate` in `Init.Data.List.TakeDrop` for a generalization with different lengths. -/
-@[simp] theorem zip_replicate' {a : α} {b : β} {n : Nat} :
-    zip (replicate n a) (replicate n b) = replicate n (a, b) := by
-  induction n with
-  | zero => rfl
-  | succ n ih => simp [replicate_succ, ih]
-
-/-! ### zipWith -/
-
-theorem zipWith_comm (f : α → β → γ) :
-    ∀ (la : List α) (lb : List β), zipWith f la lb = zipWith (fun b a => f a b) lb la
-  | [], _ => List.zipWith_nil_right.symm
-  | _ :: _, [] => rfl
-  | _ :: as, _ :: bs => congrArg _ (zipWith_comm f as bs)
-
-theorem zipWith_comm_of_comm (f : α → α → β) (comm : ∀ x y : α, f x y = f y x) (l l' : List α) :
-    zipWith f l l' = zipWith f l' l := by
-  rw [zipWith_comm]
-  simp only [comm]
-
-@[simp]
-theorem zipWith_same (f : α → α → δ) : ∀ l : List α, zipWith f l l = l.map fun a => f a a
-  | [] => rfl
-  | _ :: xs => congrArg _ (zipWith_same f xs)
-
-/--
-See also `getElem?_zipWith'` for a variant
-using `Option.map` and `Option.bind` rather than a `match`.
--/
-theorem getElem?_zipWith {f : α → β → γ} {i : Nat} :
-    (List.zipWith f as bs)[i]? = match as[i]?, bs[i]? with
-      | some a, some b => some (f a b) | _, _ => none := by
-  induction as generalizing bs i with
-  | nil => cases bs with
-    | nil => simp
-    | cons b bs => simp
-  | cons a as aih => cases bs with
-    | nil => simp
-    | cons b bs => cases i <;> simp_all
-
-/-- Variant of `getElem?_zipWith` using `Option.map` and `Option.bind` rather than a `match`. -/
-theorem getElem?_zipWith' {f : α → β → γ} {i : Nat} :
-    (zipWith f l₁ l₂)[i]? = (l₁[i]?.map f).bind fun g => l₂[i]?.map g := by
-  induction l₁ generalizing l₂ i with
-  | nil => rw [zipWith] <;> simp
-  | cons head tail =>
-    cases l₂
-    · simp
-    · cases i <;> simp_all
-
-theorem getElem?_zipWith_eq_some (f : α → β → γ) (l₁ : List α) (l₂ : List β) (z : γ) (i : Nat) :
-    (zipWith f l₁ l₂)[i]? = some z ↔
-      ∃ x y, l₁[i]? = some x ∧ l₂[i]? = some y ∧ f x y = z := by
-  induction l₁ generalizing l₂ i
-  · simp
-  · cases l₂ <;> cases i <;> simp_all
-
-theorem getElem?_zip_eq_some (l₁ : List α) (l₂ : List β) (z : α × β) (i : Nat) :
-    (zip l₁ l₂)[i]? = some z ↔ l₁[i]? = some z.1 ∧ l₂[i]? = some z.2 := by
-  cases z
-  rw [zip, getElem?_zipWith_eq_some]; constructor
-  · rintro ⟨x, y, h₀, h₁, h₂⟩
-    simpa [h₀, h₁] using h₂
-  · rintro ⟨h₀, h₁⟩
-    exact ⟨_, _, h₀, h₁, rfl⟩
-
-@[deprecated getElem?_zipWith (since := "2024-06-12")]
-theorem get?_zipWith {f : α → β → γ} :
-    (List.zipWith f as bs).get? i = match as.get? i, bs.get? i with
-      | some a, some b => some (f a b) | _, _ => none := by
-  simp [getElem?_zipWith]
-
-set_option linter.deprecated false in
-@[deprecated getElem?_zipWith (since := "2024-06-07")] abbrev zipWith_get? := @get?_zipWith
-
-theorem head?_zipWith {f : α → β → γ} :
-    (List.zipWith f as bs).head? = match as.head?, bs.head? with
-      | some a, some b => some (f a b) | _, _ => none := by
-  simp [head?_eq_getElem?, getElem?_zipWith]
-
-theorem head_zipWith {f : α → β → γ} (h):
-    (List.zipWith f as bs).head h = f (as.head (by rintro rfl; simp_all)) (bs.head (by rintro rfl; simp_all)) := by
-  apply Option.some.inj
-  rw [← head?_eq_head, head?_zipWith, head?_eq_head, head?_eq_head]
-
-@[simp]
-theorem zipWith_map {μ} (f : γ → δ → μ) (g : α → γ) (h : β → δ) (l₁ : List α) (l₂ : List β) :
-    zipWith f (l₁.map g) (l₂.map h) = zipWith (fun a b => f (g a) (h b)) l₁ l₂ := by
-  induction l₁ generalizing l₂ <;> cases l₂ <;> simp_all
-
-theorem zipWith_map_left (l₁ : List α) (l₂ : List β) (f : α → α') (g : α' → β → γ) :
-    zipWith g (l₁.map f) l₂ = zipWith (fun a b => g (f a) b) l₁ l₂ := by
-  induction l₁ generalizing l₂ <;> cases l₂ <;> simp_all
-
-theorem zipWith_map_right (l₁ : List α) (l₂ : List β) (f : β → β') (g : α → β' → γ) :
-    zipWith g l₁ (l₂.map f) = zipWith (fun a b => g a (f b)) l₁ l₂ := by
-  induction l₁ generalizing l₂ <;> cases l₂ <;> simp_all
-
-theorem zipWith_foldr_eq_zip_foldr {f : α → β → γ} (i : δ):
-    (zipWith f l₁ l₂).foldr g i = (zip l₁ l₂).foldr (fun p r => g (f p.1 p.2) r) i := by
-  induction l₁ generalizing l₂ <;> cases l₂ <;> simp_all
-
-theorem zipWith_foldl_eq_zip_foldl {f : α → β → γ} (i : δ):
-    (zipWith f l₁ l₂).foldl g i = (zip l₁ l₂).foldl (fun r p => g r (f p.1 p.2)) i := by
-  induction l₁ generalizing i l₂ <;> cases l₂ <;> simp_all
-
-@[simp]
-theorem zipWith_eq_nil_iff {f : α → β → γ} {l l'} : zipWith f l l' = [] ↔ l = [] ∨ l' = [] := by
-  cases l <;> cases l' <;> simp
-
-theorem map_zipWith {δ : Type _} (f : α → β) (g : γ → δ → α) (l : List γ) (l' : List δ) :
-    map f (zipWith g l l') = zipWith (fun x y => f (g x y)) l l' := by
-  induction l generalizing l' with
-  | nil => simp
-  | cons hd tl hl =>
-    · cases l'
-      · simp
-      · simp [hl]
-
-theorem take_zipWith : (zipWith f l l').take n = zipWith f (l.take n) (l'.take n) := by
-  induction l generalizing l' n with
-  | nil => simp
-  | cons hd tl hl =>
-    cases l'
-    · simp
-    · cases n
-      · simp
-      · simp [hl]
-
-@[deprecated take_zipWith (since := "2024-07-26")] abbrev zipWith_distrib_take := @take_zipWith
-
-theorem drop_zipWith : (zipWith f l l').drop n = zipWith f (l.drop n) (l'.drop n) := by
-  induction l generalizing l' n with
-  | nil => simp
-  | cons hd tl hl =>
-    · cases l'
-      · simp
-      · cases n
-        · simp
-        · simp [hl]
-
-@[deprecated drop_zipWith (since := "2024-07-26")] abbrev zipWith_distrib_drop := @drop_zipWith
-
-theorem tail_zipWith : (zipWith f l l').tail = zipWith f l.tail l'.tail := by
-  rw [← drop_one]; simp [drop_zipWith]
-
-@[deprecated tail_zipWith (since := "2024-07-28")] abbrev zipWith_distrib_tail := @tail_zipWith
-
-theorem zipWith_append (f : α → β → γ) (l la : List α) (l' lb : List β)
-    (h : l.length = l'.length) :
-    zipWith f (l ++ la) (l' ++ lb) = zipWith f l l' ++ zipWith f la lb := by
-  induction l generalizing l' with
-  | nil =>
-    have : l' = [] := eq_nil_of_length_eq_zero (by simpa using h.symm)
-    simp [this]
-  | cons hl tl ih =>
-    cases l' with
-    | nil => simp at h
-    | cons head tail =>
-      simp only [length_cons, Nat.succ.injEq] at h
-      simp [ih _ h]
-
-/-- See also `List.zipWith_replicate` in `Init.Data.List.TakeDrop` for a generalization with different lengths. -/
-@[simp] theorem zipWith_replicate' {a : α} {b : β} {n : Nat} :
-    zipWith f (replicate n a) (replicate n b) = replicate n (f a b) := by
-  induction n with
-  | zero => rfl
-  | succ n ih => simp [replicate_succ, ih]
-
-/-! ### zipWithAll -/
-
-theorem getElem?_zipWithAll {f : Option α → Option β → γ} {i : Nat} :
-    (zipWithAll f as bs)[i]? = match as[i]?, bs[i]? with
-      | none, none => .none | a?, b? => some (f a? b?) := by
-  induction as generalizing bs i with
-  | nil => induction bs generalizing i with
-    | nil => simp
-    | cons b bs bih => cases i <;> simp_all
-  | cons a as aih => cases bs with
-    | nil =>
-      specialize @aih []
-      cases i <;> simp_all
-    | cons b bs => cases i <;> simp_all
-
-@[deprecated getElem?_zipWithAll (since := "2024-06-12")]
-theorem get?_zipWithAll {f : Option α → Option β → γ} :
-    (zipWithAll f as bs).get? i = match as.get? i, bs.get? i with
-      | none, none => .none | a?, b? => some (f a? b?) := by
-  simp [getElem?_zipWithAll]
-
-set_option linter.deprecated false in
-@[deprecated getElem?_zipWithAll (since := "2024-06-07")] abbrev zipWithAll_get? := @get?_zipWithAll
-
-theorem head?_zipWithAll {f : Option α → Option β → γ} :
-    (zipWithAll f as bs).head? = match as.head?, bs.head? with
-      | none, none => .none | a?, b? => some (f a? b?) := by
-  simp [head?_eq_getElem?, getElem?_zipWithAll]
-
-theorem head_zipWithAll {f : Option α → Option β → γ} (h) :
-    (zipWithAll f as bs).head h = f as.head? bs.head? := by
-  apply Option.some.inj
-  rw [← head?_eq_head, head?_zipWithAll]
-  split <;> simp_all
-
-theorem zipWithAll_map {μ} (f : Option γ → Option δ → μ) (g : α → γ) (h : β → δ) (l₁ : List α) (l₂ : List β) :
-    zipWithAll f (l₁.map g) (l₂.map h) = zipWithAll (fun a b => f (g <$> a) (h <$> b)) l₁ l₂ := by
-  induction l₁ generalizing l₂ <;> cases l₂ <;> simp_all
-
-theorem zipWithAll_map_left (l₁ : List α) (l₂ : List β) (f : α → α') (g : Option α' → Option β → γ) :
-    zipWithAll g (l₁.map f) l₂ = zipWithAll (fun a b => g (f <$> a) b) l₁ l₂ := by
-  induction l₁ generalizing l₂ <;> cases l₂ <;> simp_all
-
-theorem zipWithAll_map_right (l₁ : List α) (l₂ : List β) (f : β → β') (g : Option α → Option β' → γ) :
-    zipWithAll g l₁ (l₂.map f) = zipWithAll (fun a b => g a (f <$> b)) l₁ l₂ := by
-  induction l₁ generalizing l₂ <;> cases l₂ <;> simp_all
-
-theorem map_zipWithAll {δ : Type _} (f : α → β) (g : Option γ → Option δ → α) (l : List γ) (l' : List δ) :
-    map f (zipWithAll g l l') = zipWithAll (fun x y => f (g x y)) l l' := by
-  induction l generalizing l' with
-  | nil => simp
-  | cons hd tl hl =>
-    cases l' <;> simp_all
-
-@[simp] theorem zipWithAll_replicate {a : α} {b : β} {n : Nat} :
-    zipWithAll f (replicate n a) (replicate n b) = replicate n (f a b) := by
-  induction n with
-  | zero => rfl
-  | succ n ih => simp [replicate_succ, ih]
-
-/-! ### unzip -/
-
-@[simp] theorem unzip_fst : (unzip l).fst = l.map Prod.fst := by
-  induction l <;> simp_all
-
-@[simp] theorem unzip_snd : (unzip l).snd = l.map Prod.snd := by
-  induction l <;> simp_all
-
-@[deprecated unzip_fst (since := "2024-07-28")] abbrev unzip_left := @unzip_fst
-@[deprecated unzip_snd (since := "2024-07-28")] abbrev unzip_right := @unzip_snd
-
-theorem unzip_eq_map : ∀ l : List (α × β), unzip l = (l.map Prod.fst, l.map Prod.snd)
-  | [] => rfl
-  | (a, b) :: l => by simp only [unzip_cons, map_cons, unzip_eq_map l]
-
-theorem zip_unzip : ∀ l : List (α × β), zip (unzip l).1 (unzip l).2 = l
-  | [] => rfl
-  | (a, b) :: l => by simp only [unzip_cons, zip_cons_cons, zip_unzip l]
-
-theorem unzip_zip_left :
-    ∀ {l₁ : List α} {l₂ : List β}, length l₁ ≤ length l₂ → (unzip (zip l₁ l₂)).1 = l₁
-  | [], l₂, _ => rfl
-  | l₁, [], h => by rw [eq_nil_of_length_eq_zero (Nat.eq_zero_of_le_zero h)]; rfl
-  | a :: l₁, b :: l₂, h => by
-    simp only [zip_cons_cons, unzip_cons, unzip_zip_left (le_of_succ_le_succ h)]
-
-theorem unzip_zip_right :
-    ∀ {l₁ : List α} {l₂ : List β}, length l₂ ≤ length l₁ → (unzip (zip l₁ l₂)).2 = l₂
-  | [], l₂, _ => by simp_all
-  | l₁, [], _ => by simp
-  | a :: l₁, b :: l₂, h => by
-    simp only [zip_cons_cons, unzip_cons, unzip_zip_right (le_of_succ_le_succ h)]
-
-theorem unzip_zip {l₁ : List α} {l₂ : List β} (h : length l₁ = length l₂) :
-    unzip (zip l₁ l₂) = (l₁, l₂) := by
-  ext
-  · rw [unzip_zip_left (Nat.le_of_eq h)]
-  · rw [unzip_zip_right (Nat.le_of_eq h.symm)]
-
-theorem zip_of_prod {l : List α} {l' : List β} {lp : List (α × β)} (hl : lp.map Prod.fst = l)
-    (hr : lp.map Prod.snd = l') : lp = l.zip l' := by
-  rw [← hl, ← hr, ← zip_unzip lp, ← unzip_fst, ← unzip_snd, zip_unzip, zip_unzip]
-
-@[simp] theorem unzip_replicate {n : Nat} {a : α} {b : β} :
-    unzip (replicate n (a, b)) = (replicate n a, replicate n b) := by
-  ext1 <;> simp

src/Init/Data/Nat/Basic.lean

@@ -102,13 +102,6 @@ def blt (a b : Nat) : Bool :=
 attribute [simp] Nat.zero_le
 attribute [simp] Nat.not_lt_zero
 
-theorem and_forall_add_one {p : Nat → Prop} : p 0 ∧ (∀ n, p (n + 1)) ↔ ∀ n, p n :=
-  ⟨fun h n => Nat.casesOn n h.1 h.2, fun h => ⟨h _, fun _ => h _⟩⟩
-
-theorem or_exists_add_one : p 0 ∨ (Exists fun n => p (n + 1)) ↔ Exists p :=
-  ⟨fun h => h.elim (fun h0 => ⟨0, h0⟩) fun ⟨n, hn⟩ => ⟨n + 1, hn⟩,
-    fun ⟨n, h⟩ => match n with | 0 => Or.inl h | n+1 => Or.inr ⟨n, h⟩⟩
-
 /-! # Helper "packing" theorems -/
 
 @[simp] theorem zero_eq : Nat.zero = 0 := rfl
@@ -395,11 +388,11 @@ theorem le_or_eq_of_le_succ {m n : Nat} (h : m ≤ succ n) : m ≤ n ∨ m = suc
 theorem le_or_eq_of_le_add_one {m n : Nat} (h : m ≤ n + 1) : m ≤ n ∨ m = n + 1 :=
   le_or_eq_of_le_succ h
 
-@[simp] theorem le_add_right : ∀ (n k : Nat), n ≤ n + k
+theorem le_add_right : ∀ (n k : Nat), n ≤ n + k
   | n, 0   => Nat.le_refl n
   | n, k+1 => le_succ_of_le (le_add_right n k)
 
-@[simp] theorem le_add_left (n m : Nat): n ≤ m + n :=
+theorem le_add_left (n m : Nat): n ≤ m + n :=
   Nat.add_comm n m ▸ le_add_right n m
 
 theorem le_of_add_right_le {n m k : Nat} (h : n + k ≤ m) : n ≤ m :=
@@ -535,7 +528,7 @@ protected theorem le_of_add_le_add_right {a b c : Nat} : a + b ≤ c + b → a
   rw [Nat.add_comm _ b, Nat.add_comm _ b]
   apply Nat.le_of_add_le_add_left
 
-@[simp] protected theorem add_le_add_iff_right {n : Nat} : m + n ≤ k + n ↔ m ≤ k :=
+protected theorem add_le_add_iff_right {n : Nat} : m + n ≤ k + n ↔ m ≤ k :=
   ⟨Nat.le_of_add_le_add_right, fun h => Nat.add_le_add_right h _⟩
 
 /-! ### le/lt -/

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

@@ -265,8 +265,8 @@ theorem testBit_two_pow_add_gt {i j : Nat} (j_lt_i : j < i) (x : Nat) :
       have x_eq : x = y + 2^j := Nat.eq_add_of_sub_eq x_ge_j y_eq
       simp only [Nat.two_pow_pos, x_eq, Nat.le_add_left, true_and, ite_true]
       have y_lt_x : y < x := by
-        simp only [x_eq, Nat.lt_add_right_iff_pos]
-        exact Nat.two_pow_pos j
+            simp [x_eq]
+            exact Nat.lt_add_of_pos_right (Nat.two_pow_pos j)
       simp only [hyp y y_lt_x]
       if i_lt_j : i < j then
         rw [Nat.add_comm _ (2^_), testBit_two_pow_add_gt i_lt_j]

src/Init/Data/Nat/Div.lean

@@ -203,10 +203,6 @@ theorem mod_add_div (m k : Nat) : m % k + k * (m / k) = m := by
   | base x y h => simp [h]
   | ind x y h IH => simp [h]; rw [Nat.mul_succ, ← Nat.add_assoc, IH, Nat.sub_add_cancel h.2]
 
-theorem mod_def (m k : Nat) : m % k = m - k * (m / k) := by
-  rw [Nat.sub_eq_of_eq_add]
-  apply (Nat.mod_add_div _ _).symm
-
 @[simp] protected theorem div_one (n : Nat) : n / 1 = n := by
   have := mod_add_div n 1
   rwa [mod_one, Nat.zero_add, Nat.one_mul] at this

src/Init/Data/Nat/Gcd.lean

@@ -46,9 +46,6 @@ theorem gcd_succ (x y : Nat) : gcd (succ x) y = gcd (y % succ x) (succ x) := by
 theorem gcd_add_one (x y : Nat) : gcd (x + 1) y = gcd (y % (x + 1)) (x + 1) := by
   rw [gcd]; rfl
 
-theorem gcd_def (x y : Nat) : gcd x y = if x = 0 then y else gcd (y % x) x := by
-  cases x <;> simp [Nat.gcd_add_one]
-
 @[simp] theorem gcd_one_left (n : Nat) : gcd 1 n = 1 := by
   rw [gcd_succ, mod_one]
   rfl

src/Init/Data/Nat/Lemmas.lean

@@ -19,14 +19,6 @@ and later these lemmas should be organised into other files more systematically.
 -/
 
 namespace Nat
-
-@[deprecated and_forall_add_one (since := "2024-07-30")] abbrev and_forall_succ := @and_forall_add_one
-@[deprecated or_exists_add_one (since := "2024-07-30")] abbrev or_exists_succ := @or_exists_add_one
-
-@[simp] theorem exists_ne_zero {P : Nat → Prop} : (∃ n, ¬ n = 0 ∧ P n) ↔ ∃ n, P (n + 1) :=
-  ⟨fun ⟨n, h, w⟩ => by cases n with | zero => simp at h | succ n => exact ⟨n, w⟩,
-    fun ⟨n, w⟩ => ⟨n + 1, by simp, w⟩⟩
-
 /-! ## add -/
 
 protected theorem add_add_add_comm (a b c d : Nat) : (a + b) + (c + d) = (a + c) + (b + d) := by
@@ -44,13 +36,13 @@ protected theorem eq_zero_of_add_eq_zero_right (h : n + m = 0) : n = 0 :=
 protected theorem add_eq_zero_iff : n + m = 0 ↔ n = 0 ∧ m = 0 :=
   ⟨Nat.eq_zero_of_add_eq_zero, fun ⟨h₁, h₂⟩ => h₂.symm ▸ h₁⟩
 
-@[simp] protected theorem add_left_cancel_iff {n : Nat} : n + m = n + k ↔ m = k :=
+protected theorem add_left_cancel_iff {n : Nat} : n + m = n + k ↔ m = k :=
   ⟨Nat.add_left_cancel, fun | rfl => rfl⟩
 
-@[simp] protected theorem add_right_cancel_iff {n : Nat} : m + n = k + n ↔ m = k :=
+protected theorem add_right_cancel_iff {n : Nat} : m + n = k + n ↔ m = k :=
   ⟨Nat.add_right_cancel, fun | rfl => rfl⟩
 
-@[simp] protected theorem add_le_add_iff_left {n : Nat} : n + m ≤ n + k ↔ m ≤ k :=
+protected theorem add_le_add_iff_left {n : Nat} : n + m ≤ n + k ↔ m ≤ k :=
   ⟨Nat.le_of_add_le_add_left, fun h => Nat.add_le_add_left h _⟩
 
 protected theorem lt_of_add_lt_add_right : ∀ {n : Nat}, k + n < m + n → k < m
@@ -60,10 +52,10 @@ protected theorem lt_of_add_lt_add_right : ∀ {n : Nat}, k + n < m + n → k <
 protected theorem lt_of_add_lt_add_left {n : Nat} : n + k < n + m → k < m := by
   rw [Nat.add_comm n, Nat.add_comm n]; exact Nat.lt_of_add_lt_add_right
 
-@[simp] protected theorem add_lt_add_iff_left {k n m : Nat} : k + n < k + m ↔ n < m :=
+protected theorem add_lt_add_iff_left {k n m : Nat} : k + n < k + m ↔ n < m :=
   ⟨Nat.lt_of_add_lt_add_left, fun h => Nat.add_lt_add_left h _⟩
 
-@[simp] protected theorem add_lt_add_iff_right {k n m : Nat} : n + k < m + k ↔ n < m :=
+protected theorem add_lt_add_iff_right {k n m : Nat} : n + k < m + k ↔ n < m :=
   ⟨Nat.lt_of_add_lt_add_right, fun h => Nat.add_lt_add_right h _⟩
 
 protected theorem add_lt_add_of_le_of_lt {a b c d : Nat} (hle : a ≤ b) (hlt : c < d) :
@@ -83,10 +75,10 @@ protected theorem pos_of_lt_add_right (h : n < n + k) : 0 < k :=
 protected theorem pos_of_lt_add_left : n < k + n → 0 < k := by
   rw [Nat.add_comm]; exact Nat.pos_of_lt_add_right
 
-@[simp] protected theorem lt_add_right_iff_pos : n < n + k ↔ 0 < k :=
+protected theorem lt_add_right_iff_pos : n < n + k ↔ 0 < k :=
   ⟨Nat.pos_of_lt_add_right, Nat.lt_add_of_pos_right⟩
 
-@[simp] protected theorem lt_add_left_iff_pos : n < k + n ↔ 0 < k :=
+protected theorem lt_add_left_iff_pos : n < k + n ↔ 0 < k :=
   ⟨Nat.pos_of_lt_add_left, Nat.lt_add_of_pos_left⟩
 
 protected theorem add_pos_left (h : 0 < m) (n) : 0 < m + n :=

src/Init/Data/Nat/Linear.lean

@@ -173,13 +173,13 @@ instance : LawfulBEq PolyCnstr where
   eq_of_beq {a b} h := by
     cases a; rename_i eq₁ lhs₁ rhs₁
     cases b; rename_i eq₂ lhs₂ rhs₂
-    have h : eq₁ == eq₂ && (lhs₁ == lhs₂ && rhs₁ == rhs₂) := h
+    have h : eq₁ == eq₂ && lhs₁ == lhs₂ && rhs₁ == rhs₂ := h
     simp at h
-    have ⟨h₁, h₂, h₃⟩ := h
+    have ⟨⟨h₁, h₂⟩, h₃⟩ := h
     rw [h₁, h₂, h₃]
   rfl {a} := by
     cases a; rename_i eq lhs rhs
-    show (eq == eq && (lhs == lhs && rhs == rhs)) = true
+    show (eq == eq && lhs == lhs && rhs == rhs) = true
     simp [LawfulBEq.rfl]
 
 def PolyCnstr.mul (k : Nat) (c : PolyCnstr) : PolyCnstr :=

src/Init/Data/Option/Basic.lean

@@ -212,9 +212,6 @@ instance (α) [BEq α] [LawfulBEq α] : LawfulBEq (Option α) where
 @[simp] theorem all_none : Option.all p none = true := rfl
 @[simp] theorem all_some : Option.all p (some x) = p x := rfl
 
-@[simp] theorem any_none : Option.any p none = false := rfl
-@[simp] theorem any_some : Option.any p (some x) = p x := rfl
-
 /-- The minimum of two optional values. -/
 protected def min [Min α] : Option α → Option α → Option α
   | some x, some y => some (Min.min x y)

src/Init/Data/Option/Lemmas.lean

@@ -193,16 +193,6 @@ theorem mem_map_of_mem (g : α → β) (h : a ∈ x) : g a ∈ Option.map g x :=
 @[simp] theorem filter_none (p : α → Bool) : none.filter p = none := rfl
 theorem filter_some : Option.filter p (some a) = if p a then some a else none := rfl
 
-@[simp] theorem all_guard (p : α → Prop) [DecidablePred p] (a : α) :
-    Option.all q (guard p a) = (!p a || q a) := by
-  simp only [guard]
-  split <;> simp_all
-
-@[simp] theorem any_guard (p : α → Prop) [DecidablePred p] (a : α) :
-    Option.any q (guard p a) = (p a && q a) := by
-  simp only [guard]
-  split <;> simp_all
-
 theorem bind_map_comm {α β} {x : Option (Option α)} {f : α → β} :
     x.bind (Option.map f) = (x.map (Option.map f)).bind id := by cases x <;> simp
 

src/Init/Data/Prod.lean

@@ -5,18 +5,9 @@ Author: Leonardo de Moura
 -/
 prelude
 import Init.SimpLemmas
-import Init.NotationExtra
 
 instance [BEq α] [BEq β] [LawfulBEq α] [LawfulBEq β] : LawfulBEq (α × β) where
   eq_of_beq {a b} (h : a.1 == b.1 && a.2 == b.2) := by
     cases a; cases b
     refine congr (congrArg _ (eq_of_beq ?_)) (eq_of_beq ?_) <;> simp_all
   rfl {a} := by cases a; simp [BEq.beq, LawfulBEq.rfl]
-
-@[simp]
-protected theorem Prod.forall {p : α × β → Prop} : (∀ x, p x) ↔ ∀ a b, p (a, b) :=
-  ⟨fun h a b ↦ h (a, b), fun h ⟨a, b⟩ ↦ h a b⟩
-
-@[simp]
-protected theorem Prod.exists {p : α × β → Prop} : (∃ x, p x) ↔ ∃ a b, p (a, b) :=
-  ⟨fun ⟨⟨a, b⟩, h⟩ ↦ ⟨a, b, h⟩, fun ⟨a, b, h⟩ ↦ ⟨⟨a, b⟩, h⟩⟩

src/Init/Data/Subtype.lean

@@ -1,27 +0,0 @@
-/-
-Copyright (c) 2017 Johannes Hölzl. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Johannes Hölzl
--/
-prelude
-import Init.Ext
-
-namespace Subtype
-
-universe u
-variable {α : Sort u} {p q : α → Prop}
-
-@[ext]
-protected theorem ext : ∀ {a1 a2 : { x // p x }}, (a1 : α) = (a2 : α) → a1 = a2
-  | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl
-
-@[simp]
-protected theorem «forall» {q : { a // p a } → Prop} : (∀ x, q x) ↔ ∀ a b, q ⟨a, b⟩ :=
-  ⟨fun h a b ↦ h ⟨a, b⟩, fun h ⟨a, b⟩ ↦ h a b⟩
-
-@[simp]
-protected theorem «exists» {q : { a // p a } → Prop} :
-    (Exists fun x => q x) ↔ Exists fun a => Exists fun b => q ⟨a, b⟩ :=
-  ⟨fun ⟨⟨a, b⟩, h⟩ ↦ ⟨a, b, h⟩, fun ⟨a, b, h⟩ ↦ ⟨⟨a, b⟩, h⟩⟩
-
-end Subtype

src/Init/Ext.lean

@@ -78,10 +78,7 @@ end Elab.Tactic.Ext
 end Lean
 
 attribute [ext] Prod PProd Sigma PSigma
-attribute [ext] funext propext Subtype.eq Array.ext
+attribute [ext] funext propext Subtype.eq
 
 @[ext] protected theorem PUnit.ext (x y : PUnit) : x = y := rfl
 protected theorem Unit.ext (x y : Unit) : x = y := rfl
-
-@[ext] protected theorem Thunk.ext : {a b : Thunk α} → a.get = b.get → a = b
-  | {..}, {..}, heq => congrArg _ <| funext fun _ => heq

src/Init/Meta.lean

@@ -399,16 +399,9 @@ def setTailInfo (stx : Syntax) (info : SourceInfo) : Syntax :=
   | some stx => stx
   | none     => stx
 
-/--
-Replaces the trailing whitespace in `stx`, if any, with an empty substring.
-
-The trailing substring's `startPos` and `str` are preserved in order to ensure that the result could
-have been produced by the parser, in case any syntax consumers rely on such an assumption.
--/
 def unsetTrailing (stx : Syntax) : Syntax :=
   match stx.getTailInfo with
-  | SourceInfo.original lead pos trail endPos =>
-    stx.setTailInfo (SourceInfo.original lead pos { trail with stopPos := trail.startPos } endPos)
+  | SourceInfo.original lead pos _ endPos => stx.setTailInfo (SourceInfo.original lead pos "".toSubstring endPos)
   | _                                     => stx
 
 @[specialize] private partial def updateFirst {α} [Inhabited α] (a : Array α) (f : α → Option α) (i : Nat) : Option (Array α) :=

src/Init/MetaTypes.lean

@@ -219,13 +219,13 @@ structure Config where
   -/
   index             : Bool := true
   /--
-  When `true` (default: `true`), `simp` will **not** create a proof for a rewriting rule associated
+  When `true` (default: `false`), `simp` will **not** create a proof for a rewriting rule associated
   with an `rfl`-theorem.
   Rewriting rules are provided by users by annotating theorems with the attribute `@[simp]`.
   If the proof of the theorem is just `rfl` (reflexivity), and `implicitDefEqProofs := true`, `simp`
   will **not** create a proof term which is an application of the annotated theorem.
   -/
-  implicitDefEqProofs : Bool := true
+  implicitDefEqProofs : Bool := false
   deriving Inhabited, BEq
 
 -- Configuration object for `simp_all`

src/Init/Omega/IntList.lean

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
 prelude
-import Init.Data.List.Zip
+import Init.Data.List.Lemmas
 import Init.Data.Int.DivModLemmas
 import Init.Data.Nat.Gcd
 

src/Init/Prelude.lean

@@ -320,7 +320,7 @@ Because this is in the `Eq` namespace, if you have a variable `h : a = b`,
 
 For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality)
 -/
-@[symm] theorem Eq.symm {α : Sort u} {a b : α} (h : Eq a b) : Eq b a :=
+theorem Eq.symm {α : Sort u} {a b : α} (h : Eq a b) : Eq b a :=
   h ▸ rfl
 
 /--
@@ -2214,17 +2214,12 @@ def Char.utf8Size (c : Char) : Nat :=
 or `none`. In functional programming languages, this type is used to represent
 the possibility of failure, or sometimes nullability.
 
-For example, the function `HashMap.get? : HashMap α β → α → Option β` looks up
+For example, the function `HashMap.find? : HashMap α β → α → Option β` looks up
 a specified key `a : α` inside the map. Because we do not know in advance
 whether the key is actually in the map, the return type is `Option β`, where
 `none` means the value was not in the map, and `some b` means that the value
 was found and `b` is the value retrieved.
 
-The `xs[i]` syntax, which is used to index into collections, has a variant
-`xs[i]?` that returns an optional value depending on whether the given index
-is valid. For example, if `m : HashMap α β` and `a : α`, then `m[a]?` is
-equivalent to `HashMap.get? m a`.
-
 To extract a value from an `Option α`, we use pattern matching:
 ```
 def map (f : α → β) (x : Option α) : Option β :=

src/Init/PropLemmas.lean

@@ -202,17 +202,6 @@ theorem exists_imp : ((∃ x, p x) → b) ↔ ∀ x, p x → b := forall_exists_
 @[simp] theorem exists_const (α) [i : Nonempty α] : (∃ _ : α, b) ↔ b :=
   ⟨fun ⟨_, h⟩ => h, i.elim Exists.intro⟩
 
-@[congr]
-theorem exists_prop_congr {p p' : Prop} {q q' : p → Prop} (hq : ∀ h, q h ↔ q' h) (hp : p ↔ p') :
-    Exists q ↔ ∃ h : p', q' (hp.2 h) :=
-  ⟨fun ⟨_, _⟩ ↦ ⟨hp.1 ‹_›, (hq _).1 ‹_›⟩, fun ⟨_, _⟩ ↦ ⟨_, (hq _).2 ‹_›⟩⟩
-
-theorem exists_prop_of_true {p : Prop} {q : p → Prop} (h : p) : (Exists fun h' : p => q h') ↔ q h :=
-  @exists_const (q h) p ⟨h⟩
-
-@[simp] theorem exists_true_left (p : True → Prop) : Exists p ↔ p True.intro :=
-  exists_prop_of_true _
-
 section forall_congr
 
 theorem forall_congr' (h : ∀ a, p a ↔ q a) : (∀ a, p a) ↔ ∀ a, q a :=
@@ -320,11 +309,6 @@ theorem not_forall_of_exists_not {p : α → Prop} : (∃ x, ¬p x) → ¬∀ x,
 @[simp] theorem exists_eq_right_right' : (∃ (a : α), p a ∧ q a ∧ a' = a) ↔ p a' ∧ q a' := by
   simp [@eq_comm _ a']
 
-@[simp] theorem exists_or_eq_left (y : α) (p : α → Prop) : ∃ x : α, x = y ∨ p x := ⟨y, .inl rfl⟩
-@[simp] theorem exists_or_eq_right (y : α) (p : α → Prop) : ∃ x : α, p x ∨ x = y := ⟨y, .inr rfl⟩
-@[simp] theorem exists_or_eq_left' (y : α) (p : α → Prop) : ∃ x : α, y = x ∨ p x := ⟨y, .inl rfl⟩
-@[simp] theorem exists_or_eq_right' (y : α) (p : α → Prop) : ∃ x : α, p x ∨ y = x := ⟨y, .inr rfl⟩
-
 @[simp] theorem exists_prop : (∃ _h : a, b) ↔ a ∧ b :=
   ⟨fun ⟨hp, hq⟩ => ⟨hp, hq⟩, fun ⟨hp, hq⟩ => ⟨hp, hq⟩⟩
 

src/Init/ShareCommon.lean

@@ -109,4 +109,4 @@ A more restrictive but efficient max sharing primitive.
 Remark: it optimizes the number of RC operations, and the strategy for caching results.
 -/
 @[extern "lean_sharecommon_quick"]
-def ShareCommon.shareCommon' (a : @& α) : α := a
+def ShareCommon.shareCommon' (a : α) : α := a

src/Init/System/IO.lean

@@ -435,12 +435,6 @@ Note that EOF does not actually close a handle, so further reads may block and r
 
 end Handle
 
-/--
-Resolves a pathname to an absolute pathname with no '.', '..', or symbolic links.
-
-This function coincides with the [POSIX `realpath` function](https://pubs.opengroup.org/onlinepubs/9699919799/functions/realpath.html),
-see there for more information.
--/
 @[extern "lean_io_realpath"] opaque realPath (fname : FilePath) : IO FilePath
 @[extern "lean_io_remove_file"] opaque removeFile (fname : @& FilePath) : IO Unit
 /-- Remove given directory. Fails if not empty; see also `IO.FS.removeDirAll`. -/
@@ -470,23 +464,31 @@ def withFile (fn : FilePath) (mode : Mode) (f : Handle → IO α) : IO α :=
 def Handle.putStrLn (h : Handle) (s : String) : IO Unit :=
   h.putStr (s.push '\n')
 
-partial def Handle.readBinToEndInto (h : Handle) (buf : ByteArray) : IO ByteArray := do
+partial def Handle.readBinToEnd (h : Handle) : IO ByteArray := do
   let rec loop (acc : ByteArray) : IO ByteArray := do
     let buf ← h.read 1024
     if buf.isEmpty then
       return acc
     else
       loop (acc ++ buf)
-  loop buf
+  loop ByteArray.empty
 
-partial def Handle.readBinToEnd (h : Handle) : IO ByteArray := do
-  h.readBinToEndInto .empty
+partial def Handle.readToEnd (h : Handle) : IO String := do
+  let rec loop (s : String) := do
+    let line ← h.getLine
+    if line.isEmpty then
+      return s
+    else
+      loop (s ++ line)
+  loop ""
 
-def Handle.readToEnd (h : Handle) : IO String := do
-  let data ← h.readBinToEnd
-  match String.fromUTF8? data with
-  | some s => return s
-  | none => throw <| .userError s!"Tried to read from handle containing non UTF-8 data."
+def readBinFile (fname : FilePath) : IO ByteArray := do
+  let h ← Handle.mk fname Mode.read
+  h.readBinToEnd
+
+def readFile (fname : FilePath) : IO String := do
+  let h ← Handle.mk fname Mode.read
+  h.readToEnd
 
 partial def lines (fname : FilePath) : IO (Array String) := do
   let h ← Handle.mk fname Mode.read
@@ -592,28 +594,6 @@ end System.FilePath
 
 namespace IO
 
-namespace FS
-
-def readBinFile (fname : FilePath) : IO ByteArray := do
-  -- Requires metadata so defined after metadata
-  let mdata ← fname.metadata
-  let size := mdata.byteSize.toUSize
-  let handle ← IO.FS.Handle.mk fname .read
-  let buf ←
-    if size > 0 then
-      handle.read mdata.byteSize.toUSize
-    else
-      pure <| ByteArray.mkEmpty 0
-  handle.readBinToEndInto buf
-
-def readFile (fname : FilePath) : IO String := do
-  let data ← readBinFile fname
-  match String.fromUTF8? data with
-  | some s => return s
-  | none => throw <| .userError s!"Tried to read file '{fname}' containing non UTF-8 data."
-
-end FS
-
 def withStdin [Monad m] [MonadFinally m] [MonadLiftT BaseIO m] (h : FS.Stream) (x : m α) : m α := do
   let prev ← setStdin h
   try x finally discard <| setStdin prev

src/Init/WF.lean

@@ -68,7 +68,6 @@ noncomputable def recursion {C : α → Sort v} (a : α) (h : ∀ x, (∀ y, r y
   induction (apply hwf a) with
   | intro x₁ _ ih => exact h x₁ ih
 
-include hwf in
 theorem induction {C : α → Prop} (a : α) (h : ∀ x, (∀ y, r y x → C y) → C x) : C a :=
   recursion hwf a h
 

src/Lean/Attributes.lean

@@ -53,7 +53,7 @@ structure AttributeImpl extends AttributeImplCore where
   erase (decl : Name) : AttrM Unit := throwError "attribute cannot be erased"
   deriving Inhabited
 
-builtin_initialize attributeMapRef : IO.Ref (Std.HashMap Name AttributeImpl) ← IO.mkRef {}
+builtin_initialize attributeMapRef : IO.Ref (HashMap Name AttributeImpl) ← IO.mkRef {}
 
 /-- Low level attribute registration function. -/
 def registerBuiltinAttribute (attr : AttributeImpl) : IO Unit := do
@@ -296,7 +296,7 @@ end EnumAttributes
 -/
 
 abbrev AttributeImplBuilder := Name → List DataValue → Except String AttributeImpl
-abbrev AttributeImplBuilderTable := Std.HashMap Name AttributeImplBuilder
+abbrev AttributeImplBuilderTable := HashMap Name AttributeImplBuilder
 
 builtin_initialize attributeImplBuilderTableRef : IO.Ref AttributeImplBuilderTable ← IO.mkRef {}
 
@@ -307,7 +307,7 @@ def registerAttributeImplBuilder (builderId : Name) (builder : AttributeImplBuil
 
 def mkAttributeImplOfBuilder (builderId ref : Name) (args : List DataValue) : IO AttributeImpl := do
   let table ← attributeImplBuilderTableRef.get
-  match table[builderId]? with
+  match table.find? builderId with
   | none         => throw (IO.userError ("unknown attribute implementation builder '" ++ toString builderId ++ "'"))
   | some builder => IO.ofExcept <| builder ref args
 
@@ -317,7 +317,7 @@ inductive AttributeExtensionOLeanEntry where
 
 structure AttributeExtensionState where
   newEntries : List AttributeExtensionOLeanEntry := []
-  map        : Std.HashMap Name AttributeImpl
+  map        : HashMap Name AttributeImpl
   deriving Inhabited
 
 abbrev AttributeExtension := PersistentEnvExtension AttributeExtensionOLeanEntry (AttributeExtensionOLeanEntry × AttributeImpl) AttributeExtensionState
@@ -348,7 +348,7 @@ private def AttributeExtension.addImported (es : Array (Array AttributeExtension
   let map ← es.foldlM
     (fun map entries =>
       entries.foldlM
-        (fun (map : Std.HashMap Name AttributeImpl) entry => do
+        (fun (map : HashMap Name AttributeImpl) entry => do
           let attrImpl ← mkAttributeImplOfEntry ctx.env ctx.opts entry
           return map.insert attrImpl.name attrImpl)
         map)
@@ -378,7 +378,7 @@ def getBuiltinAttributeNames : IO (List Name) :=
 
 def getBuiltinAttributeImpl (attrName : Name) : IO AttributeImpl := do
   let m ← attributeMapRef.get
-  match m[attrName]? with
+  match m.find? attrName with
   | some attr => pure attr
   | none      => throw (IO.userError ("unknown attribute '" ++ toString attrName ++ "'"))
 
@@ -396,7 +396,7 @@ def getAttributeNames (env : Environment) : List Name :=
 
 def getAttributeImpl (env : Environment) (attrName : Name) : Except String AttributeImpl :=
   let m := (attributeExtension.getState env).map
-  match m[attrName]? with
+  match m.find? attrName with
   | some attr => pure attr
   | none      => throw ("unknown attribute '" ++ toString attrName ++ "'")
 

src/Lean/AuxRecursor.lean

@@ -37,7 +37,7 @@ def isAuxRecursor (env : Environment) (declName : Name) : Bool :=
 
 def isAuxRecursorWithSuffix (env : Environment) (declName : Name) (suffix : String) : Bool :=
   match declName with
-  | .str _ s => (s == suffix || s.startsWith s!"{suffix}_") && isAuxRecursor env declName
+  | .str _ s => s == suffix && isAuxRecursor env declName
   | _ => false
 
 def isCasesOnRecursor (env : Environment) (declName : Name) : Bool :=

src/Lean/Compiler/IR/Borrow.lean

@@ -26,9 +26,9 @@ instance : Hashable Key := ⟨getHash⟩
 end OwnedSet
 
 open OwnedSet (Key) in
-abbrev OwnedSet := Std.HashMap Key Unit
-def OwnedSet.insert (s : OwnedSet) (k : OwnedSet.Key) : OwnedSet := Std.HashMap.insert s k ()
-def OwnedSet.contains (s : OwnedSet) (k : OwnedSet.Key) : Bool   := Std.HashMap.contains s k
+abbrev OwnedSet := HashMap Key Unit
+def OwnedSet.insert (s : OwnedSet) (k : OwnedSet.Key) : OwnedSet := HashMap.insert s k ()
+def OwnedSet.contains (s : OwnedSet) (k : OwnedSet.Key) : Bool   := HashMap.contains s k
 
 /-! We perform borrow inference in a block of mutually recursive functions.
    Join points are viewed as local functions, and are identified using
@@ -49,7 +49,7 @@ instance : Hashable Key := ⟨getHash⟩
 end ParamMap
 
 open ParamMap (Key)
-abbrev ParamMap := Std.HashMap Key (Array Param)
+abbrev ParamMap := HashMap Key (Array Param)
 
 def ParamMap.fmt (map : ParamMap) : Format :=
   let fmts := map.fold (fun fmt k ps =>
@@ -109,7 +109,7 @@ partial def visitFnBody (fn : FunId) (paramMap : ParamMap) : FnBody → FnBody
   | FnBody.jdecl j _  v b =>
     let v := visitFnBody fn paramMap v
     let b := visitFnBody fn paramMap b
-    match paramMap[ParamMap.Key.jp fn j]? with
+    match paramMap.find? (ParamMap.Key.jp fn j) with
     | some ys => FnBody.jdecl j ys v b
     | none    => unreachable!
   | FnBody.case tid x xType alts =>
@@ -125,7 +125,7 @@ def visitDecls (decls : Array Decl) (paramMap : ParamMap) : Array Decl :=
   decls.map fun decl => match decl with
     | Decl.fdecl f _  ty b info =>
       let b := visitFnBody f paramMap b
-      match paramMap[ParamMap.Key.decl f]? with
+      match paramMap.find? (ParamMap.Key.decl f) with
       | some xs => Decl.fdecl f xs ty b info
       | none    => unreachable!
     | other => other
@@ -178,7 +178,7 @@ def isOwned (x : VarId) : M Bool := do
 /-- Updates `map[k]` using the current set of `owned` variables. -/
 def updateParamMap (k : ParamMap.Key) : M Unit := do
   let s ← get
-  match s.paramMap[k]? with
+  match s.paramMap.find? k with
   | some ps => do
     let ps ← ps.mapM fun (p : Param) => do
       if !p.borrow then pure p
@@ -192,7 +192,7 @@ def updateParamMap (k : ParamMap.Key) : M Unit := do
 
 def getParamInfo (k : ParamMap.Key) : M (Array Param) := do
   let s ← get
-  match s.paramMap[k]? with
+  match s.paramMap.find? k with
   | some ps => pure ps
   | none    =>
     match k with

src/Lean/Compiler/IR/Boxing.lean

@@ -11,7 +11,6 @@ import Lean.Compiler.IR.Basic
 import Lean.Compiler.IR.CompilerM
 import Lean.Compiler.IR.FreeVars
 import Lean.Compiler.IR.ElimDeadVars
-import Lean.Data.AssocList
 
 namespace Lean.IR.ExplicitBoxing
 /-!

src/Lean/Compiler/IR/ElimDeadBranches.lean

@@ -152,7 +152,7 @@ def getFunctionSummary? (env : Environment) (fid : FunId) : Option Value :=
   | some modIdx => findAtSorted? (functionSummariesExt.getModuleEntries env modIdx) fid
   | none        => functionSummariesExt.getState env |>.find? fid
 
-abbrev Assignment := Std.HashMap VarId Value
+abbrev Assignment := HashMap VarId Value
 
 structure InterpContext where
   currFnIdx : Nat := 0
@@ -172,7 +172,7 @@ def findVarValue (x : VarId) : M Value := do
   let ctx ← read
   let s ← get
   let assignment := s.assignments[ctx.currFnIdx]!
-  return assignment.getD x bot
+  return assignment.findD x bot
 
 def findArgValue (arg : Arg) : M Value :=
   match arg with
@@ -303,7 +303,7 @@ partial def elimDeadAux (assignment : Assignment) : FnBody → FnBody
   | FnBody.vdecl x t e b  => FnBody.vdecl x t e (elimDeadAux assignment b)
   | FnBody.jdecl j ys v b => FnBody.jdecl j ys (elimDeadAux assignment v) (elimDeadAux assignment b)
   | FnBody.case tid x xType alts =>
-    let v := assignment.getD x bot
+    let v := assignment.findD x bot
     let alts := alts.map fun alt =>
       match alt with
       | Alt.ctor i b  => Alt.ctor i <| if containsCtor v i then elimDeadAux assignment b else FnBody.unreachable

src/Lean/Compiler/IR/EmitC.lean

@@ -94,15 +94,7 @@ def emitCInitName (n : Name) : M Unit :=
 def shouldExport (n : Name) : Bool :=
   -- HACK: exclude symbols very unlikely to be used by the interpreter or other consumers of
   -- libleanshared to avoid Windows symbol limit
-  !(`Lean.Compiler.LCNF).isPrefixOf n &&
-  !(`Lean.IR).isPrefixOf n &&
-  -- Lean.Server.findModuleRefs is used in SubVerso, and the contents of RequestM are used by the
-  -- full Verso as well as anything else that extends the LSP server.
-  (!(`Lean.Server.Watchdog).isPrefixOf n) &&
-  (!(`Lean.Server.ImportCompletion).isPrefixOf n) &&
-  (!(`Lean.Server.Completion).isPrefixOf n)
-
-
+  !(`Lean.Compiler.LCNF).isPrefixOf n && !(`Lean.IR).isPrefixOf n && !(`Lean.Server).isPrefixOf n
 
 def emitFnDeclAux (decl : Decl) (cppBaseName : String) (isExternal : Bool) : M Unit := do
   let ps := decl.params
@@ -257,7 +249,7 @@ def throwUnknownVar {α : Type} (x : VarId) : M α :=
 
 def getJPParams (j : JoinPointId) : M (Array Param) := do
   let ctx ← read;
-  match ctx.jpMap[j]? with
+  match ctx.jpMap.find? j with
   | some ps => pure ps
   | none    => throw "unknown join point"
 

src/Lean/Compiler/IR/EmitLLVM.lean

@@ -65,8 +65,8 @@ structure Context (llvmctx : LLVM.Context) where
   llvmmodule : LLVM.Module llvmctx
 
 structure State (llvmctx : LLVM.Context) where
-  var2val : Std.HashMap VarId (LLVM.LLVMType llvmctx × LLVM.Value llvmctx)
-  jp2bb   : Std.HashMap JoinPointId (LLVM.BasicBlock llvmctx)
+  var2val : HashMap VarId (LLVM.LLVMType llvmctx × LLVM.Value llvmctx)
+  jp2bb   : HashMap JoinPointId (LLVM.BasicBlock llvmctx)
 
 abbrev Error := String
 
@@ -84,7 +84,7 @@ def addJpTostate (jp : JoinPointId) (bb : LLVM.BasicBlock llvmctx) : M llvmctx U
 
 def emitJp (jp : JoinPointId) : M llvmctx (LLVM.BasicBlock llvmctx) := do
   let state ← get
-  match state.jp2bb[jp]? with
+  match state.jp2bb.find? jp with
   | .some bb => return bb
   | .none => throw s!"unable to find join point {jp}"
 
@@ -531,7 +531,7 @@ def emitFnDecls : M llvmctx Unit := do
 
 def emitLhsSlot_ (x : VarId) : M llvmctx (LLVM.LLVMType llvmctx × LLVM.Value llvmctx) := do
   let state ← get
-  match state.var2val[x]? with
+  match state.var2val.find? x with
   | .some v => return v
   | .none => throw s!"unable to find variable {x}"
 
@@ -1029,7 +1029,7 @@ def emitTailCall (builder : LLVM.Builder llvmctx) (f : FunId) (v : Expr) : M llv
 
 def emitJmp (builder : LLVM.Builder llvmctx) (jp : JoinPointId) (xs : Array Arg) : M llvmctx Unit := do
  let llvmctx ← read
-  let ps ← match llvmctx.jpMap[jp]? with
+  let ps ← match llvmctx.jpMap.find? jp with
   | some ps => pure ps
   | none    => throw s!"Unknown join point {jp}"
   unless xs.size == ps.size do throw s!"Invalid goto, mismatched sizes between arguments, formal parameters."

src/Lean/Compiler/IR/EmitUtil.lean

@@ -51,8 +51,8 @@ end CollectUsedDecls
 def collectUsedDecls (env : Environment) (decl : Decl) (used : NameSet := {}) : NameSet :=
   (CollectUsedDecls.collectDecl decl env).run' used
 
-abbrev VarTypeMap  := Std.HashMap VarId IRType
-abbrev JPParamsMap := Std.HashMap JoinPointId (Array Param)
+abbrev VarTypeMap  := HashMap VarId IRType
+abbrev JPParamsMap := HashMap JoinPointId (Array Param)
 
 namespace CollectMaps
 abbrev Collector := (VarTypeMap × JPParamsMap) → (VarTypeMap × JPParamsMap)

src/Lean/Compiler/IR/ExpandResetReuse.lean

@@ -10,7 +10,7 @@ import Lean.Compiler.IR.FreeVars
 
 namespace Lean.IR.ExpandResetReuse
 /-- Mapping from variable to projections -/
-abbrev ProjMap  := Std.HashMap VarId Expr
+abbrev ProjMap  := HashMap VarId Expr
 namespace CollectProjMap
 abbrev Collector := ProjMap → ProjMap
 @[inline] def collectVDecl (x : VarId) (v : Expr) : Collector := fun m =>
@@ -148,20 +148,20 @@ def setFields (y : VarId) (zs : Array Arg) (b : FnBody) : FnBody :=
 def isSelfSet (ctx : Context) (x : VarId) (i : Nat) (y : Arg) : Bool :=
   match y with
   | Arg.var y =>
-    match ctx.projMap[y]? with
+    match ctx.projMap.find? y with
     | some (Expr.proj j w) => j == i && w == x
     | _ => false
   | _ => false
 
 /-- Given `uset x[i] := y`, return true iff `y := uproj[i] x` -/
 def isSelfUSet (ctx : Context) (x : VarId) (i : Nat) (y : VarId) : Bool :=
-  match ctx.projMap[y]? with
+  match ctx.projMap.find? y with
   | some (Expr.uproj j w) => j == i && w == x
   | _                     => false
 
 /-- Given `sset x[n, i] := y`, return true iff `y := sproj[n, i] x` -/
 def isSelfSSet (ctx : Context) (x : VarId) (n : Nat) (i : Nat) (y : VarId) : Bool :=
-  match ctx.projMap[y]? with
+  match ctx.projMap.find? y with
   | some (Expr.sproj m j w) => n == m && j == i && w == x
   | _                       => false
 

src/Lean/Compiler/LCNF/CompilerM.lean

@@ -64,34 +64,34 @@ instance : AddMessageContext CompilerM where
 
 def getType (fvarId : FVarId) : CompilerM Expr := do
   let lctx := (← get).lctx
-  if let some decl := lctx.letDecls[fvarId]? then
+  if let some decl := lctx.letDecls.find? fvarId then
     return decl.type
-  else if let some decl := lctx.params[fvarId]? then
+  else if let some decl := lctx.params.find? fvarId then
     return decl.type
-  else if let some decl := lctx.funDecls[fvarId]? then
+  else if let some decl := lctx.funDecls.find? fvarId then
     return decl.type
   else
     throwError "unknown free variable {fvarId.name}"
 
 def getBinderName (fvarId : FVarId) : CompilerM Name := do
   let lctx := (← get).lctx
-  if let some decl := lctx.letDecls[fvarId]? then
+  if let some decl := lctx.letDecls.find? fvarId then
     return decl.binderName
-  else if let some decl := lctx.params[fvarId]? then
+  else if let some decl := lctx.params.find? fvarId then
     return decl.binderName
-  else if let some decl := lctx.funDecls[fvarId]? then
+  else if let some decl := lctx.funDecls.find? fvarId then
     return decl.binderName
   else
     throwError "unknown free variable {fvarId.name}"
 
 def findParam? (fvarId : FVarId) : CompilerM (Option Param) :=
-  return (← get).lctx.params[fvarId]?
+  return (← get).lctx.params.find? fvarId
 
 def findLetDecl? (fvarId : FVarId) : CompilerM (Option LetDecl) :=
-  return (← get).lctx.letDecls[fvarId]?
+  return (← get).lctx.letDecls.find? fvarId
 
 def findFunDecl? (fvarId : FVarId) : CompilerM (Option FunDecl) :=
-  return (← get).lctx.funDecls[fvarId]?
+  return (← get).lctx.funDecls.find? fvarId
 
 def findLetValue? (fvarId : FVarId) : CompilerM (Option LetValue) := do
   let some { value, .. } ← findLetDecl? fvarId | return none
@@ -166,7 +166,7 @@ it is a free variable, a type (or type former), or `lcErased`.
 
 `Check.lean` contains a substitution validator.
 -/
-abbrev FVarSubst := Std.HashMap FVarId Expr
+abbrev FVarSubst := HashMap FVarId Expr
 
 /--
 Replace the free variables in `e` using the given substitution.
@@ -190,7 +190,7 @@ where
   go (e : Expr) : Expr :=
     if e.hasFVar then
       match e with
-      | .fvar fvarId => match s[fvarId]? with
+      | .fvar fvarId => match s.find? fvarId with
         | some e => if translator then e else go e
         | none => e
       | .lit .. | .const .. | .sort .. | .mvar .. | .bvar .. => e
@@ -224,7 +224,7 @@ That is, it is not a type (or type former), nor `lcErased`. Recall that a valid
 expressions that are free variables, `lcErased`, or type formers.
 -/
 private partial def normFVarImp (s : FVarSubst) (fvarId : FVarId) (translator : Bool) : NormFVarResult :=
-  match s[fvarId]? with
+  match s.find? fvarId with
   | some (.fvar fvarId') =>
     if translator then
       .fvar fvarId'
@@ -246,7 +246,7 @@ private partial def normArgImp (s : FVarSubst) (arg : Arg) (translator : Bool) :
   match arg with
   | .erased => arg
   | .fvar fvarId =>
-    match s[fvarId]? with
+    match s.find? fvarId with
     | some (.fvar fvarId') =>
       let arg' := .fvar fvarId'
       if translator then arg' else normArgImp s arg' translator

src/Lean/Compiler/LCNF/ElimDeadBranches.lean

@@ -268,7 +268,7 @@ def getFunctionSummary? (env : Environment) (fid : Name) : Option Value :=
 A map from variable identifiers to the `Value` produced by the abstract
 interpreter for them.
 -/
-abbrev Assignment := Std.HashMap FVarId Value
+abbrev Assignment := HashMap FVarId Value
 
 /--
 The context of `InterpM`.
@@ -332,7 +332,7 @@ If none is available return `Value.bot`.
 -/
 def findVarValue (var : FVarId) : InterpM Value := do
   let assignment ← getAssignment
-  return assignment.getD var .bot
+  return assignment.findD var .bot
 
 /--
 Find the value of `arg` using the logic of `findVarValue`.
@@ -547,13 +547,13 @@ where
     | .jp decl k | .fun decl k =>
       return code.updateFun! (← decl.updateValue (← go decl.value)) (← go k)
     | .cases cs =>
-      let discrVal := assignment.getD cs.discr .bot
+      let discrVal := assignment.findD cs.discr .bot
       let processAlt typ alt := do
         match alt with
         | .alt ctor args body =>
           if discrVal.containsCtor ctor then
             let filter param := do
-              if let some val := assignment[param.fvarId]? then
+              if let some val := assignment.find? param.fvarId then
                 if let some literal ← val.getLiteral then
                   return some (param, literal)
               return none

src/Lean/Compiler/LCNF/FixedParams.lean

@@ -62,7 +62,7 @@ structure State where
   Whenever there is function application `f a₁ ... aₙ`, where `f` is in `decls`, `f` is not `main`, and
   we visit with the abstract values assigned to `aᵢ`, but first we record the visit here.
   -/
-  visited : Std.HashSet (Name × Array AbsValue) := {}
+  visited : HashSet (Name × Array AbsValue) := {}
   /--
   Bitmask containing the result, i.e., which parameters of `main` are fixed.
   We initialize it with `true` everywhere.

src/Lean/Compiler/LCNF/FloatLetIn.lean

@@ -59,7 +59,7 @@ structure FloatState where
   /--
   A map from identifiers of declarations to their current decision.
   -/
-  decision : Std.HashMap FVarId Decision
+  decision : HashMap FVarId Decision
   /--
   A map from decisions (excluding `unknown`) to the declarations with
   these decisions (in correct order). Basically:
@@ -67,7 +67,7 @@ structure FloatState where
   - Which declarations do we move into a certain arm
   - Which declarations do we move into the default arm
   -/
-  newArms : Std.HashMap Decision (List CodeDecl)
+  newArms : HashMap Decision (List CodeDecl)
 
 /--
 Use to collect relevant declarations for the floating mechanism.
@@ -116,8 +116,8 @@ up to this point, with respect to `cs`. The initial decisions are:
 - `arm` or `default` if we see the declaration only being used in exactly one cases arm
 - `unknown` otherwise
 -/
-def initialDecisions (cs : Cases) : BaseFloatM (Std.HashMap FVarId Decision) := do
-  let mut map := Std.HashMap.empty (← read).decls.length
+def initialDecisions (cs : Cases) : BaseFloatM (HashMap FVarId Decision) := do
+  let mut map := mkHashMap (← read).decls.length
   let folder val acc := do
     if let .let decl := val then
       if (← ignore? decl) then
@@ -130,25 +130,25 @@ def initialDecisions (cs : Cases) : BaseFloatM (Std.HashMap FVarId Decision) :=
   (_, map) ← goCases cs |>.run map
   return map
 where
-  goFVar (plannedDecision : Decision) (var : FVarId) : StateRefT (Std.HashMap FVarId Decision) BaseFloatM Unit := do
-    if let some decision := (← get)[var]? then
+  goFVar (plannedDecision : Decision) (var : FVarId) : StateRefT (HashMap FVarId Decision) BaseFloatM Unit := do
+    if let some decision := (← get).find? var then
       if decision == .unknown then
         modify fun s => s.insert var plannedDecision
       else if decision != plannedDecision then
           modify fun s => s.insert var .dont
       -- otherwise we already have the proper decision
 
-  goAlt (alt : Alt) : StateRefT (Std.HashMap FVarId Decision) BaseFloatM Unit :=
+  goAlt (alt : Alt) : StateRefT (HashMap FVarId Decision) BaseFloatM Unit :=
     forFVarM (goFVar (.ofAlt alt)) alt
-  goCases (cs : Cases) : StateRefT (Std.HashMap FVarId Decision) BaseFloatM Unit :=
+  goCases (cs : Cases) : StateRefT (HashMap FVarId Decision) BaseFloatM Unit :=
     cs.alts.forM goAlt
 
 /--
 Compute the initial new arms. This will just set up a map from all arms of
 `cs` to empty `Array`s, plus one additional entry for `dont`.
 -/
-def initialNewArms (cs : Cases) : Std.HashMap Decision (List CodeDecl) := Id.run do
-  let mut map := Std.HashMap.empty (cs.alts.size + 1)
+def initialNewArms (cs : Cases) : HashMap Decision (List CodeDecl) := Id.run do
+  let mut map := mkHashMap (cs.alts.size + 1)
   map := map.insert .dont []
   cs.alts.foldr (init := map) fun val acc => acc.insert (.ofAlt val) []
 
@@ -170,7 +170,7 @@ respectively but since `z` can't be moved we don't want that to move `x` and `y`
 -/
 def dontFloat (decl : CodeDecl) : FloatM Unit := do
   forFVarM goFVar decl
-  modify fun s => { s with newArms := s.newArms.insert .dont (decl :: s.newArms[Decision.dont]!) }
+  modify fun s => { s with newArms := s.newArms.insert .dont (decl :: s.newArms.find! .dont) }
 where
   goFVar (fvar : FVarId) : FloatM Unit := do
     if (← get).decision.contains fvar then
@@ -223,12 +223,12 @@ Will:
     If we are at `y` `x` is still marked to be moved but we don't want that.
 -/
 def float (decl : CodeDecl) : FloatM Unit := do
-  let arm := (← get).decision[decl.fvarId]!
+  let arm := (← get).decision.find! decl.fvarId
   forFVarM (goFVar · arm) decl
-  modify fun s => { s with newArms := s.newArms.insert arm (decl :: s.newArms[arm]!) }
+  modify fun s => { s with newArms := s.newArms.insert arm (decl :: s.newArms.find! arm) }
 where
   goFVar (fvar : FVarId) (arm : Decision) : FloatM Unit := do
-    let some decision := (← get).decision[fvar]? | return ()
+    let some decision := (← get).decision.find? fvar | return ()
     if decision != arm then
       modify fun s => { s with decision := s.decision.insert fvar .dont }
     else if decision == .unknown then
@@ -249,7 +249,7 @@ where
   -/
   goCases : FloatM Unit := do
     for decl in (← read).decls do
-      let currentDecision := (← get).decision[decl.fvarId]!
+      let currentDecision := (← get).decision.find! decl.fvarId
       if currentDecision == .unknown then
         /-
         If the decision is still unknown by now this means `decl` is
@@ -284,10 +284,10 @@ where
         newArms := initialNewArms cs
       }
       let (_, res) ← goCases |>.run base
-      let remainders := res.newArms[Decision.dont]!
+      let remainders := res.newArms.find! .dont
       let altMapper alt := do
-        let decision := Decision.ofAlt alt
-        let newCode := res.newArms[decision]!
+        let decision := .ofAlt alt
+        let newCode := res.newArms.find! decision
         trace[Compiler.floatLetIn] "Size of code that was pushed into arm: {repr decision} {newCode.length}"
         let fused ← withNewScope do
           go (attachCodeDecls newCode.toArray alt.getCode)

src/Lean/Compiler/LCNF/JoinPoints.lean

@@ -29,7 +29,7 @@ structure CandidateInfo where
   The set of candidates that rely on this candidate to be a join point.
   For a more detailed explanation see the documentation of `find`
   -/
-  associated : Std.HashSet FVarId
+  associated : HashSet FVarId
   deriving Inhabited
 
 /--
@@ -39,14 +39,14 @@ structure FindState where
   /--
   All current join point candidates accessible by their `FVarId`.
   -/
-  candidates : Std.HashMap FVarId CandidateInfo := .empty
+  candidates : HashMap FVarId CandidateInfo := .empty
   /--
   The `FVarId`s of all `fun` declarations that were declared within the
   current `fun`.
   -/
-  scope : Std.HashSet FVarId := .empty
+  scope : HashSet FVarId := .empty
 
-abbrev ReplaceCtx := Std.HashMap FVarId Name
+abbrev ReplaceCtx := HashMap FVarId Name
 
 abbrev FindM := ReaderT (Option FVarId) StateRefT FindState ScopeM
 abbrev ReplaceM := ReaderT ReplaceCtx CompilerM
@@ -55,7 +55,7 @@ abbrev ReplaceM := ReaderT ReplaceCtx CompilerM
 Attempt to find a join point candidate by its `FVarId`.
 -/
 private def findCandidate? (fvarId : FVarId) : FindM (Option CandidateInfo) := do
-  return (← get).candidates[fvarId]?
+  return (← get).candidates.find? fvarId
 
 /--
 Erase a join point candidate as well as all the ones that depend on it
@@ -69,7 +69,7 @@ private partial def eraseCandidate (fvarId : FVarId) : FindM Unit := do
 /--
 Combinator for modifying the candidates in `FindM`.
 -/
-private def modifyCandidates (f : Std.HashMap FVarId CandidateInfo → Std.HashMap FVarId CandidateInfo) : FindM Unit :=
+private def modifyCandidates (f : HashMap FVarId CandidateInfo → HashMap FVarId CandidateInfo) : FindM Unit :=
   modify (fun state => {state with candidates := f state.candidates })
 
 /--
@@ -196,7 +196,7 @@ where
           return code
       | _, _ => return Code.updateLet! code decl (← go k)
     | .fun decl k =>
-      if let some replacement := (← read)[decl.fvarId]? then
+      if let some replacement := (← read).find? decl.fvarId then
         let newDecl := { decl with
           binderName := replacement,
           value := (← go decl.value)
@@ -244,7 +244,7 @@ structure ExtendState where
   to `Param`s. The free variables in this map are the once that the context
   of said join point will be extended by by passing in the respective parameter.
   -/
-  fvarMap : Std.HashMap FVarId (Std.HashMap FVarId Param) := {}
+  fvarMap : HashMap FVarId (HashMap FVarId Param) := {}
 
 /--
 The monad for the `extendJoinPointContext` pass.
@@ -262,7 +262,7 @@ otherwise just return `fvar`.
 def replaceFVar (fvar : FVarId) : ExtendM FVarId := do
   if (← read).candidates.contains fvar then
     if let some currentJp := (← read).currentJp? then
-      if let some replacement := (← get).fvarMap[currentJp]![fvar]? then
+      if let some replacement := (← get).fvarMap.find! currentJp |>.find? fvar then
         return replacement.fvarId
   return fvar
 
@@ -313,7 +313,7 @@ This is necessary if:
 -/
 def extendByIfNecessary (fvar : FVarId) : ExtendM Unit := do
   if let some currentJp := (← read).currentJp? then
-    let mut translator := (← get).fvarMap[currentJp]!
+    let mut translator := (← get).fvarMap.find! currentJp
     let candidates := (← read).candidates
     if !(← isInScope fvar) && !translator.contains fvar && candidates.contains fvar then
       let typ ← getType fvar
@@ -337,7 +337,7 @@ of `j.2` in `j.1`.
 -/
 def mergeJpContextIfNecessary (jp : FVarId) : ExtendM Unit := do
   if (← read).currentJp?.isSome then
-    let additionalArgs := (← get).fvarMap[jp]!.toArray
+    let additionalArgs := (← get).fvarMap.find! jp |>.toArray
     for (fvar, _) in additionalArgs do
       extendByIfNecessary fvar
 
@@ -405,7 +405,7 @@ where
     | .jp decl k =>
       let decl ← withNewJpScope decl do
         let value ← go decl.value
-        let additionalParams := (← get).fvarMap[decl.fvarId]!.toArray |>.map Prod.snd
+        let additionalParams := (← get).fvarMap.find! decl.fvarId |>.toArray |>.map Prod.snd
         let newType := additionalParams.foldr (init := decl.type) (fun val acc => .forallE val.binderName val.type acc .default)
         decl.update newType (additionalParams ++ decl.params) value
       mergeJpContextIfNecessary decl.fvarId
@@ -426,7 +426,7 @@ where
       return Code.updateCases! code cs.resultType discr alts
     | .jmp fn args =>
       let mut newArgs ← args.mapM (mapFVarM goFVar)
-      let additionalArgs := (← get).fvarMap[fn]!.toArray |>.map Prod.fst
+      let additionalArgs := (← get).fvarMap.find! fn |>.toArray |>.map Prod.fst
       if let some _currentJp := (← read).currentJp? then
         let f := fun arg => do
           return .fvar (← goFVar arg)
@@ -545,7 +545,7 @@ where
       if let some knownArgs := (← get).jpJmpArgs.find? fn then
         let mut newArgs := knownArgs
         for (param, arg) in decl.params.zip args do
-          if let some knownVal := newArgs[param.fvarId]? then
+          if let some knownVal := newArgs.find? param.fvarId then
             if arg.toExpr != knownVal then
               newArgs := newArgs.erase param.fvarId
         modify fun s => { s with jpJmpArgs := s.jpJmpArgs.insert fn newArgs }

src/Lean/Compiler/LCNF/LCtx.lean

@@ -13,9 +13,9 @@ namespace Lean.Compiler.LCNF
 LCNF local context.
 -/
 structure LCtx where
-  params   : Std.HashMap FVarId Param := {}
-  letDecls : Std.HashMap FVarId LetDecl := {}
-  funDecls : Std.HashMap FVarId FunDecl := {}
+  params   : HashMap FVarId Param := {}
+  letDecls : HashMap FVarId LetDecl := {}
+  funDecls : HashMap FVarId FunDecl := {}
   deriving Inhabited
 
 def LCtx.addParam (lctx : LCtx) (param : Param) : LCtx :=

src/Lean/Compiler/LCNF/Level.lean

@@ -30,7 +30,7 @@ structure State where
   /-- Counter for generating new (normalized) universe parameter names. -/
   nextIdx    : Nat := 1
   /-- Mapping from existing universe parameter names to the new ones. -/
-  map        : Std.HashMap Name Level := {}
+  map        : HashMap Name Level := {}
   /-- Parameters that have been normalized. -/
   paramNames : Array Name := #[]
 
@@ -49,7 +49,7 @@ partial def normLevel (u : Level) : M Level := do
     | .max v w  => return u.updateMax! (← normLevel v) (← normLevel w)
     | .imax v w => return u.updateIMax! (← normLevel v) (← normLevel w)
     | .mvar _   => unreachable!
-    | .param n  => match (← get).map[n]? with
+    | .param n  => match (← get).map.find? n with
       | some u => return u
       | none   =>
         let u := Level.param <| (`u).appendIndexAfter (← get).nextIdx

src/Lean/Compiler/LCNF/Probing.lean

@@ -31,9 +31,9 @@ def sortedBySize : Probe Decl (Nat × Decl) := fun decls =>
     if sz₁ == sz₂ then Name.lt decl₁.name decl₂.name else sz₁ < sz₂
 
 def countUnique [ToString α] [BEq α] [Hashable α] : Probe α (α × Nat) := fun data => do
-  let mut map := Std.HashMap.empty
+  let mut map := HashMap.empty
   for d in data do
-    if let some count := map[d]? then
+    if let some count := map.find? d then
       map := map.insert d (count + 1)
     else
       map := map.insert d 1

src/Lean/Compiler/LCNF/Simp/FunDeclInfo.lean

@@ -40,7 +40,7 @@ structure FunDeclInfoMap where
   /--
   Mapping from local function name to inlining information.
   -/
-  map : Std.HashMap FVarId FunDeclInfo := {}
+  map : HashMap FVarId FunDeclInfo := {}
   deriving Inhabited
 
 def FunDeclInfoMap.format (s : FunDeclInfoMap) : CompilerM Format := do
@@ -56,7 +56,7 @@ Add new occurrence for the local function with binder name `key`.
 def FunDeclInfoMap.add (s : FunDeclInfoMap) (fvarId : FVarId) : FunDeclInfoMap :=
   match s with
   | { map } =>
-    match map[fvarId]? with
+    match map.find? fvarId with
     | some .once => { map := map.insert fvarId .many }
     | none       => { map := map.insert fvarId .once }
     | _          => { map }
@@ -67,7 +67,7 @@ Add new occurrence for the local function occurring as an argument for another f
 def FunDeclInfoMap.addHo (s : FunDeclInfoMap) (fvarId : FVarId) : FunDeclInfoMap :=
   match s with
   | { map } =>
-    match map[fvarId]? with
+    match map.find? fvarId with
     | some .once | none => { map := map.insert fvarId .many }
     | _ => { map }
 

src/Lean/Compiler/LCNF/Simp/SimpM.lean

@@ -173,7 +173,7 @@ Execute `x` with `fvarId` set as `mustInline`.
 After execution the original setting is restored.
 -/
 def withAddMustInline (fvarId : FVarId) (x : SimpM α) : SimpM α := do
-  let saved? := (← get).funDeclInfoMap.map[fvarId]?
+  let saved? := (← get).funDeclInfoMap.map.find? fvarId
   try
     addMustInline fvarId
     x
@@ -185,7 +185,7 @@ Return true if the given local function declaration or join point id is marked a
 `once` or `mustInline`. We use this information to decide whether to inline them.
 -/
 def isOnceOrMustInline (fvarId : FVarId) : SimpM Bool := do
-  match (← get).funDeclInfoMap.map[fvarId]? with
+  match (← get).funDeclInfoMap.map.find? fvarId with
     | some .once | some .mustInline  => return true
     | _ => return false
 

src/Lean/Compiler/LCNF/ToLCNF.lean

@@ -199,9 +199,9 @@ structure State where
   /-- Cache from Lean regular expression to LCNF argument. -/
   cache : PHashMap Expr Arg := {}
   /-- `toLCNFType` cache -/
-  typeCache : Std.HashMap Expr Expr := {}
+  typeCache : HashMap Expr Expr := {}
   /-- isTypeFormerType cache -/
-  isTypeFormerTypeCache : Std.HashMap Expr Bool := {}
+  isTypeFormerTypeCache : HashMap Expr Bool := {}
   /-- LCNF sequence, we chain it to create a LCNF `Code` object. -/
   seq : Array Element := #[]
   /--
@@ -257,7 +257,7 @@ private partial def isTypeFormerType (type : Expr) : M Bool := do
   | .true => return true
   | .false => return false
   | .undef =>
-    if let some result := (← get).isTypeFormerTypeCache[type]? then
+    if let some result := (← get).isTypeFormerTypeCache.find? type then
       return result
     let result ← liftMetaM <| Meta.isTypeFormerType type
     modify fun s => { s with isTypeFormerTypeCache := s.isTypeFormerTypeCache.insert type result }
@@ -305,7 +305,7 @@ def applyToAny (type : Expr) : M Expr := do
     | _ => none
 
 def toLCNFType (type : Expr) : M Expr := do
-  match (← get).typeCache[type]? with
+  match (← get).typeCache.find? type with
   | some type' => return type'
   | none =>
     let type' ← liftMetaM <| LCNF.toLCNFType type

src/Lean/CoreM.lean

@@ -31,16 +31,7 @@ register_builtin_option maxHeartbeats : Nat := {
   descr := "maximum amount of heartbeats per command. A heartbeat is number of (small) memory allocations (in thousands), 0 means no limit"
 }
 
-/--
-If the `diagnostics` option is not already set, gives a message explaining this option.
-Begins with a `\n`, so an error message can look like `m!"some error occurred{useDiagnosticMsg}"`.
--/
-def useDiagnosticMsg : MessageData :=
-  MessageData.lazy fun ctx =>
-    if diagnostics.get ctx.opts then
-      pure ""
-    else
-      pure s!"\nAdditional diagnostic information may be available using the `set_option {diagnostics.name} true` command."
+def useDiagnosticMsg := s!"use `set_option {diagnostics.name} true` to get diagnostic information"
 
 namespace Core
 
@@ -309,10 +300,8 @@ register_builtin_option debug.moduleNameAtTimeout : Bool := {
 def throwMaxHeartbeat (moduleName : Name) (optionName : Name) (max : Nat) : CoreM Unit := do
   let includeModuleName := debug.moduleNameAtTimeout.get (← getOptions)
   let atModuleName := if includeModuleName then s!" at `{moduleName}`" else ""
-  throw <| Exception.error (← getRef) m!"\
-    (deterministic) timeout{atModuleName}, maximum number of heartbeats ({max/1000}) has been reached\n\
-    Use `set_option {optionName} <num>` to set the limit.\
-    {useDiagnosticMsg}"
+  let msg := s!"(deterministic) timeout{atModuleName}, maximum number of heartbeats ({max/1000}) has been reached\nuse `set_option {optionName} <num>` to set the limit\n{useDiagnosticMsg}"
+  throw <| Exception.error (← getRef) (MessageData.ofFormat (Std.Format.text msg))
 
 def checkMaxHeartbeatsCore (moduleName : String) (optionName : Name) (max : Nat) : CoreM Unit := do
   unless max == 0 do

src/Lean/Data/HashMap.lean

@@ -6,8 +6,6 @@ Author: Leonardo de Moura
 prelude
 import Init.Data.Nat.Power2
 import Lean.Data.AssocList
-import Std.Data.HashMap.Basic
-import Std.Data.HashMap.Raw
 namespace Lean
 
 def HashMapBucket (α : Type u) (β : Type v) :=
@@ -271,11 +269,17 @@ def ofListWith (l : List (α × β)) (f : β → β → β) : HashMap α β :=
         | none   => m.insert p.fst p.snd
         | some v => m.insert p.fst $ f v p.snd)
 
-attribute [deprecated Std.HashMap] HashMap
-attribute [deprecated Std.HashMap.Raw] HashMapImp
-attribute [deprecated Std.HashMap.Raw.empty] mkHashMapImp
-attribute [deprecated Std.HashMap.empty] mkHashMap
-attribute [deprecated Std.HashMap.empty] HashMap.empty
-attribute [deprecated Std.HashMap.ofList] HashMap.ofList
-
 end Lean.HashMap
+
+/--
+Groups all elements `x`, `y` in `xs` with `key x == key y` into the same array
+`(xs.groupByKey key).find! (key x)`. Groups preserve the relative order of elements in `xs`.
+-/
+def Array.groupByKey [BEq α] [Hashable α] (key : β → α) (xs : Array β)
+    : Lean.HashMap α (Array β) := Id.run do
+  let mut groups := ∅
+  for x in xs do
+    let group := groups.findD (key x) #[]
+    groups := groups.erase (key x) -- make `group` referentially unique
+    groups := groups.insert (key x) (group.push x)
+  return groups

src/Lean/Data/HashSet.lean

@@ -6,8 +6,6 @@ Author: Leonardo de Moura
 prelude
 import Init.Data.Nat.Power2
 import Init.Data.List.Control
-import Std.Data.HashSet.Basic
-import Std.Data.HashSet.Raw
 namespace Lean
 universe u v w
 
@@ -219,9 +217,3 @@ def insertMany [ForIn Id ρ α] (s : HashSet α) (as : ρ) : HashSet α := Id.ru
 def merge {α : Type u} [BEq α] [Hashable α] (s t : HashSet α) : HashSet α :=
   t.fold (init := s) fun s a => s.insert a
   -- We don't use `insertMany` here because it gives weird universes.
-
-attribute [deprecated Std.HashSet] HashSet
-attribute [deprecated Std.HashSet.Raw] HashSetImp
-attribute [deprecated Std.HashSet.Raw.empty] mkHashSetImp
-attribute [deprecated Std.HashSet.empty] mkHashSet
-attribute [deprecated Std.HashSet.empty] HashSet.empty