fix: add a bunch of structures

.github/workflows/build-template.yml

@@ -104,7 +104,7 @@ jobs:
           # NOTE: must be in sync with `save` below and with `restore-cache` in `update-stage0.yml`
           path: |
             .ccache
-            ${{ matrix.name == 'Linux Lake (cached)' && 'build/stage1/**/*.trace
+            ${{ matrix.name == 'Linux Lake' && false && 'build/stage1/**/*.trace
             build/stage1/**/*.olean*
             build/stage1/**/*.ilean
             build/stage1/**/*.ir
@@ -119,15 +119,9 @@ jobs:
         run: |
           ccache --zero-stats
         if: runner.os == 'Linux'
-      - name: Set up env
+      - name: Set up NPROC
         run: |
           echo "NPROC=$(nproc 2>/dev/null || sysctl -n hw.logicalcpu 2>/dev/null || echo 4)" >> $GITHUB_ENV
-          if ! diff src/stdlib_flags.h stage0/src/stdlib_flags.h; then
-            echo "src/stdlib_flags.h and stage0/src/stdlib_flags.h differ, will test and pack stage 2"
-            echo "TARGET_STAGE=stage2" >> $GITHUB_ENV
-          else
-            echo "TARGET_STAGE=stage1" >> $GITHUB_ENV
-          fi
       - name: Build
         run: |
           ulimit -c unlimited  # coredumps
@@ -148,9 +142,6 @@ jobs:
           if [[ -n '${{ matrix.prepare-llvm }}' ]]; then
             wget -q ${{ matrix.llvm-url }}
             PREPARE="$(${{ matrix.prepare-llvm }})"
-            if [ "$TARGET_STAGE" == "stage2" ]; then
-              cp -r stage1 stage2
-            fi
             eval "OPTIONS+=($PREPARE)"
           fi
           if [[ -n '${{ matrix.release }}' && -n '${{ inputs.nightly }}' ]]; then
@@ -165,10 +156,10 @@ jobs:
           fi
           # contortion to support empty OPTIONS with old macOS bash
           cmake .. --preset ${{ matrix.CMAKE_PRESET || 'release' }} -B . ${{ matrix.CMAKE_OPTIONS }} ${OPTIONS[@]+"${OPTIONS[@]}"} -DLEAN_INSTALL_PREFIX=$PWD/..
-          time make $TARGET_STAGE -j$NPROC
+          time make -j$NPROC
       - name: Install
         run: |
-          make -C build/$TARGET_STAGE install
+          make -C build install
       - name: Check Binaries
         run: ${{ matrix.binary-check }} lean-*/bin/* || true
       - name: Count binary symbols
@@ -199,18 +190,18 @@ jobs:
           path: pack/*
       - name: Lean stats
         run: |
-          build/stage1/bin/lean --stats src/Lean.lean -Dexperimental.module=true
+          build/stage1/bin/lean --stats src/Lean.lean
         if: ${{ !matrix.cross }}
       - name: Test
         id: test
         run: |
           ulimit -c unlimited  # coredumps
-          time ctest --preset ${{ matrix.CMAKE_PRESET || 'release' }} --test-dir build/$TARGET_STAGE -j$NPROC --output-junit test-results.xml ${{ matrix.CTARGET_OPTIONS }}
+          time ctest --preset ${{ matrix.CMAKE_PRESET || 'release' }} --test-dir build/stage1 -j$NPROC --output-junit test-results.xml ${{ matrix.CTEST_OPTIONS }}
         if: (matrix.wasm || !matrix.cross) && (inputs.check-level >= 1 || matrix.test)
       - name: Test Summary
         uses: test-summary/action@v2
         with:
-          paths: build/${{ env.TARGET_STAGE }}/test-results.xml
+          paths: build/stage1/test-results.xml
         # prefix `if` above with `always` so it's run even if tests failed
         if: always() && steps.test.conclusion != 'skipped'
       - name: Check Test Binary
@@ -235,9 +226,8 @@ jobs:
         if: matrix.test-speedcenter
       - name: Check rebootstrap
         run: |
-          # clean rebuild in case of Makefile changes/Lake does not detect uncommited stage 0
-          # changes yet
-          make -C build update-stage0 && make -C build/stage1 clean-stdlib && make -C build -j$NPROC
+          # clean rebuild in case of Makefile changes
+          make -C build update-stage0 && rm -rf build/stage* && make -C build -j$NPROC
         if: matrix.check-rebootstrap
       - name: CCache stats
         if: always()
@@ -256,15 +246,10 @@ jobs:
           # NOTE: must be in sync with `restore` above
           path: |
             .ccache
-            ${{ matrix.name == 'Linux Lake (cached)' && 'build/stage1/**/*.trace
+            ${{ matrix.name == 'Linux Lake' && false && 'build/stage1/**/*.trace
             build/stage1/**/*.olean*
             build/stage1/**/*.ilean
             build/stage1/**/*.ir
             build/stage1/**/*.c
             build/stage1/**/*.c.o*' || '' }}
           key: ${{ steps.restore-cache.outputs.cache-primary-key }}
-      - name: Upload Build Artifact
-        if: always() && matrix.name == 'Linux Lake (cached)'
-        uses: actions/upload-artifact@v4
-        with:
-          path: build

.github/workflows/ci.yml

@@ -165,7 +165,7 @@ jobs:
               {
                 // portable release build: use channel with older glibc (2.26)
                 "name": "Linux release",
-                "os": "ubuntu-latest",
+                "os": large && level < 2 ? "nscloud-ubuntu-22.04-amd64-4x16" : "ubuntu-latest",
                 "release": true,
                 // Special handling for release jobs. We want:
                 // 1. To run it in PRs so developers get PR toolchains (so secondary is sufficient)
@@ -194,13 +194,6 @@ jobs:
                 "test-speedcenter": large && level >= 2,
                 "CMAKE_OPTIONS": "-DUSE_LAKE=ON",
               },
-              {
-                "name": "Linux Lake (cached)",
-                "os": "ubuntu-latest",
-                "check-level": (isPr || isPushToMaster) ? 0 : 2,
-                "secondary": true,
-                "CMAKE_OPTIONS": "-DUSE_LAKE=ON",
-              },
               {
                 "name": "Linux Reldebug",
                 "os": "ubuntu-latest",
@@ -232,8 +225,8 @@ jobs:
               },
               {
                 "name": "macOS aarch64",
-                // standard GH runner only comes with 7GB so use large runner if possible when running tests
-                "os": large && !isPr ? "nscloud-macos-sonoma-arm64-6x14" : "macos-14",
+                // standard GH runner only comes with 7GB so use large runner if possible
+                "os": large ? "nscloud-macos-sonoma-arm64-6x14" : "macos-14",
                 "CMAKE_OPTIONS": "-DLEAN_INSTALL_SUFFIX=-darwin_aarch64",
                 "release": true,
                 "shell": "bash -euxo pipefail {0}",
@@ -241,13 +234,13 @@ jobs:
                 "prepare-llvm": "../script/prepare-llvm-macos.sh lean-llvm*",
                 "binary-check": "otool -L",
                 "tar": "gtar", // https://github.com/actions/runner-images/issues/2619
-                // See "Linux release" for release job levels; Grove is not a concern here
+                // See above for release job levels
                 "check-level": isPr ? 0 : 2,
                 "secondary": isPr,
               },
               {
                 "name": "Windows",
-                "os": large && level == 2 ? "namespace-profile-windows-amd64-4x16" : "windows-2022",
+                "os": "windows-2022",
                 "release": true,
                 "check-level": 2,
                 "shell": "msys2 {0}",

.github/workflows/grove.yml

@@ -30,8 +30,8 @@ jobs:
           # Check if it's a push to master (no PR number and target branch is master)
           if [ -z "${{ steps.workflow-info.outputs.pullRequestNumber }}" ]; then
             if [ "${{ github.event.workflow_run.head_branch }}" = "master" ]; then
-              echo "Push to master detected. Running Grove."
-              echo "should-run=true" >> "$GITHUB_OUTPUT"
+              echo "Push to master detected. Skipping for now, to be enabled later."
+              echo "should-run=false" >> "$GITHUB_OUTPUT"
             else
               echo "Push to non-master branch, skipping"
               echo "should-run=false" >> "$GITHUB_OUTPUT"
@@ -40,7 +40,7 @@ jobs:
             # Check if it's a PR with grove label
             PR_LABELS='${{ steps.workflow-info.outputs.pullRequestLabels }}'
             if echo "$PR_LABELS" | grep -q '"grove"'; then
-              echo "PR with grove label detected. Running Grove."
+              echo "PR with grove label detected"
               echo "should-run=true" >> "$GITHUB_OUTPUT"
             else
               echo "PR without grove label, skipping"
@@ -51,7 +51,7 @@ jobs:
       - name: Fetch upstream invalidated facts
         if: ${{ steps.should-run.outputs.should-run == 'true' && steps.workflow-info.outputs.pullRequestNumber != '' }}
         id: fetch-upstream
-        uses: TwoFx/grove-action/fetch-upstream@v0.4
+        uses: TwoFx/grove-action/fetch-upstream@v0.3
         with:
           artifact-name: grove-invalidated-facts
           base-ref: master
@@ -64,7 +64,7 @@ jobs:
           commit: ${{ steps.workflow-info.outputs.sourceHeadSha }}
           workflow: ci.yml
           path: artifacts
-          name: "build-Linux release"
+          name: build-Linux.*
           name_is_regexp: true
 
       - name: Unpack toolchain
@@ -95,7 +95,7 @@ jobs:
       - name: Build
         if: ${{ steps.should-run.outputs.should-run == 'true' }}
         id: build
-        uses: TwoFx/grove-action/build@v0.4
+        uses: TwoFx/grove-action/build@v0.3
         with:
           project-path: doc/std/grove
           script-name: grove-stdlib

CODEOWNERS

@@ -48,7 +48,3 @@
 /src/Std/Do @sgraf812
 /src/Std/Tactic/Do @sgraf812
 /src/Lean/Elab/Tactic/Do @sgraf812
-/src/Init/Data/Range/Polymorphic @datokrat
-/src/Init/Data/Slice @datokrat
-/src/Init/Data/Iterators @datokrat
-/src/Std/Data/Iterators @datokrat

doc/make/index.md

@@ -44,20 +44,15 @@ Useful CMake Configuration Settings
 Pass these along with the `cmake --preset release` command.
 There are also two alternative presets that combine some of these options you can use instead of `release`: `debug` and `sandebug` (sanitize + debug).
 
-* `-DCMAKE_BUILD_TYPE=`\
+* `-D CMAKE_BUILD_TYPE=`\
   Select the build type. Valid values are `RELEASE` (default), `DEBUG`,
   `RELWITHDEBINFO`, and `MINSIZEREL`.
 
-* `-DCMAKE_C_COMPILER=`\
-  `-DCMAKE_CXX_COMPILER=`\
+* `-D CMAKE_C_COMPILER=`\
+  `-D CMAKE_CXX_COMPILER=`\
   Select the C/C++ compilers to use. Official Lean releases currently use Clang;
   see also `.github/workflows/ci.yml` for the CI config.
 
-* `-DUSE_LAKE=ON`\
-  Experimental option to build the core libraries using Lake instead of `lean.mk`.  Caveats:
-  * As native code compilation is still handled by cmake, changes to stage0/ (such as from `git pull`) are picked up only when invoking the build via `make`, not via `Refresh Dependencies` in the editor.
-  * `USE_LAKE` is not yet compatible with `LAKE_ARTIFACT_CACHE`
-
 Lean will automatically use [CCache](https://ccache.dev/) if available to avoid
 redundant builds, especially after stage 0 has been updated.
 

doc/make/osx-10.9.md

@@ -1,4 +1,4 @@
-# Install Packages on OS X
+# Install Packages on OS X 14.5
 
 We assume that you are using [homebrew][homebrew] as a package manager.
 
@@ -6,23 +6,23 @@ We assume that you are using [homebrew][homebrew] as a package manager.
 
 ## Compilers
 
-You need a C++14-compatible compiler to build Lean. As of July
-2025, you have three options:
+You need a C++11-compatible compiler to build Lean. As of November
+2014, you have three options:
 
- - clang++ shipped with OSX (at time of writing v17.0.0)
- - clang++ via homebrew (at time of writing, v20.1.8)
- - gcc via homebrew (at time of writing, v15.1.0)
+ - clang++-3.5 (shipped with OSX, Apple LLVM version 6.0)
+ - gcc-4.9.1 (homebrew)
+ - clang++-3.5 (homebrew)
 
 We recommend to use Apple's clang++ because it is pre-shipped with OS
 X and requires no further installation.
 
-To install gcc via homebrew, please execute:
+To install gcc-4.9.1 via homebrew, please execute:
 ```bash
 brew install gcc
 ```
-To install clang via homebrew, please execute:
+To install clang++-3.5 via homebrew, please execute:
 ```bash
-brew install llvm lld
+brew install llvm
 ```
 To use compilers other than the default one (Apple's clang++), you
 need to use `-DCMAKE_CXX_COMPILER` option to specify the compiler

doc/std/grove/GroveStdlib/Generated.lean

@@ -1,9 +1,5 @@
 import Grove.Framework
 import GroveStdlib.Generated.«associative-query-operations»
-import GroveStdlib.Generated.«associative-creation-operations»
-import GroveStdlib.Generated.«associative-modification-operations»
-import GroveStdlib.Generated.«associative-create-then-query»
-import GroveStdlib.Generated.«associative-all-operations-covered»
 
 /-
 This file is autogenerated by grove. You can manually edit it, for example to resolve merge
@@ -16,7 +12,3 @@ namespace GroveStdlib.Generated
 
 def restoreState : RestoreStateM Unit := do
   «associative-query-operations».restoreState
-  «associative-creation-operations».restoreState
-  «associative-modification-operations».restoreState
-  «associative-create-then-query».restoreState
-  «associative-all-operations-covered».restoreState

doc/std/grove/GroveStdlib/Generated/associative-all-operations-covered.lean

@@ -1,34 +0,0 @@
-import Grove.Framework
-
-/-
-This file is autogenerated by grove. You can manually edit it, for example to resolve merge
-conflicts, but be careful.
--/
-
-open Grove.Framework Widget
-
-namespace GroveStdlib.Generated.«associative-all-operations-covered»
-
-def «all-covered» : Assertion.Fact where
-  widgetId := "associative-all-operations-covered"
-  factId := "all-covered"
-  assertionId := "all-covered"
-  state := {
-    assertionId := "all-covered"
-    description := "All operations should be covered"
-    passed := false
-    message := "There were 19697 operations that were not covered."
-  }
-  metadata := {
-    status := .bad
-    comment := "Still missing some!"
-  }
-
-def table : Assertion.Data  where
-  widgetId := "associative-all-operations-covered"
-  facts := #[
-    «all-covered»,
-  ]
-
-def restoreState : RestoreStateM Unit := do
-  addAssertion table

doc/std/grove/GroveStdlib/Generated/associative-create-then-query.lean

@@ -1,357 +0,0 @@
-import Grove.Framework
-
-/-
-This file is autogenerated by grove. You can manually edit it, for example to resolve merge
-conflicts, but be careful.
--/
-
-open Grove.Framework Widget
-
-namespace GroveStdlib.Generated.«associative-create-then-query»
-
-def «2cb3c441-9663-4ce7-9527-0f40fc29925a:::01f88623-fa5f-4380-9772-b30f2fec5c94:::Std.DHashMap::Std.DHashMap.Raw::Std.ExtDHashMap::Std.DTreeMap::Std.DTreeMap.Raw::Std.ExtDTreeMap» : Table.Fact .subexpression .subexpression .declaration where
-  widgetId := "associative-create-then-query"
-  factId := "2cb3c441-9663-4ce7-9527-0f40fc29925a:::01f88623-fa5f-4380-9772-b30f2fec5c94:::Std.DHashMap::Std.DHashMap.Raw::Std.ExtDHashMap::Std.DTreeMap::Std.DTreeMap.Raw::Std.ExtDTreeMap"
-  rowAssociationId := "2cb3c441-9663-4ce7-9527-0f40fc29925a"
-  columnAssociationId := "01f88623-fa5f-4380-9772-b30f2fec5c94"
-  selectedLayers := #["Std.DHashMap", "Std.DHashMap.Raw", "Std.ExtDHashMap", "Std.DTreeMap", "Std.DTreeMap.Raw", "Std.ExtDTreeMap", ]
-  layerStates := #[
-    {
-      layerIdentifier := "Std.DHashMap"
-      rowState := 
-        
-        some ⟨"Std.DHashMap.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DHashMap.emptyWithCapacity,
-              renderedStatement := "Std.DHashMap.emptyWithCapacity.{u, v} {α : Type u} {β : α → Type v} [BEq α] [Hashable α]\n  (capacity : Nat := 8) : Std.DHashMap α β",
-              isDeprecated := false })⟩
-        
-      columnState := 
-        
-        some ⟨"Std.DHashMap.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DHashMap.isEmpty,
-              renderedStatement := "Std.DHashMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (m : Std.DHashMap α β) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-      ]
-    },
-    {
-      layerIdentifier := "Std.DHashMap.Raw"
-      rowState := 
-        
-        some ⟨"Std.DHashMap.Raw.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DHashMap.Raw.emptyWithCapacity,
-              renderedStatement := "Std.DHashMap.Raw.emptyWithCapacity.{u, v} {α : Type u} {β : α → Type v} (capacity : Nat := 8) :\n  Std.DHashMap.Raw α β",
-              isDeprecated := false })⟩
-        
-      columnState := 
-        
-        some ⟨"Std.DHashMap.Raw.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DHashMap.Raw.isEmpty,
-              renderedStatement := "Std.DHashMap.Raw.isEmpty.{u, v} {α : Type u} {β : α → Type v} (m : Std.DHashMap.Raw α β) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-      ]
-    },
-    {
-      layerIdentifier := "Std.ExtDHashMap"
-      rowState := 
-        
-        some ⟨"Std.ExtDHashMap.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.ExtDHashMap.emptyWithCapacity,
-              renderedStatement := "Std.ExtDHashMap.emptyWithCapacity.{u, v} {α : Type u} {β : α → Type v} [BEq α] [Hashable α]\n  (capacity : Nat := 8) : Std.ExtDHashMap α β",
-              isDeprecated := false })⟩
-        
-      columnState := 
-        
-        some ⟨"Std.ExtDHashMap.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.ExtDHashMap.isEmpty,
-              renderedStatement := "Std.ExtDHashMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  [EquivBEq α] [LawfulHashable α] (m : Std.ExtDHashMap α β) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-      ]
-    },
-    {
-      layerIdentifier := "Std.DTreeMap"
-      rowState := 
-        
-        some ⟨"Std.DTreeMap.empty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DTreeMap.empty,
-              renderedStatement := "Std.DTreeMap.empty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} :\n  Std.DTreeMap α β cmp",
-              isDeprecated := false })⟩
-        
-      columnState := 
-        
-        some ⟨"Std.DTreeMap.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DTreeMap.isEmpty,
-              renderedStatement := "Std.DTreeMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap α β cmp) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-      ]
-    },
-    {
-      layerIdentifier := "Std.DTreeMap.Raw"
-      rowState := 
-        
-        some ⟨"Std.DTreeMap.Raw.empty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DTreeMap.Raw.empty,
-              renderedStatement := "Std.DTreeMap.Raw.empty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} :\n  Std.DTreeMap.Raw α β cmp",
-              isDeprecated := false })⟩
-        
-      columnState := 
-        
-        some ⟨"Std.DTreeMap.Raw.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DTreeMap.Raw.isEmpty,
-              renderedStatement := "Std.DTreeMap.Raw.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap.Raw α β cmp) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-      ]
-    },
-    {
-      layerIdentifier := "Std.ExtDTreeMap"
-      rowState := 
-        
-        some ⟨"Std.ExtDTreeMap.empty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.ExtDTreeMap.empty,
-              renderedStatement := "Std.ExtDTreeMap.empty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} :\n  Std.ExtDTreeMap α β cmp",
-              isDeprecated := false })⟩
-        
-      columnState := 
-        
-        some ⟨"Std.ExtDTreeMap.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.ExtDTreeMap.isEmpty,
-              renderedStatement := "Std.ExtDTreeMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.ExtDTreeMap α β cmp) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-      ]
-    },
-  ]
-  metadata := {
-    status := .done
-    comment := "Not necessary for `ExtDHashMap` because of simp lemma turning into varno"
-  }
-
-def «5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d:::01f88623-fa5f-4380-9772-b30f2fec5c94:::Std.DHashMap::Std.DHashMap.Raw::Std.ExtDHashMap::Std.DTreeMap::Std.DTreeMap.Raw::Std.ExtDTreeMap» : Table.Fact .subexpression .subexpression .declaration where
-  widgetId := "associative-create-then-query"
-  factId := "5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d:::01f88623-fa5f-4380-9772-b30f2fec5c94:::Std.DHashMap::Std.DHashMap.Raw::Std.ExtDHashMap::Std.DTreeMap::Std.DTreeMap.Raw::Std.ExtDTreeMap"
-  rowAssociationId := "5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d"
-  columnAssociationId := "01f88623-fa5f-4380-9772-b30f2fec5c94"
-  selectedLayers := #["Std.DHashMap", "Std.DHashMap.Raw", "Std.ExtDHashMap", "Std.DTreeMap", "Std.DTreeMap.Raw", "Std.ExtDTreeMap", ]
-  layerStates := #[
-    {
-      layerIdentifier := "Std.DHashMap"
-      rowState := 
-        
-        some ⟨"app (EmptyCollection.emptyCollection) (Std.DHashMap*)", Grove.Framework.Subexpression.State.predicate
-          { key := "app (EmptyCollection.emptyCollection) (Std.DHashMap*)", displayShort := "∅" }⟩
-        
-      columnState := 
-        
-        some ⟨"Std.DHashMap.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DHashMap.isEmpty,
-              renderedStatement := "Std.DHashMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (m : Std.DHashMap α β) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-        ⟨"Std.DHashMap.isEmpty_empty", Grove.Framework.Declaration.thm
-  { name := `Std.DHashMap.isEmpty_empty,
-    renderedStatement := "Std.DHashMap.isEmpty_empty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} :\n  ∅.isEmpty = true",
-    isSimp := true,
-    isDeprecated := false }⟩
-,
-      ]
-    },
-    {
-      layerIdentifier := "Std.DHashMap.Raw"
-      rowState := 
-        
-        some ⟨"app (EmptyCollection.emptyCollection) (Std.DHashMap.Raw*)", Grove.Framework.Subexpression.State.predicate
-          { key := "app (EmptyCollection.emptyCollection) (Std.DHashMap.Raw*)", displayShort := "∅" }⟩
-        
-      columnState := 
-        
-        some ⟨"Std.DHashMap.Raw.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DHashMap.Raw.isEmpty,
-              renderedStatement := "Std.DHashMap.Raw.isEmpty.{u, v} {α : Type u} {β : α → Type v} (m : Std.DHashMap.Raw α β) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-        ⟨"Std.DHashMap.Raw.isEmpty_emptyc", Grove.Framework.Declaration.thm
-  { name := `Std.DHashMap.Raw.isEmpty_emptyc,
-    renderedStatement := "Std.DHashMap.Raw.isEmpty_emptyc.{u_1, u_2} {α : Type u_1} {β : α → Type u_2} [BEq α] [Hashable α] :\n  ∅.isEmpty = true",
-    isSimp := false,
-    isDeprecated := true }⟩
-,
-      ]
-    },
-    {
-      layerIdentifier := "Std.ExtDHashMap"
-      rowState := 
-        
-        some ⟨"app (EmptyCollection.emptyCollection) (Std.ExtDHashMap*)", Grove.Framework.Subexpression.State.predicate
-          { key := "app (EmptyCollection.emptyCollection) (Std.ExtDHashMap*)", displayShort := "∅" }⟩
-        
-      columnState := 
-        
-        some ⟨"Std.ExtDHashMap.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.ExtDHashMap.isEmpty,
-              renderedStatement := "Std.ExtDHashMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  [EquivBEq α] [LawfulHashable α] (m : Std.ExtDHashMap α β) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-      ]
-    },
-    {
-      layerIdentifier := "Std.DTreeMap"
-      rowState := 
-        
-        some ⟨"app (EmptyCollection.emptyCollection) (Std.DTreeMap*)", Grove.Framework.Subexpression.State.predicate
-          { key := "app (EmptyCollection.emptyCollection) (Std.DTreeMap*)", displayShort := "∅" }⟩
-        
-      columnState := 
-        
-        some ⟨"Std.DTreeMap.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DTreeMap.isEmpty,
-              renderedStatement := "Std.DTreeMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap α β cmp) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-        ⟨"Std.DTreeMap.isEmpty_emptyc", Grove.Framework.Declaration.thm
-  { name := `Std.DTreeMap.isEmpty_emptyc,
-    renderedStatement := "Std.DTreeMap.isEmpty_emptyc.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} :\n  ∅.isEmpty = true",
-    isSimp := true,
-    isDeprecated := false }⟩
-,
-      ]
-    },
-    {
-      layerIdentifier := "Std.DTreeMap.Raw"
-      rowState := 
-        
-        some ⟨"app (EmptyCollection.emptyCollection) (Std.DTreeMap.Raw*)", Grove.Framework.Subexpression.State.predicate
-          { key := "app (EmptyCollection.emptyCollection) (Std.DTreeMap.Raw*)", displayShort := "∅" }⟩
-        
-      columnState := 
-        
-        some ⟨"Std.DTreeMap.Raw.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.DTreeMap.Raw.isEmpty,
-              renderedStatement := "Std.DTreeMap.Raw.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap.Raw α β cmp) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-        ⟨"Std.DTreeMap.Raw.isEmpty_emptyc", Grove.Framework.Declaration.thm
-  { name := `Std.DTreeMap.Raw.isEmpty_emptyc,
-    renderedStatement := "Std.DTreeMap.Raw.isEmpty_emptyc.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} :\n  ∅.isEmpty = true",
-    isSimp := true,
-    isDeprecated := false }⟩
-,
-      ]
-    },
-    {
-      layerIdentifier := "Std.ExtDTreeMap"
-      rowState := 
-        
-        some ⟨"app (EmptyCollection.emptyCollection) (Std.ExtDTreeMap*)", Grove.Framework.Subexpression.State.predicate
-          { key := "app (EmptyCollection.emptyCollection) (Std.ExtDTreeMap*)", displayShort := "∅" }⟩
-        
-      columnState := 
-        
-        some ⟨"Std.ExtDTreeMap.isEmpty", Grove.Framework.Subexpression.State.declaration
-          (Grove.Framework.Declaration.def
-            { name := `Std.ExtDTreeMap.isEmpty,
-              renderedStatement := "Std.ExtDTreeMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.ExtDTreeMap α β cmp) : Bool",
-              isDeprecated := false })⟩
-        
-      selectedCellStates := #[
-        ⟨"Std.ExtDTreeMap.isEmpty_empty", Grove.Framework.Declaration.thm
-  { name := `Std.ExtDTreeMap.isEmpty_empty,
-    renderedStatement := "Std.ExtDTreeMap.isEmpty_empty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} :\n  ∅.isEmpty = true",
-    isSimp := true,
-    isDeprecated := false }⟩
-,
-      ]
-    },
-  ]
-  metadata := {
-    status := .bad
-    comment := "Missing for `ExtDHashMap`"
-  }
-
-def table : Table.Data .subexpression .subexpression .declaration where
-  widgetId := "associative-create-then-query"
-  selectedRowAssociations := #["2cb3c441-9663-4ce7-9527-0f40fc29925a", "7743a485-024d-43b6-bd5f-ebd3182eb94d", "5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d", ]
-  selectedColumnAssociations := #["01f88623-fa5f-4380-9772-b30f2fec5c94", "f084f852-af71-45b6-8ab3-d251a8144f72", ]
-  selectedLayers := #["Std.DHashMap", "Std.DHashMap.Raw", "Std.ExtDHashMap", "Std.DTreeMap", "Std.DTreeMap.Raw", "Std.ExtDTreeMap", ]
-  selectedCellOptions := #[
-    {
-      layerIdentifier := "Std.DHashMap"
-      rowValue := "2cb3c441-9663-4ce7-9527-0f40fc29925a"
-      columnValue := "01f88623-fa5f-4380-9772-b30f2fec5c94"
-      selectedCellOptions := #["Std.DHashMap.isEmpty_emptyWithCapacity", ]
-    },
-    {
-      layerIdentifier := "Std.DHashMap.Raw"
-      rowValue := "2cb3c441-9663-4ce7-9527-0f40fc29925a"
-      columnValue := "01f88623-fa5f-4380-9772-b30f2fec5c94"
-      selectedCellOptions := #["Std.DHashMap.Raw.isEmpty_emptyWithCapacity", ]
-    },
-    {
-      layerIdentifier := "Std.DHashMap"
-      rowValue := "5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d"
-      columnValue := "01f88623-fa5f-4380-9772-b30f2fec5c94"
-      selectedCellOptions := #["Std.DHashMap.isEmpty_empty", ]
-    },
-    {
-      layerIdentifier := "Std.DHashMap.Raw"
-      rowValue := "5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d"
-      columnValue := "01f88623-fa5f-4380-9772-b30f2fec5c94"
-      selectedCellOptions := #["Std.DHashMap.Raw.isEmpty_emptyc", ]
-    },
-    {
-      layerIdentifier := "Std.DTreeMap"
-      rowValue := "5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d"
-      columnValue := "01f88623-fa5f-4380-9772-b30f2fec5c94"
-      selectedCellOptions := #["Std.DTreeMap.isEmpty_emptyc", ]
-    },
-    {
-      layerIdentifier := "Std.DTreeMap.Raw"
-      rowValue := "5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d"
-      columnValue := "01f88623-fa5f-4380-9772-b30f2fec5c94"
-      selectedCellOptions := #["Std.DTreeMap.Raw.isEmpty_emptyc", ]
-    },
-    {
-      layerIdentifier := "Std.ExtDTreeMap"
-      rowValue := "5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d"
-      columnValue := "01f88623-fa5f-4380-9772-b30f2fec5c94"
-      selectedCellOptions := #["Std.ExtDTreeMap.isEmpty_empty", ]
-    },
-  ]
-  facts := #[
-    «2cb3c441-9663-4ce7-9527-0f40fc29925a:::01f88623-fa5f-4380-9772-b30f2fec5c94:::Std.DHashMap::Std.DHashMap.Raw::Std.ExtDHashMap::Std.DTreeMap::Std.DTreeMap.Raw::Std.ExtDTreeMap»,
-    «5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d:::01f88623-fa5f-4380-9772-b30f2fec5c94:::Std.DHashMap::Std.DHashMap.Raw::Std.ExtDHashMap::Std.DTreeMap::Std.DTreeMap.Raw::Std.ExtDTreeMap»,
-  ]
-
-def restoreState : RestoreStateM Unit := do
-  addTable table

doc/std/grove/GroveStdlib/Generated/associative-creation-operations.lean

@@ -1,216 +0,0 @@
-import Grove.Framework
-
-/-
-This file is autogenerated by grove. You can manually edit it, for example to resolve merge
-conflicts, but be careful.
--/
-
-open Grove.Framework Widget
-
-namespace GroveStdlib.Generated.«associative-creation-operations»
-
-def «2cb3c441-9663-4ce7-9527-0f40fc29925a» : AssociationTable.Fact .subexpression where
-  widgetId := "associative-creation-operations"
-  factId := "2cb3c441-9663-4ce7-9527-0f40fc29925a"
-  rowId := "2cb3c441-9663-4ce7-9527-0f40fc29925a"
-  rowState := #[⟨"Std.DHashMap", "Std.DHashMap.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DHashMap.emptyWithCapacity,
-      renderedStatement := "Std.DHashMap.emptyWithCapacity.{u, v} {α : Type u} {β : α → Type v} [BEq α] [Hashable α]\n  (capacity : Nat := 8) : Std.DHashMap α β",
-      isDeprecated := false })⟩,⟨"Std.DHashMap.Raw", "Std.DHashMap.Raw.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DHashMap.Raw.emptyWithCapacity,
-      renderedStatement := "Std.DHashMap.Raw.emptyWithCapacity.{u, v} {α : Type u} {β : α → Type v} (capacity : Nat := 8) :\n  Std.DHashMap.Raw α β",
-      isDeprecated := false })⟩,⟨"Std.ExtDHashMap", "Std.ExtDHashMap.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtDHashMap.emptyWithCapacity,
-      renderedStatement := "Std.ExtDHashMap.emptyWithCapacity.{u, v} {α : Type u} {β : α → Type v} [BEq α] [Hashable α]\n  (capacity : Nat := 8) : Std.ExtDHashMap α β",
-      isDeprecated := false })⟩,⟨"Std.DTreeMap", "Std.DTreeMap.empty", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DTreeMap.empty,
-      renderedStatement := "Std.DTreeMap.empty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} :\n  Std.DTreeMap α β cmp",
-      isDeprecated := false })⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.empty", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DTreeMap.Raw.empty,
-      renderedStatement := "Std.DTreeMap.Raw.empty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} :\n  Std.DTreeMap.Raw α β cmp",
-      isDeprecated := false })⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.empty", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtDTreeMap.empty,
-      renderedStatement := "Std.ExtDTreeMap.empty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} :\n  Std.ExtDTreeMap α β cmp",
-      isDeprecated := false })⟩,⟨"Std.HashMap", "Std.HashMap.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashMap.emptyWithCapacity,
-      renderedStatement := "Std.HashMap.emptyWithCapacity.{u, v} {α : Type u} {β : Type v} [BEq α] [Hashable α]\n  (capacity : Nat := 8) : Std.HashMap α β",
-      isDeprecated := false })⟩,⟨"Std.HashMap.Raw", "Std.HashMap.Raw.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashMap.Raw.emptyWithCapacity,
-      renderedStatement := "Std.HashMap.Raw.emptyWithCapacity.{u, v} {α : Type u} {β : Type v} (capacity : Nat := 8) :\n  Std.HashMap.Raw α β",
-      isDeprecated := false })⟩,⟨"Std.ExtHashMap", "Std.ExtHashMap.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtHashMap.emptyWithCapacity,
-      renderedStatement := "Std.ExtHashMap.emptyWithCapacity.{u, v} {α : Type u} {β : Type v} [BEq α] [Hashable α]\n  (capacity : Nat := 8) : Std.ExtHashMap α β",
-      isDeprecated := false })⟩,⟨"Std.TreeMap", "Std.TreeMap.empty", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeMap.empty,
-      renderedStatement := "Std.TreeMap.empty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} : Std.TreeMap α β cmp",
-      isDeprecated := false })⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.empty", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeMap.Raw.empty,
-      renderedStatement := "Std.TreeMap.Raw.empty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} :\n  Std.TreeMap.Raw α β cmp",
-      isDeprecated := false })⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.empty", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtTreeMap.empty,
-      renderedStatement := "Std.ExtTreeMap.empty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} :\n  Std.ExtTreeMap α β cmp",
-      isDeprecated := false })⟩,⟨"Std.HashSet", "Std.HashSet.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashSet.emptyWithCapacity,
-      renderedStatement := "Std.HashSet.emptyWithCapacity.{u} {α : Type u} [BEq α] [Hashable α] (capacity : Nat := 8) :\n  Std.HashSet α",
-      isDeprecated := false })⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashSet.Raw.emptyWithCapacity,
-      renderedStatement := "Std.HashSet.Raw.emptyWithCapacity.{u} {α : Type u} (capacity : Nat := 8) : Std.HashSet.Raw α",
-      isDeprecated := false })⟩,⟨"Std.ExtHashSet", "Std.ExtHashSet.emptyWithCapacity", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtHashSet.emptyWithCapacity,
-      renderedStatement := "Std.ExtHashSet.emptyWithCapacity.{u} {α : Type u} [BEq α] [Hashable α] (capacity : Nat := 8) :\n  Std.ExtHashSet α",
-      isDeprecated := false })⟩,⟨"Std.TreeSet", "Std.TreeSet.empty", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeSet.empty,
-      renderedStatement := "Std.TreeSet.empty.{u} {α : Type u} {cmp : α → α → Ordering} : Std.TreeSet α cmp",
-      isDeprecated := false })⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.empty", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeSet.Raw.empty,
-      renderedStatement := "Std.TreeSet.Raw.empty.{u} {α : Type u} {cmp : α → α → Ordering} : Std.TreeSet.Raw α cmp",
-      isDeprecated := false })⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.empty", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtTreeSet.empty,
-      renderedStatement := "Std.ExtTreeSet.empty.{u} {α : Type u} {cmp : α → α → Ordering} : Std.ExtTreeSet α cmp",
-      isDeprecated := false })⟩,]
-  metadata := {
-    status := .done
-    comment := ""
-  }
-def «7743a485-024d-43b6-bd5f-ebd3182eb94d» : AssociationTable.Fact .subexpression where
-  widgetId := "associative-creation-operations"
-  factId := "7743a485-024d-43b6-bd5f-ebd3182eb94d"
-  rowId := "7743a485-024d-43b6-bd5f-ebd3182eb94d"
-  rowState := #[⟨"Std.DHashMap", "Std.DHashMap.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DHashMap.ofList,
-      renderedStatement := "Std.DHashMap.ofList.{u, v} {α : Type u} {β : α → Type v} [BEq α] [Hashable α]\n  (l : List ((a : α) × β a)) : Std.DHashMap α β",
-      isDeprecated := false })⟩,⟨"Std.DHashMap.Raw", "Std.DHashMap.Raw.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DHashMap.Raw.ofList,
-      renderedStatement := "Std.DHashMap.Raw.ofList.{u, v} {α : Type u} {β : α → Type v} [BEq α] [Hashable α]\n  (l : List ((a : α) × β a)) : Std.DHashMap.Raw α β",
-      isDeprecated := false })⟩,⟨"Std.ExtDHashMap", "Std.ExtDHashMap.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtDHashMap.ofList,
-      renderedStatement := "Std.ExtDHashMap.ofList.{u, v} {α : Type u} {β : α → Type v} [BEq α] [Hashable α]\n  (l : List ((a : α) × β a)) : Std.ExtDHashMap α β",
-      isDeprecated := false })⟩,⟨"Std.DTreeMap", "Std.DTreeMap.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DTreeMap.ofList,
-      renderedStatement := "Std.DTreeMap.ofList.{u, v} {α : Type u} {β : α → Type v} (l : List ((a : α) × β a))\n  (cmp : α → α → Ordering := by exact compare) : Std.DTreeMap α β cmp",
-      isDeprecated := false })⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DTreeMap.Raw.ofList,
-      renderedStatement := "Std.DTreeMap.Raw.ofList.{u, v} {α : Type u} {β : α → Type v} (l : List ((a : α) × β a))\n  (cmp : α → α → Ordering := by exact compare) : Std.DTreeMap.Raw α β cmp",
-      isDeprecated := false })⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtDTreeMap.ofList,
-      renderedStatement := "Std.ExtDTreeMap.ofList.{u, v} {α : Type u} {β : α → Type v} (l : List ((a : α) × β a))\n  (cmp : α → α → Ordering := by exact compare) : Std.ExtDTreeMap α β cmp",
-      isDeprecated := false })⟩,⟨"Std.HashMap", "Std.HashMap.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashMap.ofList,
-      renderedStatement := "Std.HashMap.ofList.{u, v} {α : Type u} {β : Type v} [BEq α] [Hashable α] (l : List (α × β)) :\n  Std.HashMap α β",
-      isDeprecated := false })⟩,⟨"Std.HashMap.Raw", "Std.HashMap.Raw.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashMap.Raw.ofList,
-      renderedStatement := "Std.HashMap.Raw.ofList.{u, v} {α : Type u} {β : Type v} [BEq α] [Hashable α] (l : List (α × β)) :\n  Std.HashMap.Raw α β",
-      isDeprecated := false })⟩,⟨"Std.ExtHashMap", "Std.ExtHashMap.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtHashMap.ofList,
-      renderedStatement := "Std.ExtHashMap.ofList.{u, v} {α : Type u} {β : Type v} [BEq α] [Hashable α] (l : List (α × β)) :\n  Std.ExtHashMap α β",
-      isDeprecated := false })⟩,⟨"Std.TreeMap", "Std.TreeMap.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeMap.ofList,
-      renderedStatement := "Std.TreeMap.ofList.{u, v} {α : Type u} {β : Type v} (l : List (α × β))\n  (cmp : α → α → Ordering := by exact compare) : Std.TreeMap α β cmp",
-      isDeprecated := false })⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeMap.Raw.ofList,
-      renderedStatement := "Std.TreeMap.Raw.ofList.{u, v} {α : Type u} {β : Type v} (l : List (α × β))\n  (cmp : α → α → Ordering := by exact compare) : Std.TreeMap.Raw α β cmp",
-      isDeprecated := false })⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtTreeMap.ofList,
-      renderedStatement := "Std.ExtTreeMap.ofList.{u, v} {α : Type u} {β : Type v} (l : List (α × β))\n  (cmp : α → α → Ordering := by exact compare) : Std.ExtTreeMap α β cmp",
-      isDeprecated := false })⟩,⟨"Std.HashSet", "Std.HashSet.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashSet.ofList,
-      renderedStatement := "Std.HashSet.ofList.{u} {α : Type u} [BEq α] [Hashable α] (l : List α) : Std.HashSet α",
-      isDeprecated := false })⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashSet.Raw.ofList,
-      renderedStatement := "Std.HashSet.Raw.ofList.{u} {α : Type u} [BEq α] [Hashable α] (l : List α) : Std.HashSet.Raw α",
-      isDeprecated := false })⟩,⟨"Std.ExtHashSet", "Std.ExtHashSet.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtHashSet.ofList,
-      renderedStatement := "Std.ExtHashSet.ofList.{u} {α : Type u} [BEq α] [Hashable α] (l : List α) : Std.ExtHashSet α",
-      isDeprecated := false })⟩,⟨"Std.TreeSet", "Std.TreeSet.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeSet.ofList,
-      renderedStatement := "Std.TreeSet.ofList.{u} {α : Type u} (l : List α) (cmp : α → α → Ordering := by exact compare) :\n  Std.TreeSet α cmp",
-      isDeprecated := false })⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeSet.Raw.ofList,
-      renderedStatement := "Std.TreeSet.Raw.ofList.{u} {α : Type u} (l : List α) (cmp : α → α → Ordering := by exact compare) :\n  Std.TreeSet.Raw α cmp",
-      isDeprecated := false })⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.ofList", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtTreeSet.ofList,
-      renderedStatement := "Std.ExtTreeSet.ofList.{u} {α : Type u} (l : List α) (cmp : α → α → Ordering := by exact compare) :\n  Std.ExtTreeSet α cmp",
-      isDeprecated := false })⟩,]
-  metadata := {
-    status := .done
-    comment := ""
-  }
-def «5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d» : AssociationTable.Fact .subexpression where
-  widgetId := "associative-creation-operations"
-  factId := "5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d"
-  rowId := "5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d"
-  rowState := #[⟨"Std.DHashMap", "app (EmptyCollection.emptyCollection) (Std.DHashMap*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.DHashMap*)", displayShort := "∅" }⟩,⟨"Std.DHashMap.Raw", "app (EmptyCollection.emptyCollection) (Std.DHashMap.Raw*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.DHashMap.Raw*)", displayShort := "∅" }⟩,⟨"Std.ExtDHashMap", "app (EmptyCollection.emptyCollection) (Std.ExtDHashMap*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.ExtDHashMap*)", displayShort := "∅" }⟩,⟨"Std.DTreeMap", "app (EmptyCollection.emptyCollection) (Std.DTreeMap*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.DTreeMap*)", displayShort := "∅" }⟩,⟨"Std.DTreeMap.Raw", "app (EmptyCollection.emptyCollection) (Std.DTreeMap.Raw*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.DTreeMap.Raw*)", displayShort := "∅" }⟩,⟨"Std.ExtDTreeMap", "app (EmptyCollection.emptyCollection) (Std.ExtDTreeMap*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.ExtDTreeMap*)", displayShort := "∅" }⟩,⟨"Std.HashMap", "app (EmptyCollection.emptyCollection) (Std.HashMap*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.HashMap*)", displayShort := "∅" }⟩,⟨"Std.HashMap.Raw", "app (EmptyCollection.emptyCollection) (Std.HashMap.Raw*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.HashMap.Raw*)", displayShort := "∅" }⟩,⟨"Std.ExtHashMap", "app (EmptyCollection.emptyCollection) (Std.ExtHashMap*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.ExtHashMap*)", displayShort := "∅" }⟩,⟨"Std.TreeMap", "app (EmptyCollection.emptyCollection) (Std.TreeMap*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.TreeMap*)", displayShort := "∅" }⟩,⟨"Std.TreeMap.Raw", "app (EmptyCollection.emptyCollection) (Std.TreeMap.Raw*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.TreeMap.Raw*)", displayShort := "∅" }⟩,⟨"Std.ExtTreeMap", "app (EmptyCollection.emptyCollection) (Std.ExtTreeMap*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.ExtTreeMap*)", displayShort := "∅" }⟩,⟨"Std.HashSet", "app (EmptyCollection.emptyCollection) (Std.HashSet*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.HashSet*)", displayShort := "∅" }⟩,⟨"Std.HashSet.Raw", "app (EmptyCollection.emptyCollection) (Std.HashSet.Raw*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.HashSet.Raw*)", displayShort := "∅" }⟩,⟨"Std.ExtHashSet", "app (EmptyCollection.emptyCollection) (Std.ExtHashSet*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.ExtHashSet*)", displayShort := "∅" }⟩,⟨"Std.TreeSet", "app (EmptyCollection.emptyCollection) (Std.TreeSet*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.TreeSet*)", displayShort := "∅" }⟩,⟨"Std.TreeSet.Raw", "app (EmptyCollection.emptyCollection) (Std.TreeSet.Raw*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.TreeSet.Raw*)", displayShort := "∅" }⟩,⟨"Std.ExtTreeSet", "app (EmptyCollection.emptyCollection) (Std.ExtTreeSet*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (EmptyCollection.emptyCollection) (Std.ExtTreeSet*)", displayShort := "∅" }⟩,]
-  metadata := {
-    status := .done
-    comment := ""
-  }
-
-def table : AssociationTable.Data .subexpression where
-  widgetId := "associative-creation-operations"
-  rows := #[
-    ⟨"2cb3c441-9663-4ce7-9527-0f40fc29925a", "empty", #[⟨"Std.DHashMap", "Std.DHashMap.emptyWithCapacity"⟩,⟨"Std.DHashMap.Raw", "Std.DHashMap.Raw.emptyWithCapacity"⟩,⟨"Std.ExtDHashMap", "Std.ExtDHashMap.emptyWithCapacity"⟩,⟨"Std.DTreeMap", "Std.DTreeMap.empty"⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.empty"⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.empty"⟩,⟨"Std.HashMap", "Std.HashMap.emptyWithCapacity"⟩,⟨"Std.HashMap.Raw", "Std.HashMap.Raw.emptyWithCapacity"⟩,⟨"Std.ExtHashMap", "Std.ExtHashMap.emptyWithCapacity"⟩,⟨"Std.TreeMap", "Std.TreeMap.empty"⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.empty"⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.empty"⟩,⟨"Std.HashSet", "Std.HashSet.emptyWithCapacity"⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.emptyWithCapacity"⟩,⟨"Std.ExtHashSet", "Std.ExtHashSet.emptyWithCapacity"⟩,⟨"Std.TreeSet", "Std.TreeSet.empty"⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.empty"⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.empty"⟩,]⟩,
-    ⟨"7743a485-024d-43b6-bd5f-ebd3182eb94d", "ofList", #[⟨"Std.DHashMap", "Std.DHashMap.ofList"⟩,⟨"Std.DHashMap.Raw", "Std.DHashMap.Raw.ofList"⟩,⟨"Std.ExtDHashMap", "Std.ExtDHashMap.ofList"⟩,⟨"Std.DTreeMap", "Std.DTreeMap.ofList"⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.ofList"⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.ofList"⟩,⟨"Std.HashMap", "Std.HashMap.ofList"⟩,⟨"Std.HashMap.Raw", "Std.HashMap.Raw.ofList"⟩,⟨"Std.ExtHashMap", "Std.ExtHashMap.ofList"⟩,⟨"Std.TreeMap", "Std.TreeMap.ofList"⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.ofList"⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.ofList"⟩,⟨"Std.HashSet", "Std.HashSet.ofList"⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.ofList"⟩,⟨"Std.ExtHashSet", "Std.ExtHashSet.ofList"⟩,⟨"Std.TreeSet", "Std.TreeSet.ofList"⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.ofList"⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.ofList"⟩,]⟩,
-    ⟨"5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d", "emptyCollection", #[⟨"Std.DHashMap", "app (EmptyCollection.emptyCollection) (Std.DHashMap*)"⟩,⟨"Std.DHashMap.Raw", "app (EmptyCollection.emptyCollection) (Std.DHashMap.Raw*)"⟩,⟨"Std.ExtDHashMap", "app (EmptyCollection.emptyCollection) (Std.ExtDHashMap*)"⟩,⟨"Std.DTreeMap", "app (EmptyCollection.emptyCollection) (Std.DTreeMap*)"⟩,⟨"Std.DTreeMap.Raw", "app (EmptyCollection.emptyCollection) (Std.DTreeMap.Raw*)"⟩,⟨"Std.ExtDTreeMap", "app (EmptyCollection.emptyCollection) (Std.ExtDTreeMap*)"⟩,⟨"Std.HashMap", "app (EmptyCollection.emptyCollection) (Std.HashMap*)"⟩,⟨"Std.HashMap.Raw", "app (EmptyCollection.emptyCollection) (Std.HashMap.Raw*)"⟩,⟨"Std.ExtHashMap", "app (EmptyCollection.emptyCollection) (Std.ExtHashMap*)"⟩,⟨"Std.TreeMap", "app (EmptyCollection.emptyCollection) (Std.TreeMap*)"⟩,⟨"Std.TreeMap.Raw", "app (EmptyCollection.emptyCollection) (Std.TreeMap.Raw*)"⟩,⟨"Std.ExtTreeMap", "app (EmptyCollection.emptyCollection) (Std.ExtTreeMap*)"⟩,⟨"Std.HashSet", "app (EmptyCollection.emptyCollection) (Std.HashSet*)"⟩,⟨"Std.HashSet.Raw", "app (EmptyCollection.emptyCollection) (Std.HashSet.Raw*)"⟩,⟨"Std.ExtHashSet", "app (EmptyCollection.emptyCollection) (Std.ExtHashSet*)"⟩,⟨"Std.TreeSet", "app (EmptyCollection.emptyCollection) (Std.TreeSet*)"⟩,⟨"Std.TreeSet.Raw", "app (EmptyCollection.emptyCollection) (Std.TreeSet.Raw*)"⟩,⟨"Std.ExtTreeSet", "app (EmptyCollection.emptyCollection) (Std.ExtTreeSet*)"⟩,]⟩,
-  ]
-  facts := #[
-    «2cb3c441-9663-4ce7-9527-0f40fc29925a»,
-    «7743a485-024d-43b6-bd5f-ebd3182eb94d»,
-    «5ceaa26a-d2cb-4df3-9ac8-b5c11db2ae9d»,
-  ]
-
-def restoreState : RestoreStateM Unit := do
-  addAssociationTable table

doc/std/grove/GroveStdlib/Generated/associative-modification-operations.lean

@@ -1,21 +0,0 @@
-import Grove.Framework
-
-/-
-This file is autogenerated by grove. You can manually edit it, for example to resolve merge
-conflicts, but be careful.
--/
-
-open Grove.Framework Widget
-
-namespace GroveStdlib.Generated.«associative-modification-operations»
-
-
-def table : AssociationTable.Data .subexpression where
-  widgetId := "associative-modification-operations"
-  rows := #[
-  ]
-  facts := #[
-  ]
-
-def restoreState : RestoreStateM Unit := do
-  addAssociationTable table

doc/std/grove/GroveStdlib/Generated/associative-query-operations.lean

@@ -16,7 +16,7 @@ def «01f88623-fa5f-4380-9772-b30f2fec5c94» : AssociationTable.Fact .subexpress
   rowState := #[⟨"Std.DHashMap", "Std.DHashMap.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.DHashMap.isEmpty,
-      renderedStatement := "Std.DHashMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (m : Std.DHashMap α β) : Bool",
+      renderedStatement := "Std.DHashMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} (m : Std.DHashMap α β) : Bool",
       isDeprecated := false })⟩,⟨"Std.DHashMap.Raw", "Std.DHashMap.Raw.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.DHashMap.Raw.isEmpty,
@@ -24,23 +24,23 @@ def «01f88623-fa5f-4380-9772-b30f2fec5c94» : AssociationTable.Fact .subexpress
       isDeprecated := false })⟩,⟨"Std.ExtDHashMap", "Std.ExtDHashMap.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtDHashMap.isEmpty,
-      renderedStatement := "Std.ExtDHashMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  [EquivBEq α] [LawfulHashable α] (m : Std.ExtDHashMap α β) : Bool",
+      renderedStatement := "Std.ExtDHashMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α]\n  [LawfulHashable α] (m : Std.ExtDHashMap α β) : Bool",
       isDeprecated := false })⟩,⟨"Std.DTreeMap", "Std.DTreeMap.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.DTreeMap.isEmpty,
-      renderedStatement := "Std.DTreeMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap α β cmp) : Bool",
+      renderedStatement := "Std.DTreeMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.DTreeMap α β cmp) : Bool",
       isDeprecated := false })⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.DTreeMap.Raw.isEmpty,
-      renderedStatement := "Std.DTreeMap.Raw.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap.Raw α β cmp) : Bool",
+      renderedStatement := "Std.DTreeMap.Raw.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.DTreeMap.Raw α β cmp) :\n  Bool",
       isDeprecated := false })⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtDTreeMap.isEmpty,
-      renderedStatement := "Std.ExtDTreeMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.ExtDTreeMap α β cmp) : Bool",
+      renderedStatement := "Std.ExtDTreeMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.ExtDTreeMap α β cmp) :\n  Bool",
       isDeprecated := false })⟩,⟨"Std.HashMap", "Std.HashMap.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.HashMap.isEmpty,
-      renderedStatement := "Std.HashMap.isEmpty.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (m : Std.HashMap α β) : Bool",
+      renderedStatement := "Std.HashMap.isEmpty.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} (m : Std.HashMap α β) : Bool",
       isDeprecated := false })⟩,⟨"Std.HashMap.Raw", "Std.HashMap.Raw.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.HashMap.Raw.isEmpty,
@@ -48,19 +48,19 @@ def «01f88623-fa5f-4380-9772-b30f2fec5c94» : AssociationTable.Fact .subexpress
       isDeprecated := false })⟩,⟨"Std.ExtHashMap", "Std.ExtHashMap.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtHashMap.isEmpty,
-      renderedStatement := "Std.ExtHashMap.isEmpty.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α]\n  [LawfulHashable α] (m : Std.ExtHashMap α β) : Bool",
+      renderedStatement := "Std.ExtHashMap.isEmpty.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α] [LawfulHashable α]\n  (m : Std.ExtHashMap α β) : Bool",
       isDeprecated := false })⟩,⟨"Std.TreeMap", "Std.TreeMap.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.TreeMap.isEmpty,
-      renderedStatement := "Std.TreeMap.isEmpty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (t : Std.TreeMap α β cmp) : Bool",
+      renderedStatement := "Std.TreeMap.isEmpty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp) : Bool",
       isDeprecated := false })⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.TreeMap.Raw.isEmpty,
-      renderedStatement := "Std.TreeMap.Raw.isEmpty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (t : Std.TreeMap.Raw α β cmp) : Bool",
+      renderedStatement := "Std.TreeMap.Raw.isEmpty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap.Raw α β cmp) : Bool",
       isDeprecated := false })⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtTreeMap.isEmpty,
-      renderedStatement := "Std.ExtTreeMap.isEmpty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (t : Std.ExtTreeMap α β cmp) : Bool",
+      renderedStatement := "Std.ExtTreeMap.isEmpty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.ExtTreeMap α β cmp) : Bool",
       isDeprecated := false })⟩,⟨"Std.HashSet", "Std.HashSet.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.HashSet.isEmpty,
@@ -72,7 +72,7 @@ def «01f88623-fa5f-4380-9772-b30f2fec5c94» : AssociationTable.Fact .subexpress
       isDeprecated := false })⟩,⟨"Std.ExtHashSet", "Std.ExtHashSet.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtHashSet.isEmpty,
-      renderedStatement := "Std.ExtHashSet.isEmpty.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α]\n  [LawfulHashable α] (m : Std.ExtHashSet α) : Bool",
+      renderedStatement := "Std.ExtHashSet.isEmpty.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α] [LawfulHashable α]\n  (m : Std.ExtHashSet α) : Bool",
       isDeprecated := false })⟩,⟨"Std.TreeSet", "Std.TreeSet.isEmpty", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.TreeSet.isEmpty,
@@ -97,7 +97,7 @@ def «f084f852-af71-45b6-8ab3-d251a8144f72» : AssociationTable.Fact .subexpress
   rowState := #[⟨"Std.DHashMap", "Std.DHashMap.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.DHashMap.size,
-      renderedStatement := "Std.DHashMap.size.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (m : Std.DHashMap α β) : Nat",
+      renderedStatement := "Std.DHashMap.size.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} (m : Std.DHashMap α β) : Nat",
       isDeprecated := false })⟩,⟨"Std.DHashMap.Raw", "Std.DHashMap.Raw.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.DHashMap.Raw.size,
@@ -105,23 +105,23 @@ def «f084f852-af71-45b6-8ab3-d251a8144f72» : AssociationTable.Fact .subexpress
       isDeprecated := false })⟩,⟨"Std.ExtDHashMap", "Std.ExtDHashMap.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtDHashMap.size,
-      renderedStatement := "Std.ExtDHashMap.size.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  [EquivBEq α] [LawfulHashable α] (m : Std.ExtDHashMap α β) : Nat",
+      renderedStatement := "Std.ExtDHashMap.size.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α]\n  [LawfulHashable α] (m : Std.ExtDHashMap α β) : Nat",
       isDeprecated := false })⟩,⟨"Std.DTreeMap", "Std.DTreeMap.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.DTreeMap.size,
-      renderedStatement := "Std.DTreeMap.size.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap α β cmp) : Nat",
+      renderedStatement := "Std.DTreeMap.size.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.DTreeMap α β cmp) : Nat",
       isDeprecated := false })⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.DTreeMap.Raw.size,
-      renderedStatement := "Std.DTreeMap.Raw.size.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap.Raw α β cmp) : Nat",
+      renderedStatement := "Std.DTreeMap.Raw.size.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.DTreeMap.Raw α β cmp) : Nat",
       isDeprecated := false })⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtDTreeMap.size,
-      renderedStatement := "Std.ExtDTreeMap.size.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.ExtDTreeMap α β cmp) : Nat",
+      renderedStatement := "Std.ExtDTreeMap.size.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.ExtDTreeMap α β cmp) : Nat",
       isDeprecated := false })⟩,⟨"Std.HashMap", "Std.HashMap.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.HashMap.size,
-      renderedStatement := "Std.HashMap.size.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (m : Std.HashMap α β) : Nat",
+      renderedStatement := "Std.HashMap.size.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} (m : Std.HashMap α β) : Nat",
       isDeprecated := false })⟩,⟨"Std.HashMap.Raw", "Std.HashMap.Raw.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.HashMap.Raw.size,
@@ -129,19 +129,19 @@ def «f084f852-af71-45b6-8ab3-d251a8144f72» : AssociationTable.Fact .subexpress
       isDeprecated := false })⟩,⟨"Std.ExtHashMap", "Std.ExtHashMap.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtHashMap.size,
-      renderedStatement := "Std.ExtHashMap.size.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α]\n  [LawfulHashable α] (m : Std.ExtHashMap α β) : Nat",
+      renderedStatement := "Std.ExtHashMap.size.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α] [LawfulHashable α]\n  (m : Std.ExtHashMap α β) : Nat",
       isDeprecated := false })⟩,⟨"Std.TreeMap", "Std.TreeMap.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.TreeMap.size,
-      renderedStatement := "Std.TreeMap.size.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (t : Std.TreeMap α β cmp) : Nat",
+      renderedStatement := "Std.TreeMap.size.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp) : Nat",
       isDeprecated := false })⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.TreeMap.Raw.size,
-      renderedStatement := "Std.TreeMap.Raw.size.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (t : Std.TreeMap.Raw α β cmp) : Nat",
+      renderedStatement := "Std.TreeMap.Raw.size.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap.Raw α β cmp) : Nat",
       isDeprecated := false })⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtTreeMap.size,
-      renderedStatement := "Std.ExtTreeMap.size.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (t : Std.ExtTreeMap α β cmp) : Nat",
+      renderedStatement := "Std.ExtTreeMap.size.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.ExtTreeMap α β cmp) : Nat",
       isDeprecated := false })⟩,⟨"Std.HashSet", "Std.HashSet.size", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.HashSet.size,
@@ -178,11 +178,11 @@ def «f4e6fa70-5aed-439d-aaad-5f4ced65bf7b» : AssociationTable.Fact .subexpress
   rowState := #[⟨"Std.DTreeMap", "Std.DTreeMap.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.DTreeMap.any,
-      renderedStatement := "Std.DTreeMap.any.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap α β cmp) (p : (a : α) → β a → Bool) : Bool",
+      renderedStatement := "Std.DTreeMap.any.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.DTreeMap α β cmp)\n  (p : (a : α) → β a → Bool) : Bool",
       isDeprecated := false })⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.DTreeMap.Raw.any,
-      renderedStatement := "Std.DTreeMap.Raw.any.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap.Raw α β cmp) (p : (a : α) → β a → Bool) : Bool",
+      renderedStatement := "Std.DTreeMap.Raw.any.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.DTreeMap.Raw α β cmp)\n  (p : (a : α) → β a → Bool) : Bool",
       isDeprecated := false })⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtDTreeMap.any,
@@ -190,11 +190,11 @@ def «f4e6fa70-5aed-439d-aaad-5f4ced65bf7b» : AssociationTable.Fact .subexpress
       isDeprecated := false })⟩,⟨"Std.TreeMap", "Std.TreeMap.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.TreeMap.any,
-      renderedStatement := "Std.TreeMap.any.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp)\n  (p : α → β → Bool) : Bool",
+      renderedStatement := "Std.TreeMap.any.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp) (p : α → β → Bool) :\n  Bool",
       isDeprecated := false })⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.TreeMap.Raw.any,
-      renderedStatement := "Std.TreeMap.Raw.any.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (t : Std.TreeMap.Raw α β cmp) (p : α → β → Bool) : Bool",
+      renderedStatement := "Std.TreeMap.Raw.any.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap.Raw α β cmp)\n  (p : α → β → Bool) : Bool",
       isDeprecated := false })⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtTreeMap.any,
@@ -202,7 +202,7 @@ def «f4e6fa70-5aed-439d-aaad-5f4ced65bf7b» : AssociationTable.Fact .subexpress
       isDeprecated := false })⟩,⟨"Std.HashSet", "Std.HashSet.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.HashSet.any,
-      renderedStatement := "Std.HashSet.any.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} (m : Std.HashSet α)\n  (p : α → Bool) : Bool",
+      renderedStatement := "Std.HashSet.any.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} (m : Std.HashSet α) (p : α → Bool) : Bool",
       isDeprecated := false })⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.HashSet.Raw.any,
@@ -210,15 +210,15 @@ def «f4e6fa70-5aed-439d-aaad-5f4ced65bf7b» : AssociationTable.Fact .subexpress
       isDeprecated := false })⟩,⟨"Std.TreeSet", "Std.TreeSet.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.TreeSet.any,
-      renderedStatement := "Std.TreeSet.any.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet α cmp) (p : α → Bool) :\n  Bool",
+      renderedStatement := "Std.TreeSet.any.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet α cmp) (p : α → Bool) : Bool",
       isDeprecated := false })⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.TreeSet.Raw.any,
-      renderedStatement := "Std.TreeSet.Raw.any.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet.Raw α cmp)\n  (p : α → Bool) : Bool",
+      renderedStatement := "Std.TreeSet.Raw.any.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet.Raw α cmp) (p : α → Bool) : Bool",
       isDeprecated := false })⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.any", Grove.Framework.Subexpression.State.declaration
   (Grove.Framework.Declaration.def
     { name := `Std.ExtTreeSet.any,
-      renderedStatement := "Std.ExtTreeSet.any.{u} {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtTreeSet α cmp) (p : α → Bool) : Bool",
+      renderedStatement := "Std.ExtTreeSet.any.{u} {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] (t : Std.ExtTreeSet α cmp)\n  (p : α → Bool) : Bool",
       isDeprecated := false })⟩,]
   metadata := {
     status := .bad
@@ -228,51 +228,62 @@ def «c1d181f6-3204-4956-946f-e81619f9feb4» : AssociationTable.Fact .subexpress
   widgetId := "associative-query-operations"
   factId := "c1d181f6-3204-4956-946f-e81619f9feb4"
   rowId := "c1d181f6-3204-4956-946f-e81619f9feb4"
-  rowState := #[⟨"Std.DTreeMap", "Std.DTreeMap.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DTreeMap.all,
-      renderedStatement := "Std.DTreeMap.all.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap α β cmp) (p : (a : α) → β a → Bool) : Bool",
-      isDeprecated := false })⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DTreeMap.Raw.all,
-      renderedStatement := "Std.DTreeMap.Raw.all.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap.Raw α β cmp) (p : (a : α) → β a → Bool) : Bool",
-      isDeprecated := false })⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtDTreeMap.all,
-      renderedStatement := "Std.ExtDTreeMap.all.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtDTreeMap α β cmp) (p : (a : α) → β a → Bool) : Bool",
-      isDeprecated := false })⟩,⟨"Std.TreeMap", "Std.TreeMap.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeMap.all,
-      renderedStatement := "Std.TreeMap.all.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp)\n  (p : α → β → Bool) : Bool",
-      isDeprecated := false })⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeMap.Raw.all,
-      renderedStatement := "Std.TreeMap.Raw.all.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (t : Std.TreeMap.Raw α β cmp) (p : α → β → Bool) : Bool",
-      isDeprecated := false })⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtTreeMap.all,
-      renderedStatement := "Std.ExtTreeMap.all.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtTreeMap α β cmp) (p : α → β → Bool) : Bool",
-      isDeprecated := false })⟩,⟨"Std.HashSet", "Std.HashSet.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashSet.all,
-      renderedStatement := "Std.HashSet.all.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} (m : Std.HashSet α)\n  (p : α → Bool) : Bool",
-      isDeprecated := false })⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashSet.Raw.all,
-      renderedStatement := "Std.HashSet.Raw.all.{u} {α : Type u} (m : Std.HashSet.Raw α) (p : α → Bool) : Bool",
-      isDeprecated := false })⟩,⟨"Std.TreeSet", "Std.TreeSet.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeSet.all,
-      renderedStatement := "Std.TreeSet.all.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet α cmp) (p : α → Bool) :\n  Bool",
-      isDeprecated := false })⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeSet.Raw.all,
-      renderedStatement := "Std.TreeSet.Raw.all.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet.Raw α cmp)\n  (p : α → Bool) : Bool",
-      isDeprecated := false })⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.all", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtTreeSet.all,
-      renderedStatement := "Std.ExtTreeSet.all.{u} {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtTreeSet α cmp) (p : α → Bool) : Bool",
-      isDeprecated := false })⟩,]
+  rowState := #[⟨"Std.DTreeMap", "Std.DTreeMap.all", .declaration (Declaration.def {
+    name := `Std.DTreeMap.all
+    renderedStatement := "Std.DTreeMap.all.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.DTreeMap α β cmp)\n  (p : (a : α) → β a → Bool) : Bool"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.all", .declaration (Declaration.def {
+    name := `Std.DTreeMap.Raw.all
+    renderedStatement := "Std.DTreeMap.Raw.all.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t : Std.DTreeMap.Raw α β cmp)\n  (p : (a : α) → β a → Bool) : Bool"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.all", .declaration (Declaration.def {
+    name := `Std.ExtDTreeMap.all
+    renderedStatement := "Std.ExtDTreeMap.all.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtDTreeMap α β cmp) (p : (a : α) → β a → Bool) : Bool"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.TreeMap", "Std.TreeMap.all", .declaration (Declaration.def {
+    name := `Std.TreeMap.all
+    renderedStatement := "Std.TreeMap.all.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp) (p : α → β → Bool) :\n  Bool"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.all", .declaration (Declaration.def {
+    name := `Std.TreeMap.Raw.all
+    renderedStatement := "Std.TreeMap.Raw.all.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap.Raw α β cmp)\n  (p : α → β → Bool) : Bool"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.all", .declaration (Declaration.def {
+    name := `Std.ExtTreeMap.all
+    renderedStatement := "Std.ExtTreeMap.all.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtTreeMap α β cmp) (p : α → β → Bool) : Bool"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.HashSet", "Std.HashSet.all", .declaration (Declaration.def {
+    name := `Std.HashSet.all
+    renderedStatement := "Std.HashSet.all.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} (m : Std.HashSet α) (p : α → Bool) : Bool"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.all", .declaration (Declaration.def {
+    name := `Std.HashSet.Raw.all
+    renderedStatement := "Std.HashSet.Raw.all.{u} {α : Type u} (m : Std.HashSet.Raw α) (p : α → Bool) : Bool"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.TreeSet", "Std.TreeSet.all", .declaration (Declaration.def {
+    name := `Std.TreeSet.all
+    renderedStatement := "Std.TreeSet.all.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet α cmp) (p : α → Bool) : Bool"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.all", .declaration (Declaration.def {
+    name := `Std.TreeSet.Raw.all
+    renderedStatement := "Std.TreeSet.Raw.all.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet.Raw α cmp) (p : α → Bool) : Bool"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.all", .declaration (Declaration.def {
+    name := `Std.ExtTreeSet.all
+    renderedStatement := "Std.ExtTreeSet.all.{u} {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] (t : Std.ExtTreeSet α cmp)\n  (p : α → Bool) : Bool"
+    isDeprecated := false
+  }
+)⟩,]
   metadata := {
     status := .bad
     comment := "Missing for some containers"
@@ -281,79 +292,97 @@ def «efe57f41-7db7-4303-b3a6-5216a70c43ce» : AssociationTable.Fact .subexpress
   widgetId := "associative-query-operations"
   factId := "efe57f41-7db7-4303-b3a6-5216a70c43ce"
   rowId := "efe57f41-7db7-4303-b3a6-5216a70c43ce"
-  rowState := #[⟨"Std.DHashMap", "Std.DHashMap.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DHashMap.getD,
-      renderedStatement := "Std.DHashMap.getD.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [LawfulBEq α]\n  (m : Std.DHashMap α β) (a : α) (fallback : β a) : β a",
-      isDeprecated := false })⟩,⟨"Std.DHashMap.Raw", "Std.DHashMap.Raw.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DHashMap.Raw.getD,
-      renderedStatement := "Std.DHashMap.Raw.getD.{u, v} {α : Type u} {β : α → Type v} [BEq α] [Hashable α] [LawfulBEq α]\n  (m : Std.DHashMap.Raw α β) (a : α) (fallback : β a) : β a",
-      isDeprecated := false })⟩,⟨"Std.ExtDHashMap", "Std.ExtDHashMap.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtDHashMap.getD,
-      renderedStatement := "Std.ExtDHashMap.getD.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  [LawfulBEq α] (m : Std.ExtDHashMap α β) (a : α) (fallback : β a) : β a",
-      isDeprecated := false })⟩,⟨"Std.DTreeMap", "Std.DTreeMap.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DTreeMap.getD,
-      renderedStatement := "Std.DTreeMap.getD.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  [Std.LawfulEqCmp cmp] (t : Std.DTreeMap α β cmp) (a : α) (fallback : β a) : β a",
-      isDeprecated := false })⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DTreeMap.Raw.getD,
-      renderedStatement := "Std.DTreeMap.Raw.getD.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  [Std.LawfulEqCmp cmp] (t : Std.DTreeMap.Raw α β cmp) (a : α) (fallback : β a) : β a",
-      isDeprecated := false })⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtDTreeMap.getD,
-      renderedStatement := "Std.ExtDTreeMap.getD.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  [Std.TransCmp cmp] [Std.LawfulEqCmp cmp] (t : Std.ExtDTreeMap α β cmp) (a : α) (fallback : β a) :\n  β a",
-      isDeprecated := false })⟩,⟨"Std.HashMap", "Std.HashMap.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashMap.getD,
-      renderedStatement := "Std.HashMap.getD.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (m : Std.HashMap α β) (a : α) (fallback : β) : β",
-      isDeprecated := false })⟩,⟨"Std.HashMap.Raw", "Std.HashMap.Raw.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashMap.Raw.getD,
-      renderedStatement := "Std.HashMap.Raw.getD.{u, v} {α : Type u} {β : Type v} [BEq α] [Hashable α] (m : Std.HashMap.Raw α β)\n  (a : α) (fallback : β) : β",
-      isDeprecated := false })⟩,⟨"Std.ExtHashMap", "Std.ExtHashMap.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtHashMap.getD,
-      renderedStatement := "Std.ExtHashMap.getD.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α]\n  [LawfulHashable α] (m : Std.ExtHashMap α β) (a : α) (fallback : β) : β",
-      isDeprecated := false })⟩,⟨"Std.TreeMap", "Std.TreeMap.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeMap.getD,
-      renderedStatement := "Std.TreeMap.getD.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp)\n  (a : α) (fallback : β) : β",
-      isDeprecated := false })⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeMap.Raw.getD,
-      renderedStatement := "Std.TreeMap.Raw.getD.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (t : Std.TreeMap.Raw α β cmp) (a : α) (fallback : β) : β",
-      isDeprecated := false })⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtTreeMap.getD,
-      renderedStatement := "Std.ExtTreeMap.getD.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtTreeMap α β cmp) (a : α) (fallback : β) : β",
-      isDeprecated := false })⟩,⟨"Std.HashSet", "Std.HashSet.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashSet.getD,
-      renderedStatement := "Std.HashSet.getD.{u} {α : Type u} [BEq α] [Hashable α] (m : Std.HashSet α) (a fallback : α) : α",
-      isDeprecated := false })⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashSet.Raw.getD,
-      renderedStatement := "Std.HashSet.Raw.getD.{u} {α : Type u} [BEq α] [Hashable α] (m : Std.HashSet.Raw α)\n  (a fallback : α) : α",
-      isDeprecated := false })⟩,⟨"Std.ExtHashSet", "Std.ExtHashSet.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtHashSet.getD,
-      renderedStatement := "Std.ExtHashSet.getD.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α] [LawfulHashable α]\n  (m : Std.ExtHashSet α) (a fallback : α) : α",
-      isDeprecated := false })⟩,⟨"Std.TreeSet", "Std.TreeSet.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeSet.getD,
-      renderedStatement := "Std.TreeSet.getD.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet α cmp)\n  (a fallback : α) : α",
-      isDeprecated := false })⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeSet.Raw.getD,
-      renderedStatement := "Std.TreeSet.Raw.getD.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet.Raw α cmp)\n  (a fallback : α) : α",
-      isDeprecated := false })⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.getD", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtTreeSet.getD,
-      renderedStatement := "Std.ExtTreeSet.getD.{u} {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtTreeSet α cmp) (a fallback : α) : α",
-      isDeprecated := false })⟩,]
+  rowState := #[⟨"Std.DHashMap", "Std.DHashMap.getD", .declaration (Declaration.def {
+    name := `Std.DHashMap.getD
+    renderedStatement := "Std.DHashMap.getD.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [LawfulBEq α]\n  (m : Std.DHashMap α β) (a : α) (fallback : β a) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.DHashMap.Raw", "Std.DHashMap.Raw.getD", .declaration (Declaration.def {
+    name := `Std.DHashMap.Raw.getD
+    renderedStatement := "Std.DHashMap.Raw.getD.{u, v} {α : Type u} {β : α → Type v} [BEq α] [Hashable α] [LawfulBEq α] (m : Std.DHashMap.Raw α β)\n  (a : α) (fallback : β a) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtDHashMap", "Std.ExtDHashMap.getD", .declaration (Declaration.def {
+    name := `Std.ExtDHashMap.getD
+    renderedStatement := "Std.ExtDHashMap.getD.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [LawfulBEq α]\n  (m : Std.ExtDHashMap α β) (a : α) (fallback : β a) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.DTreeMap", "Std.DTreeMap.getD", .declaration (Declaration.def {
+    name := `Std.DTreeMap.getD
+    renderedStatement := "Std.DTreeMap.getD.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.LawfulEqCmp cmp]\n  (t : Std.DTreeMap α β cmp) (a : α) (fallback : β a) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.getD", .declaration (Declaration.def {
+    name := `Std.DTreeMap.Raw.getD
+    renderedStatement := "Std.DTreeMap.Raw.getD.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.LawfulEqCmp cmp]\n  (t : Std.DTreeMap.Raw α β cmp) (a : α) (fallback : β a) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.getD", .declaration (Declaration.def {
+    name := `Std.ExtDTreeMap.getD
+    renderedStatement := "Std.ExtDTreeMap.getD.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  [Std.LawfulEqCmp cmp] (t : Std.ExtDTreeMap α β cmp) (a : α) (fallback : β a) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.HashMap", "Std.HashMap.getD", .declaration (Declaration.def {
+    name := `Std.HashMap.getD
+    renderedStatement := "Std.HashMap.getD.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} (m : Std.HashMap α β) (a : α)\n  (fallback : β) : β"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.HashMap.Raw", "Std.HashMap.Raw.getD", .declaration (Declaration.def {
+    name := `Std.HashMap.Raw.getD
+    renderedStatement := "Std.HashMap.Raw.getD.{u, v} {α : Type u} {β : Type v} [BEq α] [Hashable α] (m : Std.HashMap.Raw α β) (a : α)\n  (fallback : β) : β"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtHashMap", "Std.ExtHashMap.getD", .declaration (Declaration.def {
+    name := `Std.ExtHashMap.getD
+    renderedStatement := "Std.ExtHashMap.getD.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α] [LawfulHashable α]\n  (m : Std.ExtHashMap α β) (a : α) (fallback : β) : β"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.TreeMap", "Std.TreeMap.getD", .declaration (Declaration.def {
+    name := `Std.TreeMap.getD
+    renderedStatement := "Std.TreeMap.getD.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp) (a : α)\n  (fallback : β) : β"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.TreeMap.Raw", "Std.TreeMap.Raw.getD", .declaration (Declaration.def {
+    name := `Std.TreeMap.Raw.getD
+    renderedStatement := "Std.TreeMap.Raw.getD.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap.Raw α β cmp) (a : α)\n  (fallback : β) : β"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtTreeMap", "Std.ExtTreeMap.getD", .declaration (Declaration.def {
+    name := `Std.ExtTreeMap.getD
+    renderedStatement := "Std.ExtTreeMap.getD.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtTreeMap α β cmp) (a : α) (fallback : β) : β"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.HashSet", "Std.HashSet.getD", .declaration (Declaration.def {
+    name := `Std.HashSet.getD
+    renderedStatement := "Std.HashSet.getD.{u} {α : Type u} [BEq α] [Hashable α] (m : Std.HashSet α) (a fallback : α) : α"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.getD", .declaration (Declaration.def {
+    name := `Std.HashSet.Raw.getD
+    renderedStatement := "Std.HashSet.Raw.getD.{u} {α : Type u} [BEq α] [Hashable α] (m : Std.HashSet.Raw α) (a fallback : α) : α"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtHashSet", "Std.ExtHashSet.getD", .declaration (Declaration.def {
+    name := `Std.ExtHashSet.getD
+    renderedStatement := "Std.ExtHashSet.getD.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α] [LawfulHashable α]\n  (m : Std.ExtHashSet α) (a fallback : α) : α"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.TreeSet", "Std.TreeSet.getD", .declaration (Declaration.def {
+    name := `Std.TreeSet.getD
+    renderedStatement := "Std.TreeSet.getD.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet α cmp) (a fallback : α) : α"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.getD", .declaration (Declaration.def {
+    name := `Std.TreeSet.Raw.getD
+    renderedStatement := "Std.TreeSet.Raw.getD.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet.Raw α cmp) (a fallback : α) : α"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.getD", .declaration (Declaration.def {
+    name := `Std.ExtTreeSet.getD
+    renderedStatement := "Std.ExtTreeSet.getD.{u} {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] (t : Std.ExtTreeSet α cmp)\n  (a fallback : α) : α"
+    isDeprecated := false
+  }
+)⟩,]
   metadata := {
     status := .done
     comment := ""
@@ -362,61 +391,73 @@ def «e23b1119-3b57-433e-a68d-68fd70b9943d» : AssociationTable.Fact .subexpress
   widgetId := "associative-query-operations"
   factId := "e23b1119-3b57-433e-a68d-68fd70b9943d"
   rowId := "e23b1119-3b57-433e-a68d-68fd70b9943d"
-  rowState := #[⟨"Std.DHashMap", "Std.DHashMap.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DHashMap.get,
-      renderedStatement := "Std.DHashMap.get.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [LawfulBEq α]\n  (m : Std.DHashMap α β) (a : α) (h : a ∈ m) : β a",
-      isDeprecated := false })⟩,⟨"Std.DHashMap.Raw", "Std.DHashMap.Raw.Const.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DHashMap.Raw.Const.get,
-      renderedStatement := "Std.DHashMap.Raw.Const.get.{u, v} {α : Type u} {β : Type v} [BEq α] [Hashable α]\n  (m : Std.DHashMap.Raw α fun x => β) (a : α) (h : a ∈ m) : β",
-      isDeprecated := false })⟩,⟨"Std.ExtDHashMap", "Std.ExtDHashMap.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtDHashMap.get,
-      renderedStatement := "Std.ExtDHashMap.get.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  [LawfulBEq α] (m : Std.ExtDHashMap α β) (a : α) (h : a ∈ m) : β a",
-      isDeprecated := false })⟩,⟨"Std.DTreeMap", "Std.DTreeMap.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DTreeMap.get,
-      renderedStatement := "Std.DTreeMap.get.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.LawfulEqCmp cmp]\n  (t : Std.DTreeMap α β cmp) (a : α) (h : a ∈ t) : β a",
-      isDeprecated := false })⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.DTreeMap.Raw.get,
-      renderedStatement := "Std.DTreeMap.Raw.get.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  [Std.LawfulEqCmp cmp] (t : Std.DTreeMap.Raw α β cmp) (a : α) (h : a ∈ t) : β a",
-      isDeprecated := false })⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtDTreeMap.get,
-      renderedStatement := "Std.ExtDTreeMap.get.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  [Std.LawfulEqCmp cmp] (t : Std.ExtDTreeMap α β cmp) (a : α) (h : a ∈ t) : β a",
-      isDeprecated := false })⟩,⟨"Std.HashMap", "app (GetElem.getElem) (Std.HashMap*)", Grove.Framework.Subexpression.State.predicate
+  rowState := #[⟨"Std.DHashMap", "Std.DHashMap.get", .declaration (Declaration.def {
+    name := `Std.DHashMap.get
+    renderedStatement := "Std.DHashMap.get.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [LawfulBEq α]\n  (m : Std.DHashMap α β) (a : α) (h : a ∈ m) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.DHashMap.Raw", "Std.DHashMap.Raw.Const.get", .declaration (Declaration.def {
+    name := `Std.DHashMap.Raw.Const.get
+    renderedStatement := "Std.DHashMap.Raw.Const.get.{u, v} {α : Type u} {β : Type v} [BEq α] [Hashable α] (m : Std.DHashMap.Raw α fun x => β)\n  (a : α) (h : a ∈ m) : β"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtDHashMap", "Std.ExtDHashMap.get", .declaration (Declaration.def {
+    name := `Std.ExtDHashMap.get
+    renderedStatement := "Std.ExtDHashMap.get.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [LawfulBEq α]\n  (m : Std.ExtDHashMap α β) (a : α) (h : a ∈ m) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.DTreeMap", "Std.DTreeMap.get", .declaration (Declaration.def {
+    name := `Std.DTreeMap.get
+    renderedStatement := "Std.DTreeMap.get.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.LawfulEqCmp cmp]\n  (t : Std.DTreeMap α β cmp) (a : α) (h : a ∈ t) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.DTreeMap.Raw", "Std.DTreeMap.Raw.get", .declaration (Declaration.def {
+    name := `Std.DTreeMap.Raw.get
+    renderedStatement := "Std.DTreeMap.Raw.get.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.LawfulEqCmp cmp]\n  (t : Std.DTreeMap.Raw α β cmp) (a : α) (h : a ∈ t) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtDTreeMap", "Std.ExtDTreeMap.get", .declaration (Declaration.def {
+    name := `Std.ExtDTreeMap.get
+    renderedStatement := "Std.ExtDTreeMap.get.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  [Std.LawfulEqCmp cmp] (t : Std.ExtDTreeMap α β cmp) (a : α) (h : a ∈ t) : β a"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.HashMap", "app (GetElem.getElem) (Std.HashMap*)", Grove.Framework.Subexpression.State.predicate
   { key := "app (GetElem.getElem) (Std.HashMap*)", displayShort := "Std.HashMap[·]" }⟩,⟨"Std.HashMap.Raw", "app (GetElem.getElem) (Std.HashMap.Raw*)", Grove.Framework.Subexpression.State.predicate
   { key := "app (GetElem.getElem) (Std.HashMap.Raw*)", displayShort := "Std.HashMap.Raw[·]" }⟩,⟨"Std.ExtHashMap", "app (GetElem.getElem) (Std.ExtHashMap*)", Grove.Framework.Subexpression.State.predicate
   { key := "app (GetElem.getElem) (Std.ExtHashMap*)", displayShort := "Std.ExtHashMap[·]" }⟩,⟨"Std.TreeMap", "app (GetElem.getElem) (Std.TreeMap*)", Grove.Framework.Subexpression.State.predicate
   { key := "app (GetElem.getElem) (Std.TreeMap*)", displayShort := "Std.TreeMap[·]" }⟩,⟨"Std.TreeMap.Raw", "app (GetElem.getElem) (Std.TreeMap.Raw*)", Grove.Framework.Subexpression.State.predicate
   { key := "app (GetElem.getElem) (Std.TreeMap.Raw*)", displayShort := "Std.TreeMap.Raw[·]" }⟩,⟨"Std.ExtTreeMap", "app (GetElem.getElem) (Std.ExtTreeMap*)", Grove.Framework.Subexpression.State.predicate
-  { key := "app (GetElem.getElem) (Std.ExtTreeMap*)", displayShort := "Std.ExtTreeMap[·]" }⟩,⟨"Std.HashSet", "Std.HashSet.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashSet.get,
-      renderedStatement := "Std.HashSet.get.{u} {α : Type u} [BEq α] [Hashable α] (m : Std.HashSet α) (a : α) (h : a ∈ m) : α",
-      isDeprecated := false })⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.HashSet.Raw.get,
-      renderedStatement := "Std.HashSet.Raw.get.{u} {α : Type u} [BEq α] [Hashable α] (m : Std.HashSet.Raw α) (a : α)\n  (h : a ∈ m) : α",
-      isDeprecated := false })⟩,⟨"Std.ExtHashSet", "Std.ExtHashSet.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtHashSet.get,
-      renderedStatement := "Std.ExtHashSet.get.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α] [LawfulHashable α]\n  (m : Std.ExtHashSet α) (a : α) (h : a ∈ m) : α",
-      isDeprecated := false })⟩,⟨"Std.TreeSet", "Std.TreeSet.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeSet.get,
-      renderedStatement := "Std.TreeSet.get.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet α cmp) (a : α)\n  (h : a ∈ t) : α",
-      isDeprecated := false })⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.TreeSet.Raw.get,
-      renderedStatement := "Std.TreeSet.Raw.get.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet.Raw α cmp) (a : α)\n  (h : a ∈ t) : α",
-      isDeprecated := false })⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.get", Grove.Framework.Subexpression.State.declaration
-  (Grove.Framework.Declaration.def
-    { name := `Std.ExtTreeSet.get,
-      renderedStatement := "Std.ExtTreeSet.get.{u} {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtTreeSet α cmp) (a : α) (h : a ∈ t) : α",
-      isDeprecated := false })⟩,]
+  { key := "app (GetElem.getElem) (Std.ExtTreeMap*)", displayShort := "Std.ExtTreeMap[·]" }⟩,⟨"Std.HashSet", "Std.HashSet.get", .declaration (Declaration.def {
+    name := `Std.HashSet.get
+    renderedStatement := "Std.HashSet.get.{u} {α : Type u} [BEq α] [Hashable α] (m : Std.HashSet α) (a : α) (h : a ∈ m) : α"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.HashSet.Raw", "Std.HashSet.Raw.get", .declaration (Declaration.def {
+    name := `Std.HashSet.Raw.get
+    renderedStatement := "Std.HashSet.Raw.get.{u} {α : Type u} [BEq α] [Hashable α] (m : Std.HashSet.Raw α) (a : α) (h : a ∈ m) : α"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtHashSet", "Std.ExtHashSet.get", .declaration (Declaration.def {
+    name := `Std.ExtHashSet.get
+    renderedStatement := "Std.ExtHashSet.get.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α] [LawfulHashable α]\n  (m : Std.ExtHashSet α) (a : α) (h : a ∈ m) : α"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.TreeSet", "Std.TreeSet.get", .declaration (Declaration.def {
+    name := `Std.TreeSet.get
+    renderedStatement := "Std.TreeSet.get.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet α cmp) (a : α) (h : a ∈ t) : α"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.TreeSet.Raw", "Std.TreeSet.Raw.get", .declaration (Declaration.def {
+    name := `Std.TreeSet.Raw.get
+    renderedStatement := "Std.TreeSet.Raw.get.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet.Raw α cmp) (a : α) (h : a ∈ t) : α"
+    isDeprecated := false
+  }
+)⟩,⟨"Std.ExtTreeSet", "Std.ExtTreeSet.get", .declaration (Declaration.def {
+    name := `Std.ExtTreeSet.get
+    renderedStatement := "Std.ExtTreeSet.get.{u} {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] (t : Std.ExtTreeSet α cmp) (a : α)\n  (h : a ∈ t) : α"
+    isDeprecated := false
+  }
+)⟩,]
   metadata := {
     status := .bad
     comment := "Should *Set have GetElem?"

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

@@ -20,75 +20,23 @@ def sequentialContainers : Node :=
 
 namespace AssociativeContainers
 
-def associativeContainers : List Lean.Name :=
-  [`Std.DHashMap, `Std.DHashMap.Raw, `Std.ExtDHashMap, `Std.DTreeMap, `Std.DTreeMap.Raw, `Std.ExtDTreeMap, `Std.HashMap,
-   `Std.HashMap.Raw, `Std.ExtHashMap, `Std.TreeMap, `Std.TreeMap.Raw, `Std.ExtTreeMap, `Std.HashSet, `Std.HashSet.Raw, `Std.ExtHashSet,
-   `Std.TreeSet, `Std.TreeSet.Raw, `Std.ExtTreeSet]
-
-def associativeQueryOperations : AssociationTable .subexpression associativeContainers where
+def associativeQueryOperations : AssociationTable .subexpression
+    [`Std.DHashMap, `Std.DHashMap.Raw, `Std.ExtDHashMap, `Std.DTreeMap, `Std.DTreeMap.Raw, `Std.ExtDTreeMap, `Std.HashMap,
+     `Std.HashMap.Raw, `Std.ExtHashMap, `Std.TreeMap, `Std.TreeMap.Raw, `Std.ExtTreeMap, `Std.HashSet, `Std.HashSet.Raw, `Std.ExtHashSet,
+     `Std.TreeSet, `Std.TreeSet.Raw, `Std.ExtTreeSet] where
   id := "associative-query-operations"
   title := "Associative query operations"
   description := "Operations that take as input an associative container and return a 'single' piece of information (e.g., `GetElem` or `isEmpty`, but not `toList`)."
   dataSources n :=
-    (DataSource.definitionsInNamespace n)
+    (DataSource.declarationsInNamespace n .definitionsOnly)
       |>.map Subexpression.declaration
       |>.or (DataSource.getElem n)
 
-def associativeCreationOperations : AssociationTable .subexpression associativeContainers where
-  id := "associative-creation-operations"
-  title := "Associative creation operations"
-  description := "Operations that create a new associative container"
-  dataSources n :=
-    (DataSource.definitionsInNamespace n)
-      |>.map Subexpression.declaration
-      |>.or (DataSource.emptyCollection n)
-
-def associativeModificationOperations : AssociationTable .subexpression associativeContainers where
-  id := "associative-modification-operations"
-  title := "Associative modification operations"
-  description := "Operations that both accept and return an associative container"
-  dataSources n :=
-    (DataSource.definitionsInNamespace n)
-      |>.map Subexpression.declaration
-
-def associativeCreateThenQuery : Table .subexpression .subexpression .declaration associativeContainers where
-  id := "associative-create-then-query"
-  title := "Associative create then query"
-  description := "Lemmas that say what happens when creating a new associative container and then immediately querying from it"
-  rowsFrom := .table associativeCreationOperations
-  columnsFrom := .table associativeQueryOperations
-  cellData := .classic _ { relevantNamespaces := associativeContainers }
-
-def allOperationsCovered : Assertion where
-  widgetId := "associative-all-operations-covered"
-  title := "All operations on associative containers covered"
-  description := "All operations on an associative container should appear in at least one of the tables"
-  check := do
-    let allValuesArray : Array String ← #[associativeQueryOperations, associativeCreationOperations, associativeModificationOperations].flatMapM valuesInAssociationTable
-    let allValues : Std.HashSet String := Std.HashSet.ofArray allValuesArray
-    let env ← Lean.getEnv
-    let mut numBad := 0
-    for (n, _) in env.constants do
-      if associativeContainers.any (fun namesp => namesp.isPrefixOf n) then
-        if !n.toString ∈ allValues then
-          numBad := numBad + 1
-    return #[{
-      assertionId := "all-covered"
-      description := "All operations should be covered"
-      passed := numBad == 0
-      message := if numBad = 0 then "All operations were covered" else s!"There were {numBad} operations that were not covered."
-    }]
-
 end AssociativeContainers
 
-open AssociativeContainers in
 def associativeContainers : Node :=
   .section "associative-containers" "Associative containers" #[
-    .associationTable associativeQueryOperations,
-    .associationTable associativeCreationOperations,
-    .associationTable associativeModificationOperations,
-    .table associativeCreateThenQuery,
-    .assertion allOperationsCovered
+    .associationTable AssociativeContainers.associativeQueryOperations
   ]
 
 namespace PersistentDataStructures

doc/std/grove/grove-local.sh

@@ -3,10 +3,8 @@
 lake exe grove-stdlib --full metadata.json
 cd .lake/packages/grove/frontend
 npm install
-cp ../../../../metadata.json public/metadata.json
 if [ -f "../../../../invalidated.json" ]; then
-    cp ../../../../invalidated.json public/invalidated.json
-    GROVE_DATA_LOCATION=public/metadata.json GROVE_UPSTREAM_INVALIDATED_FACTS_LOCATION=public/invalidated.json npm run dev
+    GROVE_DATA_LOCATION=../../../../metadata.json GROVE_UPSTREAM_INVALIDATED_FACTS_LOCATION=../../../../invalidated.json npm run dev
 else
-    GROVE_DATA_LOCATION=public/metadata.json npm run dev
-fi
+    GROVE_DATA_LOCATION=../../../../metadata.json npm run dev
+fi

doc/std/grove/lake-manifest.json

@@ -5,7 +5,7 @@
    "type": "git",
    "subDir": "backend",
    "scope": "",
-   "rev": "3e8aabdea58c11813c5d3b7eeb187ded44ee9a34",
+   "rev": "e8127fc6554b99fb988ecdceb770a5e112afbe24",
    "name": "grove",
    "manifestFile": "lake-manifest.json",
    "inputRev": "master",

script/bench.sh

@@ -1,96 +1,9 @@
 #!/usr/bin/env bash
-set -euxo pipefail
+set -euo pipefail
 
-cmake --preset release -DUSE_LAKE=ON 1>&2
-
-# We benchmark against stage2/bin to test new optimizations.
-timeout -s KILL 1h time make -C build/release -j$(nproc) stage3 1>&2
+# We benchmark against stage 2 to test new optimizations.
+timeout -s KILL 1h time bash -c 'mkdir -p build/release; cd build/release; cmake ../.. && make -j$(nproc) stage2' 1>&2
 export PATH=$PWD/build/release/stage2/bin:$PATH
-
-# The extra opts used to be passed to the Makefile during benchmarking only but with Lake it is
-# easier to configure them statically.
-cmake -B build/release/stage3 -S src -DLEAN_EXTRA_LAKEFILE_TOML='weakLeanArgs=["-Dprofiler=true", "-Dprofiler.threshold=9999999", "--stats"]' 1>&2
-
-(
 cd tests/bench
 timeout -s KILL 1h time temci exec --config speedcenter.yaml --in speedcenter.exec.velcom.yaml 1>&2
 temci report run_output.yaml --reporter codespeed2
-)
-
-if [ -d .git ]; then
-    DIR="$(git rev-parse @)"
-    BASE_URL="https://speed.lean-lang.org/lean4-out/$DIR"
-    {
-        cat <<'EOF'
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="UTF-8">
-  <title>Lakeprof Report</title>
-</head>
-<h1>Lakeprof Report</h1>
-<button type="button" id="btn_fetch">View build trace in Perfetto</button>
-<script type="text/javascript">
-const ORIGIN = 'https://ui.perfetto.dev';
-
-const btnFetch = document.getElementById('btn_fetch');
-
-async function fetchAndOpen(traceUrl) {
-  const resp = await fetch(traceUrl);
-  // Error checking is left as an exercise to the reader.
-  const blob = await resp.blob();
-  const arrayBuffer = await blob.arrayBuffer();
-  openTrace(arrayBuffer, traceUrl);
-}
-
-function openTrace(arrayBuffer, traceUrl) {
-  const win = window.open(ORIGIN);
-  if (!win) {
-    btnFetch.style.background = '#f3ca63';
-  	btnFetch.onclick = () => openTrace(arrayBuffer);
-    btnFetch.innerText = 'Popups blocked, click here to open the trace file';
-    return;
-  }
-
-  const timer = setInterval(() => win.postMessage('PING', ORIGIN), 50);
-
-  const onMessageHandler = (evt) => {
-    if (evt.data !== 'PONG') return;
-
-    // We got a PONG, the UI is ready.
-    window.clearInterval(timer);
-    window.removeEventListener('message', onMessageHandler);
-
-    const reopenUrl = new URL(location.href);
-    reopenUrl.hash = `#reopen=${traceUrl}`;
-    win.postMessage({
-      perfetto: {
-        buffer: arrayBuffer,
-        title: 'Lake Build Trace',
-        url: reopenUrl.toString(),
-    }}, ORIGIN);
-  };
-
-  window.addEventListener('message', onMessageHandler);
-}
-
-// This is triggered when following the link from the Perfetto UI's sidebar.
-if (location.hash.startsWith('#reopen=')) {
- const traceUrl = location.hash.substr(8);
- fetchAndOpen(traceUrl);
-}
-EOF
-        cat <<EOF
-btnFetch.onclick = () => fetchAndOpen("$BASE_URL/lakeprof.trace_event");
-</script>
-EOF
-        echo "<pre><code>"
-        (cd src; lakeprof report -prc)
-        echo "</code></pre>"
-        echo "</body></html>"
-    } | tee index.html
-
-    curl -T index.html $BASE_URL/index.html
-    curl -T src/lakeprof.log $BASE_URL/lakeprof.log
-    curl -T src/lakeprof.trace_event $BASE_URL/lakeprof.trace_event
-fi

script/release_repos.yml

@@ -28,28 +28,6 @@ repositories:
     branch: main
     dependencies: []
 
-  - name: verso
-    url: https://github.com/leanprover/verso
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies: []
-
-  - name: plausible
-    url: https://github.com/leanprover-community/plausible
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies: []
-
-  - name: import-graph
-    url: https://github.com/leanprover-community/import-graph
-    toolchain-tag: true
-    stable-branch: false
-    branch: main
-    dependencies:
-      - lean4-cli
-
   - name: doc-gen4
     url: https://github.com/leanprover/doc-gen4
     toolchain-tag: true
@@ -57,6 +35,13 @@ repositories:
     branch: main
     dependencies: [lean4-cli]
 
+  - name: verso
+    url: https://github.com/leanprover/verso
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies: []
+
   - name: reference-manual
     url: https://github.com/leanprover/reference-manual
     toolchain-tag: true
@@ -80,6 +65,22 @@ repositories:
     dependencies:
       - batteries
 
+  - name: import-graph
+    url: https://github.com/leanprover-community/import-graph
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies:
+      - lean4-cli
+      - batteries
+
+  - name: plausible
+    url: https://github.com/leanprover-community/plausible
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies: []
+
   - name: mathlib4
     url: https://github.com/leanprover-community/mathlib4
     toolchain-tag: true

script/release_steps.py

@@ -195,7 +195,7 @@ def execute_release_steps(repo, version, config):
     run_command(f"git checkout {default_branch} && git pull", cwd=repo_path)
     
     # Special rc1 safety check for batteries and mathlib4 (before creating any branches)
-    if repo_name in ["batteries", "mathlib4"] and version.endswith('-rc1'):
+    if re.search(r'rc\d+$', version) and repo_name in ["batteries", "mathlib4"] and version.endswith('-rc1'):
         print(blue("This repo has nightly-testing infrastructure"))
         print(blue(f"Checking if nightly-testing can be safely merged into bump/{version.split('-rc')[0]}..."))
         
@@ -403,7 +403,7 @@ def execute_release_steps(repo, version, config):
                 raise
 
     # Handle special merging cases
-    if version.endswith('-rc1') and repo_name in ["batteries", "mathlib4"]:
+    if re.search(r'rc\d+$', version) and repo_name in ["batteries", "mathlib4"]:
         print(blue("This repo uses `bump/v4.X.0` branches for reviewed content from nightly-testing."))
         
         # Determine which remote to use for bump branches
@@ -474,7 +474,7 @@ def execute_release_steps(repo, version, config):
                 
                 print(green("✅ Merge completed successfully with automatic conflict resolution"))
     
-    elif version.endswith('-rc1'):
+    elif re.search(r'rc\d+$', version):
         # For all other repos with rc versions, merge nightly-testing
         if repo_name in ["verso", "reference-manual"]:
             print(yellow("This repo does development on nightly-testing: remember to rebase merge the PR."))

src/CMakeLists.txt

@@ -533,21 +533,12 @@ else()
         OUTPUT_VARIABLE GIT_SHA1
         OUTPUT_STRIP_TRAILING_WHITESPACE)
     message(STATUS "stage0 sha1: ${GIT_SHA1}")
-    # Now that we've prepared the information for the next stage, we can forget that we will use
-    # Lake in the future as we won't use it in this stage
-    set(USE_LAKE OFF)
   else()
     set(GIT_SHA1 "")
   endif()
 endif()
 configure_file("${LEAN_SOURCE_DIR}/githash.h.in" "${LEAN_BINARY_DIR}/githash.h")
 
-if(USE_LAKE AND ${STAGE} EQUAL 0)
-  # Now that we've prepared the information for the next stage, we can forget that we will use
-  # Lake in the future as we won't use it in this stage
-  set(USE_LAKE OFF)
-endif()
-
 # Windows uses ";" as a path separator. We use `LEAN_PATH_SEPARATOR` on scripts such as lean.mk.in
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
   set(LEAN_PATH_SEPARATOR ";")
@@ -684,17 +675,12 @@ if (LLVM AND ${STAGE} GREATER 0)
   set(EXTRA_LEANMAKE_OPTS "LLVM=1")
 endif()
 
-set(STDLIBS Init Std Lean Leanc)
-if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-  list(APPEND STDLIBS Lake)
-endif()
-
 add_custom_target(make_stdlib ALL
   WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
   # The actual rule is in a separate makefile because we want to prefix it with '+' to use the Make job server
   # for a parallelized nested build, but CMake doesn't let us do that.
   # We use `lean` from the previous stage, but `leanc`, headers, etc. from the current stage
-  COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make ${STDLIBS}
+  COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make Init Std Lean Leanc
   VERBATIM)
 
 # if we have LLVM enabled, then build `lean.h.bc` which has the LLVM bitcode
@@ -738,9 +724,14 @@ else()
 endif()
 
 if(NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-  add_custom_target(lake_shared
+  add_custom_target(lake_lib
     WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
     DEPENDS leanshared
+    COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make Lake
+    VERBATIM)
+  add_custom_target(lake_shared
+    WORKING_DIRECTORY ${LEAN_SOURCE_DIR}
+    DEPENDS lake_lib
     COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make libLake_shared
     VERBATIM)
   add_custom_target(lake ALL
@@ -821,12 +812,6 @@ if(LEAN_INSTALL_PREFIX)
   set(CMAKE_INSTALL_PREFIX "${LEAN_INSTALL_PREFIX}/lean-${LEAN_VERSION_STRING}${LEAN_INSTALL_SUFFIX}")
 endif()
 
-if (STAGE GREATER 1)
-  # The build of stage2+ may depend on local changes made to src/ that are not reflected by the
-  # commit hash in stage1/bin/lean, so we make sure to disable the global cache
-  string(APPEND LEAN_EXTRA_LAKEFILE_TOML "\n\nenableArtifactCache = false")
-endif()
-
 # Escape for `make`. Yes, twice.
 string(REPLACE "$" "\\\$$" CMAKE_EXE_LINKER_FLAGS_MAKE "${CMAKE_EXE_LINKER_FLAGS}")
 configure_file(${LEAN_SOURCE_DIR}/stdlib.make.in ${CMAKE_BINARY_DIR}/stdlib.make)
@@ -853,10 +838,6 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
   set(LAKE_LIB_PREFIX "lib")
 endif()
 
-if(USE_LAKE)
-  configure_file(${LEAN_SOURCE_DIR}/lakefile.toml.in ${CMAKE_BINARY_DIR}/lakefile.toml)
-  # copy for editing
-  if(STAGE EQUAL 1)
-    configure_file(${LEAN_SOURCE_DIR}/lakefile.toml.in ${LEAN_SOURCE_DIR}/lakefile.toml)
-  endif()
+if(USE_LAKE AND STAGE EQUAL 1)
+  configure_file(${LEAN_SOURCE_DIR}/lakefile.toml.in ${LEAN_SOURCE_DIR}/lakefile.toml)
 endif()

src/Init/BinderNameHint.lean

@@ -39,7 +39,7 @@ This gadget is supported by
 * `simp`, `dsimp` and `rw` in the right-hand-side of an equation
 * `simp` in the assumptions of congruence rules
 
-It is ineffective in other positions (hypotheses of rewrite rules) or when used by other tactics
+It is ineffective in other positions (hyptheses of rewrite rules) or when used by other tactics
 (e.g. `apply`).
 -/
 @[simp ↓, expose]

src/Init/Control/Basic.lean

@@ -9,7 +9,7 @@ prelude
 public import Init.Core
 public import Init.BinderNameHint
 
-@[expose] public section
+public section
 
 universe u v w
 

src/Init/Control/Except.lean

@@ -12,7 +12,7 @@ public import Init.Control.Basic
 public import Init.Control.Id
 public import Init.Coe
 
-@[expose] public section
+public section
 
 namespace Except
 variable {ε : Type u}

src/Init/Control/Reader.lean

@@ -52,4 +52,4 @@ instance ReaderT.tryFinally [MonadFinally m] : MonadFinally (ReaderT ρ m) where
 A monad with access to a read-only value of type `ρ`. The value can be locally overridden by
 `withReader`, but it cannot be mutated.
 -/
-abbrev ReaderM (ρ : Type u) := ReaderT ρ Id
+@[reducible] def ReaderM (ρ : Type u) := ReaderT ρ Id

src/Init/Conv.lean

@@ -187,9 +187,6 @@ match [a, b] with
 simplifies to `a`. -/
 syntax (name := simpMatch) "simp_match" : conv
 
-/-- Removes one or more hypotheses from the local context. -/
-syntax (name := clear) "clear" (ppSpace colGt term:max)+ : conv
-
 /-- Executes the given tactic block without converting `conv` goal into a regular goal. -/
 syntax (name := nestedTacticCore) "tactic'" " => " tacticSeq : conv
 
@@ -265,7 +262,7 @@ resulting in `t'`, which becomes the new target subgoal. -/
 syntax (name := convConvSeq) "conv" " => " convSeq : conv
 
 /-- `· conv` focuses on the main conv goal and tries to solve it using `s`. -/
-macro dot:patternIgnore("· " <|> ". ") s:convSeq : conv => `(conv| {%$dot ($s) })
+macro dot:patternIgnore("·" <|> ".") s:convSeq : conv => `(conv| {%$dot ($s) })
 
 
 /-- `fail_if_success t` fails if the tactic `t` succeeds. -/
@@ -345,7 +342,7 @@ This is the conv mode version of the `lift_lets` tactic.
 syntax (name := liftLets) "lift_lets " optConfig : conv
 
 /--
-Transforms `let` expressions into `have` expressions within the target expression when possible.
+Transforms `let` expressions into `have` expressions within th etarget expression when possible.
 This is the conv mode version of the `let_to_have` tactic.
 -/
 syntax (name := letToHave) "let_to_have" : conv

src/Init/Core.lean

@@ -752,8 +752,6 @@ Unlike `x ≠ y` (which is notation for `Ne x y`), this is `Bool` valued instead
 
 @[inherit_doc] infix:50 " != " => bne
 
-macro_rules | `($x != $y) => `(binrel_no_prop% bne $x $y)
-
 recommended_spelling "bne" for "!=" in [bne, «term_!=_»]
 
 /-- `ReflBEq α` says that the `BEq` implementation is reflexive. -/
@@ -855,8 +853,6 @@ and asserts that `a` and `b` are not equal.
 
 @[inherit_doc] infix:50 " ≠ "  => Ne
 
-macro_rules | `($x ≠ $y) => `(binrel% Ne $x $y)
-
 recommended_spelling "ne" for "≠" in [Ne, «term_≠_»]
 
 section Ne
@@ -1536,13 +1532,38 @@ end Setoid
 /-! # Propositional extensionality -/
 
 /--
-The [axiom](lean-manual://section/axioms) of **propositional extensionality**. It asserts that if
-propositions `a` and `b` are logically equivalent (that is, if `a` can be proved from `b` and vice
-versa), then `a` and `b` are *equal*, meaning `a` can be replaced with `b` in all contexts.
+The axiom of **propositional extensionality**. It asserts that if propositions
+`a` and `b` are logically equivalent (i.e. we can prove `a` from `b` and vice versa),
+then `a` and `b` are *equal*, meaning that we can replace `a` with `b` in all
+contexts.
 
-The standard logical connectives provably respect propositional extensionality. However, an axiom is
-needed for higher order expressions like `P a` where `P : Prop → Prop` is unknown, as well as for
-equality. Propositional extensionality is intuitionistically valid.
+For simple expressions like `a ∧ c ∨ d → e` we can prove that because all the logical
+connectives respect logical equivalence, we can replace `a` with `b` in this expression
+without using `propext`. However, for higher order expressions like `P a` where
+`P : Prop → Prop` is unknown, or indeed for `a = b` itself, we cannot replace `a` with `b`
+without an axiom which says exactly this.
+
+This is a relatively uncontroversial axiom, which is intuitionistically valid.
+It does however block computation when using `#reduce` to reduce proofs directly
+(which is not recommended), meaning that canonicity,
+the property that all closed terms of type `Nat` normalize to numerals,
+fails to hold when this (or any) axiom is used:
+```
+set_option pp.proofs true
+
+def foo : Nat := by
+  have : (True → True) ↔ True := ⟨λ _ => trivial, λ _ _ => trivial⟩
+  have := propext this ▸ (2 : Nat)
+  exact this
+
+#reduce foo
+-- propext { mp := fun x x => True.intro, mpr := fun x => True.intro } ▸ 2
+
+#eval foo -- 2
+```
+`#eval` can evaluate it to a numeral because the compiler erases casts and
+does not evaluate proofs, so `propext`, whose return type is a proposition,
+can never block it.
 -/
 axiom propext {a b : Prop} : (a ↔ b) → a = b
 
@@ -1573,7 +1594,6 @@ gen_injective_theorems% MProd
 gen_injective_theorems% NonScalar
 gen_injective_theorems% Option
 gen_injective_theorems% PLift
-gen_injective_theorems% PULift
 gen_injective_theorems% PNonScalar
 gen_injective_theorems% PProd
 gen_injective_theorems% Prod
@@ -2518,7 +2538,3 @@ class Irrefl (r : α → α → Prop) : Prop where
   irrefl : ∀ a, ¬r a a
 
 end Std
-
-/-- Deprecated alias for `XorOp`. -/
-@[deprecated XorOp (since := "2025-07-30")]
-abbrev Xor := XorOp

src/Init/Data.lean

@@ -49,5 +49,6 @@ public import Init.Data.Vector
 public import Init.Data.Iterators
 public import Init.Data.Range.Polymorphic
 public import Init.Data.Slice
+public import Init.Data.ByteSlice
 
 public section

src/Init/Data/AC.lean

@@ -10,7 +10,7 @@ prelude
 public import Init.Classical
 public import Init.ByCases
 
-@[expose] public section
+public section
 
 namespace Lean.Data.AC
 inductive Expr

src/Init/Data/Array/Basic.lean

@@ -1165,7 +1165,7 @@ Examples:
 def zipIdx (xs : Array α) (start := 0) : Array (α × Nat) :=
   xs.mapIdx fun i a => (a, start + i)
 
-
+@[deprecated zipIdx (since := "2025-01-21")] abbrev zipWithIndex := @zipIdx
 
 /--
 Returns the first element of the array for which the predicate `p` returns `true`, or `none` if no
@@ -1285,7 +1285,7 @@ def findFinIdx? {α : Type u} (p : α → Bool) (as : Array α) : Option (Fin as
     decreasing_by simp_wf; decreasing_trivial_pre_omega
   loop 0
 
-private theorem findIdx?_loop_eq_map_findFinIdx?_loop_val {xs : Array α} {p : α → Bool} {j} :
+theorem findIdx?_loop_eq_map_findFinIdx?_loop_val {xs : Array α} {p : α → Bool} {j} :
     findIdx?.loop p xs j = (findFinIdx?.loop p xs j).map (·.val) := by
   unfold findIdx?.loop
   unfold findFinIdx?.loop
@@ -1322,7 +1322,8 @@ def idxOfAux [BEq α] (xs : Array α) (v : α) (i : Nat) : Option (Fin xs.size)
   else none
 decreasing_by simp_wf; decreasing_trivial_pre_omega
 
-
+@[deprecated idxOfAux (since := "2025-01-29")]
+abbrev indexOfAux := @idxOfAux
 
 /--
 Returns the index of the first element equal to `a`, or the size of the array if no element is equal
@@ -1337,7 +1338,8 @@ Examples:
 def finIdxOf? [BEq α] (xs : Array α) (v : α) : Option (Fin xs.size) :=
   idxOfAux xs v 0
 
-
+@[deprecated "`Array.indexOf?` has been deprecated, use `idxOf?` or `finIdxOf?` instead." (since := "2025-01-29")]
+abbrev indexOf? := @finIdxOf?
 
 /--
 Returns the index of the first element equal to `a`, or the size of the array if no element is equal
@@ -1954,16 +1956,16 @@ def isPrefixOf [BEq α] (as bs : Array α) : Bool :=
     false
 
 @[semireducible, specialize] -- This is otherwise irreducible because it uses well-founded recursion.
-def zipWithMAux {m : Type v → Type w} [Monad m] (as : Array α) (bs : Array β) (f : α → β → m γ) (i : Nat) (cs : Array γ) : m (Array γ) := do
+def zipWithAux (as : Array α) (bs : Array β) (f : α → β → γ) (i : Nat) (cs : Array γ) : Array γ :=
   if h : i < as.size then
     let a := as[i]
     if h : i < bs.size then
       let b := bs[i]
-      zipWithMAux as bs f (i+1) <| cs.push (← f a b)
+      zipWithAux as bs f (i+1) <| cs.push <| f a b
     else
-      return cs
+      cs
   else
-    return cs
+    cs
 decreasing_by simp_wf; decreasing_trivial_pre_omega
 
 /--
@@ -1977,7 +1979,7 @@ Examples:
 * `#[x₁, x₂, x₃].zipWith f #[y₁, y₂, y₃, y₄] = #[f x₁ y₁, f x₂ y₂, f x₃ y₃]`
 -/
 @[inline] def zipWith (f : α → β → γ) (as : Array α) (bs : Array β) : Array γ :=
-  Id.run (zipWithMAux as bs (pure <| f · ·) 0 #[])
+  zipWithAux as bs f 0 #[]
 
 /--
 Combines two arrays into an array of pairs in which the first and second components are the
@@ -2014,13 +2016,6 @@ where go (as : Array α) (bs : Array β) (i : Nat) (cs : Array γ) :=
   termination_by max as.size bs.size - i
   decreasing_by simp_wf; decreasing_trivial_pre_omega
 
-/--
-Applies a monadic function to the corresponding elements of two arrays, left-to-right, stopping at
-the end of the shorter array. `zipWithM f as bs` is equivalent to `mapM id (zipWith f as bs)`.
--/
-@[inline] def zipWithM {m : Type v → Type w} [Monad m] (f : α → β → m γ) (as : Array α) (bs : Array β) : m (Array γ) :=
-  zipWithMAux as bs f 0 #[]
-
 /--
 Separates an array of pairs into two arrays that contain the respective first and second components.
 

src/Init/Data/Array/Bootstrap.lean

@@ -123,9 +123,15 @@ abbrev pop_toList := @Array.toList_pop
 @[simp, grind =] theorem append_empty {xs : Array α} : xs ++ #[] = xs := by
   apply ext'; simp only [toList_append, List.append_nil]
 
+@[deprecated append_empty (since := "2025-01-13")]
+abbrev append_nil := @append_empty
+
 @[simp, grind =] theorem empty_append {xs : Array α} : #[] ++ xs = xs := by
   apply ext'; simp only [toList_append, List.nil_append]
 
+@[deprecated empty_append (since := "2025-01-13")]
+abbrev nil_append := @empty_append
+
 @[simp, grind _=_] theorem append_assoc {xs ys zs : Array α} : xs ++ ys ++ zs = xs ++ (ys ++ zs) := by
   apply ext'; simp only [toList_append, List.append_assoc]
 
@@ -136,6 +142,7 @@ abbrev pop_toList := @Array.toList_pop
   rw [← appendList_eq_append]; unfold Array.appendList
   induction l generalizing xs <;> simp [*]
 
-
+@[deprecated toList_appendList (since := "2024-12-11")]
+abbrev appendList_toList := @toList_appendList
 
 end Array

src/Init/Data/Array/Lemmas.lean

@@ -8,20 +8,19 @@ module
 prelude
 public import Init.Data.Nat.Lemmas
 public import Init.Data.List.Range
+public import all Init.Data.List.Control
 public import Init.Data.List.Nat.TakeDrop
 public import Init.Data.List.Nat.Modify
 public import Init.Data.List.Nat.Basic
 public import Init.Data.List.Monadic
 public import Init.Data.List.OfFn
+public import all Init.Data.Array.Bootstrap
 public import Init.Data.Array.Mem
 public import Init.Data.Array.DecidableEq
 public import Init.Data.Array.Lex.Basic
 public import Init.Data.Range.Lemmas
 public import Init.TacticsExtra
 public import Init.Data.List.ToArray
-import all Init.Data.List.Control
-import all Init.Data.Array.Basic
-import all Init.Data.Array.Bootstrap
 
 public section
 
@@ -838,10 +837,16 @@ theorem mem_of_contains_eq_true [BEq α] [LawfulBEq α] {a : α} {as : Array α}
   cases as
   simp
 
+@[deprecated mem_of_contains_eq_true (since := "2024-12-12")]
+abbrev mem_of_elem_eq_true := @mem_of_contains_eq_true
+
 theorem contains_eq_true_of_mem [BEq α] [LawfulBEq α] {a : α} {as : Array α} (h : a ∈ as) : as.contains a = true := by
   cases as
   simpa using h
 
+@[deprecated contains_eq_true_of_mem (since := "2024-12-12")]
+abbrev elem_eq_true_of_mem := @contains_eq_true_of_mem
+
 @[simp] theorem elem_eq_contains [BEq α] {a : α} {xs : Array α} :
     elem a xs = xs.contains a := by
   simp [elem]
@@ -899,9 +904,15 @@ theorem all_push {xs : Array α} {a : α} {p : α → Bool} :
   cases xs
   simp
 
+@[deprecated getElem_set_self (since := "2024-12-11")]
+abbrev getElem_set_eq := @getElem_set_self
+
 @[simp] theorem getElem?_set_self {xs : Array α} {i : Nat} (h : i < xs.size) {v : α} :
     (xs.set i v)[i]? = some v := by simp [h]
 
+@[deprecated getElem?_set_self (since := "2024-12-11")]
+abbrev getElem?_set_eq := @getElem?_set_self
+
 @[simp] theorem getElem_set_ne {xs : Array α} {i : Nat} (h' : i < xs.size) {v : α} {j : Nat}
     (pj : j < xs.size) (h : i ≠ j) :
     (xs.set i v)[j]'(by simp [*]) = xs[j] := by
@@ -992,6 +1003,9 @@ grind_pattern mem_or_eq_of_mem_set => a ∈ xs.set i b
 theorem setIfInBounds_def (xs : Array α) (i : Nat) (a : α) :
     xs.setIfInBounds i a = if h : i < xs.size then xs.set i a else xs := rfl
 
+@[deprecated set!_eq_setIfInBounds (since := "2024-12-12")]
+abbrev set!_is_setIfInBounds := @set!_eq_setIfInBounds
+
 @[simp, grind] theorem size_setIfInBounds {xs : Array α} {i : Nat} {a : α} :
     (xs.setIfInBounds i a).size = xs.size := by
   if h : i < xs.size  then
@@ -1013,6 +1027,9 @@ theorem setIfInBounds_def (xs : Array α) (i : Nat) (a : α) :
   simp at h
   simp only [setIfInBounds, h, ↓reduceDIte, getElem_set_self]
 
+@[deprecated getElem_setIfInBounds_self (since := "2024-12-11")]
+abbrev getElem_setIfInBounds_eq := @getElem_setIfInBounds_self
+
 @[simp] theorem getElem_setIfInBounds_ne {xs : Array α} {i : Nat} {a : α} {j : Nat}
     (hj : j < xs.size) (h : i ≠ j) :
     (xs.setIfInBounds i a)[j]'(by simpa using hj) = xs[j] := by
@@ -1032,6 +1049,9 @@ theorem getElem?_setIfInBounds_self_of_lt {xs : Array α} {i : Nat} {a : α} (h
     (xs.setIfInBounds i a)[i]? = some a := by
   simp [h]
 
+@[deprecated getElem?_setIfInBounds_self (since := "2024-12-11")]
+abbrev getElem?_setIfInBounds_eq := @getElem?_setIfInBounds_self
+
 @[simp] theorem getElem?_setIfInBounds_ne {xs : Array α} {i j : Nat} (h : i ≠ j) {a : α}  :
     (xs.setIfInBounds i a)[j]? = xs[j]? := by
   simp [getElem?_setIfInBounds, h]
@@ -1357,6 +1377,23 @@ theorem mapM_eq_mapM_toList [Monad m] [LawfulMonad m] {f : α → m β} {xs : Ar
     toList <$> xs.mapM f = xs.toList.mapM f := by
   simp [mapM_eq_mapM_toList]
 
+@[deprecated "Use `mapM_eq_foldlM` instead" (since := "2025-01-08")]
+theorem mapM_map_eq_foldl {as : Array α} {f : α → β} {i : Nat} :
+    mapM.map (m := Id) (pure <| f ·) as i b = pure (as.foldl (start := i) (fun acc a => acc.push (f a)) b) := by
+  unfold mapM.map
+  split <;> rename_i h
+  · ext : 1
+    dsimp [foldl, foldlM]
+    rw [mapM_map_eq_foldl, dif_pos (by omega), foldlM.loop, dif_pos h]
+    -- Calling `split` here gives a bad goal.
+    have : size as - i = Nat.succ (size as - i - 1) := by omega
+    rw [this]
+    simp [foldl, foldlM, Nat.sub_add_eq]
+  · dsimp [foldl, foldlM]
+    rw [dif_pos (by omega), foldlM.loop, dif_neg h]
+    rfl
+termination_by as.size - i
+
 /--
 Use this as `induction ass using array₂_induction` on a hypothesis of the form `ass : Array (Array α)`.
 The hypothesis `ass` will be replaced with a hypothesis `ass : List (List α)`,
@@ -1639,12 +1676,12 @@ theorem filterMap_eq_map' {f : α → β} (w : stop = as.size) :
     filterMap (fun x => some (f x)) as 0 stop = map f as :=
   filterMap_eq_map w
 
-theorem filterMap_some_fun : filterMap (some : α → Option α) = id := by
+@[simp] theorem filterMap_some_fun : filterMap (some : α → Option α) = id := by
   funext xs
   cases xs
   simp
 
-@[simp, grind] theorem filterMap_some {xs : Array α} : filterMap some xs = xs := by
+@[grind] theorem filterMap_some {xs : Array α} : filterMap some xs = xs := by
   cases xs
   simp
 
@@ -2962,6 +2999,9 @@ theorem getElem?_extract {xs : Array α} {start stop : Nat} :
   · rw [size_extract, Nat.min_self, Nat.sub_zero]
   · intros; rw [getElem_extract]; congr; rw [Nat.zero_add]
 
+@[deprecated extract_size (since := "2025-01-19")]
+abbrev extract_all := @extract_size
+
 theorem extract_empty_of_stop_le_start {xs : Array α} {start stop : Nat} (h : stop ≤ start) :
     xs.extract start stop = #[] := by
   simp only [extract, Nat.sub_eq, emptyWithCapacity_eq]
@@ -2996,14 +3036,14 @@ theorem take_size {xs : Array α} : xs.take xs.size = xs := by
 
 /-! ### shrink -/
 
-@[simp] private theorem size_shrink_loop {xs : Array α} {n : Nat} : (shrink.loop n xs).size = xs.size - n := by
+@[simp] theorem size_shrink_loop {xs : Array α} {n : Nat} : (shrink.loop n xs).size = xs.size - n := by
   induction n generalizing xs with
   | zero => simp [shrink.loop]
   | succ n ih =>
     simp [shrink.loop, ih]
     omega
 
-@[simp] private theorem getElem_shrink_loop {xs : Array α} {n i : Nat} (h : i < (shrink.loop n xs).size) :
+@[simp] theorem getElem_shrink_loop {xs : Array α} {n i : Nat} (h : i < (shrink.loop n xs).size) :
     (shrink.loop n xs)[i] = xs[i]'(by simp at h; omega) := by
   induction n generalizing xs i with
   | zero => simp [shrink.loop]
@@ -3272,11 +3312,11 @@ theorem foldl_induction
   let rec go {i j b} (h₁ : j ≤ as.size) (h₂ : as.size ≤ i + j) (H : motive j b) :
     (motive as.size) (foldlM.loop (m := Id) f as as.size (Nat.le_refl _) i j b) := by
     unfold foldlM.loop; split
-    next hj =>
+    · next hj =>
       split
       · cases Nat.not_le_of_gt (by simp [hj]) h₂
       · exact go hj (by rwa [Nat.succ_add] at h₂) (hf ⟨j, hj⟩ b H)
-    next hj => exact Nat.le_antisymm h₁ (Nat.ge_of_not_lt hj) ▸ H
+    · next hj => exact Nat.le_antisymm h₁ (Nat.ge_of_not_lt hj) ▸ H
   simpa [foldl, foldlM] using go (Nat.zero_le _) (Nat.le_refl _) h0
 
 theorem foldr_induction
@@ -3286,13 +3326,13 @@ theorem foldr_induction
   let rec go {i b} (hi : i ≤ as.size) (H : motive i b) :
     (motive 0) (foldrM.fold (m := Id) f as 0 i hi b) := by
     unfold foldrM.fold; simp; split
-    next hi => exact (hi ▸ H)
-    next hi =>
+    · next hi => exact (hi ▸ H)
+    · next hi =>
       split; {simp at hi}
-      next i hi' =>
+      · next i hi' =>
         exact go _ (hf ⟨i, hi'⟩ b H)
   simp [foldr, foldrM]; split; {exact go _ h0}
-  next h => exact (Nat.eq_zero_of_not_pos h ▸ h0)
+  · next h => exact (Nat.eq_zero_of_not_pos h ▸ h0)
 
 @[congr]
 theorem foldl_congr {as bs : Array α} (h₀ : as = bs) {f g : β → α → β} (h₁ : f = g)
@@ -4279,7 +4319,7 @@ Examples:
 
 /-! ### Preliminaries about `ofFn` -/
 
-@[simp] private theorem size_ofFn_go {n} {f : Fin n → α} {i acc h} :
+@[simp] theorem size_ofFn_go {n} {f : Fin n → α} {i acc h} :
     (ofFn.go f acc i h).size = acc.size + i := by
   induction i generalizing acc with
   | zero => simp [ofFn.go]
@@ -4289,7 +4329,7 @@ Examples:
 @[simp] theorem size_ofFn {n : Nat} {f : Fin n → α} : (ofFn f).size = n := by simp [ofFn]
 
 -- Recall `ofFn.go f acc i h = acc ++ #[f (n - i), ..., f(n - 1)]`
-private theorem getElem_ofFn_go {f : Fin n → α} {acc i k} (h : i ≤ n) (w₁ : k < acc.size + i) :
+theorem getElem_ofFn_go {f : Fin n → α} {acc i k} (h : i ≤ n) (w₁ : k < acc.size + i) :
     (ofFn.go f acc i h)[k]'(by simpa using w₁) =
       if w₂ : k < acc.size then acc[k] else f ⟨n - i + k - acc.size, by omega⟩ := by
   induction i generalizing acc k with
@@ -4373,17 +4413,10 @@ theorem getElem?_range {n : Nat} {i : Nat} : (Array.range n)[i]? = if i < n then
 
 -- Without further algebraic hypotheses, there's no useful `sum_push` lemma.
 
-@[simp, grind =]
 theorem sum_eq_sum_toList [Add α] [Zero α] {as : Array α} : as.toList.sum = as.sum := by
   cases as
   simp [Array.sum, List.sum]
 
-@[simp, grind =]
-theorem sum_append_nat {as₁ as₂ : Array Nat} : (as₁ ++ as₂).sum = as₁.sum + as₂.sum := by
-  cases as₁
-  cases as₂
-  simp [List.sum_append_nat]
-
 theorem foldl_toList_eq_flatMap {l : List α} {acc : Array β}
     {F : Array β → α → Array β} {G : α → List β}
     (H : ∀ acc a, (F acc a).toList = acc.toList ++ G a) :
@@ -4694,10 +4727,27 @@ end List
 /-! ### Deprecations -/
 namespace Array
 
+@[deprecated size_toArray (since := "2024-12-11")]
+theorem size_mk (as : List α) : (Array.mk as).size = as.length := by simp
+
+@[deprecated getElem?_eq_getElem (since := "2024-12-11")]
+theorem getElem?_lt
+    (xs : Array α) {i : Nat} (h : i < xs.size) : xs[i]? = some xs[i] := dif_pos h
+
+@[deprecated getElem?_eq_none (since := "2024-12-11")]
+theorem getElem?_ge
+    (xs : Array α) {i : Nat} (h : i ≥ xs.size) : xs[i]? = none := dif_neg (Nat.not_lt_of_le h)
+
 set_option linter.deprecated false in
 @[deprecated "`get?` is deprecated" (since := "2025-02-12"), simp]
 theorem get?_eq_getElem? (xs : Array α) (i : Nat) : xs.get? i = xs[i]? := rfl
 
+@[deprecated getElem?_eq_none (since := "2024-12-11")]
+theorem getElem?_len_le (xs : Array α) {i : Nat} (h : xs.size ≤ i) : xs[i]? = none := by
+  simp [h]
+
+@[deprecated getD_getElem? (since := "2024-12-11")] abbrev getD_get? := @getD_getElem?
+
 @[deprecated getD_eq_getD_getElem? (since := "2025-02-12")] abbrev getD_eq_get? := @getD_eq_getD_getElem?
 
 set_option linter.deprecated false in
@@ -4722,9 +4772,64 @@ theorem get?_eq_get?_toList (xs : Array α) (i : Nat) : xs.get? i = xs.toList.ge
 set_option linter.deprecated false in
 @[deprecated get!_eq_getD_getElem? (since := "2025-02-12")] abbrev get!_eq_get? := @get!_eq_getD_getElem?
 
+@[deprecated getElem_set_self (since := "2025-01-17")]
+theorem get_set_eq (xs : Array α) (i : Nat) (v : α) (h : i < xs.size) :
+    (xs.set i v h)[i]'(by simp [h]) = v := by
+  simp only [set, ← getElem_toList, List.getElem_set_self]
+
+@[deprecated Array.getElem_toList (since := "2024-12-08")]
+theorem getElem_eq_getElem_toList {xs : Array α} (h : i < xs.size) : xs[i] = xs.toList[i] := rfl
+
+@[deprecated Array.getElem?_toList (since := "2024-12-08")]
+theorem getElem?_eq_getElem?_toList (xs : Array α) (i : Nat) : xs[i]? = xs.toList[i]? := by
+  rw [getElem?_def]
+  split <;> simp_all
+
+@[deprecated LawfulGetElem.getElem?_def (since := "2024-12-08")]
+theorem getElem?_eq {xs : Array α} {i : Nat} :
+    xs[i]? = if h : i < xs.size then some xs[i] else none := by
+  rw [getElem?_def]
+
+/-! ### map -/
+
+@[deprecated "Use `toList_map` or `List.map_toArray` to characterize `Array.map`." (since := "2025-01-06")]
+theorem map_induction (xs : Array α) (f : α → β) (motive : Nat → Prop) (h0 : motive 0)
+    (p : Fin xs.size → β → Prop) (hs : ∀ i, motive i.1 → p i (f xs[i]) ∧ motive (i+1)) :
+    motive xs.size ∧
+      ∃ eq : (xs.map f).size = xs.size, ∀ i h, p ⟨i, h⟩ ((xs.map f)[i]) := by
+  have t := foldl_induction (as := xs) (β := Array β)
+    (motive := fun i xs => motive i ∧ xs.size = i ∧ ∀ i h2, p i xs[i.1])
+    (init := #[]) (f := fun acc a => acc.push (f a)) ?_ ?_
+  obtain ⟨m, eq, w⟩ := t
+  · refine ⟨m, by simp, ?_⟩
+    intro i h
+    simp only [eq] at w
+    specialize w ⟨i, h⟩ h
+    simpa using w
+  · exact ⟨h0, rfl, nofun⟩
+  · intro i bs ⟨m, ⟨eq, w⟩⟩
+    refine ⟨?_, ?_, ?_⟩
+    · exact (hs _ m).2
+    · simp_all
+    · intro j h
+      simp at h ⊢
+      by_cases h' : j < size bs
+      · rw [getElem_push]
+        simp_all
+      · rw [getElem_push, dif_neg h']
+        simp only [show j = i by omega]
+        exact (hs _ m).1
+
+set_option linter.deprecated false in
+@[deprecated "Use `toList_map` or `List.map_toArray` to characterize `Array.map`." (since := "2025-01-06")]
+theorem map_spec (xs : Array α) (f : α → β) (p : Fin xs.size → β → Prop)
+    (hs : ∀ i, p i (f xs[i])) :
+    ∃ eq : (xs.map f).size = xs.size, ∀ i h, p ⟨i, h⟩ ((xs.map f)[i]) := by
+  simpa using map_induction xs f (fun _ => True) trivial p (by simp_all)
+
 /-! ### set -/
 
-@[deprecated getElem?_set_self (since := "2025-02-27")] abbrev get?_set_eq := @getElem?_set_self
+@[deprecated getElem?_set_eq (since := "2025-02-27")] abbrev get?_set_eq := @getElem?_set_self
 @[deprecated getElem?_set_ne (since := "2025-02-27")] abbrev get?_set_ne := @getElem?_set_ne
 @[deprecated getElem?_set (since := "2025-02-27")] abbrev get?_set := @getElem?_set
 @[deprecated get_set (since := "2025-02-27")] abbrev get_set := @getElem_set

src/Init/Data/Array/MapIdx.lean

@@ -60,7 +60,7 @@ theorem mapFinIdx_spec {xs : Array α} {f : (i : Nat) → α → (h : i < xs.siz
 @[simp, grind =] theorem size_zipIdx {xs : Array α} {k : Nat} : (xs.zipIdx k).size = xs.size :=
   Array.size_mapFinIdx
 
-
+@[deprecated size_zipIdx (since := "2025-01-21")] abbrev size_zipWithIndex := @size_zipIdx
 
 @[simp, grind =] theorem getElem_mapFinIdx {xs : Array α} {f : (i : Nat) → α → (h : i < xs.size) → β} {i : Nat}
     (h : i < (xs.mapFinIdx f).size) :
@@ -132,20 +132,23 @@ namespace Array
     (xs.zipIdx k)[i] = (xs[i]'(by simp_all), k + i) := by
   simp [zipIdx]
 
-
+@[deprecated getElem_zipIdx (since := "2025-01-21")]
+abbrev getElem_zipWithIndex := @getElem_zipIdx
 
 @[simp, grind =] theorem zipIdx_toArray {l : List α} {k : Nat} :
     l.toArray.zipIdx k = (l.zipIdx k).toArray := by
   ext i hi₁ hi₂ <;> simp
 
-
+@[deprecated zipIdx_toArray (since := "2025-01-21")]
+abbrev zipWithIndex_toArray := @zipIdx_toArray
 
 @[simp, grind =] theorem toList_zipIdx {xs : Array α} {k : Nat} :
     (xs.zipIdx k).toList = xs.toList.zipIdx k := by
   rcases xs with ⟨xs⟩
   simp
 
-
+@[deprecated toList_zipIdx (since := "2025-01-21")]
+abbrev toList_zipWithIndex := @toList_zipIdx
 
 theorem mk_mem_zipIdx_iff_le_and_getElem?_sub {k i : Nat} {x : α} {xs : Array α} :
     (x, i) ∈ xs.zipIdx k ↔ k ≤ i ∧ xs[i - k]? = some x := by
@@ -170,7 +173,11 @@ theorem mem_zipIdx_iff_getElem? {x : α × Nat} {xs : Array α} :
     x ∈ xs.zipIdx ↔ xs[x.2]? = some x.1 := by
   rw [mk_mem_zipIdx_iff_getElem?]
 
+@[deprecated mk_mem_zipIdx_iff_getElem? (since := "2025-01-21")]
+abbrev mk_mem_zipWithIndex_iff_getElem? := @mk_mem_zipIdx_iff_getElem?
 
+@[deprecated mem_zipIdx_iff_getElem? (since := "2025-01-21")]
+abbrev mem_zipWithIndex_iff_getElem? := @mem_zipIdx_iff_getElem?
 
 /-! ### mapFinIdx -/
 
@@ -215,7 +222,8 @@ theorem mapFinIdx_eq_zipIdx_map {xs : Array α} {f : (i : Nat) → α → (h : i
         f i x (by simp [mk_mem_zipIdx_iff_getElem?, getElem?_eq_some_iff] at m; exact m.1) := by
   ext <;> simp
 
-
+@[deprecated mapFinIdx_eq_zipIdx_map (since := "2025-01-21")]
+abbrev mapFinIdx_eq_zipWithIndex_map := @mapFinIdx_eq_zipIdx_map
 
 @[simp]
 theorem mapFinIdx_eq_empty_iff {xs : Array α} {f : (i : Nat) → α → (h : i < xs.size) → β} :
@@ -324,7 +332,8 @@ theorem mapIdx_eq_zipIdx_map {xs : Array α} {f : Nat → α → β} :
     xs.mapIdx f = xs.zipIdx.map fun ⟨a, i⟩ => f i a := by
   ext <;> simp
 
-
+@[deprecated mapIdx_eq_zipIdx_map (since := "2025-01-21")]
+abbrev mapIdx_eq_zipWithIndex_map := @mapIdx_eq_zipIdx_map
 
 @[grind =]
 theorem mapIdx_append {xs ys : Array α} :

src/Init/Data/Array/Mem.lean

@@ -18,11 +18,11 @@ set_option linter.indexVariables true -- Enforce naming conventions for index va
 namespace Array
 
 theorem sizeOf_lt_of_mem [SizeOf α] {as : Array α} (h : a ∈ as) : sizeOf a < sizeOf as := by
-  cases as with | _ as
+  cases as with | _ as =>
   exact Nat.lt_trans (List.sizeOf_lt_of_mem h.val) (by simp +arith)
 
 theorem sizeOf_get [SizeOf α] (as : Array α) (i : Nat) (h : i < as.size) : sizeOf as[i] < sizeOf as := by
-  cases as with | _ as
+  cases as with | _ as =>
   simpa using Nat.lt_trans (List.sizeOf_get _ ⟨i, h⟩) (by simp +arith)
 
 @[simp] theorem sizeOf_getElem [SizeOf α] (as : Array α) (i : Nat) (h : i < as.size) :

src/Init/Data/Array/Subarray.lean

@@ -161,8 +161,7 @@ instance : Inhabited (Subarray α) :=
   ⟨{}⟩
 
 /-!
-`ForIn`, `foldlM`, `foldl` and other operations are implemented in `Init.Data.Slice.Array.Iterator`
-using the slice iterator.
+`ForIn` and `foldlM` are implemented in `Init.Data.Slice.Array.Iterator` using the slice iterator.
 -/
 
 /--
@@ -267,8 +266,8 @@ An accumulator of type `β` is constructed by starting with `init` and combining
 subarray with the current accumulator value in turn, moving from the end to the start.
 
 Examples:
- * `#["red", "green", "blue"].toSubarray.foldr (·.length + ·) 0 = 12`
- * `#["red", "green", "blue"].toSubarray.popFront.foldr (·.length + ·) 0 = 9`
+ * `#eval #["red", "green", "blue"].toSubarray.foldr (·.length + ·) 0 = 12`
+ * `#["red", "green", "blue"].toSubarray.popFront.foldlr (·.length + ·) 0 = 9`
 -/
 @[inline]
 def foldr {α : Type u} {β : Type v} (f : α → β → β) (init : β) (as : Subarray α) : β :=

src/Init/Data/Array/Zip.lean

@@ -118,7 +118,7 @@ theorem zipWith_foldl_eq_zip_foldl {f : α → β → γ} {i : δ} :
 theorem zipWith_eq_empty_iff {f : α → β → γ} {as : Array α} {bs : Array β} : zipWith f as bs = #[] ↔ as = #[] ∨ bs = #[] := by
   cases as <;> cases bs <;> simp
 
-@[simp, grind =]
+@[grind =]
 theorem map_zipWith {δ : Type _} {f : α → β} {g : γ → δ → α} {cs : Array γ} {ds : Array δ} :
     map f (zipWith g cs ds) = zipWith (fun x y => f (g x y)) cs ds := by
   cases cs
@@ -354,15 +354,6 @@ theorem map_zipWithAll {δ : Type _} {f : α → β} {g : Option γ → Option
 @[deprecated zipWithAll_replicate (since := "2025-03-18")]
 abbrev zipWithAll_mkArray := @zipWithAll_replicate
 
-/-! ### zipWithM -/
-
-@[simp, grind =]
-theorem zipWithM_eq_mapM_id_zipWith {m : Type v → Type w} [Monad m] [LawfulMonad m] {f : α → β → m γ} {as : Array α} {bs : Array β} :
-    zipWithM f as bs = mapM id (zipWith f as bs) := by
-  cases as
-  cases bs
-  simp [List.zipWithM_toArray, ← List.zipWithM'_eq_zipWithM]
-
 /-! ### unzip -/
 
 @[deprecated fst_unzip (since := "2025-05-26")]

src/Init/Data/BitVec/Basic.lean

@@ -12,7 +12,7 @@ public import Init.Data.Nat.Power2
 public import Init.Data.Int.Bitwise
 public import Init.Data.BitVec.BasicAux
 
-@[expose] public section
+public section
 
 /-!
 We define the basic algebraic structure of bitvectors. We choose the `Fin` representation over
@@ -552,7 +552,7 @@ Example:
 @[expose]
 protected def xor (x y : BitVec n) : BitVec n :=
   (x.toNat ^^^ y.toNat)#'(Nat.xor_lt_two_pow x.isLt y.isLt)
-instance : XorOp (BitVec w) := ⟨.xor⟩
+instance : Xor (BitVec w) := ⟨.xor⟩
 
 /--
 Bitwise complement for bitvectors. Usually accessed via the `~~~` prefix operator.
@@ -736,10 +736,10 @@ def twoPow (w : Nat) (i : Nat) : BitVec w := 1#w <<< i
 end bitwise
 
 /-- The bitvector of width `w` that has the smallest value when interpreted as an integer. -/
-@[expose] def intMin (w : Nat) := twoPow w (w - 1)
+def intMin (w : Nat) := twoPow w (w - 1)
 
 /-- The bitvector of width `w` that has the largest value when interpreted as an integer. -/
-@[expose] def intMax (w : Nat) := (twoPow w (w - 1)) - 1
+def intMax (w : Nat) := (twoPow w (w - 1)) - 1
 
 /--
 Computes a hash of a bitvector, combining 64-bit words using `mixHash`.

src/Init/Data/BitVec/Bitblast.lean

@@ -15,7 +15,7 @@ public import Init.Data.BitVec.Decidable
 public import Init.Data.BitVec.Lemmas
 public import Init.Data.BitVec.Folds
 
-@[expose] public section
+public section
 
 /-!
 # Bit blasting of bitvectors
@@ -336,7 +336,7 @@ theorem add_eq_or_of_and_eq_zero {w : Nat} (x y : BitVec w)
     (h : x &&& y = 0#w) : x + y = x ||| y := by
   rw [add_eq_adc, adc, iunfoldr_replace (fun _ => false) (x ||| y)]
   · rfl
-  · simp only [adcb, atLeastTwo, Bool.and_false, Bool.or_false, bne_false,
+  · simp only [adcb, atLeastTwo, Bool.and_false, Bool.or_false, bne_false, 
     Prod.mk.injEq, and_eq_false_imp]
     intros i
     replace h : (x &&& y).getLsbD i = (0#w).getLsbD i := by rw [h]
@@ -586,6 +586,7 @@ A recurrence that describes multiplication as repeated addition.
 
 This function is useful for bit blasting multiplication.
 -/
+@[expose]
 def mulRec (x y : BitVec w) (s : Nat) : BitVec w :=
   let cur := if y.getLsbD s then (x <<< s) else 0
   match s with
@@ -621,7 +622,7 @@ theorem setWidth_setWidth_succ_eq_setWidth_setWidth_add_twoPow (x : BitVec w) (i
         simp [hik', hik'']
         omega
   · ext k
-    simp only [and_twoPow,
+    simp only [and_twoPow, 
       ]
     by_cases hi : x.getLsbD i <;> simp [hi] <;> omega
 
@@ -1046,6 +1047,7 @@ theorem lawful_divSubtractShift (qr : DivModState w) (h : qr.Poised args) :
 /-! ### Core division algorithm circuit -/
 
 /-- A recursive definition of division for bit blasting, in terms of a shift-subtraction circuit. -/
+@[expose]
 def divRec {w : Nat} (m : Nat) (args : DivModArgs w) (qr : DivModState w) :
     DivModState w :=
   match m with
@@ -1942,7 +1944,7 @@ The remainder for `srem`, i.e. division with rounding to zero is negative
 iff `x` is negative and `y` does not divide `x`.
 
 We can eventually build fast circuits for the divisibility test `x.srem y = 0`.
--/
+-/ 
 theorem msb_srem {x y : BitVec w} : (x.srem y).msb =
     (x.msb && decide (x.srem y ≠ 0)) := by
   rw [msb_eq_toInt]

src/Init/Data/BitVec/Lemmas.lean

@@ -702,7 +702,7 @@ theorem eq_zero_or_eq_one (a : BitVec 1) : a = 0#1 ∨ a = 1#1 := by
   have acases : a = 0 ∨ a = 1 := by omega
   rcases acases with ⟨rfl | rfl⟩
   · simp
-  case inr h =>
+  · case inr h =>
     subst h
     simp
 
@@ -1393,7 +1393,7 @@ theorem or_eq_zero_iff {x y : BitVec w} : (x ||| y) = 0#w ↔ x = 0#w ∧ y = 0#
   · intro h
     constructor
     all_goals
-      ext i ih
+    · ext i ih
       have := BitVec.eq_of_getElem_eq_iff.mp h i ih
       simp only [getElem_or, getElem_zero, Bool.or_eq_false_iff] at this
       simp [this]
@@ -1493,7 +1493,7 @@ theorem and_eq_allOnes_iff {x y : BitVec w} :
   · intro h
     constructor
     all_goals
-      ext i ih
+    · ext i ih
       have := BitVec.eq_of_getElem_eq_iff.mp h i ih
       simp only [getElem_and, getElem_allOnes, Bool.and_eq_true] at this
       simp [this]
@@ -3006,7 +3006,7 @@ which performs a case analysis on the start index, length, and the lengths of `x
 · If the start index is entirely contained in the `xlo` bitvector, then grab the bits from `xlo`.
 · If the start index is split between the two bitvectors,
   then append `(w - start)` bits from `xlo` with `(len - (w - start))` bits from xhi.
-  Diagrammatically:
+  Diagramatically:
   ```
                  xhi                      xlo
           (<---------------------](<-------w--------]
@@ -4419,8 +4419,8 @@ theorem neg_one_ediv_toInt_eq {w : Nat} {y : BitVec w} :
   rcases w with _|_|w
   · simp [of_length_zero]
   · cases eq_zero_or_eq_one y
-    case _ h => simp [h]
-    case _ h => simp [h]
+    · case _ h => simp [h]
+    · case _ h => simp [h]
   · by_cases 0 < y.toInt
     · simp [Int.sign_eq_one_of_pos (a := y.toInt) (by omega), Int.neg_one_ediv]
       omega
@@ -5138,7 +5138,7 @@ theorem setWidth_setWidth_succ_eq_setWidth_setWidth_of_getLsbD_false
 
 /--
 When the `(i+1)`th bit of `x` is true,
-keeping the lower `(i + 1)` bits of `x` equals keeping the lower `i` bits
+keeping the lower `(i + 1)` bits of `x` equalsk eeping the lower `i` bits
 and then performing bitwise-or with `twoPow i = (1 << i)`,
 -/
 theorem setWidth_setWidth_succ_eq_setWidth_setWidth_or_twoPow_of_getLsbD_true
@@ -5766,16 +5766,16 @@ theorem clzAuxRec_eq_clzAuxRec_of_le (x : BitVec w) (h : w - 1 ≤ n) :
   let k := n - (w - 1)
   rw [show n = (w - 1) + k by omega]
   induction k
-  case zero => simp
-  case succ k ihk =>
+  · case zero => simp
+  · case succ k ihk =>
     simp [show w - 1 + (k + 1) = (w - 1 + k) + 1 by omega, clzAuxRec_succ, ihk,
       show x.getLsbD (w - 1 + k + 1) = false by simp only [show w ≤ w - 1 + k + 1 by omega, getLsbD_of_ge]]
 
 theorem clzAuxRec_eq_clzAuxRec_of_getLsbD_false {x : BitVec w} (h : ∀ i, n < i → x.getLsbD i = false) :
     x.clzAuxRec n = x.clzAuxRec (n + k) := by
   induction k
-  case zero => simp
-  case succ k ihk =>
+  · case zero => simp
+  · case succ k ihk =>
     simp only [show n + (k + 1) = (n + k) + 1 by omega, clzAuxRec_succ]
     by_cases hxn : x.getLsbD (n + k + 1)
     · have : ¬ ∀ (i : Nat), n < i → x.getLsbD i = false := by
@@ -5842,8 +5842,13 @@ set_option linter.missingDocs false
 @[deprecated toFin_uShiftRight (since := "2025-02-18")]
 abbrev toFin_uShiftRight := @toFin_ushiftRight
 
+@[deprecated signExtend_eq_setWidth_of_msb_false (since := "2024-12-08")]
+abbrev signExtend_eq_not_setWidth_not_of_msb_false := @signExtend_eq_setWidth_of_msb_false
 
+@[deprecated replicate_zero (since := "2025-01-08")]
+abbrev replicate_zero_eq := @replicate_zero
 
-
+@[deprecated replicate_succ (since := "2025-01-08")]
+abbrev replicate_succ_eq := @replicate_succ
 
 end BitVec

src/Init/Data/Bool.lean

@@ -696,23 +696,3 @@ but may be used locally.
 
 @[simp] theorem Subtype.beq_iff {α : Type u} [BEq α] {p : α → Prop} {x y : {a : α // p a}} :
     (x == y) = (x.1 == y.1) := rfl
-
-/-! ### Proof by reflection support  -/
-
-@[expose] protected noncomputable def Bool.and' (a b : Bool) : Bool :=
-  Bool.rec false b a
-
-@[expose] protected noncomputable def Bool.or' (a b : Bool) : Bool :=
-  Bool.rec b true a
-
-@[expose] protected noncomputable def Bool.not' (a : Bool) : Bool :=
-  Bool.rec true false a
-
-@[simp] theorem Bool.and'_eq_and (a b : Bool) : a.and' b = a.and b := by
-  cases a <;> simp [Bool.and']
-
-@[simp] theorem Bool.or'_eq_or (a b : Bool) : a.or' b = a.or b := by
-  cases a <;> simp [Bool.or']
-
-@[simp] theorem Bool.not'_eq_not (a : Bool) : a.not' = a.not := by
-  cases a <;> simp [Bool.not']

src/Init/Data/ByteArray.lean

@@ -1,3 +1,4 @@
+
 /-
 Copyright (c) 2019 Microsoft Corporation. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.

src/Init/Data/ByteArray/Basic.lean

@@ -12,7 +12,7 @@ public import Init.Data.UInt.Basic
 public import all Init.Data.UInt.BasicAux
 public import Init.Data.Option.Basic
 
-@[expose] public section
+public section
 universe u
 
 structure ByteArray where
@@ -23,10 +23,18 @@ attribute [extern "lean_byte_array_data"] ByteArray.data
 
 namespace ByteArray
 
-deriving instance BEq for ByteArray
-
 attribute [ext] ByteArray
 
+/--
+Checks whether two `ByteArray` instances have the same length and identical content. Normally used
+via the `==` operator.
+-/
+@[extern "lean_byte_array_beq"]
+protected def beq (a b : @& ByteArray) : Bool :=
+  BEq.beq a.data b.data
+
+instance : BEq ByteArray := ⟨ByteArray.beq⟩
+
 instance : DecidableEq ByteArray :=
   fun _ _ => decidable_of_decidable_of_iff ByteArray.ext_iff.symm
 

src/Init/Data/ByteSlice.lean

@@ -0,0 +1,257 @@
+/-
+Copyright (c) 2019 Microsoft Corporation. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Author: Leonardo de Moura
+-/
+module
+
+prelude
+public import Init.Data.Array.Basic
+public import Init.Data.Array.DecidableEq
+public import Init.Data.UInt.Basic
+public import all Init.Data.UInt.BasicAux
+public import Init.Data.Option.Basic
+public import Init.Data.ByteArray
+public import Init.Data.Iterators.Basic
+public import Init.Data.Slice.Basic
+
+public section
+
+/--
+A slice of bytes.
+-/
+structure ByteSlice where
+  data : ByteArray
+  start : Nat
+  «end» : Nat
+  valid : start ≤ «end» ∧ «end» ≤ data.size
+
+namespace ByteSlice
+
+/--
+Creates a new `ByteSlice` from a `ByteArray.Iterator`.
+-/
+@[inline]
+def ofIterator (data : ByteArray.Iterator) (size : Nat) (h : data.pos + size ≤ data.array.size) : ByteSlice :=
+  { data := data.array, start := data.pos, «end» := data.pos + size, valid := And.intro (by simp) h }
+
+/--
+Creates a new `ByteSlice` from a `ByteArray`.
+-/
+@[inline]
+def ofByteArray (data : ByteArray) : ByteSlice :=
+  { data, start := 0, «end» := data.size, valid := by simp }
+
+/--
+Creates an empty `ByteSlice`.
+-/
+@[inline]
+def empty : ByteSlice :=
+  { data := ByteArray.empty, start := 0, «end» := 0, valid := by simp }
+
+/--
+Gets the size of the slice.
+-/
+@[inline]
+def size (slice : ByteSlice) : Nat :=
+  slice.«end» - slice.start
+
+/--
+Checks if the slice is empty.
+-/
+@[inline]
+def isEmpty (slice : ByteSlice) : Bool :=
+  slice.size = 0
+
+/--
+Gets a byte at the given index within the slice.
+Returns `none` if the index is out of bounds.
+-/
+@[inline]
+def get (slice : ByteSlice) (i : Nat) (h : i < slice.size := by get_elem_tactic) : UInt8 :=
+  have h_bounds : slice.start + i < slice.data.size := by
+    simp [size] at h
+    have h1 := slice.valid.left
+    have h2 := slice.valid.right
+    have h3 : slice.start + i < slice.«end» := by
+      rw [← Nat.add_sub_cancel' h1]
+      exact Nat.add_lt_add_left h slice.start
+    exact Nat.lt_of_lt_of_le h3 h2
+
+  slice.data.get (slice.start + i) h_bounds
+
+/--
+Gets a byte at the given index within the slice.
+Panics if the index is out of bounds.
+-/
+def get! (slice : ByteSlice) (i : Nat)  : UInt8 :=
+  if h :i < slice.size then
+    slice.get i
+  else
+    panic! "ByteSlice index out of bounds"
+
+/--
+Gets a byte at the given index within the slice.
+Panics if the index is out of bounds.
+-/
+def get? (slice : ByteSlice) (i : Nat) : Option UInt8 :=
+  if h : i < slice.size then
+    some (slice.get i)
+  else
+    none
+
+/--
+Gets a byte at the given index within the slice.
+Panics if the index is out of bounds.
+-/
+@[inline]
+def getD (slice : ByteSlice) (i : Nat) (default : UInt8) : UInt8 :=
+  slice.get? i |>.getD default
+
+/--
+Gets the first byte of the slice.
+Returns `none` if the slice is empty.
+-/
+@[inline]
+def first? (slice : ByteSlice) : Option UInt8 :=
+  slice.get? 0
+
+/--
+Gets the first byte of the slice.
+Returns `none` if the slice is empty.
+-/
+@[inline]
+def nextSlice? (slice : ByteSlice) : Option ByteSlice :=
+  if h : slice.end + 1 ≤ slice.data.size then
+    some { slice with «end» := slice.end + 1, valid := And.intro (Nat.le_trans slice.valid.left (by simp)) h }
+  else
+    none
+
+/--
+Gets the last byte of the slice.
+Returns `none` if the slice is empty.
+-/
+@[inline]
+def last? (slice : ByteSlice) : Option UInt8 :=
+  if slice.isEmpty then none else slice.get? (slice.size - 1)
+
+/--
+Creates a sub-slice from the given start index to the end.
+Returns `none` if the start index is out of bounds.
+-/
+@[inline]
+def drop (slice : ByteSlice) (n : Nat) : ByteSlice :=
+  if h : n <= slice.size then
+    let valid := by
+      simp [size] at h;
+      simp [slice.valid]
+      have h := Nat.add_le_add_left (n := n) h slice.start
+      rw [Nat.add_sub_cancel' slice.valid.left] at h
+      exact h
+    { slice with start := slice.start + n, valid }
+  else
+    { slice with start := slice.end, valid := by simp [slice.valid] }
+
+/--
+Creates a sub-slice with the first `n` elements.
+Returns `none` if `n` is greater than the slice size.
+-/
+@[inline]
+def take (slice : ByteSlice) (n : Nat) : ByteSlice :=
+  if h : n <= slice.size then
+    let newEnd := slice.start + n
+    let valid := by
+      constructor
+      · simp [newEnd]
+      · simp [newEnd]
+        simp [size] at h
+        have h3 : slice.start + n ≤ slice.start + (slice.«end» - slice.start) :=
+          Nat.add_le_add_left h slice.start
+        rw [Nat.add_sub_cancel' slice.valid.left] at h3
+        exact Nat.le_trans h3 slice.valid.right
+    { slice with «end» := newEnd, valid }
+  else
+    slice
+
+/--
+Creates a sub-slice from start index to end index (exclusive).
+Returns the slice unchanged if indices are out of bounds.
+-/
+@[inline]
+def slice (slice : ByteSlice) (start : Nat) (endIdx : Nat) : ByteSlice :=
+  if h1 : start <= endIdx ∧ endIdx <= slice.size then
+    let newStart := slice.start + start
+    let newEnd := slice.start + endIdx
+
+    let valid := by
+      constructor
+      · simp [newStart, newEnd]
+        exact h1.left
+      · simp [newEnd]
+        simp [size] at h1
+        have h4 : slice.start + endIdx ≤ slice.start + (slice.«end» - slice.start) :=
+          Nat.add_le_add_left h1.right slice.start
+        rw [Nat.add_sub_cancel' slice.valid.left] at h4
+        exact Nat.le_trans h4 slice.valid.right
+    { data := slice.data, start := newStart, «end» := newEnd, valid }
+  else
+    slice
+
+/--
+Finds the first occurrence of a byte in the slice.
+Returns the index relative to the slice start, or `none` if not found.
+-/
+def indexOf? (slice : ByteSlice) (byte : UInt8) : Option Nat :=
+  let rec loop (i : Nat) : Option Nat :=
+    if h : i < slice.size then
+      if slice.get i h = byte then
+        some i
+      else
+        loop (i + 1)
+    else
+      none
+  loop 0
+
+/--
+Checks if the slice starts with another slice.
+-/
+def startsWith (slice : ByteSlice) (pref : ByteSlice) : Bool :=
+  if pref.size > slice.size then
+    false
+  else
+    let rec loop (i : Nat) : Bool :=
+      if h : i < pref.size then
+        if h2 : i < slice.size then
+          if slice.get i = pref.get i then
+            loop (i + 1)
+          else
+            false
+        else
+          false
+      else
+        true
+    loop 0
+
+/---
+Checks if the slice contains a specific byte.
+-/
+@[inline]
+def contains (slice : ByteSlice) (byte : UInt8) : Bool :=
+  slice.indexOf? byte |>.isSome
+
+/--
+Converts the slice to a ByteArray by copying.
+-/
+@[inline]
+def toByteArray (slice : ByteSlice) : ByteArray :=
+  slice.data.extract slice.start slice.end
+
+@[extern "lean_byteslice_beq"]
+protected def beq (a b : ByteSlice) : Bool :=
+  BEq.beq a.toByteArray b.toByteArray
+
+instance : BEq ByteSlice where
+  beq := ByteSlice.beq
+
+instance : GetElem ByteSlice Nat UInt8 (fun slice i => i < slice.size) where
+  getElem := fun slice i h => slice.get i h

src/Init/Data/Char/Basic.lean

@@ -8,7 +8,7 @@ module
 prelude
 public import Init.Data.UInt.BasicAux
 
-@[expose] public section
+public section
 
 /-- Determines if the given integer is a valid [Unicode scalar value](https://www.unicode.org/glossary/#unicode_scalar_value).
 

src/Init/Data/Fin/Basic.lean

@@ -221,7 +221,7 @@ instance : AndOp (Fin n) where
   and := Fin.land
 instance : OrOp (Fin n) where
   or := Fin.lor
-instance : XorOp (Fin n) where
+instance : Xor (Fin n) where
   xor := Fin.xor
 instance : ShiftLeft (Fin n) where
   shiftLeft := Fin.shiftLeft

src/Init/Data/Fin/Fold.lean

@@ -107,14 +107,14 @@ Fin.foldrM n f xₙ = do
   subst w
   rfl
 
-private theorem foldlM_loop_lt [Monad m] (f : α → Fin n → m α) (x) (h : i < n) :
+theorem foldlM_loop_lt [Monad m] (f : α → Fin n → m α) (x) (h : i < n) :
     foldlM.loop n f x i = f x ⟨i, h⟩ >>= (foldlM.loop n f . (i+1)) := by
   rw [foldlM.loop, dif_pos h]
 
-private theorem foldlM_loop_eq [Monad m] (f : α → Fin n → m α) (x) : foldlM.loop n f x n = pure x := by
+theorem foldlM_loop_eq [Monad m] (f : α → Fin n → m α) (x) : foldlM.loop n f x n = pure x := by
   rw [foldlM.loop, dif_neg (Nat.lt_irrefl _)]
 
-private theorem foldlM_loop [Monad m] (f : α → Fin (n+1) → m α) (x) (h : i < n+1) :
+theorem foldlM_loop [Monad m] (f : α → Fin (n+1) → m α) (x) (h : i < n+1) :
     foldlM.loop (n+1) f x i = f x ⟨i, h⟩ >>= (foldlM.loop n (fun x j => f x j.succ) . i) := by
   if h' : i < n then
     rw [foldlM_loop_lt _ _ h]
@@ -170,15 +170,15 @@ theorem foldlM_add [Monad m] [LawfulMonad m] (f : α → Fin (n + k) → m α) :
   subst w
   rfl
 
-private theorem foldrM_loop_zero [Monad m] (f : Fin n → α → m α) (x) :
+theorem foldrM_loop_zero [Monad m] (f : Fin n → α → m α) (x) :
     foldrM.loop n f ⟨0, Nat.zero_le _⟩ x = pure x := by
   rw [foldrM.loop]
 
-private theorem foldrM_loop_succ [Monad m] (f : Fin n → α → m α) (x) (h : i < n) :
+theorem foldrM_loop_succ [Monad m] (f : Fin n → α → m α) (x) (h : i < n) :
     foldrM.loop n f ⟨i+1, h⟩ x = f ⟨i, h⟩ x >>= foldrM.loop n f ⟨i, Nat.le_of_lt h⟩ := by
   rw [foldrM.loop]
 
-private theorem foldrM_loop [Monad m] [LawfulMonad m] (f : Fin (n+1) → α → m α) (x) (h : i+1 ≤ n+1) :
+theorem foldrM_loop [Monad m] [LawfulMonad m] (f : Fin (n+1) → α → m α) (x) (h : i+1 ≤ n+1) :
     foldrM.loop (n+1) f ⟨i+1, h⟩ x =
       foldrM.loop n (fun j => f j.succ) ⟨i, Nat.le_of_succ_le_succ h⟩ x >>= f 0 := by
   induction i generalizing x with
@@ -228,14 +228,14 @@ theorem foldrM_add [Monad m] [LawfulMonad m] (f : Fin (n + k) → α → m α) :
   subst w
   rfl
 
-private theorem foldl_loop_lt (f : α → Fin n → α) (x) (h : i < n) :
+theorem foldl_loop_lt (f : α → Fin n → α) (x) (h : i < n) :
     foldl.loop n f x i = foldl.loop n f (f x ⟨i, h⟩) (i+1) := by
   rw [foldl.loop, dif_pos h]
 
-private theorem foldl_loop_eq (f : α → Fin n → α) (x) : foldl.loop n f x n = x := by
+theorem foldl_loop_eq (f : α → Fin n → α) (x) : foldl.loop n f x n = x := by
   rw [foldl.loop, dif_neg (Nat.lt_irrefl _)]
 
-private theorem foldl_loop (f : α → Fin (n+1) → α) (x) (h : i < n+1) :
+theorem foldl_loop (f : α → Fin (n+1) → α) (x) (h : i < n+1) :
     foldl.loop (n+1) f x i = foldl.loop n (fun x j => f x j.succ) (f x ⟨i, h⟩) i := by
   if h' : i < n then
     rw [foldl_loop_lt _ _ h]
@@ -285,15 +285,15 @@ theorem foldlM_pure [Monad m] [LawfulMonad m] {n} {f : α → Fin n → α} :
   subst w
   rfl
 
-private theorem foldr_loop_zero (f : Fin n → α → α) (x) :
+theorem foldr_loop_zero (f : Fin n → α → α) (x) :
     foldr.loop n f 0 (Nat.zero_le _) x = x := by
   rw [foldr.loop]
 
-private theorem foldr_loop_succ (f : Fin n → α → α) (x) (h : i < n) :
+theorem foldr_loop_succ (f : Fin n → α → α) (x) (h : i < n) :
     foldr.loop n f (i+1) h x = foldr.loop n f i (Nat.le_of_lt h) (f ⟨i, h⟩ x) := by
   rw [foldr.loop]
 
-private theorem foldr_loop (f : Fin (n+1) → α → α) (x) (h : i+1 ≤ n+1) :
+theorem foldr_loop (f : Fin (n+1) → α → α) (x) (h : i+1 ≤ n+1) :
     foldr.loop (n+1) f (i+1) h x =
       f 0 (foldr.loop n (fun j => f j.succ) i (Nat.le_of_succ_le_succ h) x) := by
   induction i generalizing x with

src/Init/Data/Fin/Lemmas.lean

@@ -927,34 +927,24 @@ For the induction:
 -/
 @[elab_as_elim] def reverseInduction {motive : Fin (n + 1) → Sort _} (last : motive (Fin.last n))
     (cast : ∀ i : Fin n, motive i.succ → motive (castSucc i)) (i : Fin (n + 1)) : motive i :=
-  let rec go (j : Nat) (h) (h2 : i ≤ j) (x : motive ⟨j, h⟩) : motive i :=
-    if hi : i.1 = j then _root_.cast (by simp [← hi]) x
-    else match j with
-      | 0 => by omega
-      | j + 1 => go j (by omega) (by omega) (cast ⟨j, by omega⟩ x)
-  go _ _ (by omega) last
+  if hi : i = Fin.last n then _root_.cast (congrArg motive hi.symm) last
+  else
+    let j : Fin n := ⟨i, Nat.lt_of_le_of_ne (Nat.le_of_lt_succ i.2) fun h => hi (Fin.ext h)⟩
+    cast _ (reverseInduction last cast j.succ)
+termination_by n + 1 - i
+decreasing_by decreasing_with
+  -- FIXME: we put the proof down here to avoid getting a dummy `have` in the definition
+  try simp only [Nat.succ_sub_succ_eq_sub]
+  exact Nat.add_sub_add_right .. ▸ Nat.sub_lt_sub_left i.2 (Nat.lt_succ_self i)
 
 @[simp] theorem reverseInduction_last {n : Nat} {motive : Fin (n + 1) → Sort _} {zero succ} :
     (reverseInduction zero succ (Fin.last n) : motive (Fin.last n)) = zero := by
-  rw [reverseInduction, reverseInduction.go]; simp
-
-private theorem reverseInduction_castSucc_aux {n : Nat} {motive : Fin (n + 1) → Sort _} {succ}
-    (i : Fin n) (j : Nat) (h) (h2 : i.1 < j) (zero : motive ⟨j, h⟩) :
-    reverseInduction.go (motive := motive) succ i.castSucc j h (Nat.le_of_lt h2) zero =
-      succ i (reverseInduction.go succ i.succ j h h2 zero) := by
-  induction j generalizing i with
-  | zero => omega
-  | succ j ih =>
-    rw [reverseInduction.go, dif_neg (by exact Nat.ne_of_lt h2)]
-    by_cases hij : i = j
-    · subst hij; simp [reverseInduction.go]
-    dsimp only
-    rw [ih _ _ (by omega), eq_comm, reverseInduction.go, dif_neg (by change i.1 + 1 ≠ _; omega)]
+  rw [reverseInduction]; simp
 
 @[simp] theorem reverseInduction_castSucc {n : Nat} {motive : Fin (n + 1) → Sort _} {zero succ}
     (i : Fin n) : reverseInduction (motive := motive) zero succ (castSucc i) =
       succ i (reverseInduction zero succ i.succ) := by
-  rw [reverseInduction, reverseInduction_castSucc_aux _ _ _ i.isLt, reverseInduction]
+  rw [reverseInduction, dif_neg (Fin.ne_of_lt (Fin.castSucc_lt_last i))]; rfl
 
 /--
 Proves a statement by cases on the underlying `Nat` value in a `Fin (n + 1)`, checking whether the

src/Init/Data/Int/Basic.lean

@@ -314,7 +314,7 @@ Examples:
  * `(0 : Int).natAbs = 0`
  * `((-11 : Int).natAbs = 11`
 -/
-@[extern "lean_nat_abs", expose]
+@[extern "lean_nat_abs"]
 def natAbs (m : @& Int) : Nat :=
   match m with
   | ofNat m => m
@@ -404,26 +404,6 @@ instance : Min Int := minOfLe
 
 instance : Max Int := maxOfLe
 
-/-- Equality predicate for kernel reduction. -/
-@[expose] protected noncomputable def beq' (a b : Int) : Bool :=
-  Int.rec
-    (fun a => Int.rec (fun b => Nat.beq a b) (fun _ => false) b)
-    (fun a => Int.rec (fun _ => false) (fun b => Nat.beq a b) b) a
-
-/-- `x ≤ y` for kernel reduction. -/
-@[expose] protected noncomputable def ble' (a b : Int) : Bool :=
-  Int.rec
-    (fun a => Int.rec (fun b => Nat.ble a b) (fun _ => false) b)
-    (fun a => Int.rec (fun _ => true) (fun b => Nat.ble b a) b)
-    a
-
-/-- `x < y` for kernel reduction. -/
-@[expose] protected noncomputable def blt' (a b : Int) : Bool :=
-  Int.rec
-    (fun a => Int.rec (fun b => Nat.blt a b) (fun _ => false) b)
-    (fun a => Int.rec (fun _ => true) (fun b => Nat.blt b a) b)
-    a
-
 end Int
 
 /--

src/Init/Data/Int/Compare.lean

@@ -27,7 +27,7 @@ theorem compare_eq_ite_lt (a b : Int) :
   simp only [compare, compareOfLessAndEq]
   split
   · rfl
-  next h =>
+  · next h =>
     match Int.lt_or_eq_of_le (Int.not_lt.1 h) with
     | .inl h => simp [h, Int.ne_of_gt h]
     | .inr rfl => simp
@@ -36,11 +36,11 @@ theorem compare_eq_ite_le (a b : Int) :
     compare a b = if a ≤ b then if b ≤ a then .eq else .lt else .gt := by
   rw [compare_eq_ite_lt]
   split
-  next hlt => simp [Int.le_of_lt hlt, Int.not_le.2 hlt]
-  next hge =>
+  · next hlt => simp [Int.le_of_lt hlt, Int.not_le.2 hlt]
+  · next hge =>
     split
-    next hgt => simp [Int.not_le.2 hgt]
-    next hle => simp [Int.not_lt.1 hge, Int.not_lt.1 hle]
+    · next hgt => simp [Int.not_le.2 hgt]
+    · next hle => simp [Int.not_lt.1 hge, Int.not_lt.1 hle]
 
 protected theorem compare_swap (a b : Int) : (compare a b).swap = compare b a := by
   simp only [compare_eq_ite_le]; (repeat' split) <;> try rfl

src/Init/Data/Int/Lemmas.lean

@@ -86,17 +86,6 @@ theorem negSucc_coe (n : Nat) : -[n+1] = -↑(n + 1) := rfl
 @[simp, norm_cast] theorem cast_ofNat_Int :
   (Nat.cast (no_index (OfNat.ofNat n)) : Int) = OfNat.ofNat n := rfl
 
-@[simp] theorem beq'_eq (a b : Int) : Int.beq' a b = (a = b) := by
-  cases a <;> cases b <;> simp [Int.beq', ofNat_inj]
-
-@[simp] theorem beq'_ne (a b : Int) : (Int.beq' a b = false) = (a ≠ b) := by
-  rw [Ne, ← beq'_eq, Bool.not_eq_true]
-
-theorem beq'_eq_beq (a b : Int) : (Int.beq' a b) = (a == b) := by
-  have h : (Int.beq' a b = true) = (a == b) := by simp
-  have : ∀ {a b : Bool}, (a = true) = (b = true) → a = b := by intro a b; cases a <;> cases b <;> simp
-  exact this h
-
 /- ## neg -/
 
 @[simp] protected theorem neg_neg : ∀ a : Int, -(-a) = a

src/Init/Data/Int/LemmasAux.lean

@@ -69,18 +69,6 @@ theorem natCast_succ_pos (n : Nat) : 0 < (n.succ : Int) := natCast_pos.2 n.succ_
 
 @[simp, norm_cast] theorem cast_id {n : Int} : Int.cast n = n := rfl
 
-@[simp] theorem ble'_eq_true (a b : Int) : (Int.ble' a b = true) = (a ≤ b) := by
-  cases a <;> cases b <;> simp [Int.ble'] <;> omega
-
-@[simp] theorem blt'_eq_true (a b : Int) : (Int.blt' a b = true) = (a < b) := by
-  cases a <;> cases b <;> simp [Int.blt'] <;> omega
-
-@[simp] theorem ble'_eq_false (a b : Int) : (Int.ble' a b = false) = ¬(a ≤ b) := by
-  simp [← Bool.not_eq_true]
-
-@[simp] theorem blt'_eq_false (a b : Int) : (Int.blt' a b = false) = ¬ (a < b) := by
-  simp [← Bool.not_eq_true]
-
 /-! ### toNat -/
 
 @[simp] theorem toNat_sub' (a : Int) (b : Nat) : (a - b).toNat = a.toNat - b := by

src/Init/Data/Int/OfNat.lean

@@ -9,100 +9,96 @@ prelude
 public import Init.Data.Int.Lemmas
 public import Init.Data.Int.DivMod
 public import Init.Data.Int.Linear
-public import Init.GrindInstances.ToInt
 public import Init.Data.RArray
 
 public section
 
-namespace Nat.ToInt
+namespace Int.OfNat
+/-!
+Helper definitions and theorems for converting `Nat` expressions into `Int` one.
+We use them to implement the arithmetic theories in `grind`
+-/
 
-theorem ofNat_toNat (a : Int) : (NatCast.natCast a.toNat : Int) = if a ≤ 0 then 0 else a := by simp [Int.max_def]
+abbrev Var := Nat
+abbrev Context := Lean.RArray Nat
+@[expose]
+def Var.denote (ctx : Context) (v : Var) : Nat :=
+  ctx.get v
 
-theorem toNat_nonneg (x : Nat) : (-1:Int) * (NatCast.natCast x) ≤ 0 := by simp
+inductive Expr where
+  | num  (v : Nat)
+  | var  (i : Var)
+  | add  (a b : Expr)
+  | mul  (a b : Expr)
+  | div  (a b : Expr)
+  | mod  (a b : Expr)
+  | pow  (a : Expr) (k : Nat)
+  deriving BEq
 
-theorem natCast_ofNat (n : Nat) : (NatCast.natCast (OfNat.ofNat n : Nat) : Int) = OfNat.ofNat n := by rfl
+@[expose]
+def Expr.denote (ctx : Context) : Expr → Nat
+  | .num k    => k
+  | .var v    => v.denote ctx
+  | .add a b  => Nat.add (denote ctx a) (denote ctx b)
+  | .mul a b  => Nat.mul (denote ctx a) (denote ctx b)
+  | .div a b  => Nat.div (denote ctx a) (denote ctx b)
+  | .mod a b  => Nat.mod (denote ctx a) (denote ctx b)
+  | .pow a k  => Nat.pow (denote ctx a) k
 
-theorem of_eq {a b : Nat} {a' b' : Int}
-    (h₁ : NatCast.natCast a = a') (h₂ : NatCast.natCast b = b') : a = b → a' = b' := by
-  intro h; replace h := congrArg (NatCast.natCast (R := Int)) h
-  rw [h₁, h₂] at h; assumption
+@[expose]
+def Expr.denoteAsInt (ctx : Context) : Expr → Int
+  | .num k    => Int.ofNat k
+  | .var v    => Int.ofNat (v.denote ctx)
+  | .add a b  => Int.add (denoteAsInt ctx a) (denoteAsInt ctx b)
+  | .mul a b  => Int.mul (denoteAsInt ctx a) (denoteAsInt ctx b)
+  | .div a b  => Int.ediv (denoteAsInt ctx a) (denoteAsInt ctx b)
+  | .mod a b  => Int.emod (denoteAsInt ctx a) (denoteAsInt ctx b)
+  | .pow a k  => Int.pow (denoteAsInt ctx a) k
 
-theorem of_diseq {a b : Nat} {a' b' : Int}
-    (h₁ : NatCast.natCast a = a') (h₂ : NatCast.natCast b = b') : a ≠ b → a' ≠ b' := by
-  intro hne h; rw [← h₁, ← h₂] at h
-  replace h := Int.ofNat_inj.mp h; contradiction
+theorem Expr.denoteAsInt_eq (ctx : Context) (e : Expr) : e.denoteAsInt ctx = e.denote ctx := by
+  induction e <;> simp [denote, denoteAsInt, *] <;> rfl
 
-theorem of_dvd (d a : Nat) (d' a' : Int)
-    (h₁ : NatCast.natCast d = d') (h₂ : NatCast.natCast a = a') : d ∣ a → d' ∣ a' := by
-  simp [← h₁, ←h₂, Int.ofNat_dvd]
+theorem Expr.eq_denoteAsInt (ctx : Context) (e : Expr) : e.denote ctx = e.denoteAsInt ctx := by
+  apply Eq.symm; apply denoteAsInt_eq
 
-theorem of_le {a b : Nat} {a' b' : Int}
-    (h₁ : NatCast.natCast a = a') (h₂ : NatCast.natCast b = b') : a ≤ b → a' ≤ b' := by
-  intro h; replace h := Int.ofNat_le |>.mpr h
-  rw [← h₁, ← h₂]; assumption
+theorem Expr.eq (ctx : Context) (lhs rhs : Expr)
+    : (lhs.denote ctx = rhs.denote ctx) = (lhs.denoteAsInt ctx = rhs.denoteAsInt ctx) := by
+  simp [denoteAsInt_eq, Int.ofNat_inj]
 
-theorem of_not_le {a b : Nat} {a' b' : Int}
-    (h₁ : NatCast.natCast a = a') (h₂ : NatCast.natCast b = b') : ¬ (a ≤ b) → b' + 1 ≤ a' := by
-  intro h; rw [← Int.ofNat_le] at h
-  rw [← h₁, ← h₂]; show (↑b + 1 : Int) ≤ a; omega
+theorem Expr.le (ctx : Context) (lhs rhs : Expr)
+    : (lhs.denote ctx ≤ rhs.denote ctx) = (lhs.denoteAsInt ctx ≤ rhs.denoteAsInt ctx) := by
+  simp [denoteAsInt_eq, Int.ofNat_le]
 
-theorem add_congr {a b : Nat} {a' b' : Int}
-    (h₁ : NatCast.natCast a = a') (h₂ : NatCast.natCast b = b') : NatCast.natCast (a + b) = a' + b' := by
-  simp_all [Int.natCast_add]
+theorem of_le (ctx : Context) (lhs rhs : Expr)
+    : lhs.denote ctx ≤ rhs.denote ctx → lhs.denoteAsInt ctx ≤ rhs.denoteAsInt ctx := by
+  rw [Expr.le ctx lhs rhs]; simp
 
-theorem mul_congr {a b : Nat} {a' b' : Int}
-    (h₁ : NatCast.natCast a = a') (h₂ : NatCast.natCast b = b') : NatCast.natCast (a * b) = a' * b' := by
-  simp_all [Int.natCast_mul]
+theorem of_not_le (ctx : Context) (lhs rhs : Expr)
+    : ¬ lhs.denote ctx ≤ rhs.denote ctx → ¬ lhs.denoteAsInt ctx ≤ rhs.denoteAsInt ctx := by
+  rw [Expr.le ctx lhs rhs]; simp
 
-theorem sub_congr {a b : Nat} {a' b' : Int}
-    (h₁ : NatCast.natCast a = a') (h₂ : NatCast.natCast b = b') : NatCast.natCast (a - b) = if b' + (-1)*a' ≤ 0 then a' - b' else 0 := by
-  rw [Int.neg_mul, ← Int.sub_eq_add_neg, Int.one_mul]
+theorem of_dvd (ctx : Context) (d : Nat) (e : Expr)
+    : d ∣ e.denote ctx → Int.ofNat d ∣ e.denoteAsInt ctx := by
+  simp [Expr.denoteAsInt_eq, Int.ofNat_dvd]
+
+theorem of_eq (ctx : Context) (lhs rhs : Expr)
+    : lhs.denote ctx = rhs.denote ctx → lhs.denoteAsInt ctx = rhs.denoteAsInt ctx := by
+  rw [Expr.eq ctx lhs rhs]; simp
+
+theorem of_not_eq (ctx : Context) (lhs rhs : Expr)
+    : ¬ lhs.denote ctx = rhs.denote ctx → ¬ lhs.denoteAsInt ctx = rhs.denoteAsInt ctx := by
+  rw [Expr.eq ctx lhs rhs]; simp
+
+theorem ofNat_toNat (a : Int) : (NatCast.natCast a.toNat : Int) = if a ≤ 0 then 0 else a := by
   split
   next h =>
-    have h := Int.le_of_sub_nonpos h
-    simp [← h₁, ← h₂, Int.ofNat_le] at h
-    simp [Int.ofNat_sub h]
-    rw [← h₁, ← h₂]
+    rw [Int.toNat_of_nonpos h]; rfl
   next h =>
-    have : ¬ (↑b : Int) ≤ ↑a := by
-      intro h
-      replace h := Int.sub_nonpos_of_le h
-      simp [h₁, h₂] at h
-      contradiction
-    rw [Int.ofNat_le] at this
-    simp [Lean.Omega.Int.ofNat_sub_eq_zero this]
+    simp at h
+    have := Int.toNat_of_nonneg (Int.le_of_lt h)
+    assumption
 
-theorem pow_congr {a : Nat} (k : Nat) (a' : Int)
-    (h₁ : NatCast.natCast a = a') : NatCast.natCast (a ^ k) = a' ^ k := by
-  simp_all [Int.natCast_pow]
+theorem Expr.denoteAsInt_nonneg (ctx : Context) (e : Expr) : 0 ≤ e.denoteAsInt ctx := by
+  simp [Expr.denoteAsInt_eq]
 
-theorem div_congr {a b : Nat} {a' b' : Int}
-    (h₁ : NatCast.natCast a = a') (h₂ : NatCast.natCast b = b') : NatCast.natCast (a / b) = a' / b' := by
-  simp_all [Int.natCast_ediv]
-
-theorem mod_congr {a b : Nat} {a' b' : Int}
-    (h₁ : NatCast.natCast a = a') (h₂ : NatCast.natCast b = b') : NatCast.natCast (a % b) = a' % b' := by
-  simp_all [Int.natCast_emod]
-
-theorem finVal {n : Nat} {a : Fin n} {a' : Int}
-    (h₁ : Lean.Grind.ToInt.toInt a = a') : NatCast.natCast (a.val) = a' := by
-  rw [← h₁, Lean.Grind.ToInt.toInt, Lean.Grind.instToIntFinCoOfNatIntCast]
-
-end Nat.ToInt
-
-namespace Int.Nonneg
-
-@[expose] def num_cert (a : Int) : Bool := a ≥ 0
-theorem num (a : Int) : num_cert a → a ≥ 0 := by simp [num_cert]
-theorem add (a b : Int) (h₁ : a ≥ 0) (h₂ : b ≥ 0) : a + b ≥ 0 := by exact Int.add_nonneg h₁ h₂
-theorem mul (a b : Int) (h₁ : a ≥ 0) (h₂ : b ≥ 0) : a * b ≥ 0 := by exact Int.mul_nonneg h₁ h₂
-theorem div (a b : Int) (h₁ : a ≥ 0) (h₂ : b ≥ 0) : a / b ≥ 0 := by exact Int.ediv_nonneg h₁ h₂
-theorem pow (a : Int) (k : Nat) (h₁ : a ≥ 0) : a ^ k ≥ 0 := by exact Int.pow_nonneg h₁
-theorem mod (a b : Int) (h₁ : a ≥ 0) : a % b ≥ 0 := by
-  by_cases b = 0
-  next => simp [*]
-  next h => exact emod_nonneg a h
-theorem natCast (a : Nat) : (NatCast.natCast a : Int) ≥ 0 := by simp
-theorem toPoly (e : Int) : e ≥ 0 → -1 * e ≤ 0 := by omega
-
-end Int.Nonneg
+end Int.OfNat

src/Init/Data/Int/Order.lean

@@ -1117,11 +1117,11 @@ protected theorem add_le_zero_iff_le_neg {a b : Int} : a + b ≤ 0 ↔ a ≤ -b
 protected theorem add_le_zero_iff_le_neg' {a b : Int} : a + b ≤ 0 ↔ b ≤ -a := by
   rw [Int.add_comm, Int.add_le_zero_iff_le_neg]
 
-protected theorem add_nonneg_iff_neg_le {a b : Int} : 0 ≤ a + b ↔ -b ≤ a := by
+protected theorem add_nonnneg_iff_neg_le {a b : Int} : 0 ≤ a + b ↔ -b ≤ a := by
   rw [Int.le_add_iff_sub_le, Int.zero_sub]
 
-protected theorem add_nonneg_iff_neg_le' {a b : Int} : 0 ≤ a + b ↔ -a ≤ b := by
-  rw [Int.add_comm, Int.add_nonneg_iff_neg_le]
+protected theorem add_nonnneg_iff_neg_le' {a b : Int} : 0 ≤ a + b ↔ -a ≤ b := by
+  rw [Int.add_comm, Int.add_nonnneg_iff_neg_le]
 
 /- ### Order properties and multiplication -/
 

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

@@ -10,7 +10,7 @@ public import Init.Data.Iterators.Consumers.Partial
 public import Init.Data.Iterators.Consumers.Loop
 public import Init.Data.Iterators.Consumers.Monadic.Access
 
-@[expose] public section
+public section
 
 namespace Std.Iterators
 

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

@@ -10,7 +10,7 @@ public import Init.Data.Iterators.Basic
 public import Init.Data.Iterators.Consumers.Partial
 public import Init.Data.Iterators.Consumers.Monadic.Collect
 
-@[expose] public section
+public section
 
 /-!
 # Collectors

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

@@ -9,7 +9,7 @@ prelude
 public import Init.Data.Iterators.Consumers.Monadic.Partial
 public import Init.Data.Iterators.Internal.LawfulMonadLiftFunction
 
-@[expose] public section
+public section
 
 /-!
 # Collectors

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

@@ -10,7 +10,6 @@ public import all Init.Data.Iterators.Combinators.Attach
 public import all Init.Data.Iterators.Combinators.Monadic.Attach
 public import Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach
 public import Init.Data.Iterators.Lemmas.Consumers.Collect
-public import Init.Data.Array.Attach
 
 public section
 
@@ -69,16 +68,4 @@ theorem Iter.unattach_toArray_attachWith [Iterator α Id β]
     (it.attachWith P hP).toListRev.unattach = it.toListRev := by
   simp [toListRev_eq]
 
-@[simp]
-theorem Iter.toArray_attachWith [Iterator α Id β]
-    {it : Iter (α := α) β} {hP}
-    [Finite α Id] [IteratorCollect α Id Id]
-    [LawfulIteratorCollect α Id Id] :
-    (it.attachWith P hP).toArray = it.toArray.attachWith P
-        (fun out h => hP out (isPlausibleIndirectOutput_of_mem_toArray h)) := by
-  suffices (it.attachWith P hP).toArray.toList = (it.toArray.attachWith P
-      (fun out h => hP out (isPlausibleIndirectOutput_of_mem_toArray h))).toList by
-    simpa only [Array.toList_inj]
-  simp [Iter.toList_toArray]
-
 end Std.Iterators

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

@@ -251,7 +251,7 @@ instance {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''}
     simp only [LawfulIteratorCollect.toArrayMapped_eq]
     simp only [IteratorCollect.toArrayMapped]
     rw [LawfulIteratorCollect.toArrayMapped_eq]
-    induction it using IterM.inductSteps with | step it ih_yield ih_skip
+    induction it using IterM.inductSteps with | step it ih_yield ih_skip =>
     rw [IterM.DefaultConsumers.toArrayMapped_eq_match_step]
     rw [IterM.DefaultConsumers.toArrayMapped_eq_match_step]
     simp only [bind_assoc]

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

@@ -97,7 +97,7 @@ theorem Iter.getElem?_toList_eq_atIdxSlow? {α β}
     [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {k : Nat} :
     it.toList[k]? = it.atIdxSlow? k := by
-  induction it using Iter.inductSteps generalizing k with | step it ihy ihs
+  induction it using Iter.inductSteps generalizing k with | step it ihy ihs =>
   rw [toList_eq_match_step, atIdxSlow?]
   obtain ⟨step, h⟩ := it.step
   cases step
@@ -117,7 +117,7 @@ theorem Iter.isPlausibleIndirectOutput_of_mem_toList
     [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
     {it : Iter (α := α) β} {b : β} :
     b ∈ it.toList → it.IsPlausibleIndirectOutput b := by
-  induction it using Iter.inductSteps with | step it ihy ihs
+  induction it using Iter.inductSteps with | step it ihy ihs =>
   rw [toList_eq_match_step]
   cases it.step using PlausibleIterStep.casesOn
   case yield it' out h =>
@@ -144,13 +144,4 @@ theorem Iter.isPlausibleIndirectOutput_of_mem_toListRev
   apply isPlausibleIndirectOutput_of_mem_toList
   simpa [toListRev_eq] using h
 
-theorem Iter.isPlausibleIndirectOutput_of_mem_toArray
-    [Iterator α Id β] [Finite α Id] [IteratorCollect α Id Id] [LawfulIteratorCollect α Id Id]
-    {it : Iter (α := α) β} {b : β} :
-    b ∈ it.toArray → it.IsPlausibleIndirectOutput b := by
-  intro h
-  apply isPlausibleIndirectOutput_of_mem_toList
-  rw [← Array.mem_toList_iff] at h
-  simpa [toList_toArray] using h
-
 end Std.Iterators

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

@@ -143,7 +143,7 @@ theorem Iter.mem_toList_iff_isPlausibleIndirectOutput {α β} [Iterator α Id β
     [LawfulIteratorCollect α Id Id] [LawfulDeterministicIterator α Id]
     {it : Iter (α := α) β} {out : β} :
     out ∈ it.toList ↔ it.IsPlausibleIndirectOutput out := by
-  induction it using Iter.inductSteps with | step it ihy ihs
+  induction it using Iter.inductSteps with | step it ihy ihs =>
   rw [toList_eq_match_step]
   constructor
   · intro h
@@ -194,7 +194,7 @@ theorem Iter.forIn'_toList {α β : Type w} [Iterator α Id β]
     {f : (out : β) → _ → γ → m (ForInStep γ)} :
     letI : ForIn' m (Iter (α := α) β) β _ := Iter.instForIn'
     ForIn'.forIn' it.toList init f = ForIn'.forIn' it init (fun out h acc => f out (Iter.mem_toList_iff_isPlausibleIndirectOutput.mpr h) acc) := by
-  induction it using Iter.inductSteps generalizing init with | step it ihy ihs
+  induction it using Iter.inductSteps generalizing init with case step it ihy ihs =>
   have := it.toList_eq_match_step
   generalize hs : it.step = step at this
   rw [forIn'_toList.aux this]
@@ -239,7 +239,7 @@ theorem Iter.forIn_toList {α β : Type w} [Iterator α Id β]
     {f : β → γ → m (ForInStep γ)} :
     ForIn.forIn it.toList init f = ForIn.forIn it init f := by
   rw [List.forIn_eq_foldlM]
-  induction it using Iter.inductSteps generalizing init with | step it ihy ihs
+  induction it using Iter.inductSteps generalizing init with case step it ihy ihs =>
   rw [forIn_eq_match_step, Iter.toList_eq_match_step]
   simp only [map_eq_pure_bind]
   generalize it.step = step

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

@@ -21,7 +21,8 @@ theorem IterM.DefaultConsumers.toArrayMapped.go.aux₁ [Monad n] [LawfulMonad n]
     [Finite α m] {b : γ} {bs : Array γ} :
     IterM.DefaultConsumers.toArrayMapped.go lift f it (#[b] ++ bs) (m := m) =
       (#[b] ++ ·) <$> IterM.DefaultConsumers.toArrayMapped.go lift f it bs (m := m) := by
-  induction it, bs using IterM.DefaultConsumers.toArrayMapped.go.induct with | _ it bs ih₁ ih₂
+  induction it, bs using IterM.DefaultConsumers.toArrayMapped.go.induct
+  next it bs ih₁ ih₂ =>
   rw [go, map_eq_pure_bind, go, bind_assoc]
   apply bind_congr
   intro step
@@ -92,7 +93,8 @@ theorem IterM.toList_eq_match_step [Monad m] [LawfulMonad m] [Iterator α m β]
 theorem IterM.toListRev.go.aux₁ [Monad m] [LawfulMonad m] [Iterator α m β] [Finite α m]
     {it : IterM (α := α) m β} {b : β} {bs : List β} :
     IterM.toListRev.go it (bs ++ [b]) = (· ++ [b]) <$> IterM.toListRev.go it bs:= by
-  induction it, bs using IterM.toListRev.go.induct with | _ it bs ih₁ ih₂
+  induction it, bs using IterM.toListRev.go.induct
+  next it bs ih₁ ih₂ =>
   rw [go, go, map_eq_pure_bind, bind_assoc]
   apply bind_congr
   intro step

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

@@ -208,7 +208,7 @@ theorem IterM.toList_eq_fold {α β : Type w} {m : Type w → Type w'} [Iterator
       it.fold (init := l') (fun l out => l ++ [out]) by
     specialize h []
     simpa using h
-  induction it using IterM.inductSteps with | step it ihy ihs
+  induction it using IterM.inductSteps with | step it ihy ihs =>
   intro l'
   rw [IterM.toList_eq_match_step, IterM.fold_eq_match_step]
   simp only [map_eq_pure_bind, bind_assoc]
@@ -253,7 +253,7 @@ theorem IterM.drain_eq_map_toList {α β : Type w} {m : Type w → Type w'} [Ite
     [IteratorCollect α m m] [LawfulIteratorCollect α m m]
     {it : IterM (α := α) m β} :
     it.drain = (fun _ => .unit) <$> it.toList := by
-  induction it using IterM.inductSteps with | step it ihy ihs
+  induction it using IterM.inductSteps with | step it ihy ihs =>
   rw [IterM.drain_eq_match_step, IterM.toList_eq_match_step]
   simp only [map_eq_pure_bind, bind_assoc]
   apply bind_congr

src/Init/Data/List/Basic.lean

@@ -242,7 +242,8 @@ instance instLT [LT α] : LT (List α) := ⟨List.lt⟩
 instance decidableLT [DecidableEq α] [LT α] [DecidableLT α] (l₁ l₂ : List α) :
     Decidable (l₁ < l₂) := decidableLex (· < ·) l₁ l₂
 
-
+@[deprecated decidableLT (since := "2024-12-13"), inherit_doc decidableLT]
+abbrev hasDecidableLt := @decidableLT
 
 /--
 Non-strict ordering of lists with respect to a strict ordering of their elements.
@@ -1368,7 +1369,7 @@ Each element of a list is related to all later elements of the list by `R`.
 `Pairwise R l` means that all the elements of `l` with earlier indexes are `R`-related to all the
 elements with later indexes.
 
-For example, `Pairwise (· ≠ ·) l` asserts that `l` has no duplicates, and `Pairwise (· < ·) l`
+For example, `Pairwise (· ≠ ·) l` asserts that `l` has no duplicates, and if `Pairwise (· < ·) l`
 asserts that `l` is (strictly) sorted.
 
 Examples:
@@ -1721,8 +1722,14 @@ Examples:
 -/
 def idxOf [BEq α] (a : α) : List α → Nat := findIdx (· == a)
 
+/-- Returns the index of the first element equal to `a`, or the length of the list otherwise. -/
+@[deprecated idxOf (since := "2025-01-29")] abbrev indexOf := @idxOf
+
 @[simp] theorem idxOf_nil [BEq α] : ([] : List α).idxOf x = 0 := rfl
 
+@[deprecated idxOf_nil (since := "2025-01-29")]
+theorem indexOf_nil [BEq α] : ([] : List α).idxOf x = 0 := rfl
+
 /-! ### findIdx? -/
 
 /--
@@ -1753,6 +1760,10 @@ Examples:
 -/
 @[inline] def idxOf? [BEq α] (a : α) : List α → Option Nat := findIdx? (· == a)
 
+/-- Return the index of the first occurrence of `a` in the list. -/
+@[deprecated idxOf? (since := "2025-01-29")]
+abbrev indexOf? := @idxOf?
+
 /-! ### findFinIdx? -/
 
 /--
@@ -2108,6 +2119,22 @@ def range' : (start len : Nat) → (step : Nat := 1) → List Nat
   | _, 0, _ => []
   | s, n+1, step => s :: range' (s+step) n step
 
+/-! ### iota -/
+
+/--
+`O(n)`. `iota n` is the numbers from `1` to `n` inclusive, in decreasing order.
+* `iota 5 = [5, 4, 3, 2, 1]`
+-/
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20")]
+def iota : Nat → List Nat
+  | 0       => []
+  | m@(n+1) => m :: iota n
+
+set_option linter.deprecated false in
+@[simp] theorem iota_zero : iota 0 = [] := rfl
+set_option linter.deprecated false in
+@[simp] theorem iota_succ : iota (i+1) = (i+1) :: iota i := rfl
+
 /-! ### zipIdx -/
 
 /--
@@ -2126,6 +2153,38 @@ def zipIdx : (l : List α) → (n : Nat := 0) → List (α × Nat)
 @[simp] theorem zipIdx_nil : ([] : List α).zipIdx i = [] := rfl
 @[simp] theorem zipIdx_cons : (a::as).zipIdx i = (a, i) :: as.zipIdx (i+1) := rfl
 
+/-! ### enumFrom -/
+
+/--
+`O(|l|)`. `enumFrom n l` is like `enum` but it allows you to specify the initial index.
+* `enumFrom 5 [a, b, c] = [(5, a), (6, b), (7, c)]`
+-/
+@[deprecated "Use `zipIdx` instead; note the signature change." (since := "2025-01-21")]
+def enumFrom : Nat → List α → List (Nat × α)
+  | _, [] => nil
+  | n, x :: xs   => (n, x) :: enumFrom (n + 1) xs
+
+set_option linter.deprecated false in
+@[deprecated zipIdx_nil (since := "2025-01-21"), simp]
+theorem enumFrom_nil : ([] : List α).enumFrom i = [] := rfl
+set_option linter.deprecated false in
+@[deprecated zipIdx_cons (since := "2025-01-21"), simp]
+theorem enumFrom_cons : (a::as).enumFrom i = (i, a) :: as.enumFrom (i+1) := rfl
+
+/-! ### enum -/
+
+set_option linter.deprecated false in
+/--
+`O(|l|)`. `enum l` pairs up each element with its index in the list.
+* `enum [a, b, c] = [(0, a), (1, b), (2, c)]`
+-/
+@[deprecated "Use `zipIdx` instead; note the signature change." (since := "2025-01-21")]
+def enum : List α → List (Nat × α) := enumFrom 0
+
+set_option linter.deprecated false in
+@[deprecated zipIdx_nil (since := "2025-01-21"), simp]
+theorem enum_nil : ([] : List α).enum = [] := rfl
+
 /-! ## Minima and maxima -/
 
 /-! ### min? -/
@@ -2545,6 +2604,25 @@ Examples:
     exact go s n (m + 1)
   exact (go s n 0).symm
 
+/-! ### iota -/
+
+/-- Tail-recursive version of `List.iota`. -/
+@[deprecated "Use `List.range' 1 n` instead of `iota n`." (since := "2025-01-20")]
+def iotaTR (n : Nat) : List Nat :=
+  let rec go : Nat → List Nat → List Nat
+    | 0, r => r.reverse
+    | m@(n+1), r => go n (m::r)
+  go n []
+
+set_option linter.deprecated false in
+@[csimp]
+theorem iota_eq_iotaTR : @iota = @iotaTR :=
+  have aux (n : Nat) (r : List Nat) : iotaTR.go n r = r.reverse ++ iota n := by
+    induction n generalizing r with
+    | zero => simp [iota, iotaTR.go]
+    | succ n ih => simp [iota, iotaTR.go, ih, append_assoc]
+  funext fun n => by simp [iotaTR, aux]
+
 /-! ## Other list operations -/
 
 /-! ### intersperse -/

src/Init/Data/List/Control.lean

@@ -104,20 +104,6 @@ def forA {m : Type u → Type v} [Applicative m] {α : Type w} (as : List α) (f
   | []      => pure ⟨⟩
   | a :: as => f a *> forA as f
 
-/--
-Applies the monadic action `f` to the corresponding elements of two lists, left-to-right, stopping
-at the end of the shorter list. `zipWithM f as bs` is equivalent to `mapM id (zipWith f as bs)`
-for lawful `Monad` instances.
-
-This implementation is tail recursive. `List.zipWithM'` is a a non-tail-recursive variant that may
-be more convenient to reason about.
--/
-@[inline, expose]
-def zipWithM {m : Type u → Type v} [Monad m] {α : Type w} {β : Type x} {γ : Type u} (f : α → β → m γ) (as : List α) (bs : List β) : m (List γ) :=
-  let rec @[specialize] loop
-    | a::as, b::bs, acc => do loop as bs (acc.push (← f a b))
-    | _, _, acc => pure acc.toList
-  loop as bs #[]
 
 @[specialize]
 def filterAuxM {m : Type → Type v} [Monad m] {α : Type} (f : α → m Bool) : List α → List α → m (List α)

src/Init/Data/List/Erase.lean

@@ -57,9 +57,15 @@ theorem eraseP_of_forall_not {l : List α} (h : ∀ a, a ∈ l → ¬p a) : l.er
       rintro x h' rfl
       simp_all
 
+@[deprecated eraseP_eq_nil_iff (since := "2025-01-30")]
+abbrev eraseP_eq_nil := @eraseP_eq_nil_iff
+
 theorem eraseP_ne_nil_iff {xs : List α} {p : α → Bool} : xs.eraseP p ≠ [] ↔ xs ≠ [] ∧ ∀ x, p x → xs ≠ [x] := by
   simp
 
+@[deprecated eraseP_ne_nil_iff (since := "2025-01-30")]
+abbrev eraseP_ne_nil := @eraseP_ne_nil_iff
+
 theorem exists_of_eraseP : ∀ {l : List α} {a} (_ : a ∈ l) (_ : p a),
     ∃ a l₁ l₂, (∀ b ∈ l₁, ¬p b) ∧ p a ∧ l = l₁ ++ a :: l₂ ∧ l.eraseP p = l₁ ++ l₂
   | b :: l, _, al, pa =>
@@ -331,7 +337,7 @@ theorem erase_of_not_mem [LawfulBEq α] {a : α} : ∀ {l : List α}, a ∉ l
 theorem erase_eq_eraseP' (a : α) (l : List α) : l.erase a = l.eraseP (· == a) := by
   induction l
   · simp
-  next b t ih =>
+  · next b t ih =>
     rw [erase_cons, eraseP_cons, ih]
     if h : b == a then simp [h] else simp [h]
 
@@ -346,11 +352,17 @@ theorem erase_eq_eraseP [LawfulBEq α] (a : α) : ∀ (l : List α), l.erase a =
   rw [erase_eq_eraseP]
   simp
 
+@[deprecated erase_eq_nil_iff (since := "2025-01-30")]
+abbrev erase_eq_nil := @erase_eq_nil_iff
+
 theorem erase_ne_nil_iff [LawfulBEq α] {xs : List α} {a : α} :
     xs.erase a ≠ [] ↔ xs ≠ [] ∧ xs ≠ [a] := by
   rw [erase_eq_eraseP]
   simp
 
+@[deprecated erase_ne_nil_iff (since := "2025-01-30")]
+abbrev erase_ne_nil := @erase_ne_nil_iff
+
 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 _)
@@ -570,7 +582,8 @@ theorem eraseIdx_eq_take_drop_succ :
   | a::l, 0
   | a::l, i + 1 => simp
 
-
+@[deprecated eraseIdx_eq_nil_iff (since := "2025-01-30")]
+abbrev eraseIdx_eq_nil := @eraseIdx_eq_nil_iff
 
 theorem eraseIdx_ne_nil_iff {l : List α} {i : Nat} : eraseIdx l i ≠ [] ↔ 2 ≤ l.length ∨ (l.length = 1 ∧ i ≠ 0) := by
   match l with
@@ -578,7 +591,8 @@ theorem eraseIdx_ne_nil_iff {l : List α} {i : Nat} : eraseIdx l i ≠ [] ↔ 2
   | [a]
   | a::b::l => simp
 
-
+@[deprecated eraseIdx_ne_nil_iff (since := "2025-01-30")]
+abbrev eraseIdx_ne_nil := @eraseIdx_ne_nil_iff
 
 @[grind]
 theorem eraseIdx_sublist : ∀ (l : List α) (k : Nat), eraseIdx l k <+ l
@@ -686,6 +700,7 @@ theorem erase_eq_eraseIdx_of_idxOf [BEq α] [LawfulBEq α]
     rw [eq_comm, eraseIdx_eq_self]
     exact Nat.le_of_eq (idxOf_eq_length h).symm
 
-
+@[deprecated erase_eq_eraseIdx_of_idxOf (since := "2025-01-29")]
+abbrev erase_eq_eraseIdx_of_indexOf := @erase_eq_eraseIdx_of_idxOf
 
 end List

src/Init/Data/List/FinRange.lean

@@ -46,7 +46,7 @@ theorem finRange_succ_last {n} :
       getElem_map, Fin.castSucc_mk, getElem_singleton]
     split
     · rfl
-    next h => exact Fin.eq_last_of_not_lt h
+    · next h => exact Fin.eq_last_of_not_lt h
 
 @[grind _=_]
 theorem finRange_reverse {n} : (finRange n).reverse = (finRange n).map Fin.rev := by

src/Init/Data/List/Find.lean

@@ -1098,9 +1098,15 @@ theorem idxOf_cons [BEq α] :
   dsimp [idxOf]
   simp [findIdx_cons]
 
+@[deprecated idxOf_cons (since := "2025-01-29")]
+abbrev indexOf_cons := @idxOf_cons
+
 @[simp] theorem idxOf_cons_self [BEq α] [ReflBEq α] {l : List α} : (a :: l).idxOf a = 0 := by
   simp [idxOf_cons]
 
+@[deprecated idxOf_cons_self (since := "2025-01-29")]
+abbrev indexOf_cons_self := @idxOf_cons_self
+
 @[grind =]
 theorem idxOf_append [BEq α] [LawfulBEq α] {l₁ l₂ : List α} {a : α} :
     (l₁ ++ l₂).idxOf a = if a ∈ l₁ then l₁.idxOf a else l₂.idxOf a + l₁.length := by
@@ -1111,7 +1117,8 @@ theorem idxOf_append [BEq α] [LawfulBEq α] {l₁ l₂ : List α} {a : α} :
   · rw [if_neg]
     simpa using h
 
-
+@[deprecated idxOf_append (since := "2025-01-29")]
+abbrev indexOf_append := @idxOf_append
 
 theorem idxOf_eq_length [BEq α] [LawfulBEq α] {l : List α} (h : a ∉ l) : l.idxOf a = l.length := by
   induction l with
@@ -1121,7 +1128,8 @@ theorem idxOf_eq_length [BEq α] [LawfulBEq α] {l : List α} (h : a ∉ l) : l.
     simp only [idxOf_cons, cond_eq_if, beq_iff_eq]
     split <;> simp_all
 
-
+@[deprecated idxOf_eq_length (since := "2025-01-29")]
+abbrev indexOf_eq_length := @idxOf_eq_length
 
 theorem idxOf_lt_length_of_mem [BEq α] [EquivBEq α] {l : List α} (h : a ∈ l) : l.idxOf a < l.length := by
   induction l with
@@ -1151,7 +1159,8 @@ theorem idxOf_lt_length_iff [BEq α] [LawfulBEq α] {l : List α} {a : α} :
 
 grind_pattern idxOf_lt_length_iff => l.idxOf a, l.length
 
-
+@[deprecated idxOf_lt_length_of_mem (since := "2025-01-29")]
+abbrev indexOf_lt_length := @idxOf_lt_length_of_mem
 
 /-! ### finIdxOf?
 
@@ -1222,7 +1231,8 @@ The lemmas below should be made consistent with those for `findIdx?` (and proved
   · rintro w x h rfl
     contradiction
 
-
+@[deprecated idxOf?_eq_none_iff (since := "2025-01-29")]
+abbrev indexOf?_eq_none_iff := @idxOf?_eq_none_iff
 
 @[simp, grind =]
 theorem isSome_idxOf? [BEq α] [LawfulBEq α] {l : List α} {a : α} :

src/Init/Data/List/Impl.lean

@@ -98,7 +98,7 @@ Example:
 [10, 14, 14]
 ```
 -/
-@[inline, expose] def filterMapTR (f : α → Option β) (l : List α) : List β := go l #[] where
+@[inline] def filterMapTR (f : α → Option β) (l : List α) : List β := go l #[] where
   /-- Auxiliary for `filterMap`: `filterMap.go f l = acc.toList ++ filterMap f l` -/
   @[specialize] go : List α → Array β → List β
   | [], acc => acc.toList
@@ -367,7 +367,7 @@ def modifyTR (l : List α) (i : Nat) (f : α → α) : List α := go l i #[] whe
   | a :: l, 0, acc => acc.toListAppend (f a :: l)
   | a :: l, i+1, acc => go l i (acc.push a)
 
-private theorem modifyTR_go_eq : ∀ l i, modifyTR.go f l i acc = acc.toList ++ modify l i f
+theorem modifyTR_go_eq : ∀ l i, modifyTR.go f l i acc = acc.toList ++ modify l i f
   | [], i => by cases i <;> simp [modifyTR.go, modify]
   | a :: l, 0 => by simp [modifyTR.go, modify]
   | a :: l, i+1 => by simp [modifyTR.go, modify, modifyTR_go_eq l]
@@ -399,7 +399,7 @@ Examples:
   | _, [], acc => acc.toList
   | n+1, a :: l, acc => go n l (acc.push a)
 
-private theorem insertIdxTR_go_eq : ∀ i l, insertIdxTR.go a i l acc = acc.toList ++ insertIdx l i a
+theorem insertIdxTR_go_eq : ∀ i l, insertIdxTR.go a i l acc = acc.toList ++ insertIdx l i a
   | 0, l | _+1, [] => by simp [insertIdxTR.go, insertIdx]
   | n+1, a :: l => by simp [insertIdxTR.go, insertIdx, insertIdxTR_go_eq n l]
 
@@ -564,7 +564,24 @@ def zipIdxTR (l : List α) (n : Nat := 0) : List (α × Nat) :=
 
 /-! ### enumFrom -/
 
+/-- Tail recursive version of `List.enumFrom`. -/
+@[deprecated zipIdxTR (since := "2025-01-21")]
+def enumFromTR (n : Nat) (l : List α) : List (Nat × α) :=
+  let as := l.toArray
+  (as.foldr (fun a (n, acc) => (n-1, (n-1, a) :: acc)) (n + as.size, [])).2
 
+set_option linter.deprecated false in
+@[deprecated zipIdx_eq_zipIdxTR (since := "2025-01-21"), csimp]
+theorem enumFrom_eq_enumFromTR : @enumFrom = @enumFromTR := by
+  funext α n l; simp only [enumFromTR]
+  let f := fun (a : α) (n, acc) => (n-1, (n-1, a) :: acc)
+  let rec go : ∀ l n, l.foldr f (n + l.length, []) = (n, enumFrom n l)
+    | [], n => rfl
+    | a::as, n => by
+      rw [← show _ + as.length = n + (a::as).length from Nat.succ_add .., foldr, go as]
+      simp [enumFrom, f]
+  rw [← Array.foldr_toList]
+  simp +zetaDelta [go]
 
 /-! ## Other list operations -/
 

src/Init/Data/List/Lemmas.lean

@@ -1429,12 +1429,12 @@ theorem filterMap_eq_map {f : α → β} : filterMap (some ∘ f) = map f := by
 theorem filterMap_eq_map' {f : α → β} : filterMap (fun x => some (f x)) = map f :=
   filterMap_eq_map
 
-theorem filterMap_some_fun : filterMap (some : α → Option α) = id := by
+@[simp] theorem filterMap_some_fun : filterMap (some : α → Option α) = id := by
   funext l
   erw [filterMap_eq_map]
   simp
 
-@[simp, grind] theorem filterMap_some {l : List α} : filterMap some l = l := by
+@[grind] theorem filterMap_some {l : List α} : filterMap some l = l := by
   rw [filterMap_some_fun, id]
 
 theorem map_filterMap_some_eq_filter_map_isSome {f : α → Option β} {l : List α} :
@@ -1586,7 +1586,9 @@ theorem filterMap_eq_cons_iff {l} {b} {bs} :
 theorem not_mem_append {a : α} {s t : List α} (h₁ : a ∉ s) (h₂ : a ∉ t) : a ∉ s ++ t :=
   mt mem_append.1 $ not_or.mpr ⟨h₁, h₂⟩
 
-
+@[deprecated mem_append (since := "2025-01-13")]
+theorem mem_append_eq {a : α} {s t : List α} : (a ∈ s ++ t) = (a ∈ s ∨ a ∈ t) :=
+  propext mem_append
 
 /--
 See also `eq_append_cons_of_mem`, which proves a stronger version
@@ -1696,7 +1698,7 @@ theorem getLast_concat {a : α} : ∀ {l : List α}, getLast (l ++ [a]) (by simp
 @[simp] theorem append_eq_nil_iff : p ++ q = [] ↔ p = [] ∧ q = [] := by
   cases p <;> simp
 
-
+@[deprecated append_eq_nil_iff (since := "2025-01-13")] abbrev append_eq_nil := @append_eq_nil_iff
 
 theorem nil_eq_append_iff : [] = a ++ b ↔ a = [] ∧ b = [] := by
   simp
@@ -1847,10 +1849,6 @@ theorem append_eq_map_iff {f : α → β} :
     L₁ ++ L₂ = map f l ↔ ∃ l₁ l₂, l = l₁ ++ l₂ ∧ map f l₁ = L₁ ∧ map f l₂ = L₂ := by
   rw [eq_comm, map_eq_append_iff]
 
-@[simp, grind =]
-theorem sum_append_nat {l₁ l₂ : List Nat} : (l₁ ++ l₂).sum = l₁.sum + l₂.sum := by
-  induction l₁ generalizing l₂ <;> simp_all [Nat.add_assoc]
-
 /-! ### concat
 
 Note that `concat_eq_append` is a `@[simp]` lemma, so `concat` should usually not appear in goals.
@@ -2150,7 +2148,7 @@ theorem flatMap_eq_foldl {f : α → List β} {l : List α} :
   intro l'
   induction l generalizing l'
   · simp
-  next ih => rw [flatMap_cons, ← append_assoc, ih, foldl_cons]
+  · next ih => rw [flatMap_cons, ← append_assoc, ih, foldl_cons]
 
 /-! ### replicate -/
 
@@ -2266,7 +2264,8 @@ theorem map_const' {l : List α} {b : β} : map (fun _ => b) l = replicate l.len
     simp only [mem_append, mem_replicate, ne_eq]
     rintro (⟨-, rfl⟩ | ⟨_, rfl⟩) <;> rfl
 
-
+@[deprecated replicate_append_replicate (since := "2025-01-16")]
+abbrev append_replicate_replicate := @replicate_append_replicate
 
 theorem append_eq_replicate_iff {l₁ l₂ : List α} {a : α} :
     l₁ ++ l₂ = replicate n a ↔
@@ -2654,6 +2653,8 @@ theorem foldl_map_hom {g : α → β} {f : α → α → α} {f' : β → β →
   · simp
   · simp [*]
 
+@[deprecated foldl_map_hom (since := "2025-01-20")] abbrev foldl_map' := @foldl_map_hom
+
 theorem foldr_map_hom {g : α → β} {f : α → α → α} {f' : β → β → β} {a : α} {l : List α}
     (h : ∀ x y, f' (g x) (g y) = g (f x y)) :
     (l.map g).foldr f' (g a) = g (l.foldr f a) := by
@@ -2661,6 +2662,8 @@ theorem foldr_map_hom {g : α → β} {f : α → α → α} {f' : β → β →
   · simp
   · simp [*]
 
+@[deprecated foldr_map_hom (since := "2025-01-20")] abbrev foldr_map' := @foldr_map_hom
+
 @[simp] theorem foldrM_append [Monad m] [LawfulMonad m] {f : α → β → m β} {b : β} {l l' : List α} :
     (l ++ l').foldrM f b = l'.foldrM f b >>= l.foldrM f := by
   induction l <;> simp [*]
@@ -3728,6 +3731,12 @@ theorem mem_iff_get? {a} {l : List α} : a ∈ l ↔ ∃ n, l.get? n = some a :=
 
 /-! ### Deprecations -/
 
+@[deprecated _root_.isSome_getElem? (since := "2024-12-09")]
+theorem isSome_getElem? {l : List α} {i : Nat} : l[i]?.isSome ↔ i < l.length := by
+  simp
 
+@[deprecated _root_.isNone_getElem? (since := "2024-12-09")]
+theorem isNone_getElem? {l : List α} {i : Nat} : l[i]?.isNone ↔ l.length ≤ i := by
+  simp
 
 end List

src/Init/Data/List/Lex.lean

@@ -163,7 +163,8 @@ instance [LT α] [Trans (· < · : α → α → Prop) (· < ·) (· < ·)] :
     Trans (· < · : List α → List α → Prop) (· < ·) (· < ·) where
   trans h₁ h₂ := List.lt_trans h₁ h₂
 
-
+@[deprecated List.le_antisymm (since := "2024-12-13")]
+protected abbrev lt_antisymm := @List.le_antisymm
 
 protected theorem lt_of_le_of_lt [LT α]
     [i₀ : Std.Irrefl (· < · : α → α → Prop)]

src/Init/Data/List/MapIdx.lean

@@ -182,7 +182,8 @@ theorem mapFinIdx_eq_zipIdx_map {l : List α} {f : (i : Nat) → α → (h : i <
         f i x (by rw [mk_mem_zipIdx_iff_getElem?, getElem?_eq_some_iff] at m; exact m.1) := by
   apply ext_getElem <;> simp
 
-
+@[deprecated mapFinIdx_eq_zipIdx_map (since := "2025-01-21")]
+abbrev mapFinIdx_eq_zipWithIndex_map := @mapFinIdx_eq_zipIdx_map
 
 @[simp]
 theorem mapFinIdx_eq_nil_iff {l : List α} {f : (i : Nat) → α → (h : i < l.length) → β} :
@@ -219,7 +220,7 @@ theorem mapFinIdx_eq_cons_iff {l : List α} {b : β} {f : (i : Nat) → α → (
   cases l with
   | nil => simp
   | cons x l' =>
-    simp only [mapFinIdx_cons, cons.injEq,
+    simp only [mapFinIdx_cons, cons.injEq, 
       ]
     constructor
     · rintro ⟨rfl, rfl⟩
@@ -383,7 +384,8 @@ theorem mapIdx_eq_zipIdx_map {l : List α} {f : Nat → α → β} :
   simp only [getElem?_mapIdx, Option.map, getElem?_map, getElem?_zipIdx]
   split <;> simp
 
-
+@[deprecated mapIdx_eq_zipIdx_map (since := "2025-01-21")]
+abbrev mapIdx_eq_enum_map := @mapIdx_eq_zipIdx_map
 
 @[simp, grind =]
 theorem mapIdx_cons {l : List α} {a : α} :

src/Init/Data/List/MinMax.lean

@@ -168,7 +168,7 @@ theorem max?_le_iff [Max α] [LE α]
 
 -- This could be refactored by designing appropriate typeclasses to replace `le_refl`, `max_eq_or`,
 -- and `le_min_iff`.
-theorem max?_eq_some_iff [Max α] [LE α] [anti : Std.Antisymm (· ≤ · : α → α → Prop)]
+theorem max?_eq_some_iff [Max α] [LE α] [anti : Std.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 α} :

src/Init/Data/List/Monadic.lean

@@ -101,7 +101,7 @@ theorem mapM_eq_reverse_foldlM_cons [Monad m] [LawfulMonad m] {f : α → m β}
   induction l with
   | nil => simp
   | cons a as ih =>
-    simp only [mapM'_cons, ih, bind_map_left, foldlM_cons,
+    simp only [mapM'_cons, ih, bind_map_left, foldlM_cons, 
       foldlM_cons_eq_append, _root_.map_bind, Functor.map_map, reverse_append,
       reverse_cons, reverse_nil, nil_append, singleton_append]
     simp [bind_pure_comp]
@@ -137,43 +137,6 @@ theorem filterMapM_loop_eq [Monad m] [LawfulMonad m] {f : α → m (Option β)}
     rw [filterMapM_loop_eq, filterMapM]
     simp
 
-/-! ### zipWithM -/
-
-/--
-Applies the monadic action `f` to the corresponding elements of two lists, left-to-right, stopping
-at the end of the shorter list. `zipWithM' f as bs` is equivalent to `mapM id (zipWith f as bs)`
-for lawful `Monad` instances.
--/
-@[expose]
-def zipWithM' {m : Type u → Type v} [Monad m] {α : Type w} {β : Type x} {γ : Type u} (f : α → β → m γ) : (xs : List α) → (ys : List β) → m (List γ)
-  | x::xs, y::ys => do
-    let z ← f x y
-    let zs ← zipWithM' f xs ys
-    pure (z :: zs)
-  | _,     _     => pure []
-
-@[simp, grind =] theorem zipWithM'_nil_left [Monad m] {f : α → β → m γ} : zipWithM' f [] l = pure (f := m) [] := by simp only [zipWithM']
-@[simp, grind =] theorem zipWithM'_nil_right [Monad m] {f : α → β → m γ} : zipWithM' f l [] = pure (f := m) [] := by simp only [zipWithM']
-@[simp, grind =] theorem zipWithM'_cons_cons [Monad m] {f : α → β → m γ} :
-    zipWithM' f (a :: as) (b :: bs) = do return (← f a b) :: (← zipWithM' f as bs) := by simp only [zipWithM']
-
-@[grind =]
-theorem zipWithM'_eq_zipWithM [Monad m] [LawfulMonad m] {f : α → β → m γ} {l : List α} {l' : List β} :
-    zipWithM' f l l' = zipWithM f l l' := by simp [zipWithM, go l l' #[]] where
-  go l l' acc : zipWithM.loop f l l' acc = return acc.toList ++ (← zipWithM' f l l') := by
-    fun_induction zipWithM.loop <;> simp [zipWithM', *]
-
-@[simp, grind =] theorem zipWithM_nil_left [Monad m] {f : α → β → m γ} : zipWithM f [] l = pure (f := m) [] := rfl
-@[simp, grind =] theorem zipWithM_nil_right [Monad m] {f : α → β → m γ} : zipWithM f l [] = pure (f := m) [] := by simp only [zipWithM, zipWithM.loop]
-@[simp, grind =] theorem zipWithM_cons_cons [Monad m] [LawfulMonad m] {f : α → β → m γ} :
-    zipWithM f (a :: as) (b :: bs) = do return (← f a b) :: (← zipWithM f as bs) := by
-  simp [← zipWithM'_eq_zipWithM]
-
-@[simp, grind =]
-theorem zipWithM'_eq_mapM_id_zipWith {m : Type v → Type w} [Monad m] [LawfulMonad m] {f : α → β → m γ} {as : List α} {bs : List β} :
-    zipWithM' f as bs = mapM id (zipWith f as bs) := by
-  fun_induction zipWithM' <;> simp [zipWith, *]
-
 /-! ### flatMapM -/
 
 @[simp, grind =] theorem flatMapM_nil [Monad m] {f : α → m (List β)} : [].flatMapM f = pure [] := rfl
@@ -261,7 +224,13 @@ theorem foldrM_filter [Monad m] [LawfulMonad m] {p : α → Bool} {g : α → β
 
 /-! ### forM -/
 
+@[deprecated forM_nil (since := "2025-01-31")]
+theorem forM_nil' [Monad m] : ([] : List α).forM f = (pure .unit : m PUnit) := rfl
 
+@[deprecated forM_cons (since := "2025-01-31")]
+theorem forM_cons' [Monad m] :
+    (a::as).forM f = (f a >>= fun _ => as.forM f : m PUnit) :=
+  List.forM_cons
 
 @[simp, grind =] theorem forM_append [Monad m] [LawfulMonad m] {l₁ l₂ : List α} {f : α → m PUnit} :
     forM (l₁ ++ l₂) f = (do forM l₁ f; forM l₂ f) := by

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

@@ -90,6 +90,9 @@ theorem map_sub_range' {a s : Nat} (h : a ≤ s) (n : Nat) :
   rintro rfl
   omega
 
+@[deprecated range'_eq_singleton_iff (since := "2025-01-29")]
+abbrev range'_eq_singleton := @range'_eq_singleton_iff
+
 theorem range'_eq_append_iff : range' s n = xs ++ ys ↔ ∃ k, k ≤ n ∧ xs = range' s k ∧ ys = range' (s + k) (n - k) := by
   induction n generalizing s xs ys with
   | zero => simp
@@ -227,6 +230,152 @@ theorem count_range {a n} :
   rw [range_eq_range', count_range_1']
   simp
 
+/-! ### iota -/
+
+section
+set_option linter.deprecated false
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20")]
+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]
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem length_iota (n : Nat) : length (iota n) = n := by simp [iota_eq_reverse_range']
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem iota_eq_nil {n : Nat} : iota n = [] ↔ n = 0 := by
+  cases n <;> simp
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20")]
+theorem iota_ne_nil {n : Nat} : iota n ≠ [] ↔ n ≠ 0 := by
+  cases n <;> simp
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem mem_iota {m n : Nat} : m ∈ iota n ↔ 0 < m ∧ m ≤ n := by
+  simp [iota_eq_reverse_range', Nat.add_comm, Nat.lt_succ]
+  omega
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem iota_inj : iota n = iota n' ↔ n = n' := by
+  constructor
+  · intro h
+    have h' := congrArg List.length h
+    simp at h'
+    exact h'
+  · rintro rfl
+    simp
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20")]
+theorem iota_eq_cons_iff : iota n = a :: xs ↔ n = a ∧ 0 < n ∧ xs = iota (n - 1) := by
+  simp [iota_eq_reverse_range']
+  simp [range'_eq_append_iff, reverse_eq_iff]
+  constructor
+  · rintro ⟨k, h, rfl, h'⟩
+    rw [eq_comm, range'_eq_singleton] at h'
+    simp only [reverse_inj, range'_inj, or_true, and_true]
+    omega
+  · rintro ⟨rfl, h, rfl⟩
+    refine ⟨n - 1, by simp, rfl, ?_⟩
+    rw [eq_comm, range'_eq_singleton]
+    omega
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20")]
+theorem iota_eq_append_iff : iota n = xs ++ ys ↔ ∃ k, k ≤ n ∧ xs = (range' (k + 1) (n - k)).reverse ∧ ys = iota k := by
+  simp only [iota_eq_reverse_range']
+  rw [reverse_eq_append_iff]
+  rw [range'_eq_append_iff]
+  simp only [reverse_eq_iff]
+  constructor
+  · rintro ⟨k, h, rfl, rfl⟩
+    simp; omega
+  · rintro ⟨k, h, rfl, rfl⟩
+    exact ⟨k, by simp; omega⟩
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20")]
+theorem pairwise_gt_iota (n : Nat) : Pairwise (· > ·) (iota n) := by
+  simpa only [iota_eq_reverse_range', pairwise_reverse] using pairwise_lt_range'
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20")]
+theorem nodup_iota (n : Nat) : Nodup (iota n) :=
+  (pairwise_gt_iota n).imp Nat.ne_of_gt
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem head?_iota (n : Nat) : (iota n).head? = if n = 0 then none else some n := by
+  cases n <;> simp
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem head_iota (n : Nat) (h) : (iota n).head h = n := by
+  cases n with
+  | zero => simp at h
+  | succ n => simp
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem tail_iota (n : Nat) : (iota n).tail = iota (n - 1) := by
+  cases n <;> simp
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem reverse_iota : reverse (iota n) = range' 1 n := by
+  induction n with
+  | zero => simp
+  | succ n ih =>
+    rw [iota_succ, reverse_cons, ih, range'_1_concat, Nat.add_comm]
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem getLast?_iota (n : Nat) : (iota n).getLast? = if n = 0 then none else some 1 := by
+  rw [getLast?_eq_head?_reverse]
+  simp [head?_range']
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem getLast_iota (n : Nat) (h) : (iota n).getLast h = 1 := by
+  rw [getLast_eq_head_reverse]
+  simp
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20")]
+theorem find?_iota_eq_none {n : Nat} {p : Nat → Bool} :
+    (iota n).find? p = none ↔ ∀ i, 0 < i → i ≤ n → !p i := by
+  simp
+
+@[deprecated "Use `(List.range' 1 n).reverse` instead of `iota n`." (since := "2025-01-20"), simp]
+theorem find?_iota_eq_some {n : Nat} {i : Nat} {p : Nat → Bool} :
+    (iota n).find? p = some i ↔ p i ∧ i ∈ iota n ∧ ∀ j, i < j → j ≤ n → !p j := by
+  rw [find?_eq_some_iff_append]
+  simp only [iota_eq_reverse_range', reverse_eq_append_iff, reverse_cons, append_assoc, cons_append,
+    nil_append, Bool.not_eq_eq_eq_not, Bool.not_true, exists_and_right, mem_reverse, mem_range'_1,
+    and_congr_right_iff]
+  intro h
+  constructor
+  · rintro ⟨as, ⟨xs, h⟩, h'⟩
+    constructor
+    · replace h : i ∈ range' 1 n := by
+        rw [h]
+        exact mem_append_cons_self
+      simpa using h
+    · rw [range'_eq_append_iff] at h
+      simp [reverse_eq_iff] at h
+      obtain ⟨k, h₁, rfl, h₂⟩ := h
+      rw [eq_comm, range'_eq_cons_iff, reverse_eq_iff] at h₂
+      obtain ⟨rfl, -, rfl⟩ := h₂
+      intro j j₁ j₂
+      apply h'
+      simp; omega
+  · rintro ⟨⟨i₁, i₂⟩, h⟩
+    refine ⟨(range' (i+1) (n-i)).reverse, ⟨(range' 1 (i-1)).reverse, ?_⟩, ?_⟩
+    · simp [← range'_succ]
+      rw [range'_eq_append_iff]
+      refine ⟨i-1, ?_⟩
+      constructor
+      · omega
+      · simp
+        omega
+    · simp
+      intros a a₁ a₂
+      apply h
+      · omega
+      · omega
+
+end
+
 /-! ### zipIdx -/
 
 @[simp, grind =]
@@ -363,4 +512,237 @@ theorem zipIdx_eq_append_iff {l : List α} {k : Nat} :
     refine ⟨l₁', l₂', range' k l₁'.length, range' (k + l₁'.length) l₂'.length, ?_⟩
     simp
 
+/-! ### enumFrom -/
+
+section
+set_option linter.deprecated false
+
+@[deprecated zipIdx_singleton (since := "2025-01-21"), simp]
+theorem enumFrom_singleton (x : α) (n : Nat) : enumFrom n [x] = [(n, x)] :=
+  rfl
+
+@[deprecated head?_zipIdx (since := "2025-01-21"), simp]
+theorem head?_enumFrom (n : Nat) (l : List α) :
+    (enumFrom n l).head? = l.head?.map fun a => (n, a) := by
+  simp [head?_eq_getElem?]
+
+@[deprecated getLast?_zipIdx (since := "2025-01-21"), simp]
+theorem getLast?_enumFrom (n : Nat) (l : List α) :
+    (enumFrom n l).getLast? = l.getLast?.map fun a => (n + l.length - 1, a) := by
+  simp [getLast?_eq_getElem?]
+  cases l <;> simp
+
+@[deprecated mk_add_mem_zipIdx_iff_getElem? (since := "2025-01-21")]
+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?]
+
+@[deprecated mk_mem_zipIdx_iff_le_and_getElem?_sub (since := "2025-01-21")]
+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]? = some 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]
+
+@[deprecated le_snd_of_mem_zipIdx (since := "2025-01-21")]
+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
+
+@[deprecated snd_lt_add_of_mem_zipIdx (since := "2025-01-21")]
+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
+
+@[deprecated map_zipIdx (since := "2025-01-21")]
+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
+
+@[deprecated fst_mem_of_mem_zipIdx (since := "2025-01-21")]
+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
+
+@[deprecated fst_eq_of_mem_zipIdx (since := "2025-01-21")]
+theorem snd_eq_of_mem_enumFrom {x : Nat × α} {n : Nat} {l : List α} (h : x ∈ enumFrom n l) :
+    x.2 = l[x.1 - n]'(by have := le_fst_of_mem_enumFrom h; have := fst_lt_add_of_mem_enumFrom h; omega) := by
+  induction l generalizing n with
+  | nil => cases h
+  | cons hd tl ih =>
+    cases h with
+    | head _ => simp
+    | tail h m =>
+      specialize ih m
+      have : x.1 - n = x.1 - (n + 1) + 1 := by
+        have := le_fst_of_mem_enumFrom m
+        omega
+      simp [this, ih]
+
+@[deprecated mem_zipIdx (since := "2025-01-21")]
+theorem mem_enumFrom {x : α} {i j : Nat} {xs : List α} (h : (i, x) ∈ xs.enumFrom j) :
+    j ≤ i ∧ i < j + xs.length ∧
+      x = xs[i - j]'(by have := le_fst_of_mem_enumFrom h; have := fst_lt_add_of_mem_enumFrom h; omega) :=
+  ⟨le_fst_of_mem_enumFrom h, fst_lt_add_of_mem_enumFrom h, snd_eq_of_mem_enumFrom h⟩
+
+@[deprecated zipIdx_map (since := "2025-01-21")]
+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
+
+@[deprecated zipIdx_append (since := "2025-01-21")]
+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]
+
+@[deprecated zipIdx_eq_cons_iff (since := "2025-01-21")]
+theorem enumFrom_eq_cons_iff {l : List α} {n : Nat} :
+    l.enumFrom n = x :: l' ↔ ∃ a as, l = a :: as ∧ x = (n, a) ∧ l' = enumFrom (n + 1) as := by
+  rw [enumFrom_eq_zip_range', zip_eq_cons_iff]
+  constructor
+  · rintro ⟨l₁, l₂, h, rfl, rfl⟩
+    rw [range'_eq_cons_iff] at h
+    obtain ⟨rfl, -, rfl⟩ := h
+    exact ⟨x.2, l₂, by simp [enumFrom_eq_zip_range']⟩
+  · rintro ⟨a, as, rfl, rfl, rfl⟩
+    refine ⟨range' (n+1) as.length, as, ?_⟩
+    simp [enumFrom_eq_zip_range', range'_succ]
+
+@[deprecated zipIdx_eq_append_iff (since := "2025-01-21")]
+theorem enumFrom_eq_append_iff {l : List α} {n : Nat} :
+    l.enumFrom n = l₁ ++ l₂ ↔
+      ∃ l₁' l₂', l = l₁' ++ l₂' ∧ l₁ = l₁'.enumFrom n ∧ l₂ = l₂'.enumFrom (n + l₁'.length) := by
+  rw [enumFrom_eq_zip_range', zip_eq_append_iff]
+  constructor
+  · rintro ⟨ws, xs, ys, zs, h, h', rfl, rfl, rfl⟩
+    rw [range'_eq_append_iff] at h'
+    obtain ⟨k, -, rfl, rfl⟩ := h'
+    simp only [length_range'] at h
+    obtain rfl := h
+    refine ⟨ys, zs, rfl, ?_⟩
+    simp only [enumFrom_eq_zip_range', length_append, true_and]
+    congr
+    omega
+  · rintro ⟨l₁', l₂', rfl, rfl, rfl⟩
+    simp only [enumFrom_eq_zip_range']
+    refine ⟨range' n l₁'.length, range' (n + l₁'.length) l₂'.length, l₁', l₂', ?_⟩
+    simp
+
+end
+
+/-! ### enum -/
+
+section
+set_option linter.deprecated false
+
+@[deprecated zipIdx_eq_nil_iff (since := "2025-01-21"), simp]
+theorem enum_eq_nil_iff {l : List α} : List.enum l = [] ↔ l = [] := enumFrom_eq_nil
+
+@[deprecated zipIdx_singleton (since := "2025-01-21"), simp]
+theorem enum_singleton (x : α) : enum [x] = [(0, x)] := rfl
+
+@[deprecated length_zipIdx (since := "2025-01-21"), simp]
+theorem enum_length : (enum l).length = l.length :=
+  enumFrom_length
+
+@[deprecated getElem?_zipIdx (since := "2025-01-21"), simp]
+theorem getElem?_enum (l : List α) (i : Nat) : (enum l)[i]? = l[i]?.map fun a => (i, a) := by
+  rw [enum, getElem?_enumFrom, Nat.zero_add]
+
+@[deprecated getElem_zipIdx (since := "2025-01-21"), 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]
+
+@[deprecated head?_zipIdx (since := "2025-01-21"), simp] theorem head?_enum (l : List α) :
+    l.enum.head? = l.head?.map fun a => (0, a) := by
+  simp [head?_eq_getElem?]
+
+@[deprecated getLast?_zipIdx (since := "2025-01-21"), simp]
+theorem getLast?_enum (l : List α) :
+    l.enum.getLast? = l.getLast?.map fun a => (l.length - 1, a) := by
+  simp [getLast?_eq_getElem?]
+
+@[deprecated tail_zipIdx (since := "2025-01-21"), simp]
+theorem tail_enum (l : List α) : (enum l).tail = enumFrom 1 l.tail := by
+  simp [enum]
+
+@[deprecated mk_mem_zipIdx_iff_getElem? (since := "2025-01-21")]
+theorem mk_mem_enum_iff_getElem? {i : Nat} {x : α} {l : List α} : (i, x) ∈ enum l ↔ l[i]? = some x := by
+  simp [enum, mk_mem_enumFrom_iff_le_and_getElem?_sub]
+
+@[deprecated mem_zipIdx_iff_getElem? (since := "2025-01-21")]
+theorem mem_enum_iff_getElem? {x : Nat × α} {l : List α} : x ∈ enum l ↔ l[x.1]? = some x.2 :=
+  mk_mem_enum_iff_getElem?
+
+@[deprecated snd_lt_of_mem_zipIdx (since := "2025-01-21")]
+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
+
+@[deprecated fst_mem_of_mem_zipIdx (since := "2025-01-21")]
+theorem snd_mem_of_mem_enum {x : Nat × α} {l : List α} (h : x ∈ enum l) : x.2 ∈ l :=
+  snd_mem_of_mem_enumFrom h
+
+@[deprecated fst_eq_of_mem_zipIdx (since := "2025-01-21")]
+theorem snd_eq_of_mem_enum {x : Nat × α} {l : List α} (h : x ∈ enum l) :
+    x.2 = l[x.1]'(fst_lt_of_mem_enum h) :=
+  snd_eq_of_mem_enumFrom h
+
+@[deprecated mem_zipIdx (since := "2025-01-21")]
+theorem mem_enum {x : α} {i : Nat} {xs : List α} (h : (i, x) ∈ xs.enum) :
+    i < xs.length ∧ x = xs[i]'(fst_lt_of_mem_enum h) :=
+  by simpa using mem_enumFrom h
+
+@[deprecated map_zipIdx (since := "2025-01-21")]
+theorem map_enum (f : α → β) (l : List α) : map (Prod.map id f) (enum l) = enum (map f l) :=
+  map_enumFrom f 0 l
+
+@[deprecated zipIdx_map_snd (since := "2025-01-21"), 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']
+
+@[deprecated zipIdx_map_fst (since := "2025-01-21"), simp]
+theorem enum_map_snd (l : List α) : map Prod.snd (enum l) = l :=
+  enumFrom_map_snd _ _
+
+@[deprecated zipIdx_map (since := "2025-01-21")]
+theorem enum_map (l : List α) (f : α → β) : (l.map f).enum = l.enum.map (Prod.map id f) :=
+  enumFrom_map _ _ _
+
+@[deprecated zipIdx_append (since := "2025-01-21")]
+theorem enum_append (xs ys : List α) : enum (xs ++ ys) = enum xs ++ enumFrom xs.length ys := by
+  simp [enum, enumFrom_append]
+
+@[deprecated zipIdx_eq_zip_range' (since := "2025-01-21")]
+theorem enum_eq_zip_range (l : List α) : l.enum = (range l.length).zip l :=
+  zip_of_prod (enum_map_fst _) (enum_map_snd _)
+
+@[deprecated unzip_zipIdx_eq_prod (since := "2025-01-21"), 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]
+
+@[deprecated zipIdx_eq_cons_iff (since := "2025-01-21")]
+theorem enum_eq_cons_iff {l : List α} :
+    l.enum = x :: l' ↔ ∃ a as, l = a :: as ∧ x = (0, a) ∧ l' = enumFrom 1 as := by
+  rw [enum, enumFrom_eq_cons_iff]
+
+@[deprecated zipIdx_eq_append_iff (since := "2025-01-21")]
+theorem enum_eq_append_iff {l : List α} :
+    l.enum = l₁ ++ l₂ ↔
+      ∃ l₁' l₂', l = l₁' ++ l₂' ∧ l₁ = l₁'.enum ∧ l₂ = l₂'.enumFrom l₁'.length := by
+  simp [enum, enumFrom_eq_append_iff]
+
+end
+
 end List

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

@@ -61,8 +61,8 @@ theorem getElem?_take_eq_none {l : List α} {i j : Nat} (h : i ≤ j) :
 @[grind =] theorem getElem?_take {l : List α} {i j : Nat} :
     (l.take i)[j]? = if j < i then l[j]? else none := by
   split
-  next h => exact getElem?_take_of_lt h
-  next h => exact getElem?_take_eq_none (Nat.le_of_not_lt h)
+  · next h => exact getElem?_take_of_lt h
+  · next h => exact getElem?_take_eq_none (Nat.le_of_not_lt h)
 
 theorem head?_take {l : List α} {i : Nat} :
     (l.take i).head? = if i = 0 then none else l.head? := by
@@ -114,7 +114,7 @@ theorem take_set_of_le {a : α} {i j : Nat} {l : List α} (h : j ≤ i) :
   List.ext_getElem? fun i => by
     rw [getElem?_take, getElem?_take]
     split
-    next h' => rw [getElem?_set_ne (by omega)]
+    · next h' => rw [getElem?_set_ne (by omega)]
     · rfl
 
 @[deprecated take_set_of_le (since := "2025-02-04")]
@@ -384,7 +384,7 @@ theorem take_reverse {α} {xs : List α} {i : Nat} :
   by_cases h : i ≤ xs.length
   · induction xs generalizing i <;>
       simp only [reverse_cons, drop, reverse_nil, Nat.zero_sub, length, take_nil]
-    rename_i hd tl xs_ih
+    next hd tl xs_ih =>
     cases Nat.lt_or_eq_of_le h with
     | inl h' =>
       have h' := Nat.le_of_succ_le_succ h'

src/Init/Data/List/Pairwise.lean

@@ -213,7 +213,7 @@ theorem pairwise_append_comm {R : α → α → Prop} (s : ∀ {x y}, R x y →
 @[grind] theorem Pairwise.take {l : List α} {i : Nat} (h : List.Pairwise R l) : List.Pairwise R (l.take i) :=
   h.sublist (take_sublist _ _)
 
--- This theorem is not annotated with `grind` because it leads to a loop of instantiations with `Pairwise.sublist`.
+@[grind =]
 theorem pairwise_iff_forall_sublist : l.Pairwise R ↔ (∀ {a b}, [a,b] <+ l → R a b) := by
   induction l with
   | nil => simp
@@ -232,10 +232,6 @@ theorem pairwise_iff_forall_sublist : l.Pairwise R ↔ (∀ {a b}, [a,b] <+ l
         intro a b hab
         apply h; exact hab.cons _
 
-theorem pairwise_of_forall_sublist (g : ∀ {a b}, [a,b] <+ l → R a b) : l.Pairwise R := pairwise_iff_forall_sublist.mpr g
-
-theorem Pairwise.forall_sublist (h : l.Pairwise R) : ∀ {a b}, [a,b] <+ l → R a b := pairwise_iff_forall_sublist.mp h
-
 theorem Pairwise.rel_of_mem_take_of_mem_drop
     {l : List α} (h : l.Pairwise R) (hx : x ∈ l.take i) (hy : y ∈ l.drop i) : R x y := by
   apply pairwise_iff_forall_sublist.mp h

src/Init/Data/List/Range.lean

@@ -39,9 +39,13 @@ theorem range'_succ {s n step} : range' s (n + 1) step = s :: range' (s + step)
 @[simp] theorem range'_eq_nil_iff : range' s n step = [] ↔ n = 0 := by
   rw [← length_eq_zero_iff, length_range']
 
+@[deprecated range'_eq_nil_iff (since := "2025-01-29")] abbrev range'_eq_nil := @range'_eq_nil_iff
+
 theorem range'_ne_nil_iff (s : Nat) {n step : Nat} : range' s n step ≠ [] ↔ n ≠ 0 := by
   cases n <;> simp
 
+@[deprecated range'_ne_nil_iff (since := "2025-01-29")] abbrev range'_ne_nil := @range'_ne_nil_iff
+
 @[simp] theorem range'_zero : range' s 0 step = [] := by
   simp
 
@@ -291,4 +295,107 @@ theorem zipIdx_eq_map_add {l : List α} {i : Nat} :
   | nil => rfl
   | cons _ _ ih => simp [ih (i := i + 1), zipIdx_succ, Nat.add_assoc, Nat.add_comm 1]
 
+/-! ### enumFrom -/
+
+section
+set_option linter.deprecated false
+
+@[deprecated zipIdx_eq_nil_iff (since := "2025-01-21"), simp]
+theorem enumFrom_eq_nil {n : Nat} {l : List α} : List.enumFrom n l = [] ↔ l = [] := by
+  cases l <;> simp
+
+@[deprecated length_zipIdx (since := "2025-01-21"), simp]
+theorem enumFrom_length : ∀ {n} {l : List α}, (enumFrom n l).length = l.length
+  | _, [] => rfl
+  | _, _ :: _ => congrArg Nat.succ enumFrom_length
+
+@[deprecated getElem?_zipIdx (since := "2025-01-21"), simp]
+theorem getElem?_enumFrom :
+    ∀ i (l : List α) j, (enumFrom i l)[j]? = l[j]?.map fun a => (i + j, a)
+  | _, [], _ => rfl
+  | _, _ :: _, 0 => by simp
+  | n, _ :: 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
+
+@[deprecated getElem_zipIdx (since := "2025-01-21"), 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?_get]
+  simp only [getElem?_enumFrom, getElem?_eq_getElem h]
+  simp
+
+@[deprecated tail_zipIdx (since := "2025-01-21"), simp]
+theorem tail_enumFrom (l : List α) (n : Nat) : (enumFrom n l).tail = enumFrom (n + 1) l.tail := by
+  induction l generalizing n with
+  | nil => simp
+  | cons _ l ih => simp [enumFrom_cons]
+
+@[deprecated map_snd_add_zipIdx_eq_zipIdx (since := "2025-01-21"), simp]
+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
+
+@[deprecated map_snd_add_zipIdx_eq_zipIdx (since := "2025-01-21"), simp]
+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 _ _
+
+@[deprecated zipIdx_cons' (since := "2025-01-21"), simp]
+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]
+
+@[deprecated zipIdx_map_snd (since := "2025-01-21"), simp]
+theorem enumFrom_map_fst (n) :
+    ∀ (l : List α), map Prod.fst (enumFrom n l) = range' n l.length
+  | [] => rfl
+  | _ :: _ => congrArg (cons _) (enumFrom_map_fst _ _)
+
+@[deprecated zipIdx_map_fst (since := "2025-01-21"), simp]
+theorem enumFrom_map_snd : ∀ (n) (l : List α), map Prod.snd (enumFrom n l) = l
+  | _, [] => rfl
+  | _, _ :: _ => congrArg (cons _) (enumFrom_map_snd _ _)
+
+@[deprecated zipIdx_eq_zip_range' (since := "2025-01-21")]
+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 _ _)
+
+@[deprecated unzip_zipIdx_eq_prod (since := "2025-01-21"), 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']
+
+end
+
+/-! ### enum -/
+
+section
+set_option linter.deprecated false
+
+@[deprecated zipIdx_cons (since := "2025-01-21")]
+theorem enum_cons : (a::as).enum = (0, a) :: as.enumFrom 1 := rfl
+
+@[deprecated zipIdx_cons (since := "2025-01-21")]
+theorem enum_cons' (x : α) (xs : List α) :
+    enum (x :: xs) = (0, x) :: (enum xs).map (Prod.map (· + 1) id) :=
+  enumFrom_cons' _ _ _
+
+@[deprecated "These are now both `l.zipIdx 0`" (since := "2025-01-21")]
+theorem enum_eq_enumFrom {l : List α} : l.enum = l.enumFrom 0 := rfl
+
+@[deprecated "Use the reverse direction of `map_snd_add_zipIdx_eq_zipIdx` instead" (since := "2025-01-21")]
+theorem enumFrom_eq_map_enum (l : List α) (n : Nat) :
+    enumFrom n l = (enum l).map (Prod.map (· + n) id) := by
+  induction l generalizing n with
+  | nil => simp
+  | cons x xs ih =>
+    simp only [enumFrom_cons, ih, enum_cons, map_cons, Prod.map_apply, Nat.zero_add, id_eq, map_map,
+      cons.injEq, map_inj_left, Function.comp_apply, Prod.forall, Prod.mk.injEq, and_true, true_and]
+    intro a b _
+    exact (succ_add a n).symm
+
+end
+
 end List

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

@@ -57,7 +57,7 @@ where go : List α → List α → List α → List α
     else
       go (x :: xs) ys (y :: acc)
 
-private theorem mergeTR_go_eq : mergeTR.go le l₁ l₂ acc = acc.reverse ++ merge l₁ l₂ le := by
+theorem mergeTR_go_eq : mergeTR.go le l₁ l₂ acc = acc.reverse ++ merge l₁ l₂ le := by
   induction l₁ generalizing l₂ acc with
   | nil => simp [mergeTR.go, reverseAux_eq]
   | cons x l₁ ih₁ =>
@@ -84,7 +84,7 @@ def splitRevAt (n : Nat) (l : List α) : List α × List α := go l n [] where
   | x :: xs, n+1, acc => go xs n (x :: acc)
   | xs, _, acc => (acc, xs)
 
-private theorem splitRevAt_go (xs : List α) (i : Nat) (acc : List α) :
+theorem splitRevAt_go (xs : List α) (i : Nat) (acc : List α) :
     splitRevAt.go xs i acc = ((take i xs).reverse ++ acc, drop i xs) := by
   induction xs generalizing i acc with
   | nil => simp [splitRevAt.go]
@@ -100,7 +100,7 @@ theorem splitRevAt_eq (i : Nat) (l : List α) : splitRevAt i l = ((l.take i).rev
 
 /--
 An intermediate speed-up for `mergeSort`.
-This version uses the tail-recursive `mergeTR` function as a subroutine.
+This version uses the tail-recurive `mergeTR` function as a subroutine.
 
 This is not the final version we use at runtime, as `mergeSortTR₂` is faster.
 This definition is useful as an intermediate step in proving the `@[csimp]` lemma for `mergeSortTR₂`.
@@ -172,7 +172,7 @@ theorem splitRevInTwo_snd (l : { l : List α // l.length = n }) :
     (splitRevInTwo l).2 = ⟨(splitInTwo l).2.1, by simp; omega⟩ := by
   simp only [splitRevInTwo, splitRevAt_eq, reverse_take, splitInTwo_snd]
 
-private theorem mergeSortTR_run_eq_mergeSort : {n : Nat} → (l : { l : List α // l.length = n }) → mergeSortTR.run le l = mergeSort l.1 le
+theorem mergeSortTR_run_eq_mergeSort : {n : Nat} → (l : { l : List α // l.length = n }) → mergeSortTR.run le l = mergeSort l.1 le
   | 0, ⟨[], _⟩
   | 1, ⟨[a], _⟩ => by simp [mergeSortTR.run]
   | n+2, ⟨a :: b :: l, h⟩ => by
@@ -189,7 +189,7 @@ theorem mergeSort_eq_mergeSortTR : @mergeSort = @mergeSortTR := by
 -- This mutual block is unfortunately quite slow to elaborate.
 set_option maxHeartbeats 400000 in
 mutual
-private theorem mergeSortTR₂_run_eq_mergeSort : {n : Nat} → (l : { l : List α // l.length = n }) → mergeSortTR₂.run le l = mergeSort l.1 le
+theorem mergeSortTR₂_run_eq_mergeSort : {n : Nat} → (l : { l : List α // l.length = n }) → mergeSortTR₂.run le l = mergeSort l.1 le
   | 0, ⟨[], _⟩
   | 1, ⟨[a], _⟩ => by simp [mergeSortTR₂.run]
   | n+2, ⟨a :: b :: l, h⟩ => by
@@ -201,7 +201,7 @@ private theorem mergeSortTR₂_run_eq_mergeSort : {n : Nat} → (l : { l : List
     rw [reverse_reverse]
 termination_by n => n
 
-private theorem mergeSortTR₂_run'_eq_mergeSort : {n : Nat} → (l : { l : List α // l.length = n }) → (w : l' = l.1.reverse) → mergeSortTR₂.run' le l = mergeSort l' le
+theorem mergeSortTR₂_run'_eq_mergeSort : {n : Nat} → (l : { l : List α // l.length = n }) → (w : l' = l.1.reverse) → mergeSortTR₂.run' le l = mergeSort l' le
   | 0, ⟨[], _⟩, w
   | 1, ⟨[a], _⟩, w => by simp_all [mergeSortTR₂.run']
   | n+2, ⟨a :: b :: l, h⟩, w => by

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

@@ -359,7 +359,7 @@ where go : ∀ (i : Nat) (l : List α),
       omega
 termination_by _ l => l.length
 
-
+@[deprecated mergeSort_zipIdx (since := "2025-01-21")] abbrev mergeSort_enum := @mergeSort_zipIdx
 
 theorem mergeSort_cons {le : α → α → Bool}
     (trans : ∀ (a b c : α), le a b → le b c → le a c)

src/Init/Data/List/ToArray.lean

@@ -222,11 +222,11 @@ theorem forM_toArray [Monad m] (l : List α) (f : α → m PUnit) :
     congr
     ext1 (_|_) <;> simp [ih]
 
-private theorem findSomeRevM?_find_toArray [Monad m] [LawfulMonad m] (f : α → m (Option β)) (l : List α)
+theorem findSomeRevM?_find_toArray [Monad m] [LawfulMonad m] (f : α → m (Option β)) (l : List α)
     (i : Nat) (h) :
     findSomeRevM?.find f l.toArray i h = (l.take i).reverse.findSomeM? f := by
   induction i generalizing l with
-  | zero => simp [Array.findSomeRevM?.find]
+  | zero => simp [Array.findSomeRevM?.find.eq_def]
   | succ i ih =>
     rw [size_toArray] at h
     rw [Array.findSomeRevM?.find, take_succ, getElem?_eq_getElem (by omega)]
@@ -398,46 +398,45 @@ theorem isPrefixOfAux_toArray_zero [BEq α] (l₁ l₂ : List α) (hle : l₁.le
         rw [ih]
         simp_all
 
-theorem zipWithMAux_toArray_succ {m : Type u → Type v} [Monad m] (as : List α) (bs : List β) (f : α → β → m γ) (i : Nat) (xs : Array γ) :
-    zipWithMAux as.toArray bs.toArray f (i + 1) xs = zipWithMAux as.tail.toArray bs.tail.toArray f i xs := by
-  rw [zipWithMAux]
-  conv => rhs; rw [zipWithMAux]
+theorem zipWithAux_toArray_succ (as : List α) (bs : List β) (f : α → β → γ) (i : Nat) (xs : Array γ) :
+    zipWithAux as.toArray bs.toArray f (i + 1) xs = zipWithAux as.tail.toArray bs.tail.toArray f i xs := by
+  rw [zipWithAux]
+  conv => rhs; rw [zipWithAux]
   simp only [size_toArray, getElem_toArray, length_tail, getElem_tail]
   split <;> rename_i h₁
   · split <;> rename_i h₂
-    · rw [dif_pos (by omega), dif_pos (by omega)]
-      simp only [zipWithMAux_toArray_succ as bs f (i+1)]
+    · rw [dif_pos (by omega), dif_pos (by omega), zipWithAux_toArray_succ]
     · rw [dif_pos (by omega)]
       rw [dif_neg (by omega)]
   · rw [dif_neg (by omega)]
 
-theorem zipWithMAux_toArray_succ' {m : Type u → Type v} [Monad m] (as : List α) (bs : List β) (f : α → β → m γ) (i : Nat) (xs : Array γ) :
-    zipWithMAux as.toArray bs.toArray f (i + 1) xs = zipWithMAux (as.drop (i+1)).toArray (bs.drop (i+1)).toArray f 0 xs := by
+theorem zipWithAux_toArray_succ' (as : List α) (bs : List β) (f : α → β → γ) (i : Nat) (xs : Array γ) :
+    zipWithAux as.toArray bs.toArray f (i + 1) xs = zipWithAux (as.drop (i+1)).toArray (bs.drop (i+1)).toArray f 0 xs := by
   induction i generalizing as bs xs with
-  | zero => simp [zipWithMAux_toArray_succ]
+  | zero => simp [zipWithAux_toArray_succ]
   | succ i ih =>
-    rw [zipWithMAux_toArray_succ, ih]
+    rw [zipWithAux_toArray_succ, ih]
     simp
 
-theorem zipWithMAux_toArray_zero {m : Type u → Type v} [Monad m] [LawfulMonad m] (f : α → β → m γ) (as : List α) (bs : List β) (xs : Array γ) :
-    zipWithMAux as.toArray bs.toArray f 0 xs = do return xs ++ (← List.zipWithM f as bs).toArray := by
-  rw [Array.zipWithMAux]
+theorem zipWithAux_toArray_zero (f : α → β → γ) (as : List α) (bs : List β) (xs : Array γ) :
+    zipWithAux as.toArray bs.toArray f 0 xs = xs ++ (List.zipWith f as bs).toArray := by
+  rw [Array.zipWithAux]
   match as, bs with
   | [], _ => simp
   | _, [] => simp
   | a :: as, b :: bs =>
-    simp [zipWithMAux_toArray_succ', zipWithMAux_toArray_zero, push_append_toArray]
+    simp [zipWith_cons_cons, zipWithAux_toArray_succ', zipWithAux_toArray_zero, push_append_toArray]
 
 @[simp, grind =] theorem zipWith_toArray (as : List α) (bs : List β) (f : α → β → γ) :
     Array.zipWith f as.toArray bs.toArray = (List.zipWith f as bs).toArray := by
   rw [Array.zipWith]
-  simp [zipWithMAux_toArray_zero, ← zipWithM'_eq_zipWithM]
+  simp [zipWithAux_toArray_zero]
 
 @[simp, grind =] theorem zip_toArray (as : List α) (bs : List β) :
     Array.zip as.toArray bs.toArray = (List.zip as bs).toArray := by
   simp [Array.zip, zipWith_toArray, zip]
 
-private theorem zipWithAll_go_toArray (as : List α) (bs : List β) (f : Option α → Option β → γ) (i : Nat) (xs : Array γ) :
+theorem zipWithAll_go_toArray (as : List α) (bs : List β) (f : Option α → Option β → γ) (i : Nat) (xs : Array γ) :
     zipWithAll.go f as.toArray bs.toArray i xs = xs ++ (List.zipWithAll f (as.drop i) (bs.drop i)).toArray := by
   unfold zipWithAll.go
   split <;> rename_i h
@@ -475,11 +474,6 @@ private theorem zipWithAll_go_toArray (as : List α) (bs : List β) (f : Option
     Array.zipWithAll f as.toArray bs.toArray = (List.zipWithAll f as bs).toArray := by
   simp [Array.zipWithAll, zipWithAll_go_toArray]
 
-@[simp, grind =] theorem zipWithM_toArray {m : Type u → Type v} [Monad m] [LawfulMonad m] (f : α → β → m γ) (as : List α) (bs : List β) :
-    Array.zipWithM f as.toArray bs.toArray = do return (← List.zipWithM f as bs).toArray := by
-  rw [Array.zipWithM]
-  simp [zipWithMAux_toArray_zero]
-
 @[simp, grind =] theorem toArray_appendList (l₁ l₂ : List α) :
     l₁.toArray ++ l₂ = (l₁ ++ l₂).toArray := by
   apply ext'
@@ -489,7 +483,7 @@ private theorem zipWithAll_go_toArray (as : List α) (bs : List β) (f : Option
   apply ext'
   simp
 
-private theorem takeWhile_go_succ (p : α → Bool) (a : α) (l : List α) (i : Nat) :
+theorem takeWhile_go_succ (p : α → Bool) (a : α) (l : List α) (i : Nat) :
     takeWhile.go p (a :: l).toArray (i+1) r = takeWhile.go p l.toArray i r := by
   rw [takeWhile.go, takeWhile.go]
   simp only [size_toArray, length_cons, Nat.add_lt_add_iff_right,
@@ -498,7 +492,7 @@ private theorem takeWhile_go_succ (p : α → Bool) (a : α) (l : List α) (i :
   rw [takeWhile_go_succ]
   rfl
 
-private theorem takeWhile_go_toArray (p : α → Bool) (l : List α) (i : Nat) :
+theorem takeWhile_go_toArray (p : α → Bool) (l : List α) (i : Nat) :
     Array.takeWhile.go p l.toArray i r = r ++ (takeWhile p (l.drop i)).toArray := by
   induction l generalizing i r with
   | nil => simp [takeWhile.go]

src/Init/Data/List/ToArrayImpl.lean

@@ -31,6 +31,6 @@ both `List.toArray` and `Array.mk`.
 -/
 -- This function is exported to C, where it is called by `Array.mk`
 -- (the constructor) to implement this functionality.
-@[inline, expose, match_pattern, pp_nodot, export lean_list_to_array]
+@[inline, match_pattern, pp_nodot, export lean_list_to_array]
 def List.toArrayImpl (xs : List α) : Array α :=
   xs.toArrayAux (Array.mkEmpty xs.length)

src/Init/Data/List/Zip.lean

@@ -42,7 +42,7 @@ theorem zipWith_self {f : α → α → δ} : ∀ {l : List α}, zipWith f l l =
   | [] => rfl
   | _ :: _ => congrArg _ zipWith_self
 
-
+@[deprecated zipWith_self (since := "2025-01-29")] abbrev zipWith_same := @zipWith_self
 
 /--
 See also `getElem?_zipWith'` for a variant
@@ -127,7 +127,7 @@ theorem zipWith_foldl_eq_zip_foldl {f : α → β → γ} {i : δ} {g : δ →
 theorem zipWith_eq_nil_iff {f : α → β → γ} {l l'} : zipWith f l l' = [] ↔ l = [] ∨ l' = [] := by
   cases l <;> cases l' <;> simp
 
-@[simp, grind =]
+@[grind =]
 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
@@ -306,7 +306,7 @@ theorem of_mem_zip {a b} : ∀ {l₁ : List α} {l₂ : List β}, (a, b) ∈ zip
     cases h
     case head => simp
     case tail h =>
-      have := of_mem_zip h
+    · have := of_mem_zip h
       exact ⟨Mem.tail _ this.1, Mem.tail _ this.2⟩
 
 theorem map_fst_zip :

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

@@ -97,7 +97,7 @@ def shiftRight : @& Nat → @& Nat → Nat
 
 instance : AndOp Nat := ⟨Nat.land⟩
 instance : OrOp Nat := ⟨Nat.lor⟩
-instance : XorOp Nat := ⟨Nat.xor⟩
+instance : Xor Nat := ⟨Nat.xor⟩
 instance : ShiftLeft Nat := ⟨Nat.shiftLeft⟩
 instance : ShiftRight Nat := ⟨Nat.shiftRight⟩
 
@@ -137,7 +137,7 @@ of a number.
 /--
 Returns `true` if the `(n+1)`th least significant bit is `1`, or `false` if it is `0`.
 -/
-@[expose] def testBit (m n : Nat) : Bool :=
+def testBit (m n : Nat) : Bool :=
   -- `1 &&& n` is faster than `n &&& 1` for big `n`.
   1 &&& (m >>> n) != 0
 

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

@@ -78,7 +78,8 @@ noncomputable def div2Induction {motive : Nat → Sort u}
     simp only [HAnd.hAnd, AndOp.and, land] at andz
     simp only [HAnd.hAnd, AndOp.and, land]
     unfold bitwise
-    cases mod_two_eq_zero_or_one x with | _ p => simp [xz, p, andz]
+    cases mod_two_eq_zero_or_one x with | _ p =>
+      simp [xz, p, andz]
 
 /-! ### testBit -/
 
@@ -181,8 +182,9 @@ theorem exists_testBit_ne_of_ne {x y : Nat} (p : x ≠ y) : ∃ i, testBit x i
         apply Exists.intro 0
         simp only [testBit_zero]
         revert lsb_diff
-        cases mod_two_eq_zero_or_one x with
-        | _ p => cases mod_two_eq_zero_or_one y with | _ q => simp [p,q]
+        cases mod_two_eq_zero_or_one x with | _ p =>
+          cases mod_two_eq_zero_or_one y with | _ q =>
+            simp [p,q]
 
 @[deprecated exists_testBit_ne_of_ne (since := "2025-04-04")]
 abbrev ne_implies_bit_diff := @exists_testBit_ne_of_ne
@@ -258,7 +260,8 @@ private theorem succ_mod_two : succ x % 2 = 1 - x % 2 := by
 
 private theorem testBit_succ_zero : testBit (x + 1) 0 = !(testBit x 0) := by
   simp only [testBit_eq_decide_div_mod_eq, Nat.pow_zero, Nat.div_one, succ_mod_two]
-  cases Nat.mod_two_eq_zero_or_one x with | _ p => simp [p]
+  cases Nat.mod_two_eq_zero_or_one x with | _ p =>
+    simp [p]
 
 theorem testBit_two_pow_add_eq (x i : Nat) : testBit (2^i + x) i = !(testBit x i) := by
   simp only [testBit_eq_decide_div_mod_eq, add_div_left, Nat.two_pow_pos, succ_mod_two]
@@ -274,7 +277,8 @@ theorem testBit_mul_two_pow_add_eq (a b i : Nat) :
           testBit_mul_two_pow_add_eq a,
           testBit_two_pow_add_eq,
           Nat.succ_mod_two]
-    cases mod_two_eq_zero_or_one a with | _ p => simp [p]
+    cases mod_two_eq_zero_or_one a with
+    | _ p => simp [p]
 
 theorem testBit_two_pow_add_gt {i j : Nat} (j_lt_i : j < i) (x : Nat) :
     testBit (2^i + x) j = testBit x j := by
@@ -637,7 +641,7 @@ theorem or_mod_two_pow : (a ||| b) % 2 ^ n = a % 2 ^ n ||| b % 2 ^ n :=
 
 @[simp, grind =] theorem testBit_xor (x y i : Nat) :
     (x ^^^ y).testBit i = ((x.testBit i) ^^ (y.testBit i)) := by
-  simp [HXor.hXor, XorOp.xor, xor, testBit_bitwise ]
+  simp [HXor.hXor, Xor.xor, xor, testBit_bitwise ]
 
 @[simp, grind =] theorem zero_xor (x : Nat) : 0 ^^^ x = x := by
    apply Nat.eq_of_testBit_eq
@@ -849,7 +853,8 @@ theorem shiftLeft_add_eq_or_of_lt {b : Nat} (b_lt : b < 2^i) (a : Nat) :
 /-! ### le -/
 
 theorem le_of_testBit {n m : Nat} (h : ∀ i, n.testBit i = true → m.testBit i = true) : n ≤ m := by
-  induction n using div2Induction generalizing m with | _ n ih
+  induction n using div2Induction generalizing m
+  next n ih =>
   have : n / 2 ≤ m / 2 := by
     rcases n with (_|n)
     · simp

src/Init/Data/Nat/Compare.lean

@@ -24,7 +24,7 @@ theorem compare_eq_ite_lt (a b : Nat) :
   simp only [compare, compareOfLessAndEq]
   split
   · rfl
-  next h =>
+  · next h =>
     match Nat.lt_or_eq_of_le (Nat.not_lt.1 h) with
     | .inl h => simp [h, Nat.ne_of_gt h]
     | .inr rfl => simp
@@ -36,11 +36,11 @@ theorem compare_eq_ite_le (a b : Nat) :
     compare a b = if a ≤ b then if b ≤ a then .eq else .lt else .gt := by
   rw [compare_eq_ite_lt]
   split
-  next hlt => simp [Nat.le_of_lt hlt, Nat.not_le.2 hlt]
-  next hge =>
+  · next hlt => simp [Nat.le_of_lt hlt, Nat.not_le.2 hlt]
+  · next hge =>
     split
-    next hgt => simp [Nat.not_le.2 hgt]
-    next hle => simp [Nat.not_lt.1 hge, Nat.not_lt.1 hle]
+    · next hgt => simp [Nat.not_le.2 hgt]
+    · next hle => simp [Nat.not_lt.1 hge, Nat.not_lt.1 hle]
 
 @[deprecated compare_eq_ite_le (since := "2025-03_28")]
 def compare_def_le := compare_eq_ite_le

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

@@ -350,7 +350,12 @@ theorem mod_le (x y : Nat) : x % y ≤ x := by
 theorem mod_lt_of_lt {a b c : Nat} (h : a < c) : a % b < c :=
   Nat.lt_of_le_of_lt (Nat.mod_le _ _) h
 
-@[simp] theorem zero_mod (b : Nat) : 0 % b = 0 := rfl
+@[simp] theorem zero_mod (b : Nat) : 0 % b = 0 := by
+  rw [mod_eq]
+  have : ¬ (0 < b ∧ b = 0) := by
+    intro ⟨h₁, h₂⟩
+    simp_all
+  simp [this]
 
 @[simp] theorem mod_self (n : Nat) : n % n = 0 := by
   rw [mod_eq_sub_mod (Nat.le_refl _), Nat.sub_self, zero_mod]

src/Init/Data/Nat/Fold.lean

@@ -128,7 +128,7 @@ theorem fold_congr {α : Type u} {n m : Nat} (w : n = m)
   subst m
   rfl
 
-private theorem foldTR_loop_congr {α : Type u} {n m : Nat} (w : n = m)
+theorem foldTR_loop_congr {α : Type u} {n m : Nat} (w : n = m)
      (f : (i : Nat) → i < n → α → α) (j : Nat) (h : j ≤ n) (init : α) :
      foldTR.loop n f j h init = foldTR.loop m (fun i h => f i (by omega)) j (by omega) init := by
   subst m
@@ -154,7 +154,7 @@ theorem any_congr {n m : Nat} (w : n = m) (f : (i : Nat) → i < n → Bool) : a
   subst m
   rfl
 
-private theorem anyTR_loop_congr {n m : Nat} (w : n = m) (f : (i : Nat) → i < n → Bool) (j : Nat) (h : j ≤ n) :
+theorem anyTR_loop_congr {n m : Nat} (w : n = m) (f : (i : Nat) → i < n → Bool) (j : Nat) (h : j ≤ n) :
     anyTR.loop n f j h = anyTR.loop m (fun i h => f i (by omega)) j (by omega) := by
   subst m
   rfl
@@ -179,7 +179,7 @@ theorem all_congr {n m : Nat} (w : n = m) (f : (i : Nat) → i < n → Bool) : a
   subst m
   rfl
 
-private theorem allTR_loop_congr {n m : Nat} (w : n = m) (f : (i : Nat) → i < n → Bool) (j : Nat) (h : j ≤ n) : allTR.loop n f j h = allTR.loop m (fun i h => f i (by omega)) j (by omega) := by
+theorem allTR_loop_congr {n m : Nat} (w : n = m) (f : (i : Nat) → i < n → Bool) (j : Nat) (h : j ≤ n) : allTR.loop n f j h = allTR.loop m (fun i h => f i (by omega)) j (by omega) := by
   subst m
   rfl
 
@@ -199,62 +199,6 @@ private theorem allTR_loop_congr {n m : Nat} (w : n = m) (f : (i : Nat) → i <
       omega
   go n 0 f
 
-/-! # `dfold` -/
-
-private def dfoldCast {n : Nat} (α : (i : Nat) → (h : i ≤ n := by omega) → Type u)
-    {i j : Nat} {hi : i ≤ n} (w : i = j) (x : α i hi) : α j (by omega) := by
-  subst w
-  exact x
-
-@[local simp] private theorem dfoldCast_rfl (h : i ≤ n) (w : i = i) (x : α i h) : dfoldCast α w x = x := by
-  simp [dfoldCast]
-
-@[local simp] private theorem dfoldCast_trans (h : i ≤ n) (w₁ : i = j) (w₂ : j = k) (x : α i h) :
-    dfoldCast @α w₂ (dfoldCast @α w₁ x) = dfoldCast @α (w₁.trans w₂) x := by
-  cases w₁
-  cases w₂
-  simp [dfoldCast]
-
-@[local simp] private theorem dfoldCast_eq_dfoldCast_iff {α : (i : Nat) → (h : i ≤ n := by omega) → Type u} {w₁ w₂ : i = j} {h : i ≤ n} {x : α i h} :
-    dfoldCast @α w₁ x = dfoldCast (n := n) (fun i h => α i) (hi := hi) w₂ x ↔ w₁ = w₂ := by
-  cases w₁
-  cases w₂
-  simp [dfoldCast]
-
-private theorem apply_dfoldCast {α : (i : Nat) → (h : i ≤ n := by omega) → Type u}
-    (f : (i : Nat) → (h : i < n) → α i → α (i + 1)) {i j : Nat} (h : i < n) {w : i = j} {x : α i (by omega)} :
-    f j (by omega) (dfoldCast @α w x) = dfoldCast (n := n) (fun i h => α i) (hi := by omega) (by omega) (f i h x) := by
-  subst w
-  simp
-
-/--
-`Nat.dfold` evaluates `f` on the numbers up to `n` exclusive, in increasing order:
-* `Nat.dfold f 3 init = init |> f 0 |> f 1 |> f 2`
-The input and output types of `f` are indexed by the current index, i.e. `f : (i : Nat) → (h : i < n) → α i → α (i + 1)`.
--/
-@[specialize]
-def dfold (n : Nat) {α : (i : Nat) → (h : i ≤ n := by omega) → Type u}
-    (f : (i : Nat) → (h : i < n) → α i → α (i + 1)) (init : α 0) : α n :=
-  let rec @[specialize] loop : ∀ j, j ≤ n → α (n - j) → α n
-    | 0,      h, a => a
-    | succ m, h, a =>
-      loop m (by omega) (dfoldCast @α (by omega) (f (n - succ m) (by omega) a))
-  loop n (by omega) (dfoldCast @α (by omega) init)
-
-/--
-`Nat.dfoldRev` evaluates `f` on the numbers up to `n` exclusive, in decreasing order:
-* `Nat.dfoldRev f 3 init = f 0 <| f 1 <| f 2 <| init`
-The input and output types of `f` are indexed by the current index, i.e. `f : (i : Nat) → (h : i < n) → α (i + 1) → α i`.
--/
-@[specialize]
-def dfoldRev (n : Nat) {α : (i : Nat) → (h : i ≤ n := by omega) → Type u}
-    (f : (i : Nat) → (h : i < n) → α (i + 1) → α i) (init : α n) : α 0 :=
-  match n with
-  | 0       => init
-  | (n + 1) => dfoldRev n (α := fun i h => α i) (fun i h => f i (by omega)) (f n (by omega) init)
-
-/-! # Theorems -/
-
 /-! ### `fold` -/
 
 @[simp] theorem fold_zero {α : Type u} (f : (i : Nat) → i < 0 → α → α) (init : α) :
@@ -311,102 +255,6 @@ def dfoldRev (n : Nat) {α : (i : Nat) → (h : i ≤ n := by omega) → Type u}
   | zero => simp
   | succ n ih => simp [ih, List.finRange_succ_last, List.all_map, Function.comp_def]
 
-/-! ### `dfold` -/
-
-@[simp]
-theorem dfold_zero
-    {α : (i : Nat) → (h : i ≤ 0 := by omega) → Type u}
-    (f : (i : Nat) → (h : i < 0) → α i → α (i + 1)) (init : α 0) :
-    dfold 0 f init = init := by
-  simp [dfold, dfold.loop]
-
-private theorem dfold_loop_succ
-    {α : (i : Nat) → (h : i ≤ n + 1 := by omega) → Type u}
-    (f : (i : Nat) → (h : i < n + 1) → α i → α (i + 1))
-    (a : α (n + 1 - (j + 1))) (w : j ≤ n):
-    dfold.loop (n + 1) f (j + 1) (by omega) a =
-      f n (by omega)
-        (dfold.loop n (α := fun i h => α i) (fun i h => f i (by omega)) j w (dfoldCast @α (by omega) a)) := by
-  induction j with
-  | zero => simp [dfold.loop]
-  | succ j ih =>
-    rw [dfold.loop, ih _ (by omega)]
-    congr 2
-    simp only [succ_eq_add_one, dfoldCast_trans]
-    rw [apply_dfoldCast (h := by omega) f]
-    · erw [dfoldCast_trans (h := by omega)]
-      erw [dfoldCast_eq_dfoldCast_iff]
-      omega
-
-@[simp]
-theorem dfold_succ
-    {α : (i : Nat) → (h : i ≤ n + 1 := by omega) → Type u}
-    (f : (i : Nat) → (h : i < n + 1) → α i → α (i + 1)) (init : α 0) :
-    dfold (n + 1) f init =
-      f n (by omega) (dfold n (α := fun i h => α i) (fun i h => f i (by omega)) init) := by
-  simp [dfold]
-  rw [dfold_loop_succ (w := Nat.le_refl _)]
-  congr 2
-  simp only [dfoldCast_trans]
-  erw [dfoldCast_eq_dfoldCast_iff]
-  exact le_add_left 0 (n + 1)
-
--- This isn't a proper `@[congr]` lemma, but it doesn't seem possible to state one.
-theorem dfold_congr
-    {n m : Nat} (w : n = m)
-    {α : (i : Nat) → (h : i ≤ n := by omega) → Type u}
-    (f : (i : Nat) → (h : i < n) → α i → α (i + 1)) (init : α 0) :
-      dfold n f init =
-        cast (by subst w; rfl)
-          (dfold m (α := fun i h => α i) (fun i h => f i (by omega)) init) := by
-  subst w
-  rfl
-
-theorem dfold_add
-    {α : (i : Nat) → (h : i ≤ n + m := by omega) → Type u}
-    (f : (i : Nat) → (h : i < n + m) → α i → α (i + 1)) (init : α 0) :
-    dfold (n + m) f init =
-      dfold m (α := fun i h => α (n + i)) (fun i h => f (n + i) (by omega))
-        (dfold n (α := fun i h => α i) (fun i h => f i (by omega)) init) := by
-  induction m with
-  | zero => simp; rfl
-  | succ m ih =>
-    simp [dfold_congr (Nat.add_assoc n m 1).symm, ih]
-
-@[simp] theorem dfoldRev_zero
-    {α : (i : Nat) → (h : i ≤ 0 := by omega) → Type u}
-    (f : (i : Nat) → (_ : i < 0) → α (i + 1) → α i) (init : α 0) :
-    dfoldRev 0 f init = init := by
-  simp [dfoldRev]
-
-@[simp] theorem dfoldRev_succ
-    {α : (i : Nat) → (h : i ≤ n + 1 := by omega) → Type u}
-    (f : (i : Nat) → (h : i < n + 1) → α (i + 1) → α i) (init : α (n + 1)) :
-    dfoldRev (n + 1) f init =
-      dfoldRev n (α := fun i h => α i) (fun i h => f i (by omega)) (f n (by omega) init) := by
-  simp [dfoldRev]
-
-@[congr]
-theorem dfoldRev_congr
-    {n m : Nat} (w : n = m)
-    {α : (i : Nat) → (h : i ≤ n := by omega) → Type u}
-    (f : (i : Nat) → (h : i < n) → α (i + 1) → α i) (init : α n) :
-      dfoldRev n f init =
-        dfoldRev m (α := fun i h => α i) (fun i h => f i (by omega))
-          (cast (by subst w; rfl) init) := by
-  subst w
-  rfl
-
-theorem dfoldRev_add
-    {α : (i : Nat) → (h : i ≤ n + m := by omega) → Type u}
-    (f : (i : Nat) → (h : i < n + m) → α (i + 1) → α i) (init : α (n + m)) :
-    dfoldRev (n + m) f init =
-      dfoldRev n (α := fun i h => α i) (fun i h => f i (by omega))
-        (dfoldRev m (α := fun i h => α (n + i)) (fun i h => f (n + i) (by omega)) init) := by
-  induction m with
-  | zero => simp; rfl
-  | succ m ih => simp [← Nat.add_assoc, ih]
-
 end Nat
 
 namespace Prod

src/Init/Data/Nat/Lemmas.lean

@@ -1145,7 +1145,8 @@ protected theorem pow_lt_pow_succ (h : 1 < a) : a ^ n < a ^ (n + 1) := by
 
 protected theorem pow_lt_pow_of_lt {a n m : Nat} (h : 1 < a) (w : n < m) : a ^ n < a ^ m := by
   have := Nat.exists_eq_add_of_lt w
-  cases this with | intro k p
+  cases this
+  case intro k p =>
   rw [Nat.add_right_comm] at p
   subst p
   rw [Nat.pow_add, ← Nat.mul_one (a^n)]
@@ -1560,7 +1561,7 @@ theorem mul_add_mod_of_lt {a b c : Nat} (h : c < b) : (a * b + c) % b = c := by
 @[simp] theorem mod_div_self (m n : Nat) : m % n / n = 0 := by
   cases n
   · exact (m % 0).div_zero
-  case succ n => exact Nat.div_eq_of_lt (m.mod_lt n.succ_pos)
+  · case succ n => exact Nat.div_eq_of_lt (m.mod_lt n.succ_pos)
 
 theorem mod_eq_iff {a b c : Nat} :
     a % b = c ↔ (b = 0 ∧ a = c) ∨ (c < b ∧ Exists fun k => a = b * k + c) :=
@@ -1689,17 +1690,17 @@ theorem div_lt_div_of_lt_of_dvd {a b d : Nat} (hdb : d ∣ b) (h : a < b) : a /
 
 @[simp, grind =] theorem shiftLeft_zero : n <<< 0 = n := rfl
 
-/-- Shift left on successor with multiple moved inside. -/
+/-- Shiftleft on successor with multiple moved inside. -/
 theorem shiftLeft_succ_inside (m n : Nat) : m <<< (n+1) = (2*m) <<< n := rfl
 
-/-- Shift left on successor with multiple moved to outside. -/
+/-- Shiftleft on successor with multiple moved to outside. -/
 theorem shiftLeft_succ : ∀(m n), m <<< (n + 1) = 2 * (m <<< n)
 | _, 0 => rfl
 | _, k + 1 => by
   rw [shiftLeft_succ_inside _ (k+1)]
   rw [shiftLeft_succ _ k, shiftLeft_succ_inside]
 
-/-- Shift right on successor with division moved inside. -/
+/-- Shiftright on successor with division moved inside. -/
 theorem shiftRight_succ_inside : ∀m n, m >>> (n+1) = (m/2) >>> n
 | _, 0 => rfl
 | _, k + 1 => by

src/Init/Data/Nat/Log2.lean

@@ -42,7 +42,7 @@ decreasing_by exact log2_terminates _ ‹_›
 
 theorem log2_le_self (n : Nat) : Nat.log2 n ≤ n := by
   unfold Nat.log2; split
-  next h =>
+  · next h =>
     have := log2_le_self (n / 2)
     exact Nat.lt_of_le_of_lt this (Nat.div_lt_self (Nat.le_of_lt h) (by decide))
   · apply Nat.zero_le

src/Init/Data/Ord.lean

@@ -95,10 +95,6 @@ Ordering.lt
   | .eq => b
   | a => a
 
-/-- Version of `Ordering.then'` for proof by reflection. -/
-noncomputable def then' (a b : Ordering) : Ordering :=
-  Ordering.rec a b a a
-
 /--
 Checks whether the ordering is `eq`.
 -/
@@ -295,9 +291,6 @@ instance : Std.LawfulIdentity Ordering.then eq where
   left_id _ := eq_then
   right_id _ := then_eq
 
-theorem then'_eq_then (a b : Ordering) : a.then' b = a.then b := by
-  cases a <;> simp [Ordering.then', Ordering.then]
-
 end Lemmas
 
 end Ordering

src/Init/Data/Range/Polymorphic/Iterators.lean

@@ -10,7 +10,7 @@ public import Init.Data.Range.Polymorphic.RangeIterator
 public import Init.Data.Range.Polymorphic.Basic
 public import Init.Data.Iterators.Combinators.Attach
 
-@[expose] public section
+public section
 
 open Std.Iterators
 
@@ -29,7 +29,7 @@ def Internal.iter {sl su α} [UpwardEnumerable α] [BoundedUpwardEnumerable sl
 Returns the elements of the given range as a list in ascending order, given that ranges of the given
 type and shape support this function and the range is finite.
 -/
-@[always_inline, inline, expose]
+@[always_inline, inline]
 def toList {sl su α} [UpwardEnumerable α] [BoundedUpwardEnumerable sl α]
     [SupportsUpperBound su α]
     (r : PRange ⟨sl, su⟩ α)
@@ -98,6 +98,7 @@ instance {sl su α m} [UpwardEnumerable α] [BoundedUpwardEnumerable sl α]
     [Monad m] [Finite (RangeIterator su α) Id] :
     ForIn' m (PRange ⟨sl, su⟩ α) α inferInstance where
   forIn' r init f := by
+    haveI : MonadLift Id m := ⟨Std.Internal.idToMonad (α := _)⟩
     haveI := Iter.instForIn' (α := RangeIterator su α) (β := α) (n := m)
     refine ForIn'.forIn' (α := α) (PRange.Internal.iter r) init (fun a ha acc => f a ?_ acc)
     simp only [Membership.mem] at ha

src/Init/Data/Range/Polymorphic/Lemmas.lean

@@ -115,7 +115,7 @@ theorem pairwise_toList_upwardEnumerableLt {sl su} [UpwardEnumerable α]
     r.toList.Pairwise (fun a b => UpwardEnumerable.LT a b) := by
   rw [Internal.toList_eq_toList_iter]
   generalize Internal.iter r = it
-  induction it using Iter.inductSteps with | step it ihy ihs
+  induction it using Iter.inductSteps with | step it ihy ihs =>
   rw [RangeIterator.toList_eq_match]
   repeat' split <;> (try exact .nil; done)
   rename_i a _ _

src/Init/Data/Range/Polymorphic/PRange.lean

@@ -316,7 +316,7 @@ class LawfulClosedOpenIntersection (shape : RangeShape) (α : Type w)
     [SupportsLowerBound .closed α]
     [SupportsUpperBound .open α] where
   /--
-  The intersection according to `ClosedOpenIntersection shape α` of two ranges contains exactly
+  The intersection according to `ClosedOpenIntersection shapee α` of two ranges contains exactly
   those elements that are contained in both ranges.
   -/
   mem_intersection_iff {a : α} {r : PRange ⟨shape.lower, shape.upper⟩ α}

src/Init/Data/Range/Polymorphic/UpwardEnumerable.lean

@@ -87,7 +87,7 @@ class LawfulUpwardEnumerable (α : Type u) [UpwardEnumerable α] where
   succMany?_zero (a : α) : UpwardEnumerable.succMany? 0 a = some a
   /--
   The `n + 1`-th successor of `a` is the successor of the `n`-th successor, given that said
-  successors actually exist.
+  successors actualy exist.
   -/
   succMany?_succ (n : Nat) (a : α) :
     UpwardEnumerable.succMany? (n + 1) a = (UpwardEnumerable.succMany? n a).bind UpwardEnumerable.succ?

src/Init/Data/SInt/Basic.lean

@@ -389,7 +389,7 @@ instance : LE Int8          := ⟨Int8.le⟩
 instance : Complement Int8  := ⟨Int8.complement⟩
 instance : AndOp Int8       := ⟨Int8.land⟩
 instance : OrOp Int8        := ⟨Int8.lor⟩
-instance : XorOp Int8         := ⟨Int8.xor⟩
+instance : Xor Int8         := ⟨Int8.xor⟩
 instance : ShiftLeft Int8   := ⟨Int8.shiftLeft⟩
 instance : ShiftRight Int8  := ⟨Int8.shiftRight⟩
 instance : DecidableEq Int8 := Int8.decEq
@@ -760,7 +760,7 @@ instance : LE Int16          := ⟨Int16.le⟩
 instance : Complement Int16  := ⟨Int16.complement⟩
 instance : AndOp Int16       := ⟨Int16.land⟩
 instance : OrOp Int16        := ⟨Int16.lor⟩
-instance : XorOp Int16       := ⟨Int16.xor⟩
+instance : Xor Int16         := ⟨Int16.xor⟩
 instance : ShiftLeft Int16   := ⟨Int16.shiftLeft⟩
 instance : ShiftRight Int16  := ⟨Int16.shiftRight⟩
 instance : DecidableEq Int16 := Int16.decEq
@@ -1147,7 +1147,7 @@ instance : LE Int32          := ⟨Int32.le⟩
 instance : Complement Int32  := ⟨Int32.complement⟩
 instance : AndOp Int32       := ⟨Int32.land⟩
 instance : OrOp Int32        := ⟨Int32.lor⟩
-instance : XorOp Int32         := ⟨Int32.xor⟩
+instance : Xor Int32         := ⟨Int32.xor⟩
 instance : ShiftLeft Int32   := ⟨Int32.shiftLeft⟩
 instance : ShiftRight Int32  := ⟨Int32.shiftRight⟩
 instance : DecidableEq Int32 := Int32.decEq
@@ -1554,7 +1554,7 @@ instance : LE Int64          := ⟨Int64.le⟩
 instance : Complement Int64  := ⟨Int64.complement⟩
 instance : AndOp Int64       := ⟨Int64.land⟩
 instance : OrOp Int64        := ⟨Int64.lor⟩
-instance : XorOp Int64         := ⟨Int64.xor⟩
+instance : Xor Int64         := ⟨Int64.xor⟩
 instance : ShiftLeft Int64   := ⟨Int64.shiftLeft⟩
 instance : ShiftRight Int64  := ⟨Int64.shiftRight⟩
 instance : DecidableEq Int64 := Int64.decEq
@@ -1946,7 +1946,7 @@ instance : LE ISize          := ⟨ISize.le⟩
 instance : Complement ISize  := ⟨ISize.complement⟩
 instance : AndOp ISize       := ⟨ISize.land⟩
 instance : OrOp ISize        := ⟨ISize.lor⟩
-instance : XorOp ISize         := ⟨ISize.xor⟩
+instance : Xor ISize         := ⟨ISize.xor⟩
 instance : ShiftLeft ISize   := ⟨ISize.shiftLeft⟩
 instance : ShiftRight ISize  := ⟨ISize.shiftRight⟩
 instance : DecidableEq ISize := ISize.decEq

src/Init/Data/SInt/Lemmas.lean

@@ -85,11 +85,11 @@ theorem Int64.toInt_inj {x y : Int64} : x.toInt = y.toInt ↔ x = y := ⟨Int64.
 theorem ISize.toInt.inj {x y : ISize} (h : x.toInt = y.toInt) : x = y := ISize.toBitVec.inj (BitVec.eq_of_toInt_eq h)
 theorem ISize.toInt_inj {x y : ISize} : x.toInt = y.toInt ↔ x = y := ⟨ISize.toInt.inj, fun h => h ▸ rfl⟩
 
-@[simp, int_toBitVec] theorem Int8.toBitVec_neg (x : Int8) : (-x).toBitVec = -x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem Int16.toBitVec_neg (x : Int16) : (-x).toBitVec = -x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem Int32.toBitVec_neg (x : Int32) : (-x).toBitVec = -x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem Int64.toBitVec_neg (x : Int64) : (-x).toBitVec = -x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem ISize.toBitVec_neg (x : ISize) : (-x).toBitVec = -x.toBitVec := (rfl)
+@[simp] theorem Int8.toBitVec_neg (x : Int8) : (-x).toBitVec = -x.toBitVec := (rfl)
+@[simp] theorem Int16.toBitVec_neg (x : Int16) : (-x).toBitVec = -x.toBitVec := (rfl)
+@[simp] theorem Int32.toBitVec_neg (x : Int32) : (-x).toBitVec = -x.toBitVec := (rfl)
+@[simp] theorem Int64.toBitVec_neg (x : Int64) : (-x).toBitVec = -x.toBitVec := (rfl)
+@[simp] theorem ISize.toBitVec_neg (x : ISize) : (-x).toBitVec = -x.toBitVec := (rfl)
 
 @[simp] theorem Int8.toBitVec_zero : toBitVec 0 = 0#8 := (rfl)
 @[simp] theorem Int16.toBitVec_zero : toBitVec 0 = 0#16 := (rfl)
@@ -103,11 +103,11 @@ theorem Int32.toBitVec_one : (1 : Int32).toBitVec = 1#32 := (rfl)
 theorem Int64.toBitVec_one : (1 : Int64).toBitVec = 1#64 := (rfl)
 theorem ISize.toBitVec_one : (1 : ISize).toBitVec = 1#System.Platform.numBits := (rfl)
 
-@[simp, int_toBitVec] theorem Int8.toBitVec_ofInt (i : Int) : (ofInt i).toBitVec = BitVec.ofInt _ i := (rfl)
-@[simp, int_toBitVec] theorem Int16.toBitVec_ofInt (i : Int) : (ofInt i).toBitVec = BitVec.ofInt _ i := (rfl)
-@[simp, int_toBitVec] theorem Int32.toBitVec_ofInt (i : Int) : (ofInt i).toBitVec = BitVec.ofInt _ i := (rfl)
-@[simp, int_toBitVec] theorem Int64.toBitVec_ofInt (i : Int) : (ofInt i).toBitVec = BitVec.ofInt _ i := (rfl)
-@[simp, int_toBitVec] theorem ISize.toBitVec_ofInt (i : Int) : (ofInt i).toBitVec = BitVec.ofInt _ i := (rfl)
+@[simp] theorem Int8.toBitVec_ofInt (i : Int) : (ofInt i).toBitVec = BitVec.ofInt _ i := (rfl)
+@[simp] theorem Int16.toBitVec_ofInt (i : Int) : (ofInt i).toBitVec = BitVec.ofInt _ i := (rfl)
+@[simp] theorem Int32.toBitVec_ofInt (i : Int) : (ofInt i).toBitVec = BitVec.ofInt _ i := (rfl)
+@[simp] theorem Int64.toBitVec_ofInt (i : Int) : (ofInt i).toBitVec = BitVec.ofInt _ i := (rfl)
+@[simp] theorem ISize.toBitVec_ofInt (i : Int) : (ofInt i).toBitVec = BitVec.ofInt _ i := (rfl)
 
 @[simp] protected theorem Int8.neg_zero : -(0 : Int8) = 0 := (rfl)
 @[simp] protected theorem Int16.neg_zero : -(0 : Int16) = 0 := (rfl)
@@ -271,11 +271,11 @@ theorem ISize.toInt_maxValue : ISize.maxValue.toInt = 2 ^ (System.Platform.numBi
   rw [toNatClampNeg, toInt_minValue]
   cases System.Platform.numBits_eq <;> simp_all
 
-@[simp, int_toBitVec] theorem UInt8.toBitVec_toInt8 (x : UInt8) : x.toInt8.toBitVec = x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem UInt16.toBitVec_toInt16 (x : UInt16) : x.toInt16.toBitVec = x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem UInt32.toBitVec_toInt32 (x : UInt32) : x.toInt32.toBitVec = x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem UInt64.toBitVec_toInt64 (x : UInt64) : x.toInt64.toBitVec = x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem USize.toBitVec_toISize (x : USize) : x.toISize.toBitVec = x.toBitVec := (rfl)
+@[simp] theorem UInt8.toBitVec_toInt8 (x : UInt8) : x.toInt8.toBitVec = x.toBitVec := (rfl)
+@[simp] theorem UInt16.toBitVec_toInt16 (x : UInt16) : x.toInt16.toBitVec = x.toBitVec := (rfl)
+@[simp] theorem UInt32.toBitVec_toInt32 (x : UInt32) : x.toInt32.toBitVec = x.toBitVec := (rfl)
+@[simp] theorem UInt64.toBitVec_toInt64 (x : UInt64) : x.toInt64.toBitVec = x.toBitVec := (rfl)
+@[simp] theorem USize.toBitVec_toISize (x : USize) : x.toISize.toBitVec = x.toBitVec := (rfl)
 
 @[simp] theorem Int8.ofBitVec_uInt8ToBitVec (x : UInt8) : Int8.ofBitVec x.toBitVec = x.toInt8 := (rfl)
 @[simp] theorem Int16.ofBitVec_uInt16ToBitVec (x : UInt16) : Int16.ofBitVec x.toBitVec = x.toInt16 := (rfl)
@@ -301,30 +301,30 @@ theorem ISize.toInt_maxValue : ISize.maxValue.toInt = 2 ^ (System.Platform.numBi
 @[simp] theorem Int64.toInt_toBitVec (x : Int64) : x.toBitVec.toInt = x.toInt := (rfl)
 @[simp] theorem ISize.toInt_toBitVec (x : ISize) : x.toBitVec.toInt = x.toInt := (rfl)
 
-@[simp, int_toBitVec] theorem Int8.toBitVec_toInt16 (x : Int8) : x.toInt16.toBitVec = x.toBitVec.signExtend 16 := (rfl)
-@[simp, int_toBitVec] theorem Int8.toBitVec_toInt32 (x : Int8) : x.toInt32.toBitVec = x.toBitVec.signExtend 32 := (rfl)
-@[simp, int_toBitVec] theorem Int8.toBitVec_toInt64 (x : Int8) : x.toInt64.toBitVec = x.toBitVec.signExtend 64 := (rfl)
-@[simp, int_toBitVec] theorem Int8.toBitVec_toISize (x : Int8) : x.toISize.toBitVec = x.toBitVec.signExtend System.Platform.numBits := (rfl)
+@[simp] theorem Int8.toBitVec_toInt16 (x : Int8) : x.toInt16.toBitVec = x.toBitVec.signExtend 16 := (rfl)
+@[simp] theorem Int8.toBitVec_toInt32 (x : Int8) : x.toInt32.toBitVec = x.toBitVec.signExtend 32 := (rfl)
+@[simp] theorem Int8.toBitVec_toInt64 (x : Int8) : x.toInt64.toBitVec = x.toBitVec.signExtend 64 := (rfl)
+@[simp] theorem Int8.toBitVec_toISize (x : Int8) : x.toISize.toBitVec = x.toBitVec.signExtend System.Platform.numBits := (rfl)
 
-@[simp, int_toBitVec] theorem Int16.toBitVec_toInt8 (x : Int16) : x.toInt8.toBitVec = x.toBitVec.signExtend 8 := (rfl)
-@[simp, int_toBitVec] theorem Int16.toBitVec_toInt32 (x : Int16) : x.toInt32.toBitVec = x.toBitVec.signExtend 32 := (rfl)
-@[simp, int_toBitVec] theorem Int16.toBitVec_toInt64 (x : Int16) : x.toInt64.toBitVec = x.toBitVec.signExtend 64 := (rfl)
-@[simp, int_toBitVec] theorem Int16.toBitVec_toISize (x : Int16) : x.toISize.toBitVec = x.toBitVec.signExtend System.Platform.numBits := (rfl)
+@[simp] theorem Int16.toBitVec_toInt8 (x : Int16) : x.toInt8.toBitVec = x.toBitVec.signExtend 8 := (rfl)
+@[simp] theorem Int16.toBitVec_toInt32 (x : Int16) : x.toInt32.toBitVec = x.toBitVec.signExtend 32 := (rfl)
+@[simp] theorem Int16.toBitVec_toInt64 (x : Int16) : x.toInt64.toBitVec = x.toBitVec.signExtend 64 := (rfl)
+@[simp] theorem Int16.toBitVec_toISize (x : Int16) : x.toISize.toBitVec = x.toBitVec.signExtend System.Platform.numBits := (rfl)
 
-@[simp, int_toBitVec] theorem Int32.toBitVec_toInt8 (x : Int32) : x.toInt8.toBitVec = x.toBitVec.signExtend 8 := (rfl)
-@[simp, int_toBitVec] theorem Int32.toBitVec_toInt16 (x : Int32) : x.toInt16.toBitVec = x.toBitVec.signExtend 16 := (rfl)
-@[simp, int_toBitVec] theorem Int32.toBitVec_toInt64 (x : Int32) : x.toInt64.toBitVec = x.toBitVec.signExtend 64 := (rfl)
-@[simp, int_toBitVec] theorem Int32.toBitVec_toISize (x : Int32) : x.toISize.toBitVec = x.toBitVec.signExtend System.Platform.numBits := (rfl)
+@[simp] theorem Int32.toBitVec_toInt8 (x : Int32) : x.toInt8.toBitVec = x.toBitVec.signExtend 8 := (rfl)
+@[simp] theorem Int32.toBitVec_toInt16 (x : Int32) : x.toInt16.toBitVec = x.toBitVec.signExtend 16 := (rfl)
+@[simp] theorem Int32.toBitVec_toInt64 (x : Int32) : x.toInt64.toBitVec = x.toBitVec.signExtend 64 := (rfl)
+@[simp] theorem Int32.toBitVec_toISize (x : Int32) : x.toISize.toBitVec = x.toBitVec.signExtend System.Platform.numBits := (rfl)
 
-@[simp, int_toBitVec] theorem Int64.toBitVec_toInt8 (x : Int64) : x.toInt8.toBitVec = x.toBitVec.signExtend 8 := (rfl)
-@[simp, int_toBitVec] theorem Int64.toBitVec_toInt16 (x : Int64) : x.toInt16.toBitVec = x.toBitVec.signExtend 16 := (rfl)
-@[simp, int_toBitVec] theorem Int64.toBitVec_toInt32 (x : Int64) : x.toInt32.toBitVec = x.toBitVec.signExtend 32 := (rfl)
-@[simp, int_toBitVec] theorem Int64.toBitVec_toISize (x : Int64) : x.toISize.toBitVec = x.toBitVec.signExtend System.Platform.numBits := (rfl)
+@[simp] theorem Int64.toBitVec_toInt8 (x : Int64) : x.toInt8.toBitVec = x.toBitVec.signExtend 8 := (rfl)
+@[simp] theorem Int64.toBitVec_toInt16 (x : Int64) : x.toInt16.toBitVec = x.toBitVec.signExtend 16 := (rfl)
+@[simp] theorem Int64.toBitVec_toInt32 (x : Int64) : x.toInt32.toBitVec = x.toBitVec.signExtend 32 := (rfl)
+@[simp] theorem Int64.toBitVec_toISize (x : Int64) : x.toISize.toBitVec = x.toBitVec.signExtend System.Platform.numBits := (rfl)
 
-@[simp, int_toBitVec] theorem ISize.toBitVec_toInt8 (x : ISize) : x.toInt8.toBitVec = x.toBitVec.signExtend 8 := (rfl)
-@[simp, int_toBitVec] theorem ISize.toBitVec_toInt16 (x : ISize) : x.toInt16.toBitVec = x.toBitVec.signExtend 16 := (rfl)
-@[simp, int_toBitVec] theorem ISize.toBitVec_toInt32 (x : ISize) : x.toInt32.toBitVec = x.toBitVec.signExtend 32 := (rfl)
-@[simp, int_toBitVec] theorem ISize.toBitVec_toInt64 (x : ISize) : x.toInt64.toBitVec = x.toBitVec.signExtend 64 := (rfl)
+@[simp] theorem ISize.toBitVec_toInt8 (x : ISize) : x.toInt8.toBitVec = x.toBitVec.signExtend 8 := (rfl)
+@[simp] theorem ISize.toBitVec_toInt16 (x : ISize) : x.toInt16.toBitVec = x.toBitVec.signExtend 16 := (rfl)
+@[simp] theorem ISize.toBitVec_toInt32 (x : ISize) : x.toInt32.toBitVec = x.toBitVec.signExtend 32 := (rfl)
+@[simp] theorem ISize.toBitVec_toInt64 (x : ISize) : x.toInt64.toBitVec = x.toBitVec.signExtend 64 := (rfl)
 
 theorem Int8.toInt_lt (x : Int8) : x.toInt < 2 ^ 7 := Int.lt_of_mul_lt_mul_left BitVec.two_mul_toInt_lt (by decide)
 theorem Int8.le_toInt (x : Int8) : -2 ^ 7 ≤ x.toInt := Int.le_of_mul_le_mul_left BitVec.le_two_mul_toInt (by decide)
@@ -507,11 +507,11 @@ theorem Int32.toFin_toBitVec (x : Int32) : x.toBitVec.toFin = x.toUInt32.toFin :
 theorem Int64.toFin_toBitVec (x : Int64) : x.toBitVec.toFin = x.toUInt64.toFin := (rfl)
 theorem ISize.toFin_toBitVec (x : ISize) : x.toBitVec.toFin = x.toUSize.toFin := (rfl)
 
-@[simp, int_toBitVec] theorem Int8.toBitVec_toUInt8 (x : Int8) : x.toUInt8.toBitVec = x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem Int16.toBitVec_toUInt16 (x : Int16) : x.toUInt16.toBitVec = x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem Int32.toBitVec_toUInt32 (x : Int32) : x.toUInt32.toBitVec = x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem Int64.toBitVec_toUInt64 (x : Int64) : x.toUInt64.toBitVec = x.toBitVec := (rfl)
-@[simp, int_toBitVec] theorem ISize.toBitVec_toUSize (x : ISize) : x.toUSize.toBitVec = x.toBitVec := (rfl)
+@[simp] theorem Int8.toBitVec_toUInt8 (x : Int8) : x.toUInt8.toBitVec = x.toBitVec := (rfl)
+@[simp] theorem Int16.toBitVec_toUInt16 (x : Int16) : x.toUInt16.toBitVec = x.toBitVec := (rfl)
+@[simp] theorem Int32.toBitVec_toUInt32 (x : Int32) : x.toUInt32.toBitVec = x.toBitVec := (rfl)
+@[simp] theorem Int64.toBitVec_toUInt64 (x : Int64) : x.toUInt64.toBitVec = x.toBitVec := (rfl)
+@[simp] theorem ISize.toBitVec_toUSize (x : ISize) : x.toUSize.toBitVec = x.toBitVec := (rfl)
 
 @[simp] theorem UInt8.ofBitVec_int8ToBitVec (x : Int8) : UInt8.ofBitVec x.toBitVec = x.toUInt8 := (rfl)
 @[simp] theorem UInt16.ofBitVec_int16ToBitVec (x : Int16) : UInt16.ofBitVec x.toBitVec = x.toUInt16 := (rfl)
@@ -1001,11 +1001,11 @@ theorem USize.toISize_ofNatLT {n : Nat} (hn) : (USize.ofNatLT n hn).toISize = IS
 @[simp] theorem UInt64.toInt64_ofBitVec (b) : (UInt64.ofBitVec b).toInt64 = Int64.ofBitVec b := (rfl)
 @[simp] theorem USize.toISize_ofBitVec (b) : (USize.ofBitVec b).toISize = ISize.ofBitVec b := (rfl)
 
-@[simp, int_toBitVec] theorem Int8.toBitVec_ofBitVec (b) : (Int8.ofBitVec b).toBitVec = b := (rfl)
-@[simp, int_toBitVec] theorem Int16.toBitVec_ofBitVec (b) : (Int16.ofBitVec b).toBitVec = b := (rfl)
-@[simp, int_toBitVec] theorem Int32.toBitVec_ofBitVec (b) : (Int32.ofBitVec b).toBitVec = b := (rfl)
-@[simp, int_toBitVec] theorem Int64.toBitVec_ofBitVec (b) : (Int64.ofBitVec b).toBitVec = b := (rfl)
-@[simp, int_toBitVec] theorem ISize.toBitVec_ofBitVec (b) : (ISize.ofBitVec b).toBitVec = b := (rfl)
+@[simp] theorem Int8.toBitVec_ofBitVec (b) : (Int8.ofBitVec b).toBitVec = b := (rfl)
+@[simp] theorem Int16.toBitVec_ofBitVec (b) : (Int16.ofBitVec b).toBitVec = b := (rfl)
+@[simp] theorem Int32.toBitVec_ofBitVec (b) : (Int32.ofBitVec b).toBitVec = b := (rfl)
+@[simp] theorem Int64.toBitVec_ofBitVec (b) : (Int64.ofBitVec b).toBitVec = b := (rfl)
+@[simp] theorem ISize.toBitVec_ofBitVec (b) : (ISize.ofBitVec b).toBitVec = b := (rfl)
 
 theorem Int8.toBitVec_ofIntTruncate {n : Int} (h₁ : Int8.minValue.toInt ≤ n) (h₂ : n ≤ Int8.maxValue.toInt) :
     (Int8.ofIntTruncate n).toBitVec = BitVec.ofInt _ n := by
@@ -1069,7 +1069,7 @@ theorem Int8.toNatClampNeg_ofIntTruncate_of_lt {n : Int} (h₁ : n < 2 ^ 7) :
   rw [ofIntTruncate]
   split
   · rw [dif_pos (by rw [toInt_maxValue]; omega), toNatClampNeg_ofIntLE]
-  next h =>
+  · next h =>
     rw [toNatClampNeg_minValue, eq_comm, Int.toNat_eq_zero]
     rw [toInt_minValue] at h
     omega
@@ -1078,7 +1078,7 @@ theorem Int16.toNatClampNeg_ofIntTruncate_of_lt {n : Int} (h₁ : n < 2 ^ 15) :
   rw [ofIntTruncate]
   split
   · rw [dif_pos (by rw [toInt_maxValue]; omega), toNatClampNeg_ofIntLE]
-  next h =>
+  · next h =>
     rw [toNatClampNeg_minValue, eq_comm, Int.toNat_eq_zero]
     rw [toInt_minValue] at h
     omega
@@ -1087,7 +1087,7 @@ theorem Int32.toNatClampNeg_ofIntTruncate_of_lt {n : Int} (h₁ : n < 2 ^ 31) :
   rw [ofIntTruncate]
   split
   · rw [dif_pos (by rw [toInt_maxValue]; omega), toNatClampNeg_ofIntLE]
-  next h =>
+  · next h =>
     rw [toNatClampNeg_minValue, eq_comm, Int.toNat_eq_zero]
     rw [toInt_minValue] at h
     omega
@@ -1096,7 +1096,7 @@ theorem Int64.toNatClampNeg_ofIntTruncate_of_lt {n : Int} (h₁ : n < 2 ^ 63) :
   rw [ofIntTruncate]
   split
   · rw [dif_pos (by rw [toInt_maxValue]; omega), toNatClampNeg_ofIntLE]
-  next h =>
+  · next h =>
     rw [toNatClampNeg_minValue, eq_comm, Int.toNat_eq_zero]
     rw [toInt_minValue] at h
     omega
@@ -1105,7 +1105,7 @@ theorem ISize.toNatClampNeg_ofIntTruncate_of_lt_two_pow_numBits {n : Int} (h₁
   rw [ofIntTruncate]
   split
   · rw [dif_pos (by rw [toInt_maxValue]; omega), toNatClampNeg_ofIntLE]
-  next h =>
+  · next h =>
     rw [toNatClampNeg_minValue, eq_comm, Int.toNat_eq_zero]
     rw [toInt_minValue] at h
     omega
@@ -1281,11 +1281,11 @@ theorem Int64.toISize_ofIntTruncate {n : Int} (h₁ : -2 ^ 63 ≤ n) (h₂ : n <
     (Int64.ofIntTruncate n).toISize = ISize.ofInt n := by
   rw [← ofIntLE_eq_ofIntTruncate (h₁ := h₁) (h₂ := Int.le_of_lt_add_one h₂), toISize_ofIntLE]
 
-@[simp, int_toBitVec] theorem Int8.toBitVec_minValue : minValue.toBitVec = BitVec.intMin _ := (rfl)
-@[simp, int_toBitVec] theorem Int16.toBitVec_minValue : minValue.toBitVec = BitVec.intMin _ := (rfl)
-@[simp, int_toBitVec] theorem Int32.toBitVec_minValue : minValue.toBitVec = BitVec.intMin _ := (rfl)
-@[simp, int_toBitVec] theorem Int64.toBitVec_minValue : minValue.toBitVec = BitVec.intMin _ := (rfl)
-@[simp, int_toBitVec] theorem ISize.toBitVec_minValue : minValue.toBitVec = BitVec.intMin _ :=
+@[simp] theorem Int8.toBitVec_minValue : minValue.toBitVec = BitVec.intMin _ := (rfl)
+@[simp] theorem Int16.toBitVec_minValue : minValue.toBitVec = BitVec.intMin _ := (rfl)
+@[simp] theorem Int32.toBitVec_minValue : minValue.toBitVec = BitVec.intMin _ := (rfl)
+@[simp] theorem Int64.toBitVec_minValue : minValue.toBitVec = BitVec.intMin _ := (rfl)
+@[simp] theorem ISize.toBitVec_minValue : minValue.toBitVec = BitVec.intMin _ :=
   BitVec.eq_of_toInt_eq (by rw [toInt_toBitVec, toInt_minValue,
     BitVec.toInt_intMin_of_pos (by cases System.Platform.numBits_eq <;> simp_all)])
 

src/Init/Data/Slice/Array/Iterator.lean

@@ -99,34 +99,17 @@ none
 def Subarray.foldlM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (init : β) (as : Subarray α) : m β :=
   Slice.foldlM f (init := init) as
 
-/--
-Folds an operation from left to right over the elements in a subarray.
-An accumulator of type `β` is constructed by starting with `init` and combining each
-element of the subarray with the current accumulator value in turn.
-Examples:
- * `#["red", "green", "blue"].toSubarray.foldl (· + ·.length) 0 = 12`
- * `#["red", "green", "blue"].toSubarray.popFront.foldl (· + ·.length) 0 = 9`
--/
-@[inline]
-def Subarray.foldl {α : Type u} {β : Type v} (f : β → α → β) (init : β) (as : Subarray α) : β :=
-  Slice.foldl f (init := init) as
-
-/--
-The implementation of `ForIn.forIn` for `Subarray`, which allows it to be used with `for` loops in
-`do`-notation.
--/
-@[inline]
-def Subarray.forIn {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (s : Subarray α) (b : β) (f : α → β → m (ForInStep β)) : m β :=
-  ForIn.forIn s b f
-
 namespace Array
 
 /--
 Allocates a new array that contains the contents of the subarray.
 -/
 @[coe]
-def ofSubarray (s : Subarray α) : Array α :=
-  Slice.toArray s
+def ofSubarray (s : Subarray α) : Array α := Id.run do
+  let mut as := mkEmpty (s.stop - s.start)
+  for a in s do
+    as := as.push a
+  return as
 
 instance : Coe (Subarray α) (Array α) := ⟨ofSubarray⟩
 
@@ -146,7 +129,3 @@ instance [ToString α] : ToString (Subarray α) where
   toString s := toString s.toArray
 
 end Array
-
-@[inherit_doc Array.ofSubarray]
-def Subarray.toArray (s : Subarray α) : Array α :=
-  Array.ofSubarray s

src/Init/Data/String/Basic.lean

@@ -36,7 +36,7 @@ instance : LT String :=
 instance decidableLT (s₁ s₂ : @& String) : Decidable (s₁ < s₂) :=
   List.decidableLT s₁.data s₂.data
 
-
+@[deprecated decidableLT (since := "2024-12-13")] abbrev decLt := @decidableLT
 
 /--
 Non-strict inequality on strings, typically used via the `≤` operator.
@@ -220,22 +220,22 @@ If both the replacement character and the replaced character are 7-bit ASCII cha
 string is not shared, then it is updated in-place and not copied.
 
 Examples:
-* `"abc".modify ⟨1⟩ Char.toUpper = "aBc"`
-* `"abc".modify ⟨3⟩ Char.toUpper = "abc"`
+* `abc.modify ⟨1⟩ Char.toUpper = "aBc"`
+* `abc.modify ⟨3⟩ Char.toUpper = "abc"`
 -/
 def modify (s : String) (i : Pos) (f : Char → Char) : String :=
   s.set i <| f <| s.get i
 
 /--
-Returns the next position in a string after position `p`. If `p` is not a valid position or
-`p = s.endPos`, returns the position one byte after `p`.
+Returns the next position in a string after position `p`. The result is unspecified if `p` is not a
+valid position or if `p = s.endPos`.
 
 A run-time bounds check is performed to determine whether `p` is at the end of the string. If a
 bounds check has already been performed, use `String.next'` to avoid a repeated check.
 
-Some examples of edge cases:
-* `"abc".next ⟨3⟩ = ⟨4⟩`, since `3 = "abc".endPos`
-* `"L∃∀N".next ⟨2⟩ = ⟨3⟩`, since `2` points into the middle of a multi-byte UTF-8 character
+Some examples where the result is unspecified:
+* `"abc".next ⟨3⟩`, since `3 = "abc".endPos`
+* `"L∃∀N".next ⟨2⟩`, since `2` points into the middle of a multi-byte UTF-8 character
 
 Examples:
 * `"abc".get ("abc".next 0) = 'b'`
@@ -247,18 +247,17 @@ def next (s : @& String) (p : @& Pos) : Pos :=
   p + c
 
 def utf8PrevAux : List Char → Pos → Pos → Pos
-  | [],    _, p => ⟨p.byteIdx - 1⟩
+  | [],    _, _ => 0
   | c::cs, i, p =>
     let i' := i + c
-    if p ≤ i' then i else utf8PrevAux cs i' p
+    if i' = p then i else utf8PrevAux cs i' p
 
 /--
 Returns the position in a string before a specified position, `p`. If `p = ⟨0⟩`, returns `0`. If `p`
-is greater than `endPos`, returns the position one byte before `p`. Otherwise, if `p` occurs in the
-middle of a multi-byte character, returns the beginning position of that character.
+is not a valid position, the result is unspecified.
 
-For example, `"L∃∀N".prev ⟨3⟩` is `⟨1⟩`, since byte 3 occurs in the middle of the multi-byte
-character `'∃'` that starts at byte 1.
+For example, `"L∃∀N".prev ⟨3⟩` is unspecified, since byte 3 occurs in the middle of the multi-byte
+character `'∃'`.
 
 Examples:
 * `"abc".get ("abc".endPos |> "abc".prev) = 'c'`
@@ -266,7 +265,7 @@ Examples:
 -/
 @[extern "lean_string_utf8_prev", expose]
 def prev : (@& String) → (@& Pos) → Pos
-  | ⟨s⟩, p => utf8PrevAux s 0 p
+  | ⟨s⟩, p => if p = 0 then 0 else utf8PrevAux s 0 p
 
 /--
 Returns the first character in `s`. If `s = ""`, returns `(default : Char)`.
@@ -301,7 +300,7 @@ Examples:
 * `"L∃∀N".atEnd ⟨7⟩ = false`
 * `"L∃∀N".atEnd ⟨8⟩ = true`
 -/
-@[extern "lean_string_utf8_at_end", expose]
+@[extern "lean_string_utf8_at_end"]
 def atEnd : (@& String) → (@& Pos) → Bool
   | s, p => p.byteIdx ≥ utf8ByteSize s
 
@@ -340,7 +339,7 @@ Requires evidence, `h`, that `p` is within bounds. No run-time bounds check is p
 A typical pattern combines `String.next'` with a dependent `if`-expression to avoid the overhead of
 an additional bounds check. For example:
 ```
-def next? (s : String) (p : String.Pos) : Option Char :=
+def next? (s: String) (p : String.Pos) : Option Char :=
   if h : s.atEnd p then none else s.get (s.next' p h)
 ```
 
@@ -370,17 +369,20 @@ protected theorem Pos.ne_zero_of_lt : {a b : Pos} → a < b → b ≠ 0
 theorem lt_next (s : String) (i : Pos) : i.1 < (s.next i).1 :=
   Nat.add_lt_add_left (Char.utf8Size_pos _) _
 
-theorem utf8PrevAux_lt_of_pos : ∀ (cs : List Char) (i p : Pos), i < p → p ≠ 0 →
+theorem utf8PrevAux_lt_of_pos : ∀ (cs : List Char) (i p : Pos), p ≠ 0 →
     (utf8PrevAux cs i p).1 < p.1
-  | [], _, _, _, h => Nat.sub_one_lt (mt (congrArg Pos.mk) h)
-  | c::cs, i, p, h, h' => by
+  | [], _, _, h =>
+    Nat.lt_of_le_of_lt (Nat.zero_le _)
+      (Nat.zero_lt_of_ne_zero (mt (congrArg Pos.mk) h))
+  | c::cs, i, p, h => by
     simp [utf8PrevAux]
-    apply iteInduction (motive := (Pos.byteIdx · < _)) <;> intro h''
-    next => exact h
-    next => exact utf8PrevAux_lt_of_pos _ _ _ (Nat.lt_of_not_le h'') h'
+    apply iteInduction (motive := (Pos.byteIdx · < _)) <;> intro h'
+    next => exact h' ▸ Nat.add_lt_add_left (Char.utf8Size_pos _) _
+    next => exact utf8PrevAux_lt_of_pos _ _ _ h
 
-theorem prev_lt_of_pos (s : String) (i : Pos) (h : i ≠ 0) : (s.prev i).1 < i.1 :=
-  utf8PrevAux_lt_of_pos _ _ _ (Nat.zero_lt_of_ne_zero (mt (congrArg Pos.mk) h)) h
+theorem prev_lt_of_pos (s : String) (i : Pos) (h : i ≠ 0) : (s.prev i).1 < i.1 := by
+  simp [prev, h]
+  exact utf8PrevAux_lt_of_pos _ _ _ h
 
 def posOfAux (s : String) (c : Char) (stopPos : Pos) (pos : Pos) : Pos :=
   if h : pos < stopPos then
@@ -417,7 +419,7 @@ Returns the position of the last occurrence of a character, `c`, in a string `s`
 contain `c`, returns `none`.
 
 Examples:
-* `"abcabc".revPosOf 'a' = some ⟨3⟩`
+* `"abcabc".refPosOf 'a' = some ⟨3⟩`
 * `"abcabc".revPosOf 'z' = none`
 * `"L∃∀N".revPosOf '∀' = some ⟨4⟩`
 -/
@@ -652,7 +654,7 @@ Use `String.intercalate` to place a separator string between the strings in a li
 
 Examples:
  * `String.join ["gr", "ee", "n"] = "green"`
- * `String.join ["b", "", "l", "", "ue"] = "blue"`
+ * `String.join ["b", "", "l", "", "ue"] = "red"`
  * `String.join [] = ""`
 -/
 @[inline] def join (l : List String) : String :=
@@ -2066,11 +2068,7 @@ end Pos
 
 theorem lt_next' (s : String) (p : Pos) : p < next s p := lt_next ..
 
-@[simp] theorem prev_zero (s : String) : prev s 0 = 0 := by
-  cases s with | mk cs
-  cases cs
-  next => rfl
-  next => simp [prev, utf8PrevAux, Pos.le_iff]
+@[simp] theorem prev_zero (s : String) : prev s 0 = 0 := rfl
 
 @[simp] theorem get'_eq (s : String) (p : Pos) (h) : get' s p h = get s p := rfl
 

src/Init/Data/UInt/Basic.lean

@@ -9,7 +9,7 @@ prelude
 public import Init.Data.UInt.BasicAux
 public import Init.Data.BitVec.Basic
 
-@[expose] public section
+public section
 
 set_option linter.missingDocs true
 
@@ -183,7 +183,7 @@ instance : Complement UInt8 := ⟨UInt8.complement⟩
 instance : Neg UInt8 := ⟨UInt8.neg⟩
 instance : AndOp UInt8     := ⟨UInt8.land⟩
 instance : OrOp UInt8      := ⟨UInt8.lor⟩
-instance : XorOp UInt8       := ⟨UInt8.xor⟩
+instance : Xor UInt8       := ⟨UInt8.xor⟩
 instance : ShiftLeft UInt8  := ⟨UInt8.shiftLeft⟩
 instance : ShiftRight UInt8 := ⟨UInt8.shiftRight⟩
 
@@ -397,7 +397,7 @@ instance : Complement UInt16 := ⟨UInt16.complement⟩
 instance : Neg UInt16 := ⟨UInt16.neg⟩
 instance : AndOp UInt16     := ⟨UInt16.land⟩
 instance : OrOp UInt16      := ⟨UInt16.lor⟩
-instance : XorOp UInt16       := ⟨UInt16.xor⟩
+instance : Xor UInt16       := ⟨UInt16.xor⟩
 instance : ShiftLeft UInt16  := ⟨UInt16.shiftLeft⟩
 instance : ShiftRight UInt16 := ⟨UInt16.shiftRight⟩
 
@@ -614,7 +614,7 @@ instance : Complement UInt32 := ⟨UInt32.complement⟩
 instance : Neg UInt32 := ⟨UInt32.neg⟩
 instance : AndOp UInt32     := ⟨UInt32.land⟩
 instance : OrOp UInt32      := ⟨UInt32.lor⟩
-instance : XorOp UInt32       := ⟨UInt32.xor⟩
+instance : Xor UInt32       := ⟨UInt32.xor⟩
 instance : ShiftLeft UInt32  := ⟨UInt32.shiftLeft⟩
 instance : ShiftRight UInt32 := ⟨UInt32.shiftRight⟩
 
@@ -792,7 +792,7 @@ instance : Complement UInt64 := ⟨UInt64.complement⟩
 instance : Neg UInt64 := ⟨UInt64.neg⟩
 instance : AndOp UInt64     := ⟨UInt64.land⟩
 instance : OrOp UInt64      := ⟨UInt64.lor⟩
-instance : XorOp UInt64       := ⟨UInt64.xor⟩
+instance : Xor UInt64       := ⟨UInt64.xor⟩
 instance : ShiftLeft UInt64  := ⟨UInt64.shiftLeft⟩
 instance : ShiftRight UInt64 := ⟨UInt64.shiftRight⟩
 
@@ -1056,7 +1056,7 @@ instance : Complement USize := ⟨USize.complement⟩
 instance : Neg USize := ⟨USize.neg⟩
 instance : AndOp USize      := ⟨USize.land⟩
 instance : OrOp USize       := ⟨USize.lor⟩
-instance : XorOp USize        := ⟨USize.xor⟩
+instance : Xor USize        := ⟨USize.xor⟩
 instance : ShiftLeft USize  := ⟨USize.shiftLeft⟩
 instance : ShiftRight USize := ⟨USize.shiftRight⟩
 

src/Init/Data/UInt/Lemmas.lean

@@ -473,34 +473,34 @@ theorem USize.size_dvd_uInt64Size : USize.size ∣ UInt64.size := by cases USize
 
 @[simp] theorem USize.toFin_toUInt64 (n : USize) : n.toUInt64.toFin = n.toFin.castLE size_le_uint64Size := (rfl)
 
-@[simp, int_toBitVec] theorem UInt16.toBitVec_toUInt8 (n : UInt16) : n.toUInt8.toBitVec = n.toBitVec.setWidth 8 := (rfl)
-@[simp, int_toBitVec] theorem UInt32.toBitVec_toUInt8 (n : UInt32) : n.toUInt8.toBitVec = n.toBitVec.setWidth 8 := (rfl)
-@[simp, int_toBitVec] theorem UInt64.toBitVec_toUInt8 (n : UInt64) : n.toUInt8.toBitVec = n.toBitVec.setWidth 8 := (rfl)
-@[simp, int_toBitVec] theorem USize.toBitVec_toUInt8 (n : USize) : n.toUInt8.toBitVec = n.toBitVec.setWidth 8 := BitVec.eq_of_toNat_eq (by simp)
+@[simp] theorem UInt16.toBitVec_toUInt8 (n : UInt16) : n.toUInt8.toBitVec = n.toBitVec.setWidth 8 := (rfl)
+@[simp] theorem UInt32.toBitVec_toUInt8 (n : UInt32) : n.toUInt8.toBitVec = n.toBitVec.setWidth 8 := (rfl)
+@[simp] theorem UInt64.toBitVec_toUInt8 (n : UInt64) : n.toUInt8.toBitVec = n.toBitVec.setWidth 8 := (rfl)
+@[simp] theorem USize.toBitVec_toUInt8 (n : USize) : n.toUInt8.toBitVec = n.toBitVec.setWidth 8 := BitVec.eq_of_toNat_eq (by simp)
 
-@[simp, int_toBitVec] theorem UInt8.toBitVec_toUInt16 (n : UInt8) : n.toUInt16.toBitVec = n.toBitVec.setWidth 16 := (rfl)
-@[simp, int_toBitVec] theorem UInt32.toBitVec_toUInt16 (n : UInt32) : n.toUInt16.toBitVec = n.toBitVec.setWidth 16 := (rfl)
-@[simp, int_toBitVec] theorem UInt64.toBitVec_toUInt16 (n : UInt64) : n.toUInt16.toBitVec = n.toBitVec.setWidth 16 := (rfl)
-@[simp, int_toBitVec] theorem USize.toBitVec_toUInt16 (n : USize) : n.toUInt16.toBitVec = n.toBitVec.setWidth 16 := BitVec.eq_of_toNat_eq (by simp)
+@[simp] theorem UInt8.toBitVec_toUInt16 (n : UInt8) : n.toUInt16.toBitVec = n.toBitVec.setWidth 16 := (rfl)
+@[simp] theorem UInt32.toBitVec_toUInt16 (n : UInt32) : n.toUInt16.toBitVec = n.toBitVec.setWidth 16 := (rfl)
+@[simp] theorem UInt64.toBitVec_toUInt16 (n : UInt64) : n.toUInt16.toBitVec = n.toBitVec.setWidth 16 := (rfl)
+@[simp] theorem USize.toBitVec_toUInt16 (n : USize) : n.toUInt16.toBitVec = n.toBitVec.setWidth 16 := BitVec.eq_of_toNat_eq (by simp)
 
-@[simp, int_toBitVec] theorem UInt8.toBitVec_toUInt32 (n : UInt8) : n.toUInt32.toBitVec = n.toBitVec.setWidth 32 := (rfl)
-@[simp, int_toBitVec] theorem UInt16.toBitVec_toUInt32 (n : UInt16) : n.toUInt32.toBitVec = n.toBitVec.setWidth 32 := (rfl)
-@[simp, int_toBitVec] theorem UInt64.toBitVec_toUInt32 (n : UInt64) : n.toUInt32.toBitVec = n.toBitVec.setWidth 32 := (rfl)
-@[simp, int_toBitVec] theorem USize.toBitVec_toUInt32 (n : USize) : n.toUInt32.toBitVec = n.toBitVec.setWidth 32 := BitVec.eq_of_toNat_eq (by simp)
+@[simp] theorem UInt8.toBitVec_toUInt32 (n : UInt8) : n.toUInt32.toBitVec = n.toBitVec.setWidth 32 := (rfl)
+@[simp] theorem UInt16.toBitVec_toUInt32 (n : UInt16) : n.toUInt32.toBitVec = n.toBitVec.setWidth 32 := (rfl)
+@[simp] theorem UInt64.toBitVec_toUInt32 (n : UInt64) : n.toUInt32.toBitVec = n.toBitVec.setWidth 32 := (rfl)
+@[simp] theorem USize.toBitVec_toUInt32 (n : USize) : n.toUInt32.toBitVec = n.toBitVec.setWidth 32 := BitVec.eq_of_toNat_eq (by simp)
 
-@[simp, int_toBitVec] theorem UInt8.toBitVec_toUInt64 (n : UInt8) : n.toUInt64.toBitVec = n.toBitVec.setWidth 64 := (rfl)
-@[simp, int_toBitVec] theorem UInt16.toBitVec_toUInt64 (n : UInt16) : n.toUInt64.toBitVec = n.toBitVec.setWidth 64 := (rfl)
-@[simp, int_toBitVec] theorem UInt32.toBitVec_toUInt64 (n : UInt32) : n.toUInt64.toBitVec = n.toBitVec.setWidth 64 := (rfl)
-@[simp, int_toBitVec] theorem USize.toBitVec_toUInt64 (n : USize) : n.toUInt64.toBitVec = n.toBitVec.setWidth 64 :=
+@[simp] theorem UInt8.toBitVec_toUInt64 (n : UInt8) : n.toUInt64.toBitVec = n.toBitVec.setWidth 64 := (rfl)
+@[simp] theorem UInt16.toBitVec_toUInt64 (n : UInt16) : n.toUInt64.toBitVec = n.toBitVec.setWidth 64 := (rfl)
+@[simp] theorem UInt32.toBitVec_toUInt64 (n : UInt32) : n.toUInt64.toBitVec = n.toBitVec.setWidth 64 := (rfl)
+@[simp] theorem USize.toBitVec_toUInt64 (n : USize) : n.toUInt64.toBitVec = n.toBitVec.setWidth 64 :=
   BitVec.eq_of_toNat_eq (by simp)
 
-@[simp, int_toBitVec] theorem UInt8.toBitVec_toUSize (n : UInt8) : n.toUSize.toBitVec = n.toBitVec.setWidth System.Platform.numBits :=
+@[simp] theorem UInt8.toBitVec_toUSize (n : UInt8) : n.toUSize.toBitVec = n.toBitVec.setWidth System.Platform.numBits :=
   BitVec.eq_of_toNat_eq (by simp)
-@[simp, int_toBitVec] theorem UInt16.toBitVec_toUSize (n : UInt16) : n.toUSize.toBitVec = n.toBitVec.setWidth System.Platform.numBits :=
+@[simp] theorem UInt16.toBitVec_toUSize (n : UInt16) : n.toUSize.toBitVec = n.toBitVec.setWidth System.Platform.numBits :=
   BitVec.eq_of_toNat_eq (by simp)
-@[simp, int_toBitVec] theorem UInt32.toBitVec_toUSize (n : UInt32) : n.toUSize.toBitVec = n.toBitVec.setWidth System.Platform.numBits :=
+@[simp] theorem UInt32.toBitVec_toUSize (n : UInt32) : n.toUSize.toBitVec = n.toBitVec.setWidth System.Platform.numBits :=
   BitVec.eq_of_toNat_eq (by simp)
-@[simp, int_toBitVec] theorem UInt64.toBitVec_toUSize (n : UInt64) : n.toUSize.toBitVec = n.toBitVec.setWidth System.Platform.numBits :=
+@[simp] theorem UInt64.toBitVec_toUSize (n : UInt64) : n.toUSize.toBitVec = n.toBitVec.setWidth System.Platform.numBits :=
   BitVec.eq_of_toNat_eq (by simp)
 
 @[simp] theorem UInt8.ofNatLT_toNat (n : UInt8) : UInt8.ofNatLT n.toNat n.toNat_lt = n := (rfl)
@@ -885,9 +885,9 @@ theorem USize.ofNatTruncate_eq_ofNat (n : Nat) (hn : n < USize.size) :
   apply USize.toNat.inj
   simp only [UInt32.toNat_toUSize, toNat_toUInt32, Nat.reducePow, USize.toNat_mod]
   cases USize.size_eq
-  next h => rw [Nat.mod_eq_of_lt (h ▸ n.toNat_lt_size), USize.toNat_ofNat,
+  · next h => rw [Nat.mod_eq_of_lt (h ▸ n.toNat_lt_size), USize.toNat_ofNat,
       ← USize.size_eq_two_pow, h, Nat.mod_self, Nat.mod_zero]
-  next h => rw [USize.toNat_ofNat_of_lt]; simp_all
+  · next h => rw [USize.toNat_ofNat_of_lt]; simp_all
 
 -- Note: we are currently missing the following four results for which there does not seem to
 -- be a good candidate for the RHS:
@@ -973,28 +973,28 @@ theorem USize.toFin_ofNatTruncate_of_le {n : Nat} (hn : USize.size ≤ n) :
     (USize.ofNatTruncate n).toFin = ⟨USize.size - 1, by cases USize.size_eq <;> simp_all⟩ :=
   Fin.val_inj.1 (by simp [toNat_ofNatTruncate_of_le hn])
 
-@[simp, int_toBitVec] theorem UInt8.toBitVec_ofNatLT {n : Nat} (hn : n < UInt8.size) :
+@[simp] theorem UInt8.toBitVec_ofNatLT {n : Nat} (hn : n < UInt8.size) :
     (UInt8.ofNatLT n hn).toBitVec = BitVec.ofNatLT n hn := (rfl)
-@[simp, int_toBitVec] theorem UInt16.toBitVec_ofNatLT {n : Nat} (hn : n < UInt16.size) :
+@[simp] theorem UInt16.toBitVec_ofNatLT {n : Nat} (hn : n < UInt16.size) :
     (UInt16.ofNatLT n hn).toBitVec = BitVec.ofNatLT n hn := (rfl)
-@[simp, int_toBitVec] theorem UInt32.toBitVec_ofNatLT {n : Nat} (hn : n < UInt32.size) :
+@[simp] theorem UInt32.toBitVec_ofNatLT {n : Nat} (hn : n < UInt32.size) :
     (UInt32.ofNatLT n hn).toBitVec = BitVec.ofNatLT n hn := (rfl)
-@[simp, int_toBitVec] theorem UInt64.toBitVec_ofNatLT {n : Nat} (hn : n < UInt64.size) :
+@[simp] theorem UInt64.toBitVec_ofNatLT {n : Nat} (hn : n < UInt64.size) :
     (UInt64.ofNatLT n hn).toBitVec = BitVec.ofNatLT n hn := (rfl)
-@[simp, int_toBitVec] theorem USize.toBitVec_ofNatLT {n : Nat} (hn : n < USize.size) :
+@[simp] theorem USize.toBitVec_ofNatLT {n : Nat} (hn : n < USize.size) :
     (USize.ofNatLT n hn).toBitVec = BitVec.ofNatLT n hn := (rfl)
 
-@[simp, int_toBitVec] theorem UInt8.toBitVec_ofFin (n : Fin UInt8.size) : (UInt8.ofFin n).toBitVec = BitVec.ofFin n := (rfl)
-@[simp, int_toBitVec] theorem UInt16.toBitVec_ofFin (n : Fin UInt16.size) : (UInt16.ofFin n).toBitVec = BitVec.ofFin n := (rfl)
-@[simp, int_toBitVec] theorem UInt32.toBitVec_ofFin (n : Fin UInt32.size) : (UInt32.ofFin n).toBitVec = BitVec.ofFin n := (rfl)
-@[simp, int_toBitVec] theorem UInt64.toBitVec_ofFin (n : Fin UInt64.size) : (UInt64.ofFin n).toBitVec = BitVec.ofFin n := (rfl)
-@[simp, int_toBitVec] theorem USize.toBitVec_ofFin (n : Fin USize.size) : (USize.ofFin n).toBitVec = BitVec.ofFin n := (rfl)
+@[simp] theorem UInt8.toBitVec_ofFin (n : Fin UInt8.size) : (UInt8.ofFin n).toBitVec = BitVec.ofFin n := (rfl)
+@[simp] theorem UInt16.toBitVec_ofFin (n : Fin UInt16.size) : (UInt16.ofFin n).toBitVec = BitVec.ofFin n := (rfl)
+@[simp] theorem UInt32.toBitVec_ofFin (n : Fin UInt32.size) : (UInt32.ofFin n).toBitVec = BitVec.ofFin n := (rfl)
+@[simp] theorem UInt64.toBitVec_ofFin (n : Fin UInt64.size) : (UInt64.ofFin n).toBitVec = BitVec.ofFin n := (rfl)
+@[simp] theorem USize.toBitVec_ofFin (n : Fin USize.size) : (USize.ofFin n).toBitVec = BitVec.ofFin n := (rfl)
 
-@[simp, int_toBitVec] theorem UInt8.toBitVec_ofBitVec (n) : (UInt8.ofBitVec n).toBitVec = n := (rfl)
-@[simp, int_toBitVec] theorem UInt16.toBitVec_ofBitVec (n) : (UInt16.ofBitVec n).toBitVec = n := (rfl)
-@[simp, int_toBitVec] theorem UInt32.toBitVec_ofBitVec (n) : (UInt32.ofBitVec n).toBitVec = n := (rfl)
-@[simp, int_toBitVec] theorem UInt64.toBitVec_ofBitVec (n) : (UInt64.ofBitVec n).toBitVec = n := (rfl)
-@[simp, int_toBitVec] theorem USize.toBitVec_ofBitVec (n) : (USize.ofBitVec n).toBitVec = n := (rfl)
+@[simp] theorem UInt8.toBitVec_ofBitVec (n) : (UInt8.ofBitVec n).toBitVec = n := (rfl)
+@[simp] theorem UInt16.toBitVec_ofBitVec (n) : (UInt16.ofBitVec n).toBitVec = n := (rfl)
+@[simp] theorem UInt32.toBitVec_ofBitVec (n) : (UInt32.ofBitVec n).toBitVec = n := (rfl)
+@[simp] theorem UInt64.toBitVec_ofBitVec (n) : (UInt64.ofBitVec n).toBitVec = n := (rfl)
+@[simp] theorem USize.toBitVec_ofBitVec (n) : (USize.ofBitVec n).toBitVec = n := (rfl)
 
 theorem UInt8.toBitVec_ofNatTruncate_of_lt {n : Nat} (hn : n < UInt8.size) :
     (UInt8.ofNatTruncate n).toBitVec = BitVec.ofNatLT n hn :=
@@ -2770,28 +2770,6 @@ protected theorem UInt64.pow_succ (x : UInt64) (n : Nat) : x ^ (n + 1) = x ^ n *
 @[simp] protected theorem USize.pow_zero (x : USize) : x ^ 0 = 1 := (rfl)
 protected theorem USize.pow_succ (x : USize) (n : Nat) : x ^ (n + 1) = x ^ n * x := (rfl)
 
-@[simp, int_toBitVec] protected theorem UInt8.toBitVec_pow (a : UInt8) (n : Nat) : (a ^ n).toBitVec = a.toBitVec ^ n := by
-  induction n <;> simp [*, UInt8.pow_succ, BitVec.pow_succ]
-@[simp, int_toBitVec] protected theorem UInt16.toBitVec_pow (a : UInt16) (n : Nat) : (a ^ n).toBitVec = a.toBitVec ^ n := by
-  induction n <;> simp [*, UInt16.pow_succ, BitVec.pow_succ]
-@[simp, int_toBitVec] protected theorem UInt32.toBitVec_pow (a : UInt32) (n : Nat) : (a ^ n).toBitVec = a.toBitVec ^ n := by
-  induction n <;> simp [*, UInt32.pow_succ, BitVec.pow_succ]
-@[simp, int_toBitVec] protected theorem UInt64.toBitVec_pow (a : UInt64) (n : Nat) : (a ^ n).toBitVec = a.toBitVec ^ n := by
-  induction n <;> simp [*, UInt64.pow_succ, BitVec.pow_succ]
-@[simp, int_toBitVec] protected theorem USize.toBitVec_pow (a : USize) (n : Nat) : (a ^ n).toBitVec = a.toBitVec ^ n := by
-  induction n <;> simp [*, USize.pow_succ, BitVec.pow_succ]
-
-@[simp] protected theorem UInt8.ofBitVec_pow (a : BitVec 8) (n : Nat) : ofBitVec (a ^ n) = ofBitVec a ^ n := by
-  induction n <;> simp [*, UInt8.pow_succ, BitVec.pow_succ]
-@[simp] protected theorem UInt16.ofBitVec_pow (a : BitVec 16) (n : Nat) : ofBitVec (a ^ n) = ofBitVec a ^ n := by
-  induction n <;> simp [*, UInt16.pow_succ, BitVec.pow_succ]
-@[simp] protected theorem UInt32.ofBitVec_pow (a : BitVec 32) (n : Nat) : ofBitVec (a ^ n) = ofBitVec a ^ n := by
-  induction n <;> simp [*, UInt32.pow_succ, BitVec.pow_succ]
-@[simp] protected theorem UInt64.ofBitVec_pow (a : BitVec 64) (n : Nat) : ofBitVec (a ^ n) = ofBitVec a ^ n := by
-  induction n <;> simp [*, UInt64.pow_succ, BitVec.pow_succ]
-@[simp] protected theorem USize.ofBitVec_pow (a : BitVec System.Platform.numBits) (n : Nat) : ofBitVec (a ^ n) = ofBitVec a ^ n := by
-  induction n <;> simp [*, USize.pow_succ, BitVec.pow_succ]
-
 protected theorem UInt8.mul_add {a b c : UInt8} : a * (b + c) = a * b + a * c :=
     UInt8.toBitVec_inj.1 BitVec.mul_add
 protected theorem UInt16.mul_add {a b c : UInt16} : a * (b + c) = a * b + a * c :=

src/Init/Data/Vector.lean

@@ -22,6 +22,5 @@ public import Init.Data.Vector.FinRange
 public import Init.Data.Vector.Extract
 public import Init.Data.Vector.Perm
 public import Init.Data.Vector.Find
-public import Init.Data.Vector.Algebra
 
 public section