wip

This PR adds a `HPow \a Int \a` field to `Lean.Grind.Field`, and
sufficient axioms to connect it to the operations, so that in future we
can reason about exponents in `grind`. To avoid collisions, we also move
the `HPow \a Nat \a` field in `Semiring` from the extends clause to a
field. Finally, we add some failing tests about normalizing exponents.

.github/actionlint.yaml

@@ -0,0 +1,5 @@
+self-hosted-runner:
+  labels:
+    - nscloud-ubuntu-22.04-amd64-4x16
+    - nscloud-ubuntu-22.04-amd64-8x16
+    - nscloud-macos-sonoma-arm64-6x14

.github/workflows/build-template.yml

@@ -97,14 +97,14 @@ jobs:
           sudo apt-get update
           sudo apt-get install -y gcc-multilib g++-multilib ccache libuv1-dev:i386 pkgconf:i386
         if: matrix.cmultilib
-      - name: Cache
+      - name: Restore Cache
         id: restore-cache
         uses: actions/cache/restore@v4
         with:
-          # NOTE: must be in sync with `save` below
+          # NOTE: must be in sync with `save` below and with `restore-cache` in `update-stage0.yml`
           path: |
             .ccache
-            ${{ matrix.name == 'Linux Lake' && false && 'build/stage1/**/*.trace
+            ${{ matrix.name == 'Linux Lake (cached)' && 'build/stage1/**/*.trace
             build/stage1/**/*.olean*
             build/stage1/**/*.ilean
             build/stage1/**/*.ir
@@ -119,9 +119,15 @@ jobs:
         run: |
           ccache --zero-stats
         if: runner.os == 'Linux'
-      - name: Set up NPROC
+      - name: Set up env
         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
@@ -142,6 +148,9 @@ 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
@@ -156,10 +165,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 -j$NPROC
+          time make $TARGET_STAGE -j$NPROC
       - name: Install
         run: |
-          make -C build install
+          make -C build/$TARGET_STAGE install
       - name: Check Binaries
         run: ${{ matrix.binary-check }} lean-*/bin/* || true
       - name: Count binary symbols
@@ -196,12 +205,12 @@ jobs:
         id: test
         run: |
           ulimit -c unlimited  # coredumps
-          time ctest --preset ${{ matrix.CMAKE_PRESET || 'release' }} --test-dir build/stage1 -j$NPROC --output-junit test-results.xml ${{ matrix.CTEST_OPTIONS }}
+          time ctest --preset ${{ matrix.CMAKE_PRESET || 'release' }} --test-dir build/$TARGET_STAGE -j$NPROC --output-junit test-results.xml ${{ matrix.CTARGET_OPTIONS }}
         if: (matrix.wasm || !matrix.cross) && (inputs.check-level >= 1 || matrix.test)
       - name: Test Summary
         uses: test-summary/action@v2
         with:
-          paths: build/stage1/test-results.xml
+          paths: build/${{ env.TARGET_STAGE }}/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
@@ -226,8 +235,9 @@ jobs:
         if: matrix.test-speedcenter
       - name: Check rebootstrap
         run: |
-          # clean rebuild in case of Makefile changes
-          make -C build update-stage0 && rm -rf build/stage* && make -C build -j$NPROC
+          # 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
         if: matrix.check-rebootstrap
       - name: CCache stats
         if: always()
@@ -246,7 +256,7 @@ jobs:
           # NOTE: must be in sync with `restore` above
           path: |
             .ccache
-            ${{ matrix.name == 'Linux Lake' && false && 'build/stage1/**/*.trace
+            ${{ matrix.name == 'Linux Lake (cached)' && 'build/stage1/**/*.trace
             build/stage1/**/*.olean*
             build/stage1/**/*.ilean
             build/stage1/**/*.ir

.github/workflows/ci.yml

@@ -165,7 +165,7 @@ jobs:
               {
                 // portable release build: use channel with older glibc (2.26)
                 "name": "Linux release",
-                "os": large && level < 2 ? "nscloud-ubuntu-22.04-amd64-4x16" : "ubuntu-latest",
+                "os": "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,6 +194,13 @@ 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",
@@ -225,8 +232,8 @@ jobs:
               },
               {
                 "name": "macOS aarch64",
-                // standard GH runner only comes with 7GB so use large runner if possible
-                "os": large ? "nscloud-macos-sonoma-arm64-6x14" : "macos-14",
+                // 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",
                 "CMAKE_OPTIONS": "-DLEAN_INSTALL_SUFFIX=-darwin_aarch64",
                 "release": true,
                 "shell": "bash -euxo pipefail {0}",
@@ -234,13 +241,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 above for release job levels
+                // See "Linux release" for release job levels; Grove is not a concern here
                 "check-level": isPr ? 0 : 2,
                 "secondary": isPr,
               },
               {
                 "name": "Windows",
-                "os": "windows-2022",
+                "os": large && level == 2 ? "namespace-profile-windows-amd64-4x16" : "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. Skipping for now, to be enabled later."
-              echo "should-run=false" >> "$GITHUB_OUTPUT"
+              echo "Push to master detected. Running Grove."
+              echo "should-run=true" >> "$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"
+              echo "PR with grove label detected. Running Grove."
               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.3
+        uses: TwoFx/grove-action/fetch-upstream@v0.4
         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.*
+          name: "build-Linux release"
           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.3
+        uses: TwoFx/grove-action/build@v0.4
         with:
           project-path: doc/std/grove
           script-name: grove-stdlib

.github/workflows/update-stage0.yml

@@ -18,7 +18,7 @@ concurrency:
 
 jobs:
   update-stage0:
-    runs-on: ubuntu-latest
+    runs-on: nscloud-ubuntu-22.04-amd64-8x16
     steps:
     # This action should push to an otherwise protected branch, so it
     # uses a deploy key with write permissions, as suggested at
@@ -52,6 +52,18 @@ jobs:
       run: |
         echo "NPROC=$(nproc 2>/dev/null || sysctl -n hw.logicalcpu 2>/dev/null || echo 4)" >> $GITHUB_ENV
       shell: 'nix develop -c bash -euxo pipefail {0}'
+    - name: Restore Cache
+      if: env.should_update_stage0 == 'yes'
+      uses: actions/cache/restore@v4
+      with:
+        # NOTE: must be in sync with `restore-cache` in `build-template.yml`
+        # TODO: actually switch to USE_LAKE once it caches more; for now it just caches more often than any other build type so let's use its cache
+        path: |
+          .ccache
+        key: Linux Lake-build-v3-${{ github.sha }}
+        # fall back to (latest) previous cache
+        restore-keys: |
+          Linux Lake-build-v3
     - if: env.should_update_stage0 == 'yes'
       run: cmake --preset release
       shell: 'nix develop -c bash -euxo pipefail {0}'

CODEOWNERS

@@ -45,3 +45,6 @@
 /src/Std/Tactic/BVDecide/ @hargoniX
 /src/Lean/Elab/Tactic/BVDecide/ @hargoniX
 /src/Std/Sat/ @hargoniX
+/src/Std/Do @sgraf812
+/src/Std/Tactic/Do @sgraf812
+/src/Lean/Elab/Tactic/Do @sgraf812

doc/std/grove/GroveStdlib/Generated.lean

@@ -1,5 +1,9 @@
 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
@@ -12,3 +16,7 @@ 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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,357 @@
+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

@@ -0,0 +1,216 @@
+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

@@ -0,0 +1,21 @@
+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 α} (m : Std.DHashMap α β) : Bool",
+      renderedStatement := "Std.DHashMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (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 α} [EquivBEq α]\n  [LawfulHashable α] (m : Std.ExtDHashMap α β) : Bool",
+      renderedStatement := "Std.ExtDHashMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  [EquivBEq α] [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} (t : Std.DTreeMap α β cmp) : Bool",
+      renderedStatement := "Std.DTreeMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (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} (t : Std.DTreeMap.Raw α β cmp) :\n  Bool",
+      renderedStatement := "Std.DTreeMap.Raw.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.DTreeMap.Raw α β cmp) : 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} (t : Std.ExtDTreeMap α β cmp) :\n  Bool",
+      renderedStatement := "Std.ExtDTreeMap.isEmpty.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (t : Std.ExtDTreeMap α β cmp) : 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 α} (m : Std.HashMap α β) : Bool",
+      renderedStatement := "Std.HashMap.isEmpty.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (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 α] [LawfulHashable α]\n  (m : Std.ExtHashMap α β) : Bool",
+      renderedStatement := "Std.ExtHashMap.isEmpty.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α]\n  [LawfulHashable α] (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} (t : Std.TreeMap α β cmp) : Bool",
+      renderedStatement := "Std.TreeMap.isEmpty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (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} (t : Std.TreeMap.Raw α β cmp) : Bool",
+      renderedStatement := "Std.TreeMap.Raw.isEmpty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (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} (t : Std.ExtTreeMap α β cmp) : Bool",
+      renderedStatement := "Std.ExtTreeMap.isEmpty.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (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 α] [LawfulHashable α]\n  (m : Std.ExtHashSet α) : Bool",
+      renderedStatement := "Std.ExtHashSet.isEmpty.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α]\n  [LawfulHashable α] (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 α} (m : Std.DHashMap α β) : Nat",
+      renderedStatement := "Std.DHashMap.size.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (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 α} [EquivBEq α]\n  [LawfulHashable α] (m : Std.ExtDHashMap α β) : Nat",
+      renderedStatement := "Std.ExtDHashMap.size.{u, v} {α : Type u} {β : α → Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  [EquivBEq α] [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} (t : Std.DTreeMap α β cmp) : Nat",
+      renderedStatement := "Std.DTreeMap.size.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (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} (t : Std.DTreeMap.Raw α β cmp) : Nat",
+      renderedStatement := "Std.DTreeMap.Raw.size.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (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} (t : Std.ExtDTreeMap α β cmp) : Nat",
+      renderedStatement := "Std.ExtDTreeMap.size.{u, v} {α : Type u} {β : α → Type v} {cmp : α → α → Ordering}\n  (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 α} (m : Std.HashMap α β) : Nat",
+      renderedStatement := "Std.HashMap.size.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α}\n  (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 α] [LawfulHashable α]\n  (m : Std.ExtHashMap α β) : Nat",
+      renderedStatement := "Std.ExtHashMap.size.{u, v} {α : Type u} {β : Type v} {x✝ : BEq α} {x✝¹ : Hashable α} [EquivBEq α]\n  [LawfulHashable α] (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} (t : Std.TreeMap α β cmp) : Nat",
+      renderedStatement := "Std.TreeMap.size.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (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} (t : Std.TreeMap.Raw α β cmp) : Nat",
+      renderedStatement := "Std.TreeMap.Raw.size.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (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} (t : Std.ExtTreeMap α β cmp) : Nat",
+      renderedStatement := "Std.ExtTreeMap.size.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (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} (t : Std.DTreeMap α β cmp)\n  (p : (a : α) → β a → Bool) : Bool",
+      renderedStatement := "Std.DTreeMap.any.{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.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} (t : Std.DTreeMap.Raw α β cmp)\n  (p : (a : α) → β a → Bool) : Bool",
+      renderedStatement := "Std.DTreeMap.Raw.any.{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.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) (p : α → β → Bool) :\n  Bool",
+      renderedStatement := "Std.TreeMap.any.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp)\n  (p : α → β → Bool) : 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} (t : Std.TreeMap.Raw α β cmp)\n  (p : α → β → Bool) : Bool",
+      renderedStatement := "Std.TreeMap.Raw.any.{u, v} {α : Type u} {β : Type v} {cmp : α → α → Ordering}\n  (t : Std.TreeMap.Raw α β cmp) (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 α) (p : α → Bool) : Bool",
+      renderedStatement := "Std.HashSet.any.{u} {α : Type u} {x✝ : BEq α} {x✝¹ : Hashable α} (m : Std.HashSet α)\n  (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) : Bool",
+      renderedStatement := "Std.TreeSet.any.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet α cmp) (p : α → Bool) :\n  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) (p : α → Bool) : Bool",
+      renderedStatement := "Std.TreeSet.Raw.any.{u} {α : Type u} {cmp : α → α → Ordering} (t : Std.TreeSet.Raw α cmp)\n  (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] (t : Std.ExtTreeSet α cmp)\n  (p : α → Bool) : Bool",
+      renderedStatement := "Std.ExtTreeSet.any.{u} {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp]\n  (t : Std.ExtTreeSet α cmp) (p : α → Bool) : Bool",
       isDeprecated := false })⟩,]
   metadata := {
     status := .bad
@@ -228,62 +228,51 @@ 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", .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
-  }
-)⟩,]
+  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 })⟩,]
   metadata := {
     status := .bad
     comment := "Missing for some containers"
@@ -292,97 +281,79 @@ 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", .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
-  }
-)⟩,]
+  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 })⟩,]
   metadata := {
     status := .done
     comment := ""
@@ -391,73 +362,61 @@ 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", .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
+  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
   { 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", .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
-  }
-)⟩,]
+  { 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 })⟩,]
   metadata := {
     status := .bad
     comment := "Should *Set have GetElem?"

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

@@ -20,23 +20,75 @@ def sequentialContainers : Node :=
 
 namespace AssociativeContainers
 
-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
+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
   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.declarationsInNamespace n .definitionsOnly)
+    (DataSource.definitionsInNamespace n)
       |>.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 AssociativeContainers.associativeQueryOperations
+    .associationTable associativeQueryOperations,
+    .associationTable associativeCreationOperations,
+    .associationTable associativeModificationOperations,
+    .table associativeCreateThenQuery,
+    .assertion allOperationsCovered
   ]
 
 namespace PersistentDataStructures

doc/std/grove/grove-local.sh

@@ -3,8 +3,10 @@
 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
-    GROVE_DATA_LOCATION=../../../../metadata.json GROVE_UPSTREAM_INVALIDATED_FACTS_LOCATION=../../../../invalidated.json npm run dev
+    cp ../../../../invalidated.json public/invalidated.json
+    GROVE_DATA_LOCATION=public/metadata.json GROVE_UPSTREAM_INVALIDATED_FACTS_LOCATION=public/invalidated.json npm run dev
 else
-    GROVE_DATA_LOCATION=../../../../metadata.json npm run dev
-fi
+    GROVE_DATA_LOCATION=public/metadata.json npm run dev
+fi

doc/std/grove/lake-manifest.json

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

script/bench.sh

@@ -1,9 +1,16 @@
 #!/usr/bin/env bash
 set -euo pipefail
 
+cmake --preset release -DUSE_LAKE=ON 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
+timeout -s KILL 1h time make -C build/release -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/stage2 -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

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 re.search(r'rc\d+$', version) and repo_name in ["batteries", "mathlib4"] and version.endswith('-rc1'):
+    if 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 re.search(r'rc\d+$', version) and repo_name in ["batteries", "mathlib4"]:
+    if version.endswith('-rc1') 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 re.search(r'rc\d+$', version):
+    elif version.endswith('-rc1'):
         # 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,12 +533,21 @@ 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 ";")
@@ -634,8 +643,6 @@ else()
   set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:library>)
   add_subdirectory(library/constructions)
   set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:constructions>)
-  add_subdirectory(library/compiler)
-  set(LEAN_OBJS ${LEAN_OBJS} $<TARGET_OBJECTS:compiler>)
 
   # leancpp without `initialize` (see `leaninitialize` above)
   add_library(leancpp_1 STATIC ${LEAN_OBJS})
@@ -814,6 +821,12 @@ 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)
@@ -840,6 +853,10 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
   set(LAKE_LIB_PREFIX "lib")
 endif()
 
-if(USE_LAKE AND STAGE EQUAL 1)
-  configure_file(${LEAN_SOURCE_DIR}/lakefile.toml.in ${LEAN_SOURCE_DIR}/lakefile.toml)
+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()
 endif()

src/Init.lean

@@ -44,3 +44,5 @@ public import Init.Internal
 public import Init.Try
 public import Init.BinderNameHint
 public import Init.Task
+public import Init.GetElem
+public import Init.GetElemV

src/Init/Classical.lean

@@ -16,6 +16,10 @@ universe u v
 
 namespace Classical
 
+/-- Using `Classical.choice`, extracts a term from a `Nonempty` type. -/
+protected noncomputable abbrev arbitrary (α) [h : Nonempty α] : α :=
+  Classical.choice h
+
 noncomputable def indefiniteDescription {α : Sort u} (p : α → Prop) (h : ∃ x, p x) : {x // p x} :=
   choice <| let ⟨x, px⟩ := h; ⟨⟨x, px⟩⟩
 

src/Init/Control/Except.lean

@@ -12,7 +12,7 @@ public import Init.Control.Basic
 public import Init.Control.Id
 public import Init.Coe
 
-public section
+@[expose] 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.
 -/
-@[reducible] def ReaderM (ρ : Type u) := ReaderT ρ Id
+abbrev ReaderM (ρ : Type u) := ReaderT ρ Id

src/Init/Conv.lean

@@ -262,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. -/

src/Init/Core.lean

@@ -752,6 +752,8 @@ 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. -/
@@ -853,6 +855,8 @@ 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

src/Init/Data/AC.lean

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

src/Init/Data/Array/Erase.lean

@@ -382,11 +382,12 @@ theorem eraseIdx_ne_empty_iff {xs : Array α} {i : Nat} {h} : xs.eraseIdx i ≠
     simp [h]
   · simp
 
-@[grind →]
 theorem mem_of_mem_eraseIdx {xs : Array α} {i : Nat} {h} {a : α} (h : a ∈ xs.eraseIdx i) : a ∈ xs := by
   rcases xs with ⟨xs⟩
   simpa using List.mem_of_mem_eraseIdx (by simpa using h)
 
+grind_pattern mem_of_mem_eraseIdx => a ∈ xs.eraseIdx i
+
 theorem eraseIdx_append_of_lt_size {xs : Array α} {k : Nat} (hk : k < xs.size) (ys : Array α) (h) :
     eraseIdx (xs ++ ys) k = eraseIdx xs k ++ ys := by
   rcases xs with ⟨l⟩

src/Init/Data/Array/Lemmas.lean

@@ -129,7 +129,7 @@ theorem none_eq_getElem?_iff {xs : Array α} {i : Nat} : none = xs[i]? ↔ xs.si
 theorem getElem?_eq_none {xs : Array α} (h : xs.size ≤ i) : xs[i]? = none := by
   simp [h]
 
-grind_pattern Array.getElem?_eq_none => xs.size ≤ i, xs[i]?
+grind_pattern Array.getElem?_eq_none => xs.size, xs[i]?
 
 @[simp] theorem getElem?_eq_getElem {xs : Array α} {i : Nat} (h : i < xs.size) : xs[i]? = some xs[i] :=
   getElem?_pos ..
@@ -872,24 +872,24 @@ theorem elem_eq_mem [BEq α] [LawfulBEq α] {a : α} {xs : Array α} :
 @[grind] theorem all_empty [BEq α] {p : α → Bool} : (#[] : Array α).all p = true := by simp
 
 /-- Variant of `any_push` with a side condition on `stop`. -/
-@[simp, grind] theorem any_push' [BEq α] {xs : Array α} {a : α} {p : α → Bool} (h : stop = xs.size + 1) :
+@[simp, grind] theorem any_push' {xs : Array α} {a : α} {p : α → Bool} (h : stop = xs.size + 1) :
     (xs.push a).any p 0 stop = (xs.any p || p a) := by
   cases xs
   rw [List.push_toArray]
   simp [h]
 
-theorem any_push [BEq α] {xs : Array α} {a : α} {p : α → Bool} :
+theorem any_push {xs : Array α} {a : α} {p : α → Bool} :
     (xs.push a).any p = (xs.any p || p a) :=
   any_push' (by simp)
 
 /-- Variant of `all_push` with a side condition on `stop`. -/
-@[simp, grind] theorem all_push' [BEq α] {xs : Array α} {a : α} {p : α → Bool} (h : stop = xs.size + 1) :
+@[simp, grind] theorem all_push' {xs : Array α} {a : α} {p : α → Bool} (h : stop = xs.size + 1) :
     (xs.push a).all p 0 stop = (xs.all p && p a) := by
   cases xs
   rw [List.push_toArray]
   simp [h]
 
-theorem all_push [BEq α] {xs : Array α} {a : α} {p : α → Bool} :
+theorem all_push {xs : Array α} {a : α} {p : α → Bool} :
     (xs.push a).all p = (xs.all p && p a) :=
   all_push' (by simp)
 
@@ -985,12 +985,13 @@ theorem mem_set {xs : Array α} {i : Nat} (h : i < xs.size) {a : α} :
   simp [mem_iff_getElem]
   exact ⟨i, (by simpa using h), by simp⟩
 
-@[grind →]
 theorem mem_or_eq_of_mem_set
     {xs : Array α} {i : Nat} {a b : α} {w : i < xs.size} (h : a ∈ xs.set i b) : a ∈ xs ∨ a = b := by
   cases xs
   simpa using List.mem_or_eq_of_mem_set (by simpa using h)
 
+grind_pattern mem_or_eq_of_mem_set => a ∈ xs.set i b
+
 /-! ### setIfInBounds -/
 
 @[simp, grind] theorem setIfInBounds_empty {i : Nat} {a : α} :

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

@@ -6,9 +6,12 @@ Author: Kim Morrison
 module
 
 prelude
-public import Init.Data.Array.Basic
-public import Init.Data.Nat.Lemmas
-public import Init.Data.Range
+public import Init.Core
+import Init.Data.Array.Basic
+import Init.Data.Nat.Lemmas
+import Init.Data.Range.Polymorphic.Iterators
+import Init.Data.Range.Polymorphic.Nat
+import Init.Data.Iterators.Consumers
 
 public section
 
@@ -26,9 +29,9 @@ Specifically, `Array.lex as bs lt` is true if
 * there is an index `i` such that `lt as[i] bs[i]`, and for all `j < i`, `as[j] == bs[j]`.
 -/
 def lex [BEq α] (as bs : Array α) (lt : α → α → Bool := by exact (· < ·)) : Bool := Id.run do
-  for h : i in [0 : min as.size bs.size] do
-    -- TODO: `omega` should be able to find this itself.
-    have : i < min as.size bs.size := Membership.get_elem_helper h rfl
+  for h : i in 0...(min as.size bs.size) do
+    -- TODO: `get_elem_tactic` should be able to find this itself.
+    have : i < min as.size bs.size := Std.PRange.lt_upper_of_mem h
     if lt as[i] bs[i] then
       return true
     else if as[i] != bs[i] then

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

@@ -6,9 +6,12 @@ Author: Kim Morrison
 module
 
 prelude
-public import all Init.Data.Array.Lex.Basic
+import all Init.Data.Array.Lex.Basic
+public import Init.Data.Array.Lex.Basic
 public import Init.Data.Array.Lemmas
 public import Init.Data.List.Lex
+import Init.Data.Range.Polymorphic.Lemmas
+import Init.Data.Range.Polymorphic.NatLemmas
 
 public section
 
@@ -19,11 +22,16 @@ namespace Array
 
 /-! ### Lexicographic ordering -/
 
-@[simp, grind =] theorem _root_.List.lt_toArray [LT α] {l₁ l₂ : List α} : l₁.toArray < l₂.toArray ↔ l₁ < l₂ := Iff.rfl
-@[simp, grind =] theorem _root_.List.le_toArray [LT α] {l₁ l₂ : List α} : l₁.toArray ≤ l₂.toArray ↔ l₁ ≤ l₂ := Iff.rfl
+@[simp] theorem _root_.List.lt_toArray [LT α] {l₁ l₂ : List α} : l₁.toArray < l₂.toArray ↔ l₁ < l₂ := Iff.rfl
+@[simp] theorem _root_.List.le_toArray [LT α] {l₁ l₂ : List α} : l₁.toArray ≤ l₂.toArray ↔ l₁ ≤ l₂ := Iff.rfl
 
-@[simp, grind =] theorem lt_toList [LT α] {xs ys : Array α} : xs.toList < ys.toList ↔ xs < ys := Iff.rfl
-@[simp, grind =] theorem le_toList [LT α] {xs ys : Array α} : xs.toList ≤ ys.toList ↔ xs ≤ ys := Iff.rfl
+@[simp] theorem lt_toList [LT α] {xs ys : Array α} : xs.toList < ys.toList ↔ xs < ys := Iff.rfl
+@[simp] theorem le_toList [LT α] {xs ys : Array α} : xs.toList ≤ ys.toList ↔ xs ≤ ys := Iff.rfl
+
+grind_pattern _root_.List.lt_toArray =>  l₁.toArray < l₂.toArray
+grind_pattern _root_.List.le_toArray =>  l₁.toArray ≤ l₂.toArray
+grind_pattern lt_toList => xs.toList < ys.toList
+grind_pattern le_toList => xs.toList ≤ ys.toList
 
 protected theorem not_lt_iff_ge [LT α] {xs ys : Array α} : ¬ xs < ys ↔ ys ≤ xs := Iff.rfl
 protected theorem not_le_iff_gt [LT α] {xs ys : Array α} :
@@ -31,16 +39,38 @@ protected theorem not_le_iff_gt [LT α] {xs ys : Array α} :
   Classical.not_not
 
 @[simp] theorem lex_empty [BEq α] {lt : α → α → Bool} {xs : Array α} : xs.lex #[] lt = false := by
-  simp [lex]
+  rw [lex, Std.PRange.forIn'_eq_match]
+  simp [Std.PRange.SupportsUpperBound.IsSatisfied]
+
+private theorem cons_lex_cons.forIn'_congr_aux [Monad m] {as bs : ρ} {_ : Membership α ρ}
+    [ForIn' m ρ α inferInstance] (w : as = bs)
+    {b b' : β} (hb : b = b')
+    {f : (a' : α) → a' ∈ as → β → m (ForInStep β)}
+    {g : (a' : α) → a' ∈ bs → β → m (ForInStep β)}
+    (h : ∀ a m b, f a (by simpa [w] using m) b = g a m b) :
+    forIn' as b f = forIn' bs b' g := by
+  cases hb
+  cases w
+  have : f = g := by
+    ext a ha acc
+    apply h
+  cases this
+  rfl
 
 private theorem cons_lex_cons [BEq α] {lt : α → α → Bool} {a b : α} {xs ys : Array α} :
      (#[a] ++ xs).lex (#[b] ++ ys) lt =
        (lt a b || a == b && xs.lex ys lt) := by
-  simp only [lex]
-  simp only [Std.Range.forIn'_eq_forIn'_range', size_append, List.size_toArray, List.length_singleton,
-    Nat.add_comm 1]
-  simp [Nat.add_min_add_right, List.range'_succ, getElem_append_left, List.range'_succ_left,
-    getElem_append_right]
+  simp only [lex, size_append, List.size_toArray, List.length_cons, List.length_nil, Nat.zero_add,
+    Nat.add_min_add_left, Nat.add_lt_add_iff_left, Std.PRange.forIn'_eq_forIn'_toList]
+  conv =>
+    lhs; congr; congr
+    rw [cons_lex_cons.forIn'_congr_aux Std.PRange.toList_eq_match rfl (fun _ _ _ => rfl)]
+    simp only [Std.PRange.SupportsUpperBound.IsSatisfied, bind_pure_comp, map_pure]
+    rw [cons_lex_cons.forIn'_congr_aux (if_pos (by omega)) rfl (fun _ _ _ => rfl)]
+  simp only [Std.PRange.toList_open_eq_toList_closed_of_isSome_succ? (lo := 0) (h := rfl),
+    Std.PRange.UpwardEnumerable.succ?, Nat.add_comm 1, Std.PRange.Nat.ClosedOpen.toList_succ_succ,
+    Option.get_some, List.forIn'_cons, List.size_toArray, List.length_cons, List.length_nil,
+    Nat.lt_add_one, getElem_append_left, List.getElem_toArray, List.getElem_cons_zero]
   cases lt a b
   · rw [bne]
     cases a == b <;> simp
@@ -49,10 +79,17 @@ private theorem cons_lex_cons [BEq α] {lt : α → α → Bool} {a b : α} {xs
 @[simp, grind =] theorem _root_.List.lex_toArray [BEq α] {lt : α → α → Bool} {l₁ l₂ : List α} :
     l₁.toArray.lex l₂.toArray lt = l₁.lex l₂ lt := by
   induction l₁ generalizing l₂ with
-  | nil => cases l₂ <;> simp [lex]
+  | nil =>
+    cases l₂
+    · rw [lex, Std.PRange.forIn'_eq_match]
+      simp [Std.PRange.SupportsUpperBound.IsSatisfied]
+    · rw [lex, Std.PRange.forIn'_eq_match]
+      simp [Std.PRange.SupportsUpperBound.IsSatisfied]
   | cons x l₁ ih =>
     cases l₂ with
-    | nil => simp [lex]
+    | nil =>
+      rw [lex, Std.PRange.forIn'_eq_match]
+      simp [Std.PRange.SupportsUpperBound.IsSatisfied]
     | cons y l₂ =>
       rw [List.toArray_cons, List.toArray_cons y, cons_lex_cons, List.lex, ih]
 

src/Init/Data/Array/Subarray.lean

@@ -6,7 +6,8 @@ Authors: Leonardo de Moura
 module
 
 prelude
-public import Init.Data.Array.Basic
+public import Init.GetElem
+import Init.Data.Array.GetLit
 public import Init.Data.Slice.Basic
 
 public section
@@ -159,64 +160,10 @@ instance : EmptyCollection (Subarray α) :=
 instance : Inhabited (Subarray α) :=
   ⟨{}⟩
 
-/--
-The run-time implementation of `ForIn.forIn` for `Subarray`, which allows it to be used with `for`
-loops in `do`-notation.
-
-This definition replaces `Subarray.forIn`.
+/-!
+`ForIn`, `foldlM`, `foldl` and other operations are implemented in `Init.Data.Slice.Array.Iterator`
+using the slice iterator.
 -/
-@[inline] unsafe def forInUnsafe {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (s : Subarray α) (b : β) (f : α → β → m (ForInStep β)) : m β :=
-  let sz := USize.ofNat s.stop
-  let rec @[specialize] loop (i : USize) (b : β) : m β := do
-    if i < sz then
-      let a := s.array.uget i lcProof
-      match (← f a b) with
-      | ForInStep.done  b => pure b
-      | ForInStep.yield b => loop (i+1) b
-    else
-      pure b
-  loop (USize.ofNat s.start) b
-
-/--
-The implementation of `ForIn.forIn` for `Subarray`, which allows it to be used with `for` loops in
-`do`-notation.
--/
--- TODO: provide reference implementation
-@[implemented_by Subarray.forInUnsafe]
-protected opaque forIn {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (s : Subarray α) (b : β) (f : α → β → m (ForInStep β)) : m β :=
-  pure b
-
-instance : ForIn m (Subarray α) α where
-  forIn := Subarray.forIn
-
-/--
-Folds a monadic operation from left to right over the elements in a subarray.
-
-An accumulator of type `β` is constructed by starting with `init` and monadically combining each
-element of the subarray with the current accumulator value in turn. The monad in question may permit
-early termination or repetition.
-
-Examples:
-```lean example
-#eval #["red", "green", "blue"].toSubarray.foldlM (init := "") fun acc x => do
-  let l ← Option.guard (· ≠ 0) x.length
-  return s!"{acc}({l}){x} "
-```
-```output
-some "(3)red (5)green (4)blue "
-```
-```lean example
-#eval #["red", "green", "blue"].toSubarray.foldlM (init := 0) fun acc x => do
-  let l ← Option.guard (· ≠ 5) x.length
-  return s!"{acc}({l}){x} "
-```
-```output
-none
-```
--/
-@[inline]
-def foldlM {α : Type u} {β : Type v} {m : Type v → Type w} [Monad m] (f : β → α → m β) (init : β) (as : Subarray α) : m β :=
-  as.array.foldlM f (init := init) (start := as.start) (stop := as.stop)
 
 /--
 Folds a monadic operation from right to left over the elements in a subarray.
@@ -313,20 +260,6 @@ The elements are processed starting at the highest index and moving down.
 def forRevM {α : Type u} {m : Type v → Type w} [Monad m] (f : α → m PUnit) (as : Subarray α) : m PUnit :=
   as.array.forRevM f (start := as.stop) (stop := as.start)
 
-/--
-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 foldl {α : Type u} {β : Type v} (f : β → α → β) (init : β) (as : Subarray α) : β :=
-  Id.run <| as.foldlM (pure <| f · ·) (init := init)
-
 /--
 Folds an operation from right to left over the elements in a subarray.
 
@@ -464,18 +397,6 @@ def toSubarray (as : Array α) (start : Nat := 0) (stop : Nat := as.size) : Suba
          start_le_stop := Nat.le_refl _,
          stop_le_array_size := Nat.le_refl _ }⟩
 
-/--
-Allocates a new array that contains the contents of the subarray.
--/
-@[coe]
-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⟩
-
 /-- A subarray with the provided bounds.-/
 syntax:max term noWs "[" withoutPosition(term ":" term) "]" : term
 /-- A subarray with the provided lower bound that extends to the rest of the array. -/
@@ -489,22 +410,3 @@ macro_rules
   | `($a[$start : ])      => `(let a := $a; Array.toSubarray a $start a.size)
 
 end Array
-
-@[inherit_doc Array.ofSubarray]
-def Subarray.toArray (s : Subarray α) : Array α :=
-  Array.ofSubarray s
-
-instance : Append (Subarray α) where
-  append x y :=
-   let a := x.toArray ++ y.toArray
-   a.toSubarray 0 a.size
-
-/-- `Subarray` representation. -/
-protected def Subarray.repr [Repr α] (s : Subarray α) : Std.Format :=
-  repr s.toArray ++ ".toSubarray"
-
-instance [Repr α] : Repr (Subarray α) where
-  reprPrec s  _ := Subarray.repr s
-
-instance [ToString α] : ToString (Subarray α) where
-  toString s := toString s.toArray

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
 
-public section
+@[expose] public section
 
 /-!
 We define the basic algebraic structure of bitvectors. We choose the `Fin` representation over
@@ -35,7 +35,12 @@ protected def ofNatLt {n : Nat} (i : Nat) (p : i < 2 ^ n) : BitVec n :=
 
 section Nat
 
-instance natCastInst : NatCast (BitVec w) := ⟨BitVec.ofNat w⟩
+/--
+`NatCast` instance for `BitVec`.
+-/
+-- As this is a lossy conversion, it should be removed as a global instance.
+instance instNatCast : NatCast (BitVec w) where
+  natCast x := BitVec.ofNat w x
 
 /-- Theorem for normalizing the bitvector literal representation. -/
 -- TODO: This needs more usage data to assess which direction the simp should go.
@@ -731,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. -/
-def intMin (w : Nat) := twoPow w (w - 1)
+@[expose] def intMin (w : Nat) := twoPow w (w - 1)
 
 /-- The bitvector of width `w` that has the largest value when interpreted as an integer. -/
-def intMax (w : Nat) := (twoPow w (w - 1)) - 1
+@[expose] 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
 
-public section
+@[expose] 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,7 +586,6 @@ A recurrence that describes multiplication as repeated addition.
 
 This function is useful for bit blasting multiplication.
 -/
-@[expose]
 def mulRec (x y : BitVec w) (s : Nat) : BitVec w :=
   let cur := if y.getLsbD s then (x <<< s) else 0
   match s with
@@ -622,7 +621,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
 
@@ -1047,7 +1046,6 @@ theorem lawful_divSubtractShift (qr : DivModState w) (h : qr.Poised args) :
 /-! ### Core division algorithm circuit -/
 
 /-- A recursive definition of division for bit blasting, in terms of a shift-subtraction circuit. -/
-@[expose]
 def divRec {w : Nat} (m : Nat) (args : DivModArgs w) (qr : DivModState w) :
     DivModState w :=
   match m with
@@ -1944,7 +1942,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

@@ -745,7 +745,6 @@ theorem le_toNat_of_msb_true {w : Nat} {x : BitVec w} (h : x.msb = true) : 2 ^ (
 `x.toInt` is less than `2^(w-1)`.
 We phrase the fact in terms of `2^w` to prevent a case split on `w=0` when the lemma is used.
 -/
-@[grind]
 theorem two_mul_toInt_lt {w : Nat} {x : BitVec w} : 2 * x.toInt < 2 ^ w := by
   simp only [BitVec.toInt]
   rcases w with _|w'
@@ -754,6 +753,8 @@ theorem two_mul_toInt_lt {w : Nat} {x : BitVec w} : 2 * x.toInt < 2 ^ w := by
     simp only [Nat.zero_lt_succ, Nat.mul_lt_mul_left, Int.natCast_mul, Int.cast_ofNat_Int]
     norm_cast; omega
 
+grind_pattern two_mul_toInt_lt => x.toInt
+
 theorem two_mul_toInt_le {w : Nat} {x : BitVec w} : 2 * x.toInt ≤ 2 ^ w - 1 :=
   Int.le_sub_one_of_lt two_mul_toInt_lt
 
@@ -772,7 +773,6 @@ theorem toInt_le {w : Nat} {x : BitVec w} : x.toInt ≤ 2 ^ (w - 1) - 1 :=
 `x.toInt` is greater than or equal to `-2^(w-1)`.
 We phrase the fact in terms of `2^w` to prevent a case split on `w=0` when the lemma is used.
 -/
-@[grind]
 theorem le_two_mul_toInt {w : Nat} {x : BitVec w} : -2 ^ w ≤ 2 * x.toInt := by
   simp only [BitVec.toInt]
   rcases w with _|w'
@@ -781,6 +781,8 @@ theorem le_two_mul_toInt {w : Nat} {x : BitVec w} : -2 ^ w ≤ 2 * x.toInt := by
     simp only [Nat.zero_lt_succ, Nat.mul_lt_mul_left, Int.natCast_mul, Int.cast_ofNat_Int]
     norm_cast; omega
 
+grind_pattern le_two_mul_toInt => x.toInt
+
 theorem le_toInt {w : Nat} (x : BitVec w) : -2 ^ (w - 1) ≤ x.toInt := by
   by_cases h : w = 0
   · subst h
@@ -5769,6 +5771,22 @@ theorem clzAuxRec_eq_clzAuxRec_of_le (x : BitVec w) (h : w - 1 ≤ n) :
     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 =>
+    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
+        simp only [Classical.not_forall, Bool.not_eq_false]
+        exists n + k + 1
+        simp [show n < n + k + 1 by omega, hxn]
+      contradiction
+    · simp only [hxn, Bool.false_eq_true, ↓reduceIte]
+      exact ihk
+
+
 /-! ### Inequalities (le / lt) -/
 
 theorem ule_eq_not_ult (x y : BitVec w) : x.ule y = !y.ult x := by

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
 
-public section
+@[expose] public section
 universe u
 
 structure ByteArray where

src/Init/Data/Char/Basic.lean

@@ -8,7 +8,7 @@ module
 prelude
 public import Init.Data.UInt.BasicAux
 
-public section
+@[expose] 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/Lemmas.lean

@@ -927,24 +927,34 @@ 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 :=
-  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)
+  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
 
 @[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]; simp
+  rw [reverseInduction, reverseInduction.go]; simp
+
+@[simp] 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)]
 
 @[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, dif_neg (Fin.ne_of_lt (Fin.castSucc_lt_last i))]; rfl
+  rw [reverseInduction, reverseInduction_castSucc_aux _ _ _ i.isLt, reverseInduction]
 
 /--
 Proves a statement by cases on the underlying `Nat` value in a `Fin (n + 1)`, checking whether the

src/Init/Data/Function.lean

@@ -8,6 +8,7 @@ module
 
 prelude
 public import Init.Core
+public import Init.Grind.Tactics
 
 public section
 

src/Init/Data/Int/Linear.lean

@@ -1737,32 +1737,6 @@ theorem emod_le (x y : Int) (n : Int) : emod_le_cert y n → x % y + n ≤ 0 :=
     simp only [Int.add_comm, Int.sub_neg, Int.add_zero]
     exact Int.emod_lt_of_pos x h
 
-theorem natCast_nonneg (x : Nat) : (-1:Int) * NatCast.natCast x ≤ 0 := by
-  simp
-
-theorem natCast_sub (x y : Nat)
-    : (NatCast.natCast (x - y) : Int)
-      =
-      if (NatCast.natCast y : Int) + (-1)*NatCast.natCast x ≤ 0 then
-        (NatCast.natCast x : Int) + -1*NatCast.natCast y
-      else
-        (0 : Int) := by
-  change (↑(x - y) : Int) = if (↑y : Int) + (-1)*↑x ≤ 0 then (↑x : Int) + (-1)*↑y else 0
-  rw [Int.neg_mul, ← Int.sub_eq_add_neg, Int.one_mul]
-  rw [Int.neg_mul, ← Int.sub_eq_add_neg, Int.one_mul]
-  split
-  next h =>
-    replace h := Int.le_of_sub_nonpos h
-    rw [Int.ofNat_le] at h
-    rw [Int.ofNat_sub h]
-  next h =>
-    have : ¬ (↑y : Int) ≤ ↑x := by
-      intro h
-      replace h := Int.sub_nonpos_of_le h
-      contradiction
-    rw [Int.ofNat_le] at this
-    rw [Lean.Omega.Int.ofNat_sub_eq_zero this]
-
 private theorem dvd_le_tight' {d p b₁ b₂ : Int} (hd : d > 0) (h₁ : d ∣ p + b₁) (h₂ : p + b₂ ≤ 0)
     : p + (b₁ - d*((b₁-b₂) / d)) ≤ 0 := by
   have ⟨k, h⟩ := h₁
@@ -1881,31 +1855,6 @@ theorem of_not_dvd (a b : Int) : a != 0 → ¬ (a ∣ b) → b % a > 0 := by
   simp [h₁] at h₂
   assumption
 
-@[expose]
-def le_of_le_cert (p q : Poly) (k : Nat) : Bool :=
-  q == p.addConst (- k)
-
-theorem le_of_le (ctx : Context) (p q : Poly) (k : Nat)
-    : le_of_le_cert p q k → p.denote' ctx ≤ 0 → q.denote' ctx ≤ 0 := by
-  simp [le_of_le_cert]; intro; subst q; simp
-  intro h
-  simp [Lean.Omega.Int.add_le_zero_iff_le_neg']
-  exact Int.le_trans h (Int.ofNat_zero_le _)
-
-@[expose]
-def not_le_of_le_cert (p q : Poly) (k : Nat) : Bool :=
-  q == (p.mul (-1)).addConst (1 + k)
-
-theorem not_le_of_le (ctx : Context) (p q : Poly) (k : Nat)
-    : not_le_of_le_cert p q k → p.denote' ctx ≤ 0 → ¬ q.denote' ctx ≤ 0 := by
-  simp [not_le_of_le_cert]; intro; subst q
-  intro h
-  apply Int.pos_of_neg_neg
-  apply Int.lt_of_add_one_le
-  simp [Int.neg_add]
-  rw [← Int.add_assoc, ← Int.add_assoc, Int.add_neg_cancel_right, Lean.Omega.Int.add_le_zero_iff_le_neg']
-  simp; exact Int.le_trans h (Int.ofNat_zero_le _)
-
 @[expose]
 def eq_def_cert (x : Var) (xPoly : Poly) (p : Poly) : Bool :=
   p == .add (-1) x xPoly
@@ -1950,6 +1899,62 @@ theorem diseq_norm_poly (ctx : Context) (p p' : Poly) : p.denote' ctx = p'.denot
 theorem dvd_norm_poly (ctx : Context) (d : Int) (p p' : Poly) : p.denote' ctx = p'.denote' ctx → d ∣ p.denote' ctx → d ∣ p'.denote' ctx := by
   intro h; rw [h]; simp
 
+/-!
+Constraint propagation helper theorems.
+-/
+
+@[expose]
+def le_of_le_cert (p₁ p₂ : Poly) : Bool :=
+  match p₁, p₂ with
+  | .add .., .num _ => false
+  | .num _, .add .. => false
+  | .num c₁, .num c₂ => c₁ ≥ c₂
+  | .add a₁ x₁ p₁, .add a₂ x₂ p₂ => a₁ == a₂ && x₁ == x₂ && le_of_le_cert p₁ p₂
+
+theorem le_of_le' (ctx : Context) (p₁ p₂ : Poly) : le_of_le_cert p₁ p₂ → ∀ k, p₁.denote' ctx ≤ k → p₂.denote' ctx ≤ k := by
+  simp [Poly.denote'_eq_denote]
+  fun_induction le_of_le_cert <;> simp [Poly.denote]
+  next c₁ c₂ =>
+    intro h k h₁
+    exact Int.le_trans h h₁
+  next a₁ x₁ p₁ a₂ x₂ p₂ ih =>
+    intro _ _ h; subst a₁ x₁
+    replace ih := ih h; clear h
+    intro k h
+    replace h : p₁.denote ctx ≤ k - a₂ * x₂.denote ctx := by omega
+    replace ih := ih _ h
+    omega
+
+theorem le_of_le (ctx : Context) (p₁ p₂ : Poly) : le_of_le_cert p₁ p₂ → p₁.denote' ctx ≤ 0 → p₂.denote' ctx ≤ 0 :=
+  fun h => le_of_le' ctx p₁ p₂ h 0
+
+@[expose]
+def not_le_of_le_cert (p₁ p₂ : Poly) : Bool :=
+  match p₁, p₂ with
+  | .add .., .num _ => false
+  | .num _, .add .. => false
+  | .num c₁, .num c₂ => c₁ ≥ 1 - c₂
+  | .add a₁ x₁ p₁, .add a₂ x₂ p₂ => a₁ == -a₂ && x₁ == x₂ && not_le_of_le_cert p₁ p₂
+
+theorem not_le_of_le' (ctx : Context) (p₁ p₂ : Poly) : not_le_of_le_cert p₁ p₂ → ∀ k, p₁.denote' ctx ≤ k → ¬ (p₂.denote' ctx ≤ -k) := by
+  simp [Poly.denote'_eq_denote]
+  fun_induction not_le_of_le_cert <;> simp [Poly.denote]
+  next c₁ c₂ =>
+    intro h k h₁
+    omega
+  next a₁ x₁ p₁ a₂ x₂ p₂ ih =>
+    intro _ _ h; subst a₁ x₁
+    replace ih := ih h; clear h
+    intro k h
+    replace h : p₁.denote ctx ≤ k + a₂ * x₂.denote ctx := by rw [Int.neg_mul] at h; omega
+    replace ih := ih _ h
+    omega
+
+theorem not_le_of_le (ctx : Context) (p₁ p₂ : Poly) : not_le_of_le_cert p₁ p₂ → p₁.denote' ctx ≤ 0 → ¬ (p₂.denote' ctx ≤ 0) := by
+  intro h h₁
+  have := not_le_of_le' ctx p₁ p₂ h 0 h₁; simp at this
+  simp [*]
+
 end Int.Linear
 
 theorem Int.not_le_eq (a b : Int) : (¬a ≤ b) = (b + 1 ≤ a) := by

src/Init/Data/Int/OfNat.lean

@@ -13,92 +13,91 @@ public import Init.Data.RArray
 
 public section
 
-namespace Int.OfNat
-/-!
-Helper definitions and theorems for converting `Nat` expressions into `Int` one.
-We use them to implement the arithmetic theories in `grind`
--/
+namespace Nat.ToInt
 
-abbrev Var := Nat
-abbrev Context := Lean.RArray Nat
-@[expose]
-def Var.denote (ctx : Context) (v : Var) : Nat :=
-  ctx.get v
+theorem ofNat_toNat (a : Int) : (NatCast.natCast a.toNat : Int) = if a ≤ 0 then 0 else a := by simp [Int.max_def]
 
-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 toNat_nonneg (x : Nat) : (-1:Int) * (NatCast.natCast x) ≤ 0 := by simp
 
-@[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 natCast_ofNat (n : Nat) : (NatCast.natCast (OfNat.ofNat n : Nat) : Int) = OfNat.ofNat n := by rfl
 
-@[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_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
 
-theorem Expr.denoteAsInt_eq (ctx : Context) (e : Expr) : e.denoteAsInt ctx = e.denote ctx := by
-  induction e <;> simp [denote, denoteAsInt, *] <;> rfl
+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.eq_denoteAsInt (ctx : Context) (e : Expr) : e.denote ctx = e.denoteAsInt ctx := by
-  apply Eq.symm; apply denoteAsInt_eq
+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 (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_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.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 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 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 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_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 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_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
+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]
   split
   next h =>
-    rw [Int.toNat_of_nonpos h]; rfl
+    have h := Int.le_of_sub_nonpos h
+    simp [← h₁, ← h₂, Int.ofNat_le] at h
+    simp [Int.ofNat_sub h]
+    rw [← h₁, ← h₂]
   next h =>
-    simp at h
-    have := Int.toNat_of_nonneg (Int.le_of_lt h)
-    assumption
+    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]
 
-theorem Expr.denoteAsInt_nonneg (ctx : Context) (e : Expr) : 0 ≤ e.denoteAsInt ctx := by
-  simp [Expr.denoteAsInt_eq]
+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]
 
-end Int.OfNat
+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]
+
+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

src/Init/Data/Iterators/Consumers.lean

@@ -12,4 +12,6 @@ public import Init.Data.Iterators.Consumers.Collect
 public import Init.Data.Iterators.Consumers.Loop
 public import Init.Data.Iterators.Consumers.Partial
 
+public import Init.Data.Iterators.Consumers.Stream
+
 public section

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

@@ -6,12 +6,11 @@ Authors: Paul Reichert
 module
 
 prelude
-public import Init.Data.Stream
 public import Init.Data.Iterators.Consumers.Partial
 public import Init.Data.Iterators.Consumers.Loop
 public import Init.Data.Iterators.Consumers.Monadic.Access
 
-public section
+@[expose] public section
 
 namespace Std.Iterators
 
@@ -64,15 +63,4 @@ def Iter.atIdx? {α β} [Iterator α Id β] [Productive α Id] [IteratorAccess
   | .skip _ => none
   | .done => none
 
-instance {α β} [Iterator α Id β] [Productive α Id] [IteratorAccess α Id] :
-    Stream (Iter (α := α) β) β where
-  next? it := match (it.toIterM.nextAtIdx? 0).run with
-    | .yield it' out _ => some (out, it'.toIter)
-    | .skip _ h => False.elim ?noskip
-    | .done _ => none
-  where finally
-    case noskip =>
-      revert h
-      exact IterM.not_isPlausibleNthOutputStep_yield
-
 end 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
 
-public section
+@[expose] 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
 
-public section
+@[expose] public section
 
 /-!
 # Collectors

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

@@ -9,6 +9,7 @@ prelude
 public import Init.RCases
 public import Init.Data.Iterators.Basic
 public import Init.Data.Iterators.Consumers.Monadic.Partial
+public import Init.Data.Iterators.Internal.LawfulMonadLiftFunction
 
 public section
 
@@ -32,6 +33,8 @@ asserts that an `IteratorLoop` instance equals the default implementation.
 
 namespace Std.Iterators
 
+open Std.Internal
+
 section Typeclasses
 
 /--
@@ -39,6 +42,7 @@ Relation that needs to be well-formed in order for a loop over an iterator to te
 It is assumed that the `plausible_forInStep` predicate relates the input and output of the
 stepper function.
 -/
+@[expose]
 def IteratorLoop.rel (α : Type w) (m : Type w → Type w') {β : Type w} [Iterator α m β]
     {γ : Type x} (plausible_forInStep : β → γ → ForInStep γ → Prop)
     (p' p : IterM (α := α) m β × γ) : Prop :=
@@ -48,6 +52,7 @@ def IteratorLoop.rel (α : Type w) (m : Type w → Type w') {β : Type w} [Itera
 /--
 Asserts that `IteratorLoop.rel` is well-founded.
 -/
+@[expose]
 def IteratorLoop.WellFounded (α : Type w) (m : Type w → Type w') {β : Type w} [Iterator α m β]
     {γ : Type x} (plausible_forInStep : β → γ → ForInStep γ → Prop) : Prop :=
     _root_.WellFounded (IteratorLoop.rel α m plausible_forInStep)
@@ -61,6 +66,7 @@ This class is experimental and users of the iterator API should not explicitly d
 They can, however, assume that consumers that require an instance will work for all iterators
 provided by the standard library.
 -/
+@[ext]
 class IteratorLoop (α : Type w) (m : Type w → Type w') {β : Type w} [Iterator α m β]
     (n : Type x → Type x') where
   forIn : ∀ (_liftBind : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ) (γ : Type x),
@@ -108,29 +114,24 @@ class IteratorSizePartial (α : Type w) (m : Type w → Type w') {β : Type w} [
 end Typeclasses
 
 /-- Internal implementation detail of the iterator library. -/
-def IteratorLoop.WFRel {α : Type w} {m : Type w → Type w'} {β : Type w} [Iterator α m β]
-    {γ : Type x} {plausible_forInStep : β → γ → ForInStep γ → Prop}
-    (_wf : WellFounded α m plausible_forInStep) :=
-  IterM (α := α) m β × γ
+structure IteratorLoop.WithWF (α : Type w) (m : Type w → Type w') {β : Type w} [Iterator α m β]
+    {γ : Type x} (PlausibleForInStep : β → γ → ForInStep γ → Prop)
+    (hwf : IteratorLoop.WellFounded α m PlausibleForInStep) where
+  it : IterM (α := α) m β
+  acc : γ
 
-/-- Internal implementation detail of the iterator library. -/
-def IteratorLoop.WFRel.mk {α : Type w} {m : Type w → Type w'} {β : Type w} [Iterator α m β]
-    {γ : Type x} {plausible_forInStep : β → γ → ForInStep γ → Prop}
-    (wf : WellFounded α m plausible_forInStep) (it : IterM (α := α) m β) (c : γ) :
-    IteratorLoop.WFRel wf :=
-  (it, c)
-
-private instance {α : Type w} {m : Type w → Type w'} {β : Type w} [Iterator α m β]
-    {γ : Type x} {plausible_forInStep : β → γ → ForInStep γ → Prop}
-    (wf : IteratorLoop.WellFounded α m plausible_forInStep) :
-    WellFoundedRelation (IteratorLoop.WFRel wf) where
-  rel := IteratorLoop.rel α m plausible_forInStep
-  wf := wf
+instance IteratorLoop.WithWF.instWellFoundedRelation
+    (α : Type w) (m : Type w → Type w') {β : Type w} [Iterator α m β]
+    {γ : Type x} (PlausibleForInStep : β → γ → ForInStep γ → Prop)
+    (hwf : IteratorLoop.WellFounded α m PlausibleForInStep) :
+    WellFoundedRelation (WithWF α m PlausibleForInStep hwf) where
+  rel := InvImage (IteratorLoop.rel α m PlausibleForInStep) (fun x => (x.it, x.acc))
+  wf := by exact InvImage.wf _ hwf
 
 /--
 This is the loop implementation of the default instance `IteratorLoop.defaultImplementation`.
 -/
-@[specialize]
+@[specialize, expose]
 def IterM.DefaultConsumers.forIn' {m : Type w → Type w'} {α : Type w} {β : Type w}
     [Iterator α m β]
     {n : Type x → Type x'} [Monad n]
@@ -142,27 +143,59 @@ def IterM.DefaultConsumers.forIn' {m : Type w → Type w'} {α : Type w} {β : T
     (f : (b : β) → P b → (c : γ) → n (Subtype (plausible_forInStep b c))) : n γ :=
   haveI : WellFounded _ := wf
   (lift _ _ · it.step) fun
-      | .yield it' out h => do
-        match ← f out (hP _ <| .direct ⟨_, h⟩) init with
-        | ⟨.yield c, _⟩ =>
-          IterM.DefaultConsumers.forIn' lift _ plausible_forInStep wf it' c P
-            (fun _ h' => hP _ <| .indirect ⟨_, rfl, h⟩ h') f
-        | ⟨.done c, _⟩ => return c
-      | .skip it' h =>
-        IterM.DefaultConsumers.forIn' lift _ plausible_forInStep wf it' init P
-            (fun _ h' => hP _ <| .indirect ⟨_, rfl, h⟩ h') f
-      | .done _ => return init
-termination_by IteratorLoop.WFRel.mk wf it init
+    | .yield it' out h => do
+      match ← f out (hP _ <| .direct ⟨_, h⟩) init with
+      | ⟨.yield c, _⟩ =>
+        IterM.DefaultConsumers.forIn' lift _ plausible_forInStep wf it' c P
+          (fun _ h' => hP _ <| .indirect ⟨_, rfl, h⟩ h') f
+      | ⟨.done c, _⟩ => return c
+    | .skip it' h =>
+      IterM.DefaultConsumers.forIn' lift _ plausible_forInStep wf it' init P
+          (fun _ h' => hP _ <| .indirect ⟨_, rfl, h⟩ h') f
+    | .done _ => return init
+termination_by IteratorLoop.WithWF.mk it init (hwf := wf)
 decreasing_by
   · exact Or.inl ⟨out, ‹_›, ‹_›⟩
   · exact Or.inr ⟨‹_›, rfl⟩
 
+theorem IterM.DefaultConsumers.forIn'_eq_forIn' {m : Type w → Type w'} {α : Type w} {β : Type w}
+    [Iterator α m β]
+    {n : Type x → Type x'} [Monad n]
+    {lift : ∀ γ δ, (γ → n δ) → m γ → n δ} {γ : Type x}
+    {Pl : β → γ → ForInStep γ → Prop}
+    {wf : IteratorLoop.WellFounded α m Pl}
+    {it : IterM (α := α) m β} {init : γ}
+    {P : β → Prop} {hP : ∀ b, it.IsPlausibleIndirectOutput b → P b}
+    {Q : β → Prop} {hQ : ∀ b, it.IsPlausibleIndirectOutput b → Q b}
+    {f : (b : β) → P b → (c : γ) → n (Subtype (Pl b c))}
+    {g : (b : β) → Q b → (c : γ) → n (Subtype (Pl b c))}
+    (hfg : ∀ b c, (hPb : P b) → (hQb : Q b) → f b hPb c = g b hQb c) :
+    IterM.DefaultConsumers.forIn' lift γ Pl wf it init P hP f =
+      IterM.DefaultConsumers.forIn' lift γ Pl wf it init Q hQ g := by
+  rw [forIn', forIn']
+  congr; ext step
+  split
+  · congr
+    · apply hfg
+    · ext
+      split
+      · apply IterM.DefaultConsumers.forIn'_eq_forIn'
+        assumption
+      · rfl
+  · apply IterM.DefaultConsumers.forIn'_eq_forIn'
+    assumption
+  · rfl
+termination_by IteratorLoop.WithWF.mk it init (hwf := wf)
+decreasing_by
+  · exact Or.inl ⟨_, ‹_›, ‹_›⟩
+  · exact Or.inr ⟨‹_›, rfl⟩
+
 /--
 This is the default implementation of the `IteratorLoop` class.
 It simply iterates through the iterator using `IterM.step`. For certain iterators, more efficient
 implementations are possible and should be used instead.
 -/
-@[always_inline, inline]
+@[always_inline, inline, expose]
 def IteratorLoop.defaultImplementation {α : Type w} {m : Type w → Type w'} {n : Type x → Type x'}
     [Monad n] [Iterator α m β] :
     IteratorLoop α m n where
@@ -173,8 +206,9 @@ Asserts that a given `IteratorLoop` instance is equal to `IteratorLoop.defaultIm
 (Even though equal, the given instance might be vastly more efficient.)
 -/
 class LawfulIteratorLoop (α : Type w) (m : Type w → Type w') (n : Type x → Type x')
-    [Monad n] [Iterator α m β] [Finite α m] [i : IteratorLoop α m n] where
-  lawful : i = .defaultImplementation
+    [Monad m] [Monad n] [Iterator α m β] [i : IteratorLoop α m n] where
+  lawful : ∀ lift [LawfulMonadLiftBindFunction lift], i.forIn lift =
+      IteratorLoop.defaultImplementation.forIn lift
 
 /--
 This is the loop implementation of the default instance `IteratorLoopPartial.defaultImplementation`.
@@ -214,7 +248,7 @@ instance (α : Type w) (m : Type w → Type w') (n : Type x → Type x')
     letI : IteratorLoop α m n := .defaultImplementation
     LawfulIteratorLoop α m n :=
   letI : IteratorLoop α m n := .defaultImplementation
-  ⟨rfl⟩
+  ⟨fun _ => rfl⟩
 
 theorem IteratorLoop.wellFounded_of_finite {m : Type w → Type w'}
     {α β : Type w} {γ : Type x} [Iterator α m β] [Finite α m] :

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

@@ -0,0 +1,27 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Paul Reichert
+-/
+module
+
+prelude
+public import Init.Data.Stream
+public import Init.Data.Iterators.Consumers.Access
+
+public section
+
+namespace Std.Iterators
+
+instance {α β} [Iterator α Id β] [Productive α Id] [IteratorAccess α Id] :
+    Stream (Iter (α := α) β) β where
+  next? it := match (it.toIterM.nextAtIdx? 0).run with
+    | .yield it' out _ => some (out, it'.toIter)
+    | .skip _ h => False.elim ?noskip
+    | .done _ => none
+  where finally
+    case noskip =>
+      revert h
+      exact IterM.not_isPlausibleNthOutputStep_yield
+
+end Std.Iterators

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

@@ -24,6 +24,12 @@ the requirement that the `MonadLift(T)` instance induced by `f` admits a
 
 namespace Std.Internal
 
+class LawfulMonadLiftBindFunction {m : Type u → Type v} {n : Type w → Type x} [Monad m]
+    [Monad n] (liftBind : ∀ γ δ, (γ → n δ) → m γ → n δ) where
+  liftBind_pure {γ δ} (f : γ → n δ) (a : γ) : liftBind γ δ f (pure a) = f a
+  liftBind_bind {β γ δ} (f : γ → n δ) (x : m β) (g : β → m γ) :
+    liftBind γ δ f (x >>= g) = liftBind β δ (fun b => liftBind γ δ f (g b)) x
+
 class LawfulMonadLiftFunction {m : Type u → Type v} {n : Type u → Type w}
     [Monad m] [Monad n] (lift : ⦃α : Type u⦄ → m α → n α) where
   lift_pure {α : Type u} (a : α) : lift (pure a) = pure a
@@ -79,4 +85,35 @@ instance [LawfulMonadLiftFunction lift] :
   { monadLift_pure := LawfulMonadLiftFunction.lift_pure
     monadLift_bind := LawfulMonadLiftFunction.lift_bind }
 
+section LiftBind
+
+variable {liftBind : ∀ γ δ, (γ → m δ) → m γ → m δ}
+
+instance [LawfulMonadLiftBindFunction (n := n) (fun _ _ f x => lift x >>= f)] [LawfulMonad n] :
+    LawfulMonadLiftFunction lift where
+  lift_pure {γ} a := by
+    simpa using LawfulMonadLiftBindFunction.liftBind_pure (n := n)
+      (liftBind := fun _ _ f x => lift x >>= f) (γ := γ) (δ := γ) pure a
+  lift_bind {β γ} x g := by
+    simpa using LawfulMonadLiftBindFunction.liftBind_bind (n := n)
+      (liftBind := fun _ _ f x => lift x >>= f) (β := β) (γ := γ) (δ := γ) pure x g
+
+def LawfulMonadLiftBindFunction.id [Monad m] [LawfulMonad m] :
+    LawfulMonadLiftBindFunction (m := Id) (n := m) (fun _ _ f x => f x.run) where
+  liftBind_pure := by simp
+  liftBind_bind := by simp
+
+instance {m : Type u → Type v} [Monad m] {n : Type u → Type w} [Monad n] [MonadLiftT m n]
+    [LawfulMonadLiftT m n] [LawfulMonad n] :
+    LawfulMonadLiftBindFunction (fun γ δ (f : γ → n δ) (x : m γ) => monadLift x >>= f) where
+  liftBind_pure := by simp
+  liftBind_bind := by simp
+
+instance {n : Type u → Type w} [Monad n] [LawfulMonad n] :
+    LawfulMonadLiftBindFunction (fun γ δ (f : γ → n δ) (x : Id γ) => f x.run) where
+  liftBind_pure := by simp
+  liftBind_bind := by simp
+
+end LiftBind
+
 end Std.Internal

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

@@ -6,6 +6,7 @@ Authors: Paul Reichert
 module
 
 prelude
+public import Init.Control.Lawful.MonadLift.Instances
 public import Init.Data.Iterators.Lemmas.Consumers.Collect
 public import all Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop
 public import all Init.Data.Iterators.Consumers.Loop
@@ -16,7 +17,7 @@ public section
 namespace Std.Iterators
 
 theorem Iter.forIn'_eq {α β : Type w} [Iterator α Id β] [Finite α Id]
-    {m : Type x → Type x'} [Monad m] [IteratorLoop α Id m] [hl : LawfulIteratorLoop α Id m]
+    {m : Type x → Type x'} [Monad m] [LawfulMonad m] [IteratorLoop α Id m] [hl : LawfulIteratorLoop α Id m]
     {γ : Type x} {it : Iter (α := α) β} {init : γ}
     {f : (b : β) → it.IsPlausibleIndirectOutput b → γ → m (ForInStep γ)} :
     letI : ForIn' m (Iter (α := α) β) β _ := Iter.instForIn'
@@ -25,21 +26,22 @@ theorem Iter.forIn'_eq {α β : Type w} [Iterator α Id β] [Finite α Id]
         IteratorLoop.wellFounded_of_finite it.toIterM init _ (fun _ => id)
           (fun out h acc => (⟨·, .intro⟩) <$>
             f out (Iter.isPlausibleIndirectOutput_iff_isPlausibleIndirectOutput_toIterM.mpr h) acc) := by
-  cases hl.lawful; rfl
+  simp [instForIn', ForIn'.forIn', IteratorLoop.finiteForIn', hl.lawful (fun γ δ f x => f x.run),
+    IteratorLoop.defaultImplementation]
 
 theorem Iter.forIn_eq {α β : Type w} [Iterator α Id β] [Finite α Id]
-    {m : Type x → Type x'} [Monad m] [IteratorLoop α Id m] [hl : LawfulIteratorLoop α Id m]
-    {γ : Type x} {it : Iter (α := α) β} {init : γ}
+    {m : Type x → Type x'} [Monad m] [LawfulMonad m] [IteratorLoop α Id m]
+    [hl : LawfulIteratorLoop α Id m] {γ : Type x} {it : Iter (α := α) β} {init : γ}
     {f : (b : β) → γ → m (ForInStep γ)} :
     ForIn.forIn it init f =
       IterM.DefaultConsumers.forIn' (fun _ _ f c => f c.run) γ (fun _ _ _ => True)
         IteratorLoop.wellFounded_of_finite it.toIterM init _ (fun _ => id)
           (fun out _ acc => (⟨·, .intro⟩) <$>
             f out acc) := by
-  cases hl.lawful; rfl
+  simp [ForIn.forIn, forIn'_eq, -forIn'_eq_forIn]
 
 theorem Iter.forIn'_eq_forIn'_toIterM {α β : Type w} [Iterator α Id β]
-    [Finite α Id] {m : Type w → Type w'} [Monad m] [LawfulMonad m]
+    [Finite α Id] {m : Type w → Type w''} [Monad m] [LawfulMonad m]
     [IteratorLoop α Id m] [LawfulIteratorLoop α Id m]
     {γ : Type w} {it : Iter (α := α) β} {init : γ}
     {f : (out : β) → _ → γ → m (ForInStep γ)} :

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

@@ -38,60 +38,31 @@ theorem IterM.DefaultConsumers.forIn'_eq_match_step {α β : Type w} {m : Type w
   cases step using PlausibleIterStep.casesOn <;> rfl
 
 theorem IterM.forIn'_eq {α β : Type w} {m : Type w → Type w'} [Iterator α m β] [Finite α m]
-    {n : Type w → Type w''} [Monad n] [IteratorLoop α m n] [hl : LawfulIteratorLoop α m n]
-    [MonadLiftT m n] {γ : Type w} {it : IterM (α := α) m β} {init : γ}
+    {n : Type w → Type w''} [Monad m] [Monad n] [LawfulMonad n] [IteratorLoop α m n]
+    [hl : LawfulIteratorLoop α m n]
+    [MonadLiftT m n] [LawfulMonadLiftT m n] {γ : Type w} {it : IterM (α := α) m β} {init : γ}
     {f : (b : β) → it.IsPlausibleIndirectOutput b → γ → n (ForInStep γ)} :
     letI : ForIn' n (IterM (α := α) m β) β _ := IterM.instForIn'
     ForIn'.forIn' it init f = IterM.DefaultConsumers.forIn' (n := n)
         (fun _ _ f x => monadLift x >>= f) γ (fun _ _ _ => True)
         IteratorLoop.wellFounded_of_finite it init _ (fun _ => id) ((⟨·, .intro⟩) <$> f · · ·) := by
-  cases hl.lawful; rfl
+  simp [instForIn', ForIn'.forIn', IteratorLoop.finiteForIn',
+    hl.lawful (fun _ _ f x => monadLift x >>= f), IteratorLoop.defaultImplementation]
 
 theorem IterM.forIn_eq {α β : Type w} {m : Type w → Type w'} [Iterator α m β] [Finite α m]
-    {n : Type w → Type w''} [Monad n] [IteratorLoop α m n] [hl : LawfulIteratorLoop α m n]
-    [MonadLiftT m n] {γ : Type w} {it : IterM (α := α) m β} {init : γ}
+    {n : Type w → Type w''} [Monad m] [Monad n] [LawfulMonad n] [IteratorLoop α m n]
+    [hl : LawfulIteratorLoop α m n]
+    [MonadLiftT m n] [LawfulMonadLiftT m n] {γ : Type w} {it : IterM (α := α) m β} {init : γ}
     {f : β → γ → n (ForInStep γ)} :
     ForIn.forIn it init f = IterM.DefaultConsumers.forIn' (n := n)
         (fun _ _ f x => monadLift x >>= f) γ (fun _ _ _ => True)
         IteratorLoop.wellFounded_of_finite it init _ (fun _ => id) (fun out _ acc => (⟨·, .intro⟩) <$> f out acc) := by
-  cases hl.lawful; rfl
-
-theorem IterM.DefaultConsumers.forIn'_eq_forIn' {m : Type w → Type w'} {α : Type w} {β : Type w}
-    [Iterator α m β]
-    {n : Type x → Type x'} [Monad n]
-    {liftBind : ∀ γ δ, (γ → n δ) → m γ → n δ} {γ : Type x}
-    {Pl : β → γ → ForInStep γ → Prop}
-    {wf : IteratorLoop.WellFounded α m Pl}
-    {it : IterM (α := α) m β} {init : γ}
-    {P : β → Prop} {hP : ∀ b, it.IsPlausibleIndirectOutput b → P b}
-    {Q : β → Prop} {hQ : ∀ b, it.IsPlausibleIndirectOutput b → Q b}
-    {f : (b : β) → P b → (c : γ) → n (Subtype (Pl b c))}
-    {g : (b : β) → Q b → (c : γ) → n (Subtype (Pl b c))}
-    (hfg : ∀ b c, (hPb : P b) → (hQb : Q b) → f b hPb c = g b hQb c) :
-    IterM.DefaultConsumers.forIn' liftBind γ Pl wf it init P hP f =
-      IterM.DefaultConsumers.forIn' liftBind γ Pl wf it init Q hQ g := by
-  rw [forIn', forIn']
-  congr; ext step
-  split
-  · congr
-    · apply hfg
-    · ext
-      split
-      · apply IterM.DefaultConsumers.forIn'_eq_forIn'
-        assumption
-      · rfl
-  · apply IterM.DefaultConsumers.forIn'_eq_forIn'
-    assumption
-  · rfl
-termination_by IteratorLoop.WFRel.mk wf it init
-decreasing_by
-  · exact Or.inl ⟨_, ‹_›, ‹_›⟩
-  · exact Or.inr ⟨‹_›, rfl⟩
+  simp only [ForIn.forIn, forIn'_eq]
 
 theorem IterM.forIn'_eq_match_step {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
-    [Finite α m] {n : Type w → Type w''} [Monad n] [LawfulMonad n]
+    [Finite α m] {n : Type w → Type w''} [Monad m] [Monad n] [LawfulMonad n]
     [IteratorLoop α m n] [LawfulIteratorLoop α m n]
-    [MonadLiftT m n] {γ : Type w} {it : IterM (α := α) m β} {init : γ}
+    [MonadLiftT m n] [LawfulMonadLiftT m n] {γ : Type w} {it : IterM (α := α) m β} {init : γ}
     {f : (out : β) → _ → γ → n (ForInStep γ)} :
     letI : ForIn' n (IterM (α := α) m β) β _ := IterM.instForIn'
     ForIn'.forIn' it init f = (do
@@ -124,9 +95,9 @@ theorem IterM.forIn'_eq_match_step {α β : Type w} {m : Type w → Type w'} [It
   · simp
 
 theorem IterM.forIn_eq_match_step {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
-    [Finite α m] {n : Type w → Type w''} [Monad n] [LawfulMonad n]
+    [Finite α m] {n : Type w → Type w''} [Monad m] [Monad n] [LawfulMonad n]
     [IteratorLoop α m n] [LawfulIteratorLoop α m n]
-    [MonadLiftT m n] {γ : Type w} {it : IterM (α := α) m β} {init : γ}
+    [MonadLiftT m n] [LawfulMonadLiftT m n] {γ : Type w} {it : IterM (α := α) m β} {init : γ}
     {f : β → γ → n (ForInStep γ)} :
     ForIn.forIn it init f = (do
       match ← it.step with
@@ -140,7 +111,7 @@ theorem IterM.forIn_eq_match_step {α β : Type w} {m : Type w → Type w'} [Ite
   exact forIn'_eq_match_step
 
 theorem IterM.forM_eq_forIn {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
-    [Finite α m] {n : Type w → Type w''} [Monad n] [LawfulMonad n]
+    [Finite α m] {n : Type w → Type w''} [Monad m] [Monad n] [LawfulMonad n]
     [IteratorLoop α m n] [LawfulIteratorLoop α m n]
     [MonadLiftT m n] {it : IterM (α := α) m β}
     {f : β → n PUnit} :
@@ -148,9 +119,9 @@ theorem IterM.forM_eq_forIn {α β : Type w} {m : Type w → Type w'} [Iterator
   rfl
 
 theorem IterM.forM_eq_match_step {α β : Type w} {m : Type w → Type w'} [Iterator α m β]
-    [Finite α m] {n : Type w → Type w''} [Monad n] [LawfulMonad n]
+    [Finite α m] {n : Type w → Type w''} [Monad m] [Monad n] [LawfulMonad n]
     [IteratorLoop α m n] [LawfulIteratorLoop α m n]
-    [MonadLiftT m n] {it : IterM (α := α) m β}
+    [MonadLiftT m n] [LawfulMonadLiftT m n] {it : IterM (α := α) m β}
     {f : β → n PUnit} :
     ForM.forM it f = (do
       match ← it.step with
@@ -171,7 +142,7 @@ theorem IterM.foldM_eq_forIn {α β γ : Type w} {m : Type w → Type w'} [Itera
   (rfl)
 
 theorem IterM.forIn_yield_eq_foldM {α β γ δ : Type w} {m : Type w → Type w'} [Iterator α m β]
-    [Finite α m] {n : Type w → Type w''} [Monad n] [LawfulMonad n] [IteratorLoop α m n]
+    [Finite α m] {n : Type w → Type w''} [Monad m] [Monad n] [LawfulMonad n] [IteratorLoop α m n]
     [LawfulIteratorLoop α m n] [MonadLiftT m n] {f : β → γ → n δ} {g : β → γ → δ → γ} {init : γ}
     {it : IterM (α := α) m β} :
     ForIn.forIn it init (fun c b => (fun d => .yield (g c b d)) <$> f c b) =
@@ -179,8 +150,9 @@ theorem IterM.forIn_yield_eq_foldM {α β γ δ : Type w} {m : Type w → Type w
   simp [IterM.foldM_eq_forIn]
 
 theorem IterM.foldM_eq_match_step {α β γ : Type w} {m : Type w → Type w'} [Iterator α m β] [Finite α m]
-    {n : Type w → Type w''} [Monad n] [LawfulMonad n] [IteratorLoop α m n] [LawfulIteratorLoop α m n]
-    [MonadLiftT m n] {f : γ → β → n γ} {init : γ} {it : IterM (α := α) m β} :
+    {n : Type w → Type w''} [Monad m] [Monad n] [LawfulMonad n] [IteratorLoop α m n]
+    [LawfulIteratorLoop α m n] [MonadLiftT m n] [LawfulMonadLiftT m n]
+    {f : γ → β → n γ} {init : γ} {it : IterM (α := α) m β} :
     it.foldM (init := init) f = (do
       match ← it.step with
       | .yield it' out _ => it'.foldM (init := ← f init out) f

src/Init/Data/Iterators/ToIterator.lean

@@ -6,7 +6,8 @@ Authors: Paul Reichert
 module
 
 prelude
-public import Init.Data.Iterators.Consumers
+public import Init.Data.Iterators.Consumers.Collect
+public import Init.Data.Iterators.Consumers.Loop
 
 public section
 

src/Init/Data/List/Basic.lean

@@ -1369,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 if `Pairwise (· < ·) l`
+For example, `Pairwise (· ≠ ·) l` asserts that `l` has no duplicates, and `Pairwise (· < ·) l`
 asserts that `l` is (strictly) sorted.
 
 Examples:

src/Init/Data/List/Count.lean

@@ -104,7 +104,6 @@ theorem countP_replicate {p : α → Bool} {a : α} {n : Nat} :
   simp only [countP_eq_length_filter, filter_replicate]
   split <;> simp
 
-@[grind]
 theorem boole_getElem_le_countP {p : α → Bool} {l : List α} {i : Nat} (h : i < l.length) :
     (if p l[i] then 1 else 0) ≤ l.countP p := by
   induction l generalizing i with
@@ -118,6 +117,8 @@ theorem boole_getElem_le_countP {p : α → Bool} {l : List α} {i : Nat} (h : i
       specialize ih h
       exact le_add_right_of_le ih
 
+grind_pattern boole_getElem_le_countP => l.countP p, l[i]
+
 theorem Sublist.countP_le (s : l₁ <+ l₂) : countP p l₁ ≤ countP p l₂ := by
   simp only [countP_eq_length_filter]
   apply s.filter _ |>.length_le
@@ -142,10 +143,11 @@ grind_pattern IsInfix.countP_le => l₁ <:+: l₂, countP p l₂
 
 -- See `Init.Data.List.Nat.Count` for `Sublist.le_countP : countP p l₂ - (l₂.length - l₁.length) ≤ countP p l₁`.
 
-@[grind]
 theorem countP_tail_le (l) : countP p l.tail ≤ countP p l :=
   (tail_sublist l).countP_le
 
+grind_pattern countP_tail_le => countP p l.tail
+
 -- See `Init.Data.List.Nat.Count` for `le_countP_tail : countP p l - 1 ≤ countP p l.tail`.
 
 theorem countP_filter {l : List α} :
@@ -288,12 +290,13 @@ theorem count_flatten {a : α} {l : List (List α)} : count a l.flatten = (l.map
 @[simp, grind =] theorem count_reverse {a : α} {l : List α} : count a l.reverse = count a l := by
   simp only [count_eq_countP, countP_eq_length_filter, filter_reverse, length_reverse]
 
-@[grind]
 theorem boole_getElem_le_count {a : α} {l : List α} {i : Nat} (h : i < l.length) :
     (if l[i] == a then 1 else 0) ≤ l.count a := by
   rw [count_eq_countP]
   apply boole_getElem_le_countP (p := (· == a))
 
+grind_pattern boole_getElem_le_count => l.count a, l[i]
+
 variable [LawfulBEq α]
 
 @[simp] theorem count_cons_self {a : α} {l : List α} : count a (a :: l) = count a l + 1 := by

src/Init/Data/List/FinRange.lean

@@ -57,7 +57,7 @@ theorem finRange_reverse {n} : (finRange n).reverse = (finRange n).map Fin.rev :
     conv => rhs; rw [finRange_succ]
     rw [reverse_append, reverse_cons, reverse_nil, nil_append, singleton_append, ← map_reverse,
       map_cons, ih, map_map, map_map]
-    congr; funext
+    congr 2; funext
     simp [Fin.rev_succ]
 
 end List

src/Init/Data/List/Find.lean

@@ -523,7 +523,7 @@ private theorem findIdx?_go_eq {p : α → Bool} {xs : List α} {i : Nat} :
     split
     · simp_all
     · simp_all only [findIdx?_go_succ, Bool.not_eq_true, Option.map_map, Nat.zero_add]
-      congr
+      congr 1
       ext
       simp only [Nat.add_comm i, Function.comp_apply, Nat.add_assoc]
 

src/Init/Data/List/Lemmas.lean

@@ -13,6 +13,7 @@ public import all Init.Data.List.BasicAux
 public import all Init.Data.List.Control
 public import Init.Control.Lawful.Basic
 public import Init.BinderPredicates
+public import Init.GetElemV
 
 public section
 
@@ -2331,7 +2332,7 @@ theorem filterMap_replicate_of_some {f : α → Option β} (h : f a = some b) :
   induction n with
   | zero => simp
   | succ n ih =>
-    simp only [replicate_succ, flatten_cons, ih, replicate_append_replicate, 
+    simp only [replicate_succ, flatten_cons, ih, replicate_append_replicate,
       add_one_mul, Nat.add_comm]
 
 theorem flatMap_replicate {β} {f : α → List β} : (replicate n a).flatMap f = (replicate n (f a)).flatten := by
@@ -3477,13 +3478,15 @@ theorem length_le_length_insert {l : List α} {a : α} : l.length ≤ (l.insert
 
 grind_pattern List.length_le_length_insert => (l.insert a).length
 
-@[grind] theorem length_insert_pos {l : List α} {a : α} : 0 < (l.insert a).length := by
+theorem length_insert_pos {l : List α} {a : α} : 0 < (l.insert a).length := by
   by_cases h : a ∈ l
   · rw [length_insert_of_mem h]
     exact length_pos_of_mem h
   · rw [length_insert_of_not_mem h]
     exact Nat.zero_lt_succ _
 
+grind_pattern length_insert_pos => (l.insert a).length
+
 theorem insert_eq {l : List α} {a : α} : l.insert a = if a ∈ l then l else a :: l := by
   simp [List.insert]
 
@@ -3727,6 +3730,20 @@ set_option linter.deprecated false in
 theorem mem_iff_get? {a} {l : List α} : a ∈ l ↔ ∃ n, l.get? n = some a := by
   simp [getElem?_eq_some_iff, Fin.exists_iff, mem_iff_get]
 
+/-! ### `getElemV` -/
+
+noncomputable instance : GetElemV (List α) Nat α where
+  getElemV xs i := if h : i < xs.length then xs[i] else Classical.arbitrary α
+
+instance : LawfulGetElemV (List α) Nat α (fun xs i => i < xs.length) where
+  getElemV_def xs i := by
+    simp [getElemV]
+    split <;> simp_all
+
+theorem getElemV_map [Nonempty α] [Nonempty β] {xs : List α} {f : α → β} (h : i < xs.length) :
+    (xs.map f)[i]ᵛ = f xs[i]ᵛ := by
+  simp_all [LawfulGetElemV.getElemV_def]
+
 /-! ### Deprecations -/
 
 @[deprecated _root_.isSome_getElem? (since := "2024-12-09")]

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 ((· : α) ≤ ·)]
+theorem max?_eq_some_iff [Max α] [LE α] [anti : Std.Antisymm (· ≤ · : α → α → Prop)]
     (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/Nat/Bitwise/Basic.lean

@@ -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`.
 -/
-def testBit (m n : Nat) : Bool :=
+@[expose] def testBit (m n : Nat) : Bool :=
   -- `1 &&& n` is faster than `n &&& 1` for big `n`.
   1 &&& (m >>> n) != 0
 

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

@@ -350,12 +350,7 @@ 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 := by
-  rw [mod_eq]
-  have : ¬ (0 < b ∧ b = 0) := by
-    intro ⟨h₁, h₂⟩
-    simp_all
-  simp [this]
+@[simp] theorem zero_mod (b : Nat) : 0 % b = 0 := rfl
 
 @[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/Option/Basic.lean

@@ -7,6 +7,7 @@ module
 
 prelude
 public import Init.Control.Basic
+public import Init.Grind.Tactics
 
 public section
 

src/Init/Data/Option/Lemmas.lean

@@ -11,6 +11,7 @@ public import all Init.Data.Option.Instances
 public import Init.Data.BEq
 public import Init.Classical
 public import Init.Ext
+public import Init.Grind.Tactics
 
 public section
 
@@ -1537,15 +1538,22 @@ theorem pfilter_guard {a : α} {p : α → Bool} {q : (a' : α) → guard p a =
 
 /-! ### LT and LE -/
 
-@[simp, grind] theorem not_lt_none [LT α] {a : Option α} : ¬ a < none := by cases a <;> simp [LT.lt, Option.lt]
-@[grind] theorem none_lt_some [LT α] {a : α} : none < some a := by simp [LT.lt, Option.lt]
+@[simp] theorem not_lt_none [LT α] {a : Option α} : ¬ a < none := by cases a <;> simp [LT.lt, Option.lt]
+theorem none_lt_some [LT α] {a : α} : none < some a := by simp [LT.lt, Option.lt]
 @[simp] theorem none_lt [LT α] {a : Option α} : none < a ↔ a.isSome := by cases a <;> simp [none_lt_some]
-@[simp, grind] theorem some_lt_some [LT α] {a b : α} : some a < some b ↔ a < b := by simp [LT.lt, Option.lt]
+@[simp] theorem some_lt_some [LT α] {a b : α} : some a < some b ↔ a < b := by simp [LT.lt, Option.lt]
 
-@[simp, grind] theorem none_le [LE α] {a : Option α} : none ≤ a := by cases a <;> simp [LE.le, Option.le]
-@[grind] theorem not_some_le_none [LE α] {a : α} : ¬ some a ≤ none := by simp [LE.le, Option.le]
+@[simp] theorem none_le [LE α] {a : Option α} : none ≤ a := by cases a <;> simp [LE.le, Option.le]
+theorem not_some_le_none [LE α] {a : α} : ¬ some a ≤ none := by simp [LE.le, Option.le]
 @[simp] theorem le_none [LE α] {a : Option α} : a ≤ none ↔ a = none := by cases a <;> simp [not_some_le_none]
-@[simp, grind] theorem some_le_some [LE α] {a b : α} : some a ≤ some b ↔ a ≤ b := by simp [LE.le, Option.le]
+@[simp] theorem some_le_some [LE α] {a b : α} : some a ≤ some b ↔ a ≤ b := by simp [LE.le, Option.le]
+
+grind_pattern not_lt_none => a < none
+grind_pattern none_lt_some => none < some a
+grind_pattern some_lt_some => some a < some b
+grind_pattern none_le => none ≤ a
+grind_pattern not_some_le_none => some a ≤ none
+grind_pattern some_le_some => some a ≤ some b
 
 @[simp]
 theorem filter_le [LE α] (le_refl : ∀ x : α, x ≤ x) {o : Option α} {p : α → Bool} : o.filter p ≤ o := by

src/Init/Data/Range/Polymorphic.lean

@@ -8,6 +8,7 @@ module
 prelude
 public import Init.Data.Range.Polymorphic.Basic
 public import Init.Data.Range.Polymorphic.Iterators
+public import Init.Data.Range.Polymorphic.Stream
 public import Init.Data.Range.Polymorphic.Lemmas
 public import Init.Data.Range.Polymorphic.Nat
 public import Init.Data.Range.Polymorphic.NatLemmas

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

@@ -9,9 +9,8 @@ prelude
 public import Init.Data.Range.Polymorphic.RangeIterator
 public import Init.Data.Range.Polymorphic.Basic
 public import Init.Data.Iterators.Combinators.Attach
-public import Init.Data.Stream
 
-public section
+@[expose] public section
 
 open Std.Iterators
 
@@ -26,15 +25,11 @@ def Internal.iter {sl su α} [UpwardEnumerable α] [BoundedUpwardEnumerable sl
     (r : PRange ⟨sl, su⟩ α) : Iter (α := RangeIterator su α) α :=
   ⟨⟨BoundedUpwardEnumerable.init? r.lower, r.upper⟩⟩
 
-instance {sl su α} [UpwardEnumerable α] [BoundedUpwardEnumerable sl α] :
-    ToStream (PRange ⟨sl, su⟩ α) (Iter (α := RangeIterator su α) α) where
-  toStream r := Internal.iter r
-
 /--
 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]
+@[always_inline, inline, expose]
 def toList {sl su α} [UpwardEnumerable α] [BoundedUpwardEnumerable sl α]
     [SupportsUpperBound su α]
     (r : PRange ⟨sl, su⟩ α)
@@ -63,50 +58,6 @@ def size {sl su α} [UpwardEnumerable α] [BoundedUpwardEnumerable sl α]
 
 section Iterator
 
-theorem RangeIterator.isPlausibleIndirectOutput_iff {su α}
-    [UpwardEnumerable α] [SupportsUpperBound su α]
-    [LawfulUpwardEnumerable α] [LawfulUpwardEnumerableUpperBound su α]
-    {it : Iter (α := RangeIterator su α) α} {out : α} :
-    it.IsPlausibleIndirectOutput out ↔
-      ∃ n, it.internalState.next.bind (UpwardEnumerable.succMany? n ·) = some out ∧
-        SupportsUpperBound.IsSatisfied it.internalState.upperBound out := by
-  constructor
-  · intro h
-    induction h
-    case direct h =>
-      rw [RangeIterator.isPlausibleOutput_iff] at h
-      refine ⟨0, by simp [h, LawfulUpwardEnumerable.succMany?_zero]⟩
-    case indirect h _ ih =>
-      rw [RangeIterator.isPlausibleSuccessorOf_iff] at h
-      obtain ⟨n, hn⟩ := ih
-      obtain ⟨a, ha, h₁, h₂, h₃⟩ := h
-      refine ⟨n + 1, ?_⟩
-      simp [ha, ← h₃, hn.2, LawfulUpwardEnumerable.succMany?_succ_eq_succ?_bind_succMany?, h₂, hn]
-  · rintro ⟨n, hn, hu⟩
-    induction n generalizing it
-    case zero =>
-      apply Iter.IsPlausibleIndirectOutput.direct
-      rw [RangeIterator.isPlausibleOutput_iff]
-      exact ⟨by simpa [LawfulUpwardEnumerable.succMany?_zero] using hn, hu⟩
-    case succ ih =>
-      cases hn' : it.internalState.next
-      · simp [hn'] at hn
-      rename_i a
-      simp only [hn', Option.bind_some] at hn
-      have hle : UpwardEnumerable.LE a out := ⟨_, hn⟩
-      rw [LawfulUpwardEnumerable.succMany?_succ_eq_succ?_bind_succMany?] at hn
-      cases hn' : UpwardEnumerable.succ? a
-      · simp only [hn', Option.bind_none, reduceCtorEq] at hn
-      rename_i a'
-      simp only [hn', Option.bind_some] at hn
-      specialize ih (it := ⟨some a', it.internalState.upperBound⟩) hn hu
-      refine Iter.IsPlausibleIndirectOutput.indirect ?_ ih
-      rw [RangeIterator.isPlausibleSuccessorOf_iff]
-      refine ⟨a, ‹_›, ?_, hn', rfl⟩
-      apply LawfulUpwardEnumerableUpperBound.isSatisfied_of_le _ a out
-      · exact hu
-      · exact hle
-
 theorem Internal.isPlausibleIndirectOutput_iter_iff {sl su α}
     [UpwardEnumerable α] [BoundedUpwardEnumerable sl α]
     [SupportsLowerBound sl α] [SupportsUpperBound su α]
@@ -147,7 +98,6 @@ 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/NatLemmas.lean

@@ -17,8 +17,8 @@ theorem succ_eq {n : Nat} : UpwardEnumerable.succ n = n + 1 :=
   rfl
 
 theorem ClosedOpen.toList_succ_succ  {m n : Nat} :
-    (PRange.mk (shape := ⟨.closed, .open⟩) (m+1) (n+1)).toList =
-      (PRange.mk (shape := ⟨.closed, .open⟩) m n).toList.map (· + 1) := by
+    ((m+1)...(n+1)).toList =
+      (m...n).toList.map (· + 1) := by
   simp only [← succ_eq]
   rw [Std.PRange.ClosedOpen.toList_succ_succ_eq_map]
 

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

@@ -110,16 +110,6 @@ theorem RangeIterator.step_eq_step {su} [UpwardEnumerable α] [SupportsUpperBoun
     it.step = ⟨RangeIterator.step it, isPlausibleStep_iff.mpr rfl⟩ := by
   simp [Iter.step, step_eq_monadicStep, Monadic.step_eq_step, IterM.Step.toPure]
 
-@[always_inline, inline]
-instance RangeIterator.instIteratorLoop {su} [UpwardEnumerable α] [SupportsUpperBound su α]
-    {n : Type v → Type w} [Monad n] :
-    IteratorLoop (RangeIterator su α) Id n :=
-  .defaultImplementation
-
-instance RangeIterator.instIteratorLoopPartial {su} [UpwardEnumerable α] [SupportsUpperBound su α]
-    {n : Type v → Type w} [Monad n] : IteratorLoopPartial (RangeIterator su α) Id n :=
-  .defaultImplementation
-
 instance RangeIterator.instIteratorCollect {su} [UpwardEnumerable α] [SupportsUpperBound su α]
     {n : Type u → Type w} [Monad n] : IteratorCollect (RangeIterator su α) Id n :=
   .defaultImplementation
@@ -370,4 +360,223 @@ instance RangeIterator.instLawfulDeterministicIterator {su} [UpwardEnumerable α
     LawfulDeterministicIterator (RangeIterator su α) Id where
   isPlausibleStep_eq_eq it := ⟨Monadic.step it, rfl⟩
 
-end Std.PRange
+theorem RangeIterator.Monadic.isPlausibleIndirectOutput_iff {su α}
+    [UpwardEnumerable α] [SupportsUpperBound su α]
+    [LawfulUpwardEnumerable α] [LawfulUpwardEnumerableUpperBound su α]
+    {it : IterM (α := RangeIterator su α) Id α} {out : α} :
+    it.IsPlausibleIndirectOutput out ↔
+      ∃ n, it.internalState.next.bind (UpwardEnumerable.succMany? n ·) = some out ∧
+        SupportsUpperBound.IsSatisfied it.internalState.upperBound out := by
+  constructor
+  · intro h
+    induction h
+    case direct h =>
+      rw [RangeIterator.Monadic.isPlausibleOutput_iff] at h
+      refine ⟨0, by simp [h, LawfulUpwardEnumerable.succMany?_zero]⟩
+    case indirect h _ ih =>
+      rw [RangeIterator.Monadic.isPlausibleSuccessorOf_iff] at h
+      obtain ⟨n, hn⟩ := ih
+      obtain ⟨a, ha, h₁, h₂, h₃⟩ := h
+      refine ⟨n + 1, ?_⟩
+      simp [ha, ← h₃, hn.2, LawfulUpwardEnumerable.succMany?_succ_eq_succ?_bind_succMany?, h₂, hn]
+  · rintro ⟨n, hn, hu⟩
+    induction n generalizing it
+    case zero =>
+      apply IterM.IsPlausibleIndirectOutput.direct
+      rw [RangeIterator.Monadic.isPlausibleOutput_iff]
+      exact ⟨by simpa [LawfulUpwardEnumerable.succMany?_zero] using hn, hu⟩
+    case succ ih =>
+      cases hn' : it.internalState.next
+      · simp [hn'] at hn
+      rename_i a
+      simp only [hn', Option.bind_some] at hn
+      have hle : UpwardEnumerable.LE a out := ⟨_, hn⟩
+      rw [LawfulUpwardEnumerable.succMany?_succ_eq_succ?_bind_succMany?] at hn
+      cases hn' : UpwardEnumerable.succ? a
+      · simp only [hn', Option.bind_none, reduceCtorEq] at hn
+      rename_i a'
+      simp only [hn', Option.bind_some] at hn
+      specialize ih (it := ⟨some a', it.internalState.upperBound⟩) hn hu
+      refine IterM.IsPlausibleIndirectOutput.indirect ?_ ih
+      rw [RangeIterator.Monadic.isPlausibleSuccessorOf_iff]
+      refine ⟨a, ‹_›, ?_, hn', rfl⟩
+      apply LawfulUpwardEnumerableUpperBound.isSatisfied_of_le _ a out
+      · exact hu
+      · exact hle
+
+theorem RangeIterator.isPlausibleIndirectOutput_iff {su α}
+    [UpwardEnumerable α] [SupportsUpperBound su α]
+    [LawfulUpwardEnumerable α] [LawfulUpwardEnumerableUpperBound su α]
+    {it : Iter (α := RangeIterator su α) α} {out : α} :
+    it.IsPlausibleIndirectOutput out ↔
+      ∃ n, it.internalState.next.bind (UpwardEnumerable.succMany? n ·) = some out ∧
+        SupportsUpperBound.IsSatisfied it.internalState.upperBound out := by
+  simp only [Iter.isPlausibleIndirectOutput_iff_isPlausibleIndirectOutput_toIterM,
+    Monadic.isPlausibleIndirectOutput_iff, Iter.toIterM]
+
+section IteratorLoop
+
+/-!
+## Efficient `IteratorLoop` instance
+As long as the compiler cannot optimize away the `Option` in the internal state, we use a special
+loop implementation.
+-/
+
+@[always_inline, inline]
+instance RangeIterator.instIteratorLoop {su} [UpwardEnumerable α] [SupportsUpperBound su α]
+    [LawfulUpwardEnumerable α] [LawfulUpwardEnumerableUpperBound su α]
+    {n : Type u → Type w} [Monad n] :
+    IteratorLoop (RangeIterator su α) Id n where
+  forIn _ γ Pl wf it init f :=
+    match it with
+    | ⟨⟨some next, upperBound⟩⟩ =>
+      if hu : SupportsUpperBound.IsSatisfied upperBound next then
+        loop γ Pl wf upperBound next init (fun a ha₁ ha₂ c => f a ?hf c) next ?hle hu
+      else
+        return init
+    | ⟨⟨none, _⟩⟩ => return init
+  where
+    @[specialize]
+    loop γ Pl wf (upperBound : Bound su α) least acc
+        (f : (out : α) → UpwardEnumerable.LE least out → SupportsUpperBound.IsSatisfied upperBound out → (c : γ) → n (Subtype (fun s : ForInStep γ => Pl out c s)))
+        (next : α) (hl : UpwardEnumerable.LE least next) (hu : SupportsUpperBound.IsSatisfied upperBound next) : n γ := do
+      match ← f next hl hu acc with
+      | ⟨.yield acc', h⟩ =>
+        match hs : UpwardEnumerable.succ? next with
+        | some next' =>
+          if hu : SupportsUpperBound.IsSatisfied upperBound next' then
+            loop γ Pl wf upperBound least acc' f next' ?hle' hu
+          else
+            return acc'
+        | none => return acc'
+      | ⟨.done acc', _⟩ => return acc'
+    termination_by IteratorLoop.WithWF.mk ⟨⟨some next, upperBound⟩⟩ acc (hwf := wf)
+    decreasing_by
+      simp [IteratorLoop.rel, RangeIterator.Monadic.isPlausibleStep_iff,
+        RangeIterator.Monadic.step, *]
+  finally
+    case hf =>
+      rw [RangeIterator.Monadic.isPlausibleIndirectOutput_iff]
+      obtain ⟨n, hn⟩ := ha₁
+      exact ⟨n, hn, ha₂⟩
+    case hle =>
+      exact UpwardEnumerable.le_refl _
+    case hle' =>
+      refine UpwardEnumerable.le_trans hl ⟨1, ?_⟩
+      simp [UpwardEnumerable.succMany?_one, hs]
+
+partial instance RepeatIterator.instIteratorLoopPartial {su} [UpwardEnumerable α]
+    [SupportsUpperBound su α] [LawfulUpwardEnumerable α] [LawfulUpwardEnumerableUpperBound su α]
+    {n : Type u → Type w} [Monad n] : IteratorLoopPartial (RangeIterator su α) Id n where
+  forInPartial _ γ it init f :=
+    match it with
+    | ⟨⟨some next, upperBound⟩⟩ =>
+      if hu : SupportsUpperBound.IsSatisfied upperBound next then
+        loop γ upperBound next init (fun a ha₁ ha₂ c => f a ?hf c) next ?hle hu
+      else
+        return init
+    | ⟨⟨none, _⟩⟩ => return init
+  where
+    @[specialize]
+    loop γ (upperBound : Bound su α) least acc
+        (f : (out : α) → UpwardEnumerable.LE least out → SupportsUpperBound.IsSatisfied upperBound out → (c : γ) → n (ForInStep γ))
+        (next : α) (hl : UpwardEnumerable.LE least next) (hu : SupportsUpperBound.IsSatisfied upperBound next) : n γ := do
+      match ← f next hl hu acc with
+      | .yield acc' =>
+        match hs : UpwardEnumerable.succ? next with
+        | some next' =>
+          if hu : SupportsUpperBound.IsSatisfied upperBound next' then
+            loop γ upperBound least acc' f next' ?hle' hu
+          else
+            return acc'
+        | none => return acc'
+      | .done acc' => return acc'
+  finally
+    case hf =>
+      rw [RangeIterator.Monadic.isPlausibleIndirectOutput_iff]
+      obtain ⟨n, hn⟩ := ha₁
+      exact ⟨n, hn, ha₂⟩
+    case hle =>
+      exact UpwardEnumerable.le_refl _
+    case hle' =>
+      refine UpwardEnumerable.le_trans hl ⟨1, ?_⟩
+      simp [UpwardEnumerable.succMany?_one, hs]
+
+theorem RangeIterator.instIteratorLoop.loop_eq {su} [UpwardEnumerable α] [SupportsUpperBound su α]
+    [LawfulUpwardEnumerable α] [LawfulUpwardEnumerableUpperBound su α]
+    {n : Type u → Type w} [Monad n] [LawfulMonad n] {γ : Type u}
+    {lift} [Internal.LawfulMonadLiftBindFunction lift]
+    {PlausibleForInStep} {upperBound} {next} {hl} {hu} {f} {acc} {wf} :
+    loop (α := α) (su := su) (n := n) γ PlausibleForInStep wf upperBound least acc f next hl hu =
+      (do
+        match ← f next hl hu acc with
+        | ⟨.yield c, _⟩ =>
+          letI it' : IterM (α := RangeIterator su α) Id α := ⟨⟨UpwardEnumerable.succ? next, upperBound⟩⟩
+          IterM.DefaultConsumers.forIn' (m := Id) lift γ
+            PlausibleForInStep wf it' c it'.IsPlausibleIndirectOutput (fun _ => id)
+            (fun b h c => f b
+                (by
+                  refine UpwardEnumerable.le_trans hl ?_
+                  simp only [RangeIterator.Monadic.isPlausibleIndirectOutput_iff, it',
+                    ← LawfulUpwardEnumerable.succMany?_succ_eq_succ?_bind_succMany?] at h
+                  exact ⟨h.choose + 1, h.choose_spec.1⟩)
+                (by simp only [RangeIterator.Monadic.isPlausibleIndirectOutput_iff, it'] at h; exact h.choose_spec.2) c)
+        | ⟨.done c, _⟩ => return c) := by
+  rw [loop]
+  apply bind_congr
+  intro step
+  split
+  · split
+    · split
+      · simp only [*]
+        rw [IterM.DefaultConsumers.forIn']
+        simp only [Monadic.step_eq_step, Monadic.step, ↓reduceIte, *,
+          Internal.LawfulMonadLiftBindFunction.liftBind_pure]
+        rw [loop_eq (lift := lift)]
+        apply bind_congr
+        intro step
+        split
+        · apply IterM.DefaultConsumers.forIn'_eq_forIn'
+          intros; rfl
+        · simp
+      · simp only [*]
+        rw [IterM.DefaultConsumers.forIn']
+        simp [Monadic.step_eq_step, Monadic.step, *,
+          Internal.LawfulMonadLiftBindFunction.liftBind_pure]
+    · simp only [*]
+      rw [IterM.DefaultConsumers.forIn']
+      simp [Monadic.step_eq_step, Monadic.step, Internal.LawfulMonadLiftBindFunction.liftBind_pure]
+  · simp
+termination_by IteratorLoop.WithWF.mk ⟨⟨some next, upperBound⟩⟩ acc (hwf := wf)
+decreasing_by
+      simp [IteratorLoop.rel, RangeIterator.Monadic.isPlausibleStep_iff,
+        RangeIterator.Monadic.step, *]
+
+instance RangeIterator.instLawfulIteratorLoop {su} [UpwardEnumerable α] [SupportsUpperBound su α]
+    [LawfulUpwardEnumerable α] [LawfulUpwardEnumerableUpperBound su α]
+    {n : Type u → Type w} [Monad n] [LawfulMonad n] :
+    LawfulIteratorLoop (RangeIterator su α) Id n where
+  lawful := by
+    intro lift instLawfulMonadLiftFunction
+    ext γ PlausibleForInStep hwf it init f
+    simp only [IteratorLoop.forIn, IteratorLoop.defaultImplementation]
+    rw [IterM.DefaultConsumers.forIn']
+    simp only [RangeIterator.Monadic.step_eq_step, RangeIterator.Monadic.step]
+    simp only [Internal.LawfulMonadLiftBindFunction.liftBind_pure]
+    split
+    · rename_i it f next upperBound f'
+      simp
+      split
+      · simp only
+        rw [instIteratorLoop.loop_eq (lift := lift)]
+        apply bind_congr
+        intro step
+        split
+        · apply IterM.DefaultConsumers.forIn'_eq_forIn'
+          intro b c hPb hQb
+          congr
+        · simp
+      · simp
+    · simp
+
+end Std.PRange.IteratorLoop

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

@@ -0,0 +1,22 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Paul Reichert
+-/
+module
+
+prelude
+public import Init.Data.Range.Polymorphic.Iterators
+public import Init.Data.Stream
+
+public section
+
+open Std.Iterators
+
+namespace Std.PRange
+
+instance {sl su α} [UpwardEnumerable α] [BoundedUpwardEnumerable sl α] :
+    ToStream (PRange ⟨sl, su⟩ α) (Iter (α := RangeIterator su α) α) where
+  toStream r := Internal.iter r
+
+end Std.PRange

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

@@ -8,8 +8,11 @@ module
 prelude
 public import Init.Core
 public import Init.Data.Slice.Array.Basic
-public import Init.Data.Iterators.Combinators.Attach
-public import Init.Data.Iterators.Combinators.FilterMap
+import Init.Data.Iterators.Combinators.Attach
+import Init.Data.Iterators.Combinators.FilterMap
+import Init.Data.Iterators.Combinators.ULift
+public import Init.Data.Iterators.Consumers.Collect
+public import Init.Data.Iterators.Consumers.Loop
 public import all Init.Data.Range.Polymorphic.Basic
 public import Init.Data.Range.Polymorphic.Nat
 public import Init.Data.Range.Polymorphic.Iterators
@@ -26,6 +29,7 @@ open Std Slice PRange Iterators
 
 variable {shape : RangeShape} {α : Type u}
 
+@[no_expose]
 instance {s : Subarray α} : ToIterator s Id α :=
   .of _
     (PRange.Internal.iter (s.internalRepresentation.start...<s.internalRepresentation.stop)
@@ -39,3 +43,102 @@ where finally
     intro out _ h
     have := s.internalRepresentation.stop_le_array_size
     omega
+
+universe v w
+
+@[no_expose] instance {s : Subarray α} : Iterator (ToIterator.State s Id) Id α := inferInstance
+@[no_expose] instance {s : Subarray α} : Finite (ToIterator.State s Id) Id := inferInstance
+@[no_expose] instance {s : Subarray α} : IteratorCollect (ToIterator.State s Id) Id Id := inferInstance
+@[no_expose] instance {s : Subarray α} : IteratorCollectPartial (ToIterator.State s Id) Id Id := inferInstance
+@[no_expose] instance {s : Subarray α} {m : Type v → Type w} [Monad m] :
+    IteratorLoop (ToIterator.State s Id) Id m := inferInstance
+@[no_expose] instance {s : Subarray α} {m : Type v → Type w} [Monad m] :
+    IteratorLoopPartial (ToIterator.State s Id) Id m := inferInstance
+@[no_expose] instance {s : Subarray α} :
+    IteratorSize (ToIterator.State s Id) Id := inferInstance
+@[no_expose] instance {s : Subarray α} :
+    IteratorSizePartial (ToIterator.State s Id) Id := inferInstance
+
+@[no_expose]
+instance {α : Type u} {m : Type v → Type w} :
+    ForIn m (Subarray α) α where
+  forIn xs init f := forIn (Std.Slice.Internal.iter xs) init f
+
+/-!
+Without defining the following function `Subarray.foldlM`, it is still possible to call
+`subarray.foldlM`, which would be elaborated to `Slice.foldlM (s := subarray)`. However, in order to
+maximize backward compatibility and avoid confusion in the manual entry for `Subarray`, we
+explicitly provide the wrapper function `Subarray.foldlM` for `Slice.foldlM`, providing a more
+specific docstring.
+-/
+
+/--
+Folds a monadic operation from left to right over the elements in a subarray.
+An accumulator of type `β` is constructed by starting with `init` and monadically combining each
+element of the subarray with the current accumulator value in turn. The monad in question may permit
+early termination or repetition.
+Examples:
+```lean example
+#eval #["red", "green", "blue"].toSubarray.foldlM (init := "") fun acc x => do
+  let l ← Option.guard (· ≠ 0) x.length
+  return s!"{acc}({l}){x} "
+```
+```output
+some "(3)red (5)green (4)blue "
+```
+```lean example
+#eval #["red", "green", "blue"].toSubarray.foldlM (init := 0) fun acc x => do
+  let l ← Option.guard (· ≠ 5) x.length
+  return s!"{acc}({l}){x} "
+```
+```output
+none
+```
+-/
+@[inline]
+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 foldl {α : Type u} {β : Type v} (f : β → α → β) (init : β) (as : Subarray α) : β :=
+  Slice.foldl f (init := init) as
+
+namespace Array
+
+/--
+Allocates a new array that contains the contents of the subarray.
+-/
+@[coe]
+def ofSubarray (s : Subarray α) : Array α :=
+  Slice.toArray s
+
+instance : Coe (Subarray α) (Array α) := ⟨ofSubarray⟩
+
+instance : Append (Subarray α) where
+  append x y :=
+   let a := x.toArray ++ y.toArray
+   a.toSubarray 0 a.size
+
+/-- `Subarray` representation. -/
+protected def Subarray.repr [Repr α] (s : Subarray α) : Std.Format :=
+  repr s.toArray ++ ".toSubarray"
+
+instance [Repr α] : Repr (Subarray α) where
+  reprPrec s  _ := Subarray.repr s
+
+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/Slice/Array/Lemmas.lean

@@ -21,7 +21,7 @@ open Std.Iterators Std.PRange
 
 namespace Std.Slice.Array
 
-theorem internalIter_eq {α : Type u} {s : Subarray α} :
+private theorem internalIter_eq {α : Type u} {s : Subarray α} :
     Internal.iter s = (PRange.Internal.iter (s.start...<s.stop)
       |>.attachWith (· < s.array.size)
         (fun out h => h
@@ -32,7 +32,7 @@ theorem internalIter_eq {α : Type u} {s : Subarray α} :
       |>.map fun | .up i => s.array[i.1]) := by
   simp [Internal.iter, ToIterator.iter_eq, Subarray.start, Subarray.stop, Subarray.array]
 
-theorem toList_internalIter {α : Type u} {s : Subarray α} :
+private theorem toList_internalIter {α : Type u} {s : Subarray α} :
     (Internal.iter s).toList =
       ((s.start...s.stop).toList
         |>.attachWith (· < s.array.size)

src/Init/Data/Slice/Lemmas.lean

@@ -7,6 +7,7 @@ module
 
 prelude
 public import all Init.Data.Slice.Operations
+import Init.Data.Iterators.Lemmas.Consumers
 
 public section
 

src/Init/Data/Slice/Operations.lean

@@ -8,7 +8,7 @@ module
 prelude
 public import Init.Data.Slice.Basic
 public import Init.Data.Slice.Notation
-public import Init.Data.Iterators
+public import Init.Data.Iterators.ToIterator
 
 public section
 
@@ -34,26 +34,72 @@ Returns the number of elements with distinct indices in the given slice.
 Example: `#[1, 1, 1][0...2].size = 2`.
 -/
 @[always_inline, inline]
-def size (s : Slice g) [ToIterator s Id β] [Iterator (ToIterator.State s Id) Id β]
+def size (s : Slice γ) [ToIterator s Id β] [Iterator (ToIterator.State s Id) Id β]
     [IteratorSize (ToIterator.State s Id) Id] :=
   Internal.iter s |>.size
 
 /-- Allocates a new array that contains the elements of the slice. -/
 @[always_inline, inline]
-def toArray (s : Slice g) [ToIterator s Id β] [Iterator (ToIterator.State s Id) Id β]
+def toArray (s : Slice γ) [ToIterator s Id β] [Iterator (ToIterator.State s Id) Id β]
     [IteratorCollect (ToIterator.State s Id) Id Id] [Finite (ToIterator.State s Id) Id] : Array β :=
   Internal.iter s |>.toArray
 
 /-- Allocates a new list that contains the elements of the slice. -/
 @[always_inline, inline]
-def toList (s : Slice g) [ToIterator s Id β] [Iterator (ToIterator.State s Id) Id β]
+def toList (s : Slice γ) [ToIterator s Id β] [Iterator (ToIterator.State s Id) Id β]
     [IteratorCollect (ToIterator.State s Id) Id Id] [Finite (ToIterator.State s Id) Id] : List β :=
   Internal.iter s |>.toList
 
 /-- Allocates a new list that contains the elements of the slice in reverse order. -/
 @[always_inline, inline]
-def toListRev (s : Slice g) [ToIterator s Id β] [Iterator (ToIterator.State s Id) Id β]
+def toListRev (s : Slice γ) [ToIterator s Id β] [Iterator (ToIterator.State s Id) Id β]
     [Finite (ToIterator.State s Id) Id] : List β :=
   Internal.iter s |>.toListRev
 
+/--
+Folds a monadic operation from left to right over the elements in a slice.
+An accumulator of type `β` is constructed by starting with `init` and monadically combining each
+element of the slice with the current accumulator value in turn. The monad in question may permit
+early termination or repetition.
+
+Examples for the special case of subarrays:
+```lean example
+#eval #["red", "green", "blue"].toSubarray.foldlM (init := "") fun acc x => do
+  let l ← Option.guard (· ≠ 0) x.length
+  return s!"{acc}({l}){x} "
+```
+```output
+some "(3)red (5)green (4)blue "
+```
+```lean example
+#eval #["red", "green", "blue"].toSubarray.foldlM (init := 0) fun acc x => do
+  let l ← Option.guard (· ≠ 5) x.length
+  return s!"{acc}({l}){x} "
+```
+```output
+none
+```
+-/
+@[always_inline, inline]
+def foldlM {γ : Type u} {β : Type v}
+    {δ : Type w} {m : Type w → Type w'} [Monad m] (f : δ → β → m δ) (init : δ)
+    (s : Slice γ) [ToIterator s Id β] [Iterator (ToIterator.State s Id) Id β]
+    [IteratorLoop (ToIterator.State s Id) Id m] [Finite (ToIterator.State s Id) Id] : m δ :=
+  Internal.iter s |>.foldM f init
+
+/--
+Folds an operation from left to right over the elements in a slice.
+An accumulator of type `β` is constructed by starting with `init` and combining each
+element of the slice with the current accumulator value in turn.
+Examples for the special case of subarrays:
+ * `#["red", "green", "blue"].toSubarray.foldl (· + ·.length) 0 = 12`
+ * `#["red", "green", "blue"].toSubarray.popFront.foldl (· + ·.length) 0 = 9`
+-/
+@[always_inline, inline]
+def foldl {γ : Type u} {β : Type v}
+    {δ : Type w} (f : δ → β → δ) (init : δ)
+    (s : Slice γ) [ToIterator s Id β] [Iterator (ToIterator.State s Id) Id β]
+    [IteratorLoop (ToIterator.State s Id) Id Id] [Finite (ToIterator.State s Id) Id] : δ :=
+  Internal.iter s |>.fold f init
+
 end Std.Slice

src/Init/Data/String/Basic.lean

@@ -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`. The result is unspecified if `p` is not a
-valid position or if `p = s.endPos`.
+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`.
 
 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 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
+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
 
 Examples:
 * `"abc".get ("abc".next 0) = 'b'`
@@ -247,17 +247,18 @@ def next (s : @& String) (p : @& Pos) : Pos :=
   p + c
 
 def utf8PrevAux : List Char → Pos → Pos → Pos
-  | [],    _, _ => 0
+  | [],    _, p => ⟨p.byteIdx - 1⟩
   | c::cs, i, p =>
     let i' := i + c
-    if i' = p then i else utf8PrevAux cs i' p
+    if p ≤ i' 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 not a valid position, the result is unspecified.
+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.
 
-For example, `"L∃∀N".prev ⟨3⟩` is unspecified, since byte 3 occurs in the middle of the multi-byte
-character `'∃'`.
+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.
 
 Examples:
 * `"abc".get ("abc".endPos |> "abc".prev) = 'c'`
@@ -265,7 +266,7 @@ Examples:
 -/
 @[extern "lean_string_utf8_prev", expose]
 def prev : (@& String) → (@& Pos) → Pos
-  | ⟨s⟩, p => if p = 0 then 0 else utf8PrevAux s 0 p
+  | ⟨s⟩, p => utf8PrevAux s 0 p
 
 /--
 Returns the first character in `s`. If `s = ""`, returns `(default : Char)`.
@@ -339,7 +340,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)
 ```
 
@@ -369,20 +370,17 @@ 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), p ≠ 0 →
+theorem utf8PrevAux_lt_of_pos : ∀ (cs : List Char) (i p : Pos), i < p → p ≠ 0 →
     (utf8PrevAux cs i p).1 < p.1
-  | [], _, _, 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
+  | [], _, _, _, h => Nat.sub_one_lt (mt (congrArg Pos.mk) h)
+  | c::cs, i, p, h, h' => by
     simp [utf8PrevAux]
-    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
+    apply iteInduction (motive := (Pos.byteIdx · < _)) <;> intro h''
+    next => exact h
+    next => exact utf8PrevAux_lt_of_pos _ _ _ (Nat.lt_of_not_le 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
+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
 
 def posOfAux (s : String) (c : Char) (stopPos : Pos) (pos : Pos) : Pos :=
   if h : pos < stopPos then
@@ -419,7 +417,7 @@ Returns the position of the last occurrence of a character, `c`, in a string `s`
 contain `c`, returns `none`.
 
 Examples:
-* `"abcabc".refPosOf 'a' = some ⟨3⟩`
+* `"abcabc".revPosOf 'a' = some ⟨3⟩`
 * `"abcabc".revPosOf 'z' = none`
 * `"L∃∀N".revPosOf '∀' = some ⟨4⟩`
 -/
@@ -2068,7 +2066,11 @@ 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 := rfl
+@[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 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
 
-public section
+@[expose] public section
 
 set_option linter.missingDocs true
 

src/Init/Data/Vector/Basic.lean

@@ -8,13 +8,14 @@ module
 
 prelude
 public meta import Init.Coe
+public import Init.Data.Stream
 public import Init.Data.Array.Lemmas
 public import Init.Data.Array.MapIdx
 public import Init.Data.Array.InsertIdx
 public import Init.Data.Array.Range
 public import Init.Data.Range
-import Init.Data.Slice.Array.Basic
-public import Init.Data.Stream
+-- TODO: Making this private leads to a panic in Init.Grind.Ring.Poly.
+public import Init.Data.Slice.Array.Iterator
 
 public section
 
@@ -54,6 +55,11 @@ open Lean in
 macro_rules
   | `(#v[ $elems,* ]) => `(Vector.mk (n := $(quote elems.getElems.size)) #[$elems,*] rfl)
 
+@[app_unexpander Vector.mk]
+meta def unexpandMk : Lean.PrettyPrinter.Unexpander
+  | `($_ #[ $elems,* ] $_) => `(#v[ $elems,* ])
+  | _ => throw ()
+
 recommended_spelling "empty" for "#v[]" in [Vector.mk, «term#v[_,]»]
 recommended_spelling "singleton" for "#v[x]" in [Vector.mk, «term#v[_,]»]
 
@@ -562,7 +568,7 @@ Lexicographic comparator for vectors.
 - there is an index `i` such that `lt v[i] w[i]`, and for all `j < i`, `v[j] == w[j]`.
 -/
 def lex [BEq α] (xs ys : Vector α n) (lt : α → α → Bool := by exact (· < ·)) : Bool := Id.run do
-  for h : i in [0 : n] do
+  for h : i in 0...n do
     if lt xs[i] ys[i] then
       return true
     else if xs[i] != ys[i] then

src/Init/Data/Vector/Erase.lean

@@ -55,11 +55,12 @@ theorem getElem_eraseIdx {xs : Vector α n} {i : Nat} (h : i < n) {j : Nat} (h'
   rw [← getElem?_eq_getElem, getElem?_eraseIdx]
   split <;> simp
 
-@[grind →]
 theorem mem_of_mem_eraseIdx {xs : Vector α n} {i : Nat} {h} {a : α} (h : a ∈ xs.eraseIdx i) : a ∈ xs := by
   rcases xs with ⟨xs, rfl⟩
   simpa using Array.mem_of_mem_eraseIdx (by simpa using h)
 
+grind_pattern mem_of_mem_eraseIdx => a ∈ xs.eraseIdx i
+
 theorem eraseIdx_append_of_lt_size {xs : Vector α n} {k : Nat} (hk : k < n) (xs' : Vector α n) (h) :
     eraseIdx (xs ++ xs') k = (eraseIdx xs k ++ xs').cast (by omega) := by
   rcases xs with ⟨xs⟩

src/Init/Data/Vector/Lemmas.lean

@@ -284,7 +284,7 @@ set_option linter.indexVariables false in
     (xs.drop i).toArray = xs.toArray.extract i n := by
   simp [drop]
 
-@[simp, grind] theorem toArray_empty : (#v[] : Vector α 0).toArray = #[] := rfl
+@[simp, grind =] theorem toArray_empty : (#v[] : Vector α 0).toArray = #[] := rfl
 
 @[simp, grind] theorem toArray_emptyWithCapacity {cap} :
     (Vector.emptyWithCapacity (α := α) cap).toArray = Array.emptyWithCapacity cap := rfl
@@ -828,7 +828,7 @@ theorem getElem?_eq_none {xs : Vector α n} (h : n ≤ i) : xs[i]? = none := by
 
 -- This is a more aggressive pattern than for `List/Array.getElem?_eq_none`, because
 -- `length/size` won't appear.
-grind_pattern Vector.getElem?_eq_none => n ≤ i, xs[i]?
+grind_pattern Vector.getElem?_eq_none => xs[i]?
 
 @[simp] theorem getElem?_eq_getElem {xs : Vector α n} {i : Nat} (h : i < n) : xs[i]? = some xs[i] :=
   getElem?_pos ..
@@ -1219,12 +1219,12 @@ instance [BEq α] [LawfulBEq α] (a : α) (as : Vector α n) : Decidable (a ∈
     as.contains a = decide (a ∈ as) := by
   rw [Bool.eq_iff_iff, contains_iff, decide_eq_true_iff]
 
-@[simp] theorem any_push [BEq α] {as : Vector α n} {a : α} {p : α → Bool} :
+@[simp] theorem any_push {as : Vector α n} {a : α} {p : α → Bool} :
     (as.push a).any p = (as.any p || p a) := by
   rcases as with ⟨as, rfl⟩
   simp
 
-@[simp] theorem all_push [BEq α] {as : Vector α n} {a : α} {p : α → Bool} :
+@[simp] theorem all_push {as : Vector α n} {a : α} {p : α → Bool} :
     (as.push a).all p = (as.all p && p a) := by
   rcases as with ⟨as, rfl⟩
   simp
@@ -1287,11 +1287,12 @@ theorem mem_set {xs : Vector α n} {i : Nat} {a : α} (hi : i < n) : a ∈ xs.se
   simp [mem_iff_getElem]
   exact ⟨i, (by simpa using hi), by simp⟩
 
-@[grind →]
 theorem mem_or_eq_of_mem_set {xs : Vector α n} {i : Nat} {a b : α} {hi : i < n} (h : a ∈ xs.set i b) : a ∈ xs ∨ a = b := by
   cases xs
   simpa using Array.mem_or_eq_of_mem_set (by simpa using h)
 
+grind_pattern mem_or_eq_of_mem_set => a ∈ xs.set i b
+
 /-! ### setIfInBounds -/
 
 @[simp, grind] theorem setIfInBounds_empty {i : Nat} {a : α} :

src/Init/Data/Vector/Lex.lean

@@ -10,6 +10,7 @@ public import all Init.Data.Vector.Basic
 public import Init.Data.Vector.Lemmas
 public import all Init.Data.Array.Lex.Basic
 public import Init.Data.Array.Lex.Lemmas
+import Init.Data.Range.Polymorphic.Lemmas
 
 public section
 
@@ -21,8 +22,11 @@ namespace Vector
 
 /-! ### Lexicographic ordering -/
 
-@[simp, grind =] theorem lt_toArray [LT α] {xs ys : Vector α n} : xs.toArray < ys.toArray ↔ xs < ys := Iff.rfl
-@[simp, grind =] theorem le_toArray [LT α] {xs ys : Vector α n} : xs.toArray ≤ ys.toArray ↔ xs ≤ ys := Iff.rfl
+@[simp] theorem lt_toArray [LT α] {xs ys : Vector α n} : xs.toArray < ys.toArray ↔ xs < ys := Iff.rfl
+@[simp] theorem le_toArray [LT α] {xs ys : Vector α n} : xs.toArray ≤ ys.toArray ↔ xs ≤ ys := Iff.rfl
+
+grind_pattern lt_toArray => xs.toArray < ys.toArray
+grind_pattern le_toArray => xs.toArray ≤ ys.toArray
 
 @[simp] theorem lt_toList [LT α] {xs ys : Vector α n} : xs.toList < ys.toList ↔ xs < ys := Iff.rfl
 @[simp] theorem le_toList [LT α] {xs ys : Vector α n} : xs.toList ≤ ys.toList ↔ xs ≤ ys := Iff.rfl
@@ -40,7 +44,7 @@ protected theorem not_le_iff_gt [LT α] {xs ys : Vector α n} :
 
 @[simp] theorem mk_lex_mk [BEq α] {lt : α → α → Bool} {xs ys : Array α} {n₁ : xs.size = n} {n₂ : ys.size = n} :
     (Vector.mk xs n₁).lex (Vector.mk ys n₂) lt = xs.lex ys lt := by
-  simp [Vector.lex, Array.lex, n₁, n₂]
+  simp [Vector.lex, Array.lex, n₁, n₂, Std.PRange.forIn'_eq_forIn'_toList]
   rfl
 
 @[simp, grind =] theorem lex_toArray [BEq α] {lt : α → α → Bool} {xs ys : Vector α n} :

src/Init/GetElem.lean

@@ -362,10 +362,9 @@ instance : GetElem? (List α) Nat α fun as i => i < as.length where
 theorem none_eq_getElem?_iff {l : List α} {i : Nat} : none = l[i]? ↔ length l ≤ i := by
   simp [eq_comm (a := none)]
 
+@[grind =]
 theorem getElem?_eq_none (h : length l ≤ i) : l[i]? = none := getElem?_eq_none_iff.mpr h
 
-grind_pattern List.getElem?_eq_none => l.length ≤ i, l[i]?
-
 instance : LawfulGetElem (List α) Nat α fun as i => i < as.length where
   getElem?_def as i h := by
     split <;> simp_all

src/Init/GetElemV.lean

@@ -0,0 +1,48 @@
+/-
+Copyright (c) 2025 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Kim Morrison
+-/
+module
+
+prelude
+public import Init.GetElem
+public import Init.Classical
+
+public section
+
+@[inherit_doc GetElem]
+class GetElemV (coll : Type u) (idx : Type v) (elem : outParam (Type w)) where
+  /--
+  The syntax `arr[i]ᵛ` gets the `i`'th element of the collection `arr`,
+  if it is present, and otherwise returns a (noncomputable) default value.
+  -/
+  getElemV [Nonempty elem] : coll → idx → elem
+
+export GetElemV (getElemV)
+
+/--
+The syntax `arr[i]ᵛ` gets the `i`'th element of the collection `arr` or
+a (noncomputable) default value if `i` is out of bounds.
+-/
+macro:max x:term noWs "[" i:term "]ᵛ" : term => `(getElemV $x $i)
+
+recommended_spelling "getElemV" for "xs[i]ᵛ" in [GetElemV.getElemV, «term__[_]ᵛ»]
+
+open Classical
+
+noncomputable instance (priority := low) [GetElem coll idx elem valid] : GetElemV coll idx elem where
+  getElemV xs i := if h : valid xs i then xs[i]'h else choice ‹Nonempty elem›
+
+class LawfulGetElemV (cont : Type u) (idx : Type v) (elem : outParam (Type w))
+   (dom : outParam (cont → idx → Prop)) [GetElem cont idx elem dom] [GetElemV cont idx elem] : Prop where
+  /-- The "verification only" getter notation `xs[i]ᵛ` coincides with the usual `xs[i]`. -/
+  getElemV_def [Nonempty elem] (c : cont) (i : idx) :
+      c[i]ᵛ = if h : dom c i then c[i]'h else choice ‹Nonempty elem›
+
+theorem getElem_eq_getElemV
+    [GetElem coll idx elem valid] [GetElemV coll idx elem]
+    [LawfulGetElemV coll idx elem valid] {xs : coll} {i : idx} (h : valid xs i) :
+    xs[i] = @GetElemV.getElemV _ _ _ _ ⟨xs[i]⟩ xs i := by
+  have : Nonempty elem := ⟨xs[i]⟩
+  rw [LawfulGetElemV.getElemV_def, dif_pos h]

src/Init/Grind.lean

@@ -20,6 +20,7 @@ public import Init.Grind.Ordered
 public import Init.Grind.Ext
 public import Init.Grind.ToInt
 public import Init.Grind.ToIntLemmas
+public import Init.Grind.Attr
 public import Init.Data.Int.OfNat -- This may not have otherwise been imported, breaking `grind` proofs.
 
 public section

src/Init/Grind/Attr.lean

@@ -0,0 +1,93 @@
+/-
+Copyright (c) 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+module
+
+prelude
+public import Init.Tactics
+
+public section
+
+namespace Lean.Grind
+/--
+Gadget for representing generalization steps `h : x = val` in patterns
+This gadget is used to represent patterns in theorems that have been generalized to reduce the
+number of casts introduced during E-matching based instantiation.
+
+For example, consider the theorem
+```
+Option.pbind_some {α1 : Type u_1} {a : α1} {α2 : Type u_2}
+    {f : (a_1 : α1) → some a = some a_1 → Option α2}
+    : (some a).pbind f = f a rfl
+```
+Now, suppose we have a goal containing the term `c.pbind g` and the equivalence class
+`{c, some b}`. The E-matching module generates the instance
+```
+(some b).pbind (cast ⋯ g)
+```
+The `cast` is necessary because `g`'s type contains `c` instead of `some b.
+This `cast` problematic because we don't have a systematic way of pushing casts over functions
+to its arguments. Moreover, heterogeneous equality is not effective because the following theorem
+is not provable in DTT:
+```
+theorem hcongr (h₁ : f ≍ g) (h₂ : a ≍ b)  : f a ≍ g b := ...
+```
+The standard solution is to generalize the theorem above and write it as
+```
+theorem Option.pbind_some'
+        {α1 : Type u_1} {a : α1} {α2 : Type u_2}
+        {x : Option α1}
+        {f : (a_1 : α1) → x = some a_1 → Option α2}
+        (h : x = some a)
+        : x.pbind f = f a h := by
+  subst h
+  apply Option.pbind_some
+```
+Internally, we use this gadget to mark the E-matching pattern as
+```
+(genPattern h x (some a)).pbind f
+```
+This pattern is matched in the same way we match `(some a).pbind f`, but it saves the proof
+for the actual term to the `some`-application in `f`, and the actual term in `x`.
+
+In the example above, `c.pbind g` also matches the pattern `(genPattern h x (some a)).pbind f`,
+and stores `c` in `x`, `b` in `a`, and the proof that `c = some b` in `h`.
+-/
+def genPattern {α : Sort u} (_h : Prop) (x : α) (_val : α) : α := x
+
+/-- Similar to `genPattern` but for the heterogeneous case -/
+def genHEqPattern {α β : Sort u} (_h : Prop) (x : α) (_val : β) : α := x
+end Lean.Grind
+
+namespace Lean.Parser
+/--
+Reset all `grind` attributes. This command is intended for testing purposes only and should not be used in applications.
+-/
+syntax (name := resetGrindAttrs) "reset_grind_attrs%" : command
+
+namespace Attr
+syntax grindGen    := ppSpace &"gen"
+syntax grindEq     := "=" (grindGen)?
+syntax grindEqBoth := atomic("_" "=" "_") (grindGen)?
+syntax grindEqRhs  := atomic("=" "_") (grindGen)?
+syntax grindEqBwd  := patternIgnore(atomic("←" "=") <|> atomic("<-" "="))
+syntax grindBwd    := patternIgnore("←" <|> "<-") (grindGen)?
+syntax grindFwd    := patternIgnore("→" <|> "->")
+syntax grindRL     := patternIgnore("⇐" <|> "<=")
+syntax grindLR     := patternIgnore("⇒" <|> "=>")
+syntax grindUsr    := &"usr"
+syntax grindCases  := &"cases"
+syntax grindCasesEager := atomic(&"cases" &"eager")
+syntax grindIntro  := &"intro"
+syntax grindExt    := &"ext"
+syntax grindSym    := &"symbol" ppSpace prio
+syntax grindMod :=
+    grindEqBoth <|> grindEqRhs <|> grindEq <|> grindEqBwd <|> grindBwd
+    <|> grindFwd <|> grindRL <|> grindLR <|> grindUsr <|> grindCasesEager
+    <|> grindCases <|> grindIntro <|> grindExt <|> grindGen <|> grindSym
+syntax (name := grind) "grind" (ppSpace grindMod)? : attr
+syntax (name := grind?) "grind?" (ppSpace grindMod)? : attr
+end Attr
+end Lean.Parser

src/Init/Grind/Lemmas.lean

@@ -131,6 +131,11 @@ theorem Bool.eq_true_of_not_eq_false' {a : Bool} (h : ¬ a = false) : a = true :
 theorem Bool.false_of_not_eq_self {a : Bool} (h : (!a) = a) : False := by
   by_cases a <;> simp_all
 
+theorem Bool.ne_of_eq_true_of_eq_false {a b : Bool} (h₁ : a = true) (h₂ : b = false) : (a = b) = False := by
+  cases a <;> cases b <;> simp_all
+theorem Bool.ne_of_eq_false_of_eq_true {a b : Bool} (h₁ : a = false) (h₂ : b = true) : (a = b) = False := by
+  cases a <;> cases b <;> simp_all
+
 /- The following two helper theorems are used to case-split `a = b` representing `iff`. -/
 theorem of_eq_eq_true {a b : Prop} (h : (a = b) = True) : (a ∧ b) ∨ (¬ a ∧ ¬ b) := by
   by_cases a <;> by_cases b <;> simp_all

src/Init/Grind/Module/Basic.lean

@@ -20,6 +20,24 @@ class AddRightCancel (M : Type u) [Add M] where
   /-- Addition is right-cancellative. -/
   add_right_cancel : ∀ a b c : M, a + c = b + c → a = b
 
+class AddCommMonoid (M : Type u) extends Zero M, Add M where
+  /-- Zero is the right identity for addition. -/
+  add_zero : ∀ a : M, a + 0 = a
+  /-- Addition is commutative. -/
+  add_comm : ∀ a b : M, a + b = b + a
+  /-- Addition is associative. -/
+  add_assoc : ∀ a b c : M, a + b + c = a + (b + c)
+
+attribute [instance 100] AddCommMonoid.toZero AddCommMonoid.toAdd
+
+class AddCommGroup (M : Type u) extends AddCommMonoid M, Neg M, Sub M where
+  /-- Negation is the left inverse of addition. -/
+  neg_add_cancel : ∀ a : M, -a + a = 0
+  /-- Subtraction is addition of the negative. -/
+  sub_eq_add_neg : ∀ a b : M, a - b = a + -b
+
+attribute [instance 100] AddCommGroup.toAddCommMonoid AddCommGroup.toNeg AddCommGroup.toSub
+
 /--
 A module over the natural numbers, i.e. a type with zero, addition, and scalar multiplication by natural numbers,
 satisfying appropriate compatibilities.
@@ -28,25 +46,15 @@ Equivalently, an additive commutative monoid.
 
 Use `IntModule` if the type has negation.
 -/
-class NatModule (M : Type u) extends Zero M, Add M, HMul Nat M M where
-  /-- Zero is the right identity for addition. -/
-  add_zero : ∀ a : M, a + 0 = a
-  /-- Addition is commutative. -/
-  add_comm : ∀ a b : M, a + b = b + a
-  /-- Addition is associative. -/
-  add_assoc : ∀ a b c : M, a + b + c = a + (b + c)
+class NatModule (M : Type u) extends AddCommMonoid M where
+  /-- Scalar multiplication by natural numbers. -/
+  [nsmul : HMul Nat M M]
   /-- Scalar multiplication by zero is zero. -/
-  zero_hmul : ∀ a : M, 0 * a = 0
-  /-- Scalar multiplication by one is the identity. -/
-  one_hmul : ∀ a : M, 1 * a = a
-  /-- Scalar multiplication is distributive over addition in the natural numbers. -/
-  add_hmul : ∀ n m : Nat, ∀ a : M, (n + m) * a = n * a + m * a
-  /-- Scalar multiplication of zero is zero. -/
-  hmul_zero : ∀ n : Nat, n * (0 : M) = 0
-  /-- Scalar multiplication is distributive over addition in the module. -/
-  hmul_add : ∀ n : Nat, ∀ a b : M, n * (a + b) = n * a + n * b
+  zero_nsmul : ∀ a : M, 0 * a = 0
+  /-- Scalar multiplication by a successor. -/
+  add_one_nsmul : ∀ n : Nat, ∀ a : M, (n + 1) * a = n * a + a
 
-attribute [instance 100] NatModule.toZero NatModule.toAdd NatModule.toHMul
+attribute [instance 100] NatModule.toAddCommMonoid NatModule.nsmul
 
 /--
 A module over the integers, i.e. a type with zero, addition, negation, subtraction, and scalar multiplication by integers,
@@ -54,83 +62,54 @@ satisfying appropriate compatibilities.
 
 Equivalently, an additive commutative group.
 -/
-class IntModule (M : Type u) extends Zero M, Add M, Neg M, Sub M where
+class IntModule (M : Type u) extends AddCommGroup M where
   /-- Scalar multiplication by natural numbers. -/
-  [hmulNat : HMul Nat M M]
+  [nsmul : HMul Nat M M]
   /-- Scalar multiplication by integers. -/
-  [hmulInt : HMul Int M M]
-  /-- Zero is the right identity for addition. -/
-  add_zero : ∀ a : M, a + 0 = a
-  /-- Addition is commutative. -/
-  add_comm : ∀ a b : M, a + b = b + a
-  /-- Addition is associative. -/
-  add_assoc : ∀ a b c : M, a + b + c = a + (b + c)
+  [zsmul : HMul Int M M]
   /-- Scalar multiplication by zero is zero. -/
-  zero_hmul : ∀ a : M, (0 : Int) * a = 0
+  zero_zsmul : ∀ a : M, (0 : Int) * a = 0
   /-- Scalar multiplication by one is the identity. -/
-  one_hmul : ∀ a : M, (1 : Int) * a = a
+  one_zsmul : ∀ a : M, (1 : Int) * a = a
   /-- Scalar multiplication is distributive over addition in the integers. -/
-  add_hmul : ∀ n m : Int, ∀ a : M, (n + m) * a = n * a + m * a
-  /-- Scalar multiplication of zero is zero. -/
-  hmul_zero : ∀ n : Int, n * (0 : M) = 0
-  /-- Scalar multiplication is distributive over addition in the module. -/
-  hmul_add : ∀ n : Int, ∀ a b : M, n * (a + b) = n * a + n * b
-  /-- Negation is the left inverse of addition. -/
-  neg_add_cancel : ∀ a : M, -a + a = 0
-  /-- Subtraction is addition of the negative. -/
-  sub_eq_add_neg : ∀ a b : M, a - b = a + -b
+  add_zsmul : ∀ n m : Int, ∀ a : M, (n + m) * a = n * a + m * a
   /-- Scalar multiplication by natural numbers is consistent with scalar multiplication by integers. -/
-  hmul_nat : ∀ n : Nat, ∀ a : M, (n : Int) * a = n * a
+  zsmul_natCast_eq_nsmul : ∀ n : Nat, ∀ a : M, (n : Int) * a = n * a
 
-namespace NatModule
-
-variable {M : Type u} [NatModule M]
-
-theorem zero_add (a : M) : 0 + a = a := by
-  rw [add_comm, add_zero]
-
-theorem mul_hmul (n m : Nat) (a : M) : (n * m) * a = n * (m * a) := by
-  induction n with
-  | zero => simp [zero_hmul]
-  | succ n ih =>
-    rw [Nat.add_one_mul, add_hmul, ih, add_hmul, one_hmul]
-
-instance (priority := 100) (M : Type u) [NatModule M] : SMul Nat M where
-  smul a x := a * x
-
-end NatModule
+attribute [instance 100] IntModule.toAddCommGroup IntModule.zsmul
 
 namespace IntModule
 
-attribute [instance 100] IntModule.toZero IntModule.toAdd IntModule.toNeg IntModule.toSub
-  IntModule.hmulNat IntModule.hmulInt
-
-instance toNatModule (M : Type u) [i : IntModule M] : NatModule M :=
-  { i with
-    hMul := i.hmulNat.hMul
-    zero_hmul := by simp [← hmul_nat, zero_hmul]
-    one_hmul := by simp [← hmul_nat, one_hmul]
-    hmul_zero := by simp [← hmul_nat, hmul_zero]
-    add_hmul := by simp [← hmul_nat, add_hmul]
-    hmul_add := by simp [← hmul_nat, hmul_add] }
-
-instance (priority := 100) (M : Type u) [IntModule M] : SMul Nat M where
-  smul a x := a * x
-
-instance (priority := 100) (M : Type u) [IntModule M] : SMul Int M where
-  smul a x := a * x
-
 variable {M : Type u} [IntModule M]
 
+instance (priority := 100) toNatModule [I : IntModule M] : NatModule M :=
+  { I with
+    zero_nsmul a := by rw [← zsmul_natCast_eq_nsmul, Int.natCast_zero, zero_zsmul]
+    add_one_nsmul n a := by rw [← zsmul_natCast_eq_nsmul, Int.natCast_add_one, add_zsmul,
+      zsmul_natCast_eq_nsmul, one_zsmul] }
+
+end IntModule
+
+namespace AddCommMonoid
+
+variable {M : Type u} [AddCommMonoid M]
+
 theorem zero_add (a : M) : 0 + a = a := by
   rw [add_comm, add_zero]
 
-theorem add_neg_cancel (a : M) : a + -a = 0 := by
-  rw [add_comm, neg_add_cancel]
-
 theorem add_left_comm (a b c : M) : a + (b + c) = b + (a + c) := by
   rw [← add_assoc, ← add_assoc, add_comm a]
 
+end AddCommMonoid
+
+namespace AddCommGroup
+
+variable {M : Type u} [AddCommGroup M]
+open AddCommMonoid
+
+theorem add_neg_cancel (a : M) : a + -a = 0 := by
+  rw [add_comm, neg_add_cancel]
+
 theorem add_left_inj {a b : M} (c : M) : a + c = b + c ↔ a = b :=
   ⟨fun h => by simpa [add_assoc, add_neg_cancel, add_zero] using (congrArg (· + -c) h),
    fun g => congrArg (· + c) g⟩
@@ -175,35 +154,95 @@ theorem add_sub_cancel {a b : M} : a + b - b = a := by
 theorem sub_add_cancel {a b : M} : a - b + b = a := by
   rw [sub_eq_add_neg, add_assoc, neg_add_cancel, add_zero]
 
-theorem neg_hmul (n : Int) (a : M) : (-n) * a = - (n * a) := by
+theorem neg_eq_iff (a b : M) : -a = b ↔ a = -b := by
+  constructor
+  · intro h
+    rw [← neg_neg a, h]
+  · intro h
+    rw [← neg_neg b, h]
+
+end AddCommGroup
+
+namespace NatModule
+
+variable {M : Type u} [NatModule M]
+
+theorem one_nsmul (a : M) : 1 * a = a := by
+  rw [← Nat.zero_add 1, add_one_nsmul, zero_nsmul, AddCommMonoid.zero_add]
+
+theorem add_nsmul (n m : Nat) (a : M) : (n + m) * a = n * a + m * a := by
+  induction m with
+  | zero => rw [Nat.add_zero, zero_nsmul, AddCommMonoid.add_zero]
+  | succ m ih => rw [add_one_nsmul, ← Nat.add_assoc, add_one_nsmul, ih, AddCommMonoid.add_assoc]
+
+theorem nsmul_zero (n : Nat) : n * (0 : M) = 0 := by
+  induction n with
+  | zero => rw [zero_nsmul]
+  | succ n ih => rw [add_one_nsmul, ih, AddCommMonoid.zero_add]
+
+theorem nsmul_add (n : Nat) (a b : M) : n * (a + b) = n * a + n * b := by
+  induction n with
+  | zero => rw [zero_nsmul, zero_nsmul, zero_nsmul, AddCommMonoid.zero_add]
+  | succ n ih => rw [add_one_nsmul, add_one_nsmul, add_one_nsmul, ih, AddCommMonoid.add_assoc,
+      AddCommMonoid.add_left_comm (n * b), AddCommMonoid.add_assoc]
+
+theorem mul_nsmul (n m : Nat) (a : M) : (n * m) * a = n * (m * a) := by
+  induction n with
+  | zero => simp [zero_nsmul]
+  | succ n ih =>
+    rw [Nat.add_one_mul, add_nsmul, ih, add_nsmul, one_nsmul]
+
+instance (priority := 100) (M : Type u) [NatModule M] : SMul Nat M where
+  smul a x := a * x
+
+end NatModule
+
+namespace IntModule
+
+open NatModule AddCommGroup
+
+instance (priority := 100) (M : Type u) [IntModule M] : SMul Int M where
+  smul a x := a * x
+
+variable {M : Type u} [IntModule M]
+
+theorem neg_zsmul (n : Int) (a : M) : (-n) * a = - (n * a) := by
   apply (add_left_inj (n * a)).mp
-  rw [← add_hmul, Int.add_left_neg, zero_hmul, neg_add_cancel]
+  rw [← add_zsmul, Int.add_left_neg, zero_zsmul, neg_add_cancel]
 
-theorem hmul_neg (n : Int) (a : M) : n * (-a) = - (n * a) := by
+theorem zsmul_zero (n : Int) : n * (0 : M) = 0 := by
+  match n with
+  | (n : Nat) => rw [zsmul_natCast_eq_nsmul, NatModule.nsmul_zero]
+  | -(n + 1 : Nat) => rw [neg_zsmul, zsmul_natCast_eq_nsmul, NatModule.nsmul_zero, neg_zero]
+
+theorem zsmul_add (n : Int) (a b : M) : n * (a + b) = n * a + n * b := by
+  match n with
+  | (n : Nat) => rw [zsmul_natCast_eq_nsmul, NatModule.nsmul_add, zsmul_natCast_eq_nsmul, zsmul_natCast_eq_nsmul]
+  | -(n + 1 : Nat) => rw [neg_zsmul, zsmul_natCast_eq_nsmul, NatModule.nsmul_add,
+      neg_zsmul, zsmul_natCast_eq_nsmul, neg_zsmul, zsmul_natCast_eq_nsmul, neg_add]
+
+theorem zsmul_neg (n : Int) (a : M) : n * (-a) = - (n * a) := by
   apply (add_left_inj (n * a)).mp
-  rw [← hmul_add, neg_add_cancel, neg_add_cancel, hmul_zero]
+  rw [← zsmul_add, neg_add_cancel, neg_add_cancel, zsmul_zero]
 
-theorem hmul_sub (k : Int) (a b : M) : k * (a - b) = k * a - k * b := by
-  rw [sub_eq_add_neg, hmul_add, hmul_neg, ← sub_eq_add_neg]
+theorem zsmul_sub (k : Int) (a b : M) : k * (a - b) = k * a - k * b := by
+  rw [sub_eq_add_neg, zsmul_add, zsmul_neg, ← sub_eq_add_neg]
 
-theorem sub_hmul (k₁ k₂ : Int) (a : M) : (k₁ - k₂) * a = k₁ * a - k₂ * a := by
-  rw [Int.sub_eq_add_neg, add_hmul, neg_hmul, ← sub_eq_add_neg]
+theorem sub_zsmul (k₁ k₂ : Int) (a : M) : (k₁ - k₂) * a = k₁ * a - k₂ * a := by
+  rw [Int.sub_eq_add_neg, add_zsmul, neg_zsmul, ← sub_eq_add_neg]
 
-theorem nat_zero_hmul (a : M) : (0 : Nat) * a = 0 := by
-  rw [← hmul_nat, Int.natCast_zero, zero_hmul]
-
-private theorem nat_mul_hmul (n : Nat) (m : Int) (a : M) :
+private theorem mul_zsmul_aux (n : Nat) (m : Int) (a : M) :
     ((n : Int) * m) * a = (n : Int) * (m * a) := by
   induction n with
-  | zero => simp [zero_hmul]
+  | zero => simp [zero_zsmul]
   | succ n ih =>
-    rw [Int.natCast_add, Int.add_mul, add_hmul, Int.natCast_one,
-      Int.one_mul, add_hmul, one_hmul, ih]
+    rw [Int.natCast_add, Int.add_mul, add_zsmul, Int.natCast_one,
+      Int.one_mul, add_zsmul, one_zsmul, ih]
 
-theorem mul_hmul (n m : Int) (a : M) : (n * m) * a = n * (m * a) := by
+theorem mul_zsmul (n m : Int) (a : M) : (n * m) * a = n * (m * a) := by
   match n with
-  | (n : Nat) => exact nat_mul_hmul n m a
-  | -(n + 1 : Nat) => rw [Int.neg_mul, neg_hmul, nat_mul_hmul, neg_hmul]
+  | (n : Nat) => exact mul_zsmul_aux n m a
+  | -(n + 1 : Nat) => rw [Int.neg_mul, neg_zsmul, mul_zsmul_aux, neg_zsmul]
 
 end IntModule
 
@@ -225,31 +264,35 @@ export NoNatZeroDivisors (no_nat_zero_divisors)
 namespace NoNatZeroDivisors
 
 /-- Alternative constructor for `NoNatZeroDivisors` when we have an `IntModule`. -/
-def mk' {α} [IntModule α] (eq_zero_of_mul_eq_zero : ∀ (k : Nat) (a : α), k ≠ 0 → k * a = 0 → a = 0) : NoNatZeroDivisors α where
+def mk' {α} [IntModule α]
+    (eq_zero_of_mul_eq_zero : ∀ (k : Nat) (a : α), k ≠ 0 → k * a = 0 → a = 0) :
+    NoNatZeroDivisors α where
   no_nat_zero_divisors k a b h₁ h₂ := by
-    rw [← IntModule.sub_eq_zero_iff, ← IntModule.hmul_nat, ← IntModule.hmul_nat, ← IntModule.hmul_sub, IntModule.hmul_nat] at h₂
-    rw [← IntModule.sub_eq_zero_iff]
+    rw [← AddCommGroup.sub_eq_zero_iff, ← IntModule.zsmul_natCast_eq_nsmul,
+      ← IntModule.zsmul_natCast_eq_nsmul, ← IntModule.zsmul_sub,
+      IntModule.zsmul_natCast_eq_nsmul] at h₂
+    rw [← AddCommGroup.sub_eq_zero_iff]
     apply eq_zero_of_mul_eq_zero k (a - b) h₁ h₂
 
 theorem eq_zero_of_mul_eq_zero {α : Type u} [NatModule α] [NoNatZeroDivisors α] {k : Nat} {a : α}
     : k ≠ 0 → k * a = 0 → a = 0 := by
   intro h₁ h₂
   replace h₁ : k ≠ 0 := by intro h; simp [h] at h₁
-  exact no_nat_zero_divisors k a 0 h₁ (by rwa [NatModule.hmul_zero])
+  exact no_nat_zero_divisors k a 0 h₁ (by rwa [NatModule.nsmul_zero])
 
 end NoNatZeroDivisors
 
-instance [ToInt α (IntInterval.co lo hi)] [IntModule α] [ToInt.Zero α (IntInterval.co lo hi)] [ToInt.Add α (IntInterval.co lo hi)] : ToInt.Neg α (IntInterval.co lo hi) where
+instance [ToInt α (IntInterval.co lo hi)] [AddCommGroup α] [ToInt.Zero α (IntInterval.co lo hi)] [ToInt.Add α (IntInterval.co lo hi)] : ToInt.Neg α (IntInterval.co lo hi) where
   toInt_neg x := by
     have := (ToInt.Add.toInt_add (-x) x).symm
-    rw [IntModule.neg_add_cancel, ToInt.Zero.toInt_zero, ← ToInt.Zero.wrap_zero (α := α)] at this
+    rw [AddCommGroup.neg_add_cancel, ToInt.Zero.toInt_zero, ← ToInt.Zero.wrap_zero (α := α)] at this
     rw [IntInterval.wrap_eq_wrap_iff] at this
     simp at this
     rw [← ToInt.wrap_toInt]
     rw [IntInterval.wrap_eq_wrap_iff]
     simpa
 
-instance [ToInt α (IntInterval.co lo hi)] [IntModule α] [ToInt.Add α (IntInterval.co lo hi)] [ToInt.Neg α (IntInterval.co lo hi)] : ToInt.Sub α (IntInterval.co lo hi) :=
-  ToInt.Sub.of_sub_eq_add_neg IntModule.sub_eq_add_neg (by simp)
+instance [ToInt α (IntInterval.co lo hi)] [AddCommGroup α] [ToInt.Add α (IntInterval.co lo hi)] [ToInt.Neg α (IntInterval.co lo hi)] : ToInt.Sub α (IntInterval.co lo hi) :=
+  ToInt.Sub.of_sub_eq_add_neg AddCommGroup.sub_eq_add_neg (by simp)
 
 end Lean.Grind

src/Init/Grind/Module/Envelope.lean

@@ -19,9 +19,9 @@ variable [NatModule α]
 
 -- Helper instance for `ac_rfl`
 local instance : Std.Associative (· + · : α → α → α) where
-  assoc := NatModule.add_assoc
+  assoc := AddCommMonoid.add_assoc
 local instance : Std.Commutative (· + · : α → α → α) where
-  comm := NatModule.add_comm
+  comm := AddCommMonoid.add_comm
 
 @[local simp] private theorem exists_true : ∃ (_ : α), True := ⟨0, trivial⟩
 
@@ -33,10 +33,10 @@ def Q := Quot (r α)
 variable {α}
 
 theorem r_rfl (a : α × α) : r α a a := by
-  cases a; refine ⟨0, ?_⟩; simp [NatModule.add_zero]; ac_rfl
+  cases a; refine ⟨0, ?_⟩; simp [AddCommMonoid.add_zero]; ac_rfl
 
 theorem r_sym {a b : α × α} : r α a b → r α b a := by
-  cases a; cases b; simp [r]; intro h w; refine ⟨h, ?_⟩; simp [w, NatModule.add_comm]
+  cases a; cases b; simp [r]; intro h w; refine ⟨h, ?_⟩; simp [w, AddCommMonoid.add_comm]
 
 theorem r_trans {a b c : α × α} : r α a b → r α b c → r α a c := by
   cases a; cases b; cases c;
@@ -63,20 +63,20 @@ def Q.liftOn₂ (q₁ q₂ : Q α)
   induction q₂ using Quot.ind
   apply h; assumption; apply r_rfl
 
-attribute [local simp] Q.mk Q.liftOn₂ NatModule.add_zero
+attribute [local simp] Q.mk Q.liftOn₂ AddCommMonoid.add_zero
 
 def Q.ind {β : Q α → Prop} (mk : ∀ (a : α × α), β (Q.mk a)) (q : Q α) : β q :=
   Quot.ind mk q
 
-@[local simp] def hmulNat (n : Nat) (q : Q α) : (Q α) :=
+@[local simp] def nsmul (n : Nat) (q : Q α) : (Q α) :=
   q.liftOn (fun (a, b) => Q.mk (n * a, n * b))
     (by intro (a₁, b₁) (a₂, b₂)
         simp; intro k h; apply Quot.sound; simp
         refine ⟨n * k, ?_⟩
         replace h := congrArg (fun x : α => n * x) h
-        simpa [NatModule.hmul_add] using h)
+        simpa [NatModule.nsmul_add] using h)
 
-@[local simp] def hmulInt (n : Int) (q : Q α) : (Q α) :=
+@[local simp] def zsmul (n : Int) (q : Q α) : (Q α) :=
   q.liftOn (fun (a, b) => if n < 0 then Q.mk (n.natAbs * b, n.natAbs * a) else Q.mk (n.natAbs * a, n.natAbs * b))
     (by intro (a₁, b₁) (a₂, b₂)
         simp; intro k h;
@@ -84,11 +84,11 @@ def Q.ind {β : Q α → Prop} (mk : ∀ (a : α × α), β (Q.mk a)) (q : Q α)
         · apply Quot.sound; simp
           refine ⟨n.natAbs * k, ?_⟩
           replace h := congrArg (fun x : α => n.natAbs * x) h
-          simpa [NatModule.hmul_add] using h.symm
+          simpa [NatModule.nsmul_add] using h.symm
         · apply Quot.sound; simp
           refine ⟨n.natAbs * k, ?_⟩
           replace h := congrArg (fun x : α => n.natAbs * x) h
-          simpa [NatModule.hmul_add] using h)
+          simpa [NatModule.nsmul_add] using h)
 
 @[local simp] def sub (q₁ q₂ : Q α) : Q α :=
   Q.liftOn₂ q₁ q₂ (fun (a, b) (c, d) => Q.mk (a + d, c + b))
@@ -115,8 +115,8 @@ def Q.ind {β : Q α → Prop} (mk : ∀ (a : α × α), β (Q.mk a)) (q : Q α)
         exact ⟨k, h.symm⟩)
 
 attribute [local simp]
-  Quot.liftOn NatModule.add_zero NatModule.zero_add NatModule.one_hmul NatModule.zero_hmul NatModule.hmul_zero
-  NatModule.hmul_add NatModule.add_hmul
+  Quot.liftOn AddCommMonoid.add_zero AddCommMonoid.zero_add NatModule.one_nsmul NatModule.zero_nsmul NatModule.nsmul_zero
+  NatModule.nsmul_add NatModule.add_nsmul
 
 @[local simp] def zero : Q α :=
   Q.mk (0, 0)
@@ -150,29 +150,15 @@ theorem sub_eq_add_neg (a b : Q α) : sub a b = add a (neg b) := by
   next a b =>
   cases a; cases b; simp; apply Quot.sound; simp; refine ⟨0, ?_⟩; ac_rfl
 
-theorem one_hmul (a : Q α) : hmulInt 1 a = a := by
+theorem one_zsmul (a : Q α) : zsmul 1 a = a := by
   induction a using Quot.ind
   next a => cases a; simp
 
-theorem zero_hmul (a : Q α) : hmulInt 0 a = zero := by
+theorem zero_zsmul (a : Q α) : zsmul 0 a = zero := by
   induction a using Quot.ind
   next a => cases a; simp
 
-theorem hmul_zero (a : Int) : hmulInt a (zero : Q α) = zero := by
-  simp
-
-theorem hmul_add (a : Int) (b c : Q α) : hmulInt a (add b c) = add (hmulInt a b) (hmulInt a c) := by
-  induction b using Q.ind
-  induction c using Q.ind
-  next b c =>
-  cases b; cases c; simp
-  split <;>
-  · apply Quot.sound
-    refine ⟨0, ?_⟩
-    simp
-    ac_rfl
-
-theorem add_hmul (a b : Int) (c : Q α) : hmulInt (a + b) c = add (hmulInt a c) (hmulInt b c) := by
+theorem add_zsmul (a b : Int) (c : Q α) : zsmul (a + b) c = add (zsmul a c) (zsmul b c) := by
   induction c using Q.ind
   next c =>
   rcases c with ⟨c₁, c₂⟩; simp
@@ -183,7 +169,7 @@ theorem add_hmul (a b : Int) (c : Q α) : hmulInt (a + b) c = add (hmulInt a c)
       rw [if_pos (by omega)]
       apply Quot.sound
       refine ⟨0, ?_⟩
-      rw [Int.natAbs_add_of_nonpos (by omega) (by omega), NatModule.add_hmul, NatModule.add_hmul]
+      rw [Int.natAbs_add_of_nonpos (by omega) (by omega), NatModule.add_nsmul, NatModule.add_nsmul]
       ac_rfl
     · split
       · apply Quot.sound
@@ -213,23 +199,23 @@ theorem add_hmul (a b : Int) (c : Q α) : hmulInt (a + b) c = add (hmulInt a c)
       rw [if_neg (by omega)]
       apply Quot.sound
       refine ⟨0, ?_⟩
-      rw [Int.natAbs_add_of_nonneg (by omega) (by omega), NatModule.add_hmul, NatModule.add_hmul]
+      rw [Int.natAbs_add_of_nonneg (by omega) (by omega), NatModule.add_nsmul, NatModule.add_nsmul]
       ac_rfl
 
-theorem hmul_nat (n : Nat) (a : Q α) : hmulInt (n : Int) a = hmulNat n a := by
+theorem zsmul_natCast_eq_nsmul (n : Nat) (a : Q α) : zsmul (n : Int) a = nsmul n a := by
   induction a using Q.ind
   next a =>
   rcases a with ⟨a₁, a₂⟩; simp; omega
 
 def ofNatModule : IntModule (Q α) := {
-  hmulNat := ⟨hmulNat⟩,
-  hmulInt := ⟨hmulInt⟩,
+  nsmul := ⟨nsmul⟩,
+  zsmul := ⟨zsmul⟩,
   zero,
   add, sub, neg,
   add_comm, add_assoc, add_zero,
   neg_add_cancel, sub_eq_add_neg,
-  one_hmul, zero_hmul, hmul_zero, hmul_add, add_hmul,
-  hmul_nat
+  one_zsmul, zero_zsmul, add_zsmul,
+  zsmul_natCast_eq_nsmul
 }
 
 attribute [instance] ofNatModule
@@ -257,7 +243,7 @@ private def rel (h : Equivalence (r α)) (q₁ q₂ : Q α) : Prop :=
 
 private theorem rel_rfl (h : Equivalence (r α)) (q : Q α) : rel h q q := by
   induction q using Quot.ind
-  simp [rel, NatModule.add_comm]
+  simp [rel, AddCommMonoid.add_comm]
 
 private theorem helper (h : Equivalence (r α)) (q₁ q₂ : Q α) : q₁ = q₂ → rel h q₁ q₂ := by
   intro h; subst q₁; apply rel_rfl h
@@ -287,7 +273,7 @@ instance [NatModule α] [AddRightCancel α] [NoNatZeroDivisors α] : NoNatZeroDi
     simp [r] at h₂
     rcases h₂ with ⟨k', h₂⟩
     replace h₂ := AddRightCancel.add_right_cancel _ _ _ h₂
-    simp [← NatModule.hmul_add] at h₂
+    simp [← NatModule.nsmul_add] at h₂
     replace h₂ := NoNatZeroDivisors.no_nat_zero_divisors k (a₁ + b₂) (a₂ + b₁) h₁ h₂
     apply Quot.sound; simp [r]; exists 0; simp [h₂]
 
@@ -318,7 +304,7 @@ instance [Preorder α] [OrderedAdd α] : Preorder (OfNatModule.Q α) where
     rcases a with ⟨a₁, a₂⟩
     change Q.mk _ ≤ Q.mk _
     simp only [mk_le_mk]
-    simp [NatModule.add_comm]; exact Preorder.le_refl (a₁ + a₂)
+    simp [AddCommMonoid.add_comm]; exact Preorder.le_refl (a₁ + a₂)
   le_trans {a b c} h₁ h₂ := by
     induction a using Q.ind
     induction b using Q.ind
@@ -337,12 +323,12 @@ attribute [-simp] Q.mk
 
 @[local simp] private theorem mk_lt_mk [Preorder α] [OrderedAdd α] {a₁ a₂ b₁ b₂ : α}  :
     Q.mk (a₁, a₂) < Q.mk (b₁, b₂) ↔ a₁ + b₂ < a₂ + b₁ := by
-  simp [Preorder.lt_iff_le_not_le, NatModule.add_comm]
+  simp [Preorder.lt_iff_le_not_le, AddCommMonoid.add_comm]
 
 @[local simp] private theorem mk_pos [Preorder α] [OrderedAdd α] {a₁ a₂ : α} :
     0 < Q.mk (a₁, a₂) ↔ a₂ < a₁ := by
   change Q.mk (0,0) < _ ↔ _
-  simp [mk_lt_mk, NatModule.zero_add]
+  simp [mk_lt_mk, AddCommMonoid.zero_add]
 
 @[local simp]
 theorem toQ_le [Preorder α] [OrderedAdd α] {a b : α} : toQ a ≤ toQ b ↔ a ≤ b := by

src/Init/Grind/Norm.lean

@@ -45,11 +45,19 @@ theorem imp_true_eq (p : Prop) : (p → True) = True := by simp
 theorem imp_false_eq (p : Prop) : (p → False) = ¬p := by simp
 theorem imp_self_eq (p : Prop) : (p → p) = True := by simp
 
-theorem not_and (p q : Prop) : (¬(p ∧ q)) = (¬p ∨ ¬q) := by
-  by_cases p <;> by_cases q <;> simp [*]
+theorem not_true : (¬True) = False := by simp
+theorem not_false : (¬False) = True := by simp
+theorem not_not (p : Prop) : (¬¬p) = p := by by_cases p <;> simp [*]
+theorem not_and (p q : Prop) : (¬(p ∧ q)) = (¬p ∨ ¬q) := by by_cases p <;> by_cases q <;> simp [*]
+theorem not_or (p q : Prop) : (¬(p ∨ q)) = (¬p ∧ ¬q) := by by_cases p <;> by_cases q <;> simp [*]
+theorem not_ite {_ : Decidable p} (q r : Prop) : (¬ite p q r) = ite p (¬q) (¬r) := by by_cases p <;> simp [*]
+theorem not_forall (p : α → Prop) : (¬∀ x, p x) = ∃ x, ¬p x := by simp
+theorem not_exists (p : α → Prop) : (¬∃ x, p x) = ∀ x, ¬p x := by simp
+theorem not_implies (p q : Prop) : (¬(p → q)) = (p ∧ ¬q) := by simp
 
-theorem not_ite {_ : Decidable p} (q r : Prop) : (¬ite p q r) = ite p (¬q) (¬r) := by
-  by_cases p <;> simp [*]
+theorem or_assoc (p q r : Prop) : ((p ∨ q) ∨ r) = (p ∨ (q ∨ r)) := by by_cases p <;> simp [*]
+theorem or_swap12 (p q r : Prop) : (p ∨ q ∨ r) = (q ∨ p ∨ r) := by by_cases p <;> simp [*]
+theorem or_swap13 (p q r : Prop) : (p ∨ q ∨ r) = (r ∨ q ∨ p) := by by_cases p <;> by_cases q <;> simp [*]
 
 theorem ite_true_false {_ : Decidable p} : (ite p True False) = p := by
   by_cases p <;> simp
@@ -57,10 +65,6 @@ theorem ite_true_false {_ : Decidable p} : (ite p True False) = p := by
 theorem ite_false_true {_ : Decidable p} : (ite p False True) = ¬p := by
   by_cases p <;> simp
 
-theorem not_forall (p : α → Prop) : (¬∀ x, p x) = ∃ x, ¬p x := by simp
-
-theorem not_exists (p : α → Prop) : (¬∃ x, p x) = ∀ x, ¬p x := by simp
-
 theorem cond_eq_ite (c : Bool) (a b : α) : cond c a b = ite c a b := by
   cases c <;> simp [*]
 
@@ -70,9 +74,6 @@ theorem Nat.lt_eq (a b : Nat) : (a < b) = (a + 1 ≤ b) := by
 theorem Int.lt_eq (a b : Int) : (a < b) = (a + 1 ≤ b) := by
   simp [Int.lt, LT.lt]
 
-theorem ge_eq [LE α] (a b : α) : (a ≥ b) = (b ≤ a) := rfl
-theorem gt_eq [LT α] (a b : α) : (a > b) = (b < a) := rfl
-
 theorem beq_eq_decide_eq {_ : BEq α} [LawfulBEq α] [DecidableEq α] (a b : α) : (a == b) = (decide (a = b)) := by
   by_cases a = b
   next h => simp [h]
@@ -81,14 +82,11 @@ theorem beq_eq_decide_eq {_ : BEq α} [LawfulBEq α] [DecidableEq α] (a b : α)
 theorem bne_eq_decide_not_eq {_ : BEq α} [LawfulBEq α] [DecidableEq α] (a b : α) : (a != b) = (decide (¬ a = b)) := by
   by_cases a = b <;> simp [*]
 
-theorem xor_eq (a b : Bool) : (a ^^ b) = (a != b) := by
-  rfl
-
-theorem natCast_eq [NatCast α] (a : Nat) : (Nat.cast a : α) = (NatCast.natCast a : α) := rfl
 theorem natCast_div (a b : Nat) : (NatCast.natCast (a / b) : Int) = (NatCast.natCast a) / (NatCast.natCast b) := rfl
 theorem natCast_mod (a b : Nat) : (NatCast.natCast (a % b) : Int) = (NatCast.natCast a) % (NatCast.natCast b) := rfl
 theorem natCast_add (a b : Nat) : (NatCast.natCast (a + b : Nat) : Int) = (NatCast.natCast a : Int) + (NatCast.natCast b : Int) := rfl
 theorem natCast_mul (a b : Nat) : (NatCast.natCast (a * b : Nat) : Int) = (NatCast.natCast a : Int) * (NatCast.natCast b : Int) := rfl
+theorem natCast_pow (a b : Nat) : (NatCast.natCast (a ^ b : Nat) : Int) = (NatCast.natCast a : Int) ^ b := by simp
 
 theorem Nat.pow_one (a : Nat) : a ^ 1 = a := by
   simp
@@ -127,52 +125,49 @@ theorem forall_forall_or {α : Sort u} {β : α → Sort v} (p : α → Prop) (q
     intro h'; simp at h'; have ⟨⟨b, h₁⟩, h₂⟩ := h'
     replace h := h a b; simp [h₁, h₂] at h
 
+theorem forall_and {α} {p q : α → Prop} : (∀ x, p x ∧ q x) = ((∀ x, p x) ∧ (∀ x, q x)) := by
+  apply propext; apply _root_.forall_and
+
+theorem exists_const (α : Sort u) [i : Nonempty α] {b : Prop} : (∃ _ : α, b) = b := by
+  apply propext; apply _root_.exists_const
+
+theorem exists_or {α : Sort u} {p q : α → Prop} : (∃ x, p x ∨ q x) = ((∃ x, p x) ∨ ∃ x, q x) := by
+  apply propext; apply _root_.exists_or
+
+theorem exists_prop {a b : Prop} : (∃ _h : a, b) = (a ∧ b) := by
+  apply propext; apply _root_.exists_prop
+
+theorem exists_and_left {α : Sort u} {p : α → Prop} {b : Prop} : (∃ x, b ∧ p x) = (b ∧ (∃ x, p x)) := by
+  apply propext; apply _root_.exists_and_left
+
+theorem exists_and_right {α : Sort u} {p : α → Prop} {b : Prop} : (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) := by
+  apply propext; apply _root_.exists_and_right
+
+theorem zero_sub (a : Nat) : 0 - a = 0 := by
+  simp
+
+-- Remark: for additional `grind` simprocs, check `Lean/Meta/Tactic/Grind`
 init_grind_norm
   /- Pre theorems -/
-  not_and not_or not_ite not_forall not_exists
-  /- Nat relational ops neg -/
-  Nat.not_ge_eq Nat.not_le_eq
   |
   /- Post theorems -/
-  Classical.not_not
-  ne_eq iff_eq eq_self heq_eq_eq
-  forall_or_forall forall_forall_or
-  -- Prop equality
-  eq_true_eq eq_false_eq not_eq_prop
-  -- True
-  not_true
-  -- False
-  not_false_eq_true
-  -- Implication
-  true_imp_eq false_imp_eq imp_true_eq imp_false_eq imp_self_eq
+  iff_eq heq_eq_eq
   -- And
   and_true true_and and_false false_and and_assoc
-  -- Or
-  or_true true_or or_false false_or or_assoc
   -- ite
-  ite_true ite_false ite_true_false ite_false_true
-  dite_eq_ite
-  -- Forall
-  forall_and forall_false forall_true
-  forall_imp_eq_or
-  -- Exists
-  exists_const exists_or exists_prop exists_and_left exists_and_right
+  ite_true_false ite_false_true
   -- Bool cond
   cond_eq_ite
   -- Bool or
-  Bool.or_false Bool.or_true Bool.false_or Bool.true_or Bool.or_eq_true Bool.or_assoc
+  Bool.or_false Bool.or_true Bool.false_or Bool.true_or Bool.or_eq_true
   -- Bool and
-  Bool.and_false Bool.and_true Bool.false_and Bool.true_and Bool.and_eq_true Bool.and_assoc
+  Bool.and_false Bool.and_true Bool.false_and Bool.true_and Bool.and_eq_true
   -- Bool not
   Bool.not_not
-  -- Bool xor
-  xor_eq
   -- beq
   beq_iff_eq beq_eq_decide_eq beq_self_eq_true
   -- bne
   bne_iff_ne bne_eq_decide_not_eq
-  -- Bool not eq true/false
-  Bool.not_eq_true Bool.not_eq_false
   -- decide
   decide_eq_true_eq decide_not not_decide_eq_true
   -- Nat
@@ -180,19 +175,17 @@ init_grind_norm
   Nat.add_eq Nat.sub_eq Nat.mul_eq Nat.zero_eq Nat.le_eq
   Nat.div_zero Nat.mod_zero Nat.div_one Nat.mod_one
   Nat.sub_sub Nat.pow_zero Nat.pow_one Nat.sub_self
-  Nat.one_pow
+  Nat.one_pow Nat.zero_sub
   -- Int
   Int.lt_eq
   Int.emod_neg Int.ediv_neg
   Int.ediv_zero Int.emod_zero
   Int.ediv_one Int.emod_one
   Int.negSucc_eq
-  natCast_eq natCast_div natCast_mod
-  natCast_add natCast_mul
+  natCast_div natCast_mod
+  natCast_add natCast_mul natCast_pow
   Int.one_pow
   Int.pow_zero Int.pow_one
-  -- GT GE
-  ge_eq gt_eq
   -- Int op folding
   Int.add_def Int.mul_def Int.ofNat_eq_coe
   Int.Linear.sub_fold Int.Linear.neg_fold
@@ -202,6 +195,6 @@ init_grind_norm
   Function.const_apply Function.comp_apply Function.const_comp
   Function.comp_const Function.true_comp Function.false_comp
   -- Field
-  Field.div_eq_mul_inv Field.inv_zero Field.inv_inv Field.inv_one Field.inv_neg
+  Field.inv_zero Field.inv_inv Field.inv_one Field.inv_neg
 
 end Lean.Grind

src/Init/Grind/Ordered/Linarith.lean

@@ -20,9 +20,9 @@ Support for the linear arithmetic module for `IntModule` in `grind`
 
 namespace Lean.Grind.Linarith
 abbrev Var := Nat
-open IntModule
+open AddCommMonoid AddCommGroup NatModule IntModule
 
-attribute [local simp] add_zero zero_add zero_hmul nat_zero_hmul hmul_zero one_hmul
+attribute [local simp] add_zero zero_add zero_zsmul zero_nsmul zsmul_zero one_zsmul
 
 inductive Expr where
   | zero
@@ -75,10 +75,10 @@ where
 
 -- Helper instance for `ac_rfl`
 local instance {α} [IntModule α] : Std.Associative (· + · : α → α → α) where
-  assoc := IntModule.add_assoc
+  assoc := AddCommMonoid.add_assoc
 -- Helper instance for `ac_rfl`
 local instance {α} [IntModule α] : Std.Commutative (· + · : α → α → α) where
-  comm := IntModule.add_comm
+  comm := AddCommMonoid.add_comm
 
 theorem Poly.denote'_go_eq_denote {α} [IntModule α] (ctx : Context α) (p : Poly) (r : α) : denote'.go ctx r p = p.denote ctx + r := by
   induction r, p using denote'.go.induct ctx <;> simp [denote'.go, denote]
@@ -176,7 +176,7 @@ def Poly.mul (p : Poly) (k : Int) : Poly :=
   next => simp [*, denote]
   next =>
     induction p <;> simp [mul', denote, *]
-    rw [mul_hmul, hmul_add]
+    rw [mul_zsmul, zsmul_add]
 
 theorem Poly.denote_insert {α} [IntModule α] (ctx : Context α) (k : Int) (v : Var) (p : Poly) :
     (p.insert k v).denote ctx = p.denote ctx + k * v.denote ctx := by
@@ -184,8 +184,8 @@ theorem Poly.denote_insert {α} [IntModule α] (ctx : Context α) (k : Int) (v :
   next => ac_rfl
   next h₁ h₂ h₃ =>
     simp at h₃; simp at h₂; subst h₂
-    rw [add_comm, ← add_assoc, ← add_hmul, h₃, zero_hmul, zero_add]
-  next h _ => simp at h; subst h; rw [add_hmul]; ac_rfl
+    rw [add_comm, ← add_assoc, ← add_zsmul, h₃, zero_zsmul, zero_add]
+  next h _ => simp at h; subst h; rw [add_zsmul]; ac_rfl
   next ih => rw [ih]; ac_rfl
 
 attribute [local simp] Poly.denote_insert
@@ -205,8 +205,8 @@ theorem Poly.denote_combine' {α} [IntModule α] (ctx : Context α) (fuel : Nat)
     simp_all +zetaDelta [denote]
   next h _ =>
     rw [Int.add_comm] at h
-    rw [add_left_comm, add_assoc, ← add_assoc, ← add_hmul, h, zero_hmul, zero_add]
-  next => rw [add_hmul]; ac_rfl
+    rw [add_left_comm, add_assoc, ← add_assoc, ← add_zsmul, h, zero_zsmul, zero_add]
+  next => rw [add_zsmul]; ac_rfl
   all_goals ac_rfl
 
 theorem Poly.denote_combine {α} [IntModule α] (ctx : Context α) (p₁ p₂ : Poly) : (p₁.combine p₂).denote ctx = p₁.denote ctx + p₂.denote ctx := by
@@ -216,14 +216,14 @@ attribute [local simp] Poly.denote_combine
 
 theorem Expr.denote_toPoly'_go {α} [IntModule α] {k p} (ctx : Context α) (e : Expr)
     : (toPoly'.go k e p).denote ctx = k * e.denote ctx + p.denote ctx := by
-  induction k, e using Expr.toPoly'.go.induct generalizing p <;> simp [toPoly'.go, denote, Poly.denote, *, hmul_add]
+  induction k, e using Expr.toPoly'.go.induct generalizing p <;> simp [toPoly'.go, denote, Poly.denote, *, zsmul_add]
   next => ac_rfl
-  next => rw [sub_eq_add_neg, neg_hmul, hmul_add, hmul_neg]; ac_rfl
+  next => rw [sub_eq_add_neg, neg_zsmul, zsmul_add, zsmul_neg]; ac_rfl
   next h => simp at h; subst h; simp
-  next ih => simp at ih; rw [ih, mul_hmul, IntModule.hmul_nat]
+  next ih => simp at ih; rw [ih, mul_zsmul, zsmul_natCast_eq_nsmul]
   next ih => simp at ih; simp [ih]
-  next ih => simp at ih; rw [ih, mul_hmul]
-  next => rw [hmul_neg, neg_hmul]
+  next ih => simp at ih; rw [ih, mul_zsmul]
+  next => rw [zsmul_neg, neg_zsmul]
 
 theorem Expr.denote_norm {α} [IntModule α] (ctx : Context α) (e : Expr) : e.norm.denote ctx = e.denote ctx := by
   simp [norm, toPoly', Expr.denote_toPoly'_go, Poly.denote]
@@ -280,8 +280,8 @@ def le_le_combine_cert (p₁ p₂ p₃ : Poly) : Bool :=
 theorem le_le_combine {α} [IntModule α] [Preorder α] [OrderedAdd α] (ctx : Context α) (p₁ p₂ p₃ : Poly)
     : le_le_combine_cert p₁ p₂ p₃ → p₁.denote' ctx ≤ 0 → p₂.denote' ctx ≤ 0 → p₃.denote' ctx ≤ 0 := by
   simp [le_le_combine_cert]; intro _ h₁ h₂; subst p₃; simp
-  replace h₁ := hmul_int_nonpos (coe_natAbs_nonneg p₂.leadCoeff) h₁
-  replace h₂ := hmul_int_nonpos (coe_natAbs_nonneg p₁.leadCoeff) h₂
+  replace h₁ := zsmul_nonpos (coe_natAbs_nonneg p₂.leadCoeff) h₁
+  replace h₂ := zsmul_nonpos (coe_natAbs_nonneg p₁.leadCoeff) h₂
   exact le_add_le h₁ h₂
 
 def le_lt_combine_cert (p₁ p₂ p₃ : Poly) : Bool :=
@@ -292,8 +292,8 @@ def le_lt_combine_cert (p₁ p₂ p₃ : Poly) : Bool :=
 theorem le_lt_combine {α} [IntModule α] [Preorder α] [OrderedAdd α] (ctx : Context α) (p₁ p₂ p₃ : Poly)
     : le_lt_combine_cert p₁ p₂ p₃ → p₁.denote' ctx ≤ 0 → p₂.denote' ctx < 0 → p₃.denote' ctx < 0 := by
   simp [-Int.natAbs_pos, -Int.ofNat_pos, le_lt_combine_cert]; intro hp _ h₁ h₂; subst p₃; simp
-  replace h₁ := hmul_int_nonpos (coe_natAbs_nonneg p₂.leadCoeff) h₁
-  replace h₂ := hmul_int_neg_iff (↑p₁.leadCoeff.natAbs) h₂ |>.mpr hp
+  replace h₁ := zsmul_nonpos (coe_natAbs_nonneg p₂.leadCoeff) h₁
+  replace h₂ := zsmul_neg_iff (↑p₁.leadCoeff.natAbs) h₂ |>.mpr hp
   exact le_add_lt h₁ h₂
 
 def lt_lt_combine_cert (p₁ p₂ p₃ : Poly) : Bool :=
@@ -304,8 +304,8 @@ def lt_lt_combine_cert (p₁ p₂ p₃ : Poly) : Bool :=
 theorem lt_lt_combine {α} [IntModule α] [Preorder α] [OrderedAdd α] (ctx : Context α) (p₁ p₂ p₃ : Poly)
     : lt_lt_combine_cert p₁ p₂ p₃ → p₁.denote' ctx < 0 → p₂.denote' ctx < 0 → p₃.denote' ctx < 0 := by
   simp [-Int.natAbs_pos, -Int.ofNat_pos, lt_lt_combine_cert]; intro hp₁ hp₂ _ h₁ h₂; subst p₃; simp
-  replace h₁ := hmul_int_neg_iff (↑p₂.leadCoeff.natAbs) h₁ |>.mpr hp₁
-  replace h₂ := hmul_int_neg_iff (↑p₁.leadCoeff.natAbs) h₂ |>.mpr hp₂
+  replace h₁ := zsmul_neg_iff (↑p₂.leadCoeff.natAbs) h₁ |>.mpr hp₁
+  replace h₂ := zsmul_neg_iff (↑p₁.leadCoeff.natAbs) h₂ |>.mpr hp₂
   exact lt_add_lt h₁ h₂
 
 def diseq_split_cert (p₁ p₂ : Poly) : Bool :=
@@ -320,7 +320,7 @@ theorem diseq_split {α} [IntModule α] [LinearOrder α] [OrderedAdd α] (ctx :
   next h =>
     apply Or.inr
     simp [h₁] at h
-    rw [← neg_pos_iff, neg_hmul, neg_neg, one_hmul]; assumption
+    rw [← neg_pos_iff, neg_zsmul, neg_neg, one_zsmul]; assumption
 
 theorem diseq_split_resolve {α} [IntModule α] [LinearOrder α] [OrderedAdd α] (ctx : Context α) (p₁ p₂ : Poly)
     : diseq_split_cert p₁ p₂ → p₁.denote' ctx ≠ 0 → ¬p₁.denote' ctx < 0 → p₂.denote' ctx < 0 := by
@@ -409,7 +409,7 @@ theorem eq_of_le_ge {α} [IntModule α] [PartialOrder α] [OrderedAdd α] (ctx :
   intro; subst p₂; simp
   intro h₁ h₂
   replace h₂ := add_le_left h₂ (p₁.denote ctx)
-  rw [add_comm, neg_hmul, one_hmul, ← sub_eq_add_neg, sub_self, zero_add] at h₂
+  rw [add_comm, neg_zsmul, one_zsmul, ← sub_eq_add_neg, sub_self, zero_add] at h₂
   exact PartialOrder.le_antisymm h₁ h₂
 
 /-!
@@ -429,7 +429,7 @@ def zero_lt_one_cert (p : Poly) : Bool :=
 
 theorem zero_lt_one {α} [Ring α] [Preorder α] [OrderedRing α] (ctx : Context α) (p : Poly)
     : zero_lt_one_cert p → (0 : Var).denote ctx = One.one → p.denote' ctx < 0 := by
-  simp [zero_lt_one_cert]; intro _ h; subst p; simp [Poly.denote, h, One.one, neg_hmul]
+  simp [zero_lt_one_cert]; intro _ h; subst p; simp [Poly.denote, h, One.one, neg_zsmul]
   rw [neg_lt_iff, neg_zero]; apply OrderedRing.zero_lt_one
 
 def zero_ne_one_cert (p : Poly) : Bool :=
@@ -478,7 +478,7 @@ def eq_coeff_cert (p₁ p₂ : Poly) (k : Nat) :=
 
 theorem eq_coeff {α} [IntModule α] [NoNatZeroDivisors α] (ctx : Context α) (p₁ p₂ : Poly) (k : Nat)
     : eq_coeff_cert p₁ p₂ k → p₁.denote' ctx = 0 → p₂.denote' ctx = 0 := by
-  simp [eq_coeff_cert]; intro h _; subst p₁; simp [*, hmul_nat]
+  simp [eq_coeff_cert]; intro h _; subst p₁; simp [*, zsmul_natCast_eq_nsmul]
   exact NoNatZeroDivisors.eq_zero_of_mul_eq_zero h
 
 def coeff_cert (p₁ p₂ : Poly) (k : Nat) :=
@@ -490,7 +490,7 @@ theorem le_coeff {α} [IntModule α] [LinearOrder α] [OrderedAdd α] (ctx : Con
   have : ↑k > (0 : Int) := Int.natCast_pos.mpr h
   intro h₁; apply Classical.byContradiction
   intro h₂; replace h₂ := LinearOrder.lt_of_not_le h₂
-  replace h₂ := hmul_int_pos_iff (↑k) h₂ |>.mpr this
+  replace h₂ := zsmul_pos_iff (↑k) h₂ |>.mpr this
   exact Preorder.lt_irrefl 0 (Preorder.lt_of_lt_of_le h₂ h₁)
 
 theorem lt_coeff {α} [IntModule α] [LinearOrder α] [OrderedAdd α] (ctx : Context α) (p₁ p₂ : Poly) (k : Nat)
@@ -499,11 +499,11 @@ theorem lt_coeff {α} [IntModule α] [LinearOrder α] [OrderedAdd α] (ctx : Con
   have : ↑k > (0 : Int) := Int.natCast_pos.mpr h
   intro h₁; apply Classical.byContradiction
   intro h₂; replace h₂ := LinearOrder.le_of_not_lt h₂
-  replace h₂ := hmul_int_nonneg (Int.le_of_lt this) h₂
+  replace h₂ := zsmul_nonneg (Int.le_of_lt this) h₂
   exact Preorder.lt_irrefl 0 (Preorder.lt_of_le_of_lt h₂ h₁)
 
 theorem diseq_neg {α} [IntModule α] (ctx : Context α) (p p' : Poly) : p' == p.mul (-1) → p.denote' ctx ≠ 0 → p'.denote' ctx ≠ 0 := by
-  simp; intro _ _; subst p'; simp [neg_hmul]
+  simp; intro _ _; subst p'; simp [neg_zsmul]
   intro h; replace h := congrArg (- ·) h; simp [neg_neg, neg_zero] at h
   contradiction
 
@@ -522,8 +522,8 @@ theorem eq_diseq_subst {α} [IntModule α] [NoNatZeroDivisors α] (ctx : Context
     have : (k₁.natAbs : Int) * Poly.denote ctx p₂ = 0 := by
       cases Int.natAbs_eq_iff.mp (Eq.refl k₁.natAbs)
       next h => rw [← h]; assumption
-      next h => replace h := congrArg (- ·) h; simp at h; rw [← h, IntModule.neg_hmul, h₃, IntModule.neg_zero]
-    simpa [hmul_nat] using this
+      next h => replace h := congrArg (- ·) h; simp at h; rw [← h, neg_zsmul, h₃, neg_zero]
+    simpa [zsmul_natCast_eq_nsmul] using this
   have := NoNatZeroDivisors.eq_zero_of_mul_eq_zero hne this
   contradiction
 
@@ -547,7 +547,7 @@ def eq_le_subst_cert (x : Var) (p₁ p₂ p₃ : Poly) :=
 theorem eq_le_subst {α} [IntModule α] [Preorder α] [OrderedAdd α] (ctx : Context α) (x : Var) (p₁ p₂ p₃ : Poly)
     : eq_le_subst_cert x p₁ p₂ p₃ → p₁.denote' ctx = 0 → p₂.denote' ctx ≤ 0 → p₃.denote' ctx ≤ 0 := by
   simp [eq_le_subst_cert]; intro h _ h₁ h₂; subst p₃; simp [h₁]
-  exact hmul_int_nonpos h h₂
+  exact zsmul_nonpos h h₂
 
 def eq_lt_subst_cert (x : Var) (p₁ p₂ p₃ : Poly) :=
   let a := p₁.coeff x
@@ -557,7 +557,7 @@ def eq_lt_subst_cert (x : Var) (p₁ p₂ p₃ : Poly) :=
 theorem eq_lt_subst {α} [IntModule α] [Preorder α] [OrderedAdd α] (ctx : Context α) (x : Var) (p₁ p₂ p₃ : Poly)
     : eq_lt_subst_cert x p₁ p₂ p₃ → p₁.denote' ctx = 0 → p₂.denote' ctx < 0 → p₃.denote' ctx < 0 := by
   simp [eq_lt_subst_cert]; intro h _ h₁ h₂; subst p₃; simp [h₁]
-  exact hmul_int_neg_iff (p₁.coeff x) h₂ |>.mpr h
+  exact zsmul_neg_iff (p₁.coeff x) h₂ |>.mpr h
 
 def eq_eq_subst_cert (x : Var) (p₁ p₂ p₃ : Poly) :=
   let a := p₁.coeff x

src/Init/Grind/Ordered/Module.lean

@@ -26,22 +26,15 @@ class ExistsAddOfLT (α : Type u) [LT α] [Zero α] [Add α] where
 
 namespace OrderedAdd
 
-open NatModule
+open AddCommMonoid NatModule
 
 section
 
-variable {M : Type u} [Preorder M] [NatModule M] [OrderedAdd M]
+variable {M : Type u} [Preorder M] [AddCommMonoid M] [OrderedAdd M]
 
 theorem add_le_right_iff {a b : M} (c : M) : a ≤ b ↔ c + a ≤ c + b := by
   rw [add_comm c a, add_comm c b, add_le_left_iff]
 
-theorem hmul_le_hmul {k : Nat} {a b : M} (h : a ≤ b) : k * a ≤ k * b := by
-  induction k with
-  | zero => simp [zero_hmul, Preorder.le_refl]
-  | succ k ih =>
-    rw [add_hmul, one_hmul, add_hmul, one_hmul]
-    exact Preorder.le_trans ((add_le_left_iff a).mp ih) ((add_le_right_iff (k * b)).mp h)
-
 theorem add_le_left {a b : M} (h : a ≤ b) (c : M) : a + c ≤ b + c :=
   (add_le_left_iff c).mp h
 
@@ -73,36 +66,6 @@ theorem add_lt_left_iff {a b : M} (c : M) : a < b ↔ a + c < b + c := by
 theorem add_lt_right_iff {a b : M} (c : M) : a < b ↔ c + a < c + b := by
   rw [add_comm c a, add_comm c b, add_lt_left_iff]
 
-theorem hmul_lt_hmul_iff (k : Nat) {a b : M} (h : a < b) : k * a < k * b ↔ 0 < k := by
-  induction k with
-  | zero => simp [zero_hmul, Preorder.lt_irrefl]
-  | succ k ih =>
-    rw [add_hmul, one_hmul, add_hmul, one_hmul]
-    simp only [Nat.zero_lt_succ, iff_true]
-    by_cases hk : 0 < k
-    · simp only [hk, iff_true] at ih
-      exact Preorder.lt_trans ((add_lt_left_iff a).mp ih) ((add_lt_right_iff (k * b)).mp h)
-    · simp [Nat.eq_zero_of_not_pos hk, zero_hmul, zero_add, h]
-
-theorem hmul_pos_iff {k : Nat} {a : M} (h : 0 < a) : 0 < k * a ↔ 0 < k:= by
-  rw [← hmul_lt_hmul_iff k h, hmul_zero]
-
-theorem hmul_nonneg {k : Nat} {a : M} (h : 0 ≤ a) : 0 ≤ k * a := by
-  have := hmul_le_hmul (k := k) h
-  rwa [hmul_zero] at this
-
-theorem hmul_le_hmul_of_le_of_le_of_nonneg
-    {k₁ k₂ : Nat} {x y : M} (hk : k₁ ≤ k₂) (h : x ≤ y) (w : 0 ≤ x) :
-    k₁ * x ≤ k₂ * y := by
-  apply Preorder.le_trans
-  · change k₁ * x ≤ k₂ * x
-    obtain ⟨k', rfl⟩ := Nat.exists_eq_add_of_le hk
-    rw [add_hmul]
-    conv => lhs; rw [← add_zero (k₁ * x)]
-    rw [← add_le_right_iff]
-    exact hmul_nonneg w
-  · exact hmul_le_hmul h
-
 theorem add_le_add {a b c d : M} (hab : a ≤ b) (hcd : c ≤ d) : a + c ≤ b + d :=
   Preorder.le_trans (add_le_right a hcd) (add_le_left hab d)
 
@@ -110,44 +73,90 @@ end
 
 section
 
-variable {M : Type u} [Preorder M] [IntModule M] [OrderedAdd M]
+variable {M : Type u} [Preorder M] [NatModule M] [OrderedAdd M]
+
+theorem nsmul_le_nsmul {k : Nat} {a b : M} (h : a ≤ b) : k * a ≤ k * b := by
+  induction k with
+  | zero => simp [zero_nsmul, Preorder.le_refl]
+  | succ k ih =>
+    rw [add_nsmul, one_nsmul, add_nsmul, one_nsmul]
+    exact Preorder.le_trans ((add_le_left_iff a).mp ih) ((add_le_right_iff (k * b)).mp h)
+
+theorem nsmul_lt_nsmul_iff (k : Nat) {a b : M} (h : a < b) : k * a < k * b ↔ 0 < k := by
+  induction k with
+  | zero => simp [zero_nsmul, Preorder.lt_irrefl]
+  | succ k ih =>
+    rw [add_nsmul, one_nsmul, add_nsmul, one_nsmul]
+    simp only [Nat.zero_lt_succ, iff_true]
+    by_cases hk : 0 < k
+    · simp only [hk, iff_true] at ih
+      exact Preorder.lt_trans ((add_lt_left_iff a).mp ih) ((add_lt_right_iff (k * b)).mp h)
+    · simp [Nat.eq_zero_of_not_pos hk, zero_nsmul, zero_add, h]
+
+theorem nsmul_pos_iff {k : Nat} {a : M} (h : 0 < a) : 0 < k * a ↔ 0 < k:= by
+  rw [← nsmul_lt_nsmul_iff k h, nsmul_zero]
+
+theorem nsmul_nonneg {k : Nat} {a : M} (h : 0 ≤ a) : 0 ≤ k * a := by
+  have := nsmul_le_nsmul (k := k) h
+  rwa [nsmul_zero] at this
+
+theorem nsmul_le_nsmul_of_le_of_le_of_nonneg
+    {k₁ k₂ : Nat} {x y : M} (hk : k₁ ≤ k₂) (h : x ≤ y) (w : 0 ≤ x) :
+    k₁ * x ≤ k₂ * y := by
+  apply Preorder.le_trans
+  · change k₁ * x ≤ k₂ * x
+    obtain ⟨k', rfl⟩ := Nat.exists_eq_add_of_le hk
+    rw [add_nsmul]
+    conv => lhs; rw [← add_zero (k₁ * x)]
+    rw [← add_le_right_iff]
+    exact nsmul_nonneg w
+  · exact nsmul_le_nsmul h
+
+end
+
+section
+
+open AddCommGroup
+variable {M : Type u} [Preorder M] [AddCommGroup M] [OrderedAdd M]
 
 theorem neg_le_iff {a b : M} : -a ≤ b ↔ -b ≤ a := by
-  rw [OrderedAdd.add_le_left_iff a, IntModule.neg_add_cancel]
-  conv => rhs; rw [OrderedAdd.add_le_left_iff b, IntModule.neg_add_cancel]
+  rw [OrderedAdd.add_le_left_iff a, neg_add_cancel]
+  conv => rhs; rw [OrderedAdd.add_le_left_iff b, neg_add_cancel]
   rw [add_comm]
 
 end
 section
 
 variable {M : Type u} [Preorder M] [IntModule M] [OrderedAdd M]
+open AddCommGroup IntModule
 
-theorem hmul_int_pos_iff (k : Int) {x : M} (h : 0 < x) : 0 < k * x ↔ 0 < k :=
+theorem zsmul_pos_iff (k : Int) {x : M} (h : 0 < x) : 0 < k * x ↔ 0 < k :=
   match k with
   | (k + 1 : Nat) => by
-    simpa [IntModule.hmul_zero, ← IntModule.hmul_nat] using hmul_lt_hmul_iff (k := k + 1) h
-  | (0 : Nat) => by simp [IntModule.zero_hmul]; exact Preorder.lt_irrefl 0
+    simpa [zsmul_zero, ← zsmul_natCast_eq_nsmul] using nsmul_lt_nsmul_iff (k := k + 1) h
+  | (0 : Nat) => by simp [zero_zsmul]; exact Preorder.lt_irrefl 0
   | -(k + 1 : Nat) => by
     have : ¬ (k : Int) + 1 < 0 := by omega
     simp [this]; clear this
-    rw [IntModule.neg_hmul]
+    rw [neg_zsmul]
     rw [Preorder.lt_iff_le_not_le]
     simp
     intro h'
-    rw [OrderedAdd.neg_le_iff, IntModule.neg_zero]
-    simpa [IntModule.hmul_zero, ← IntModule.hmul_nat] using
-      hmul_le_hmul (k := k + 1) (Preorder.le_of_lt h)
+    rw [OrderedAdd.neg_le_iff, neg_zero]
+    simpa [zsmul_zero, ← zsmul_natCast_eq_nsmul] using
+      nsmul_le_nsmul (k := k + 1) (Preorder.le_of_lt h)
 
-theorem hmul_int_nonneg {k : Int} {x : M} (h : 0 ≤ k) (hx : 0 ≤ x) : 0 ≤ k * x :=
+theorem zsmul_nonneg {k : Int} {x : M} (h : 0 ≤ k) (hx : 0 ≤ x) : 0 ≤ k * x :=
   match k, h with
   | (k : Nat), _ => by
-    simpa [IntModule.hmul_nat] using OrderedAdd.hmul_nonneg hx
+    simpa [zsmul_natCast_eq_nsmul] using nsmul_nonneg hx
 
 end
 
-variable {M : Type u} [Preorder M] [IntModule M] [OrderedAdd M]
+section
+variable {M : Type u} [Preorder M] [AddCommGroup M] [OrderedAdd M]
 
-open IntModule
+open AddCommGroup
 
 theorem le_neg_iff {a b : M} : a ≤ -b ↔ b ≤ -a := by
   conv => lhs; rw [← neg_neg a]
@@ -168,31 +177,40 @@ theorem neg_pos_iff {a : M} : 0 < -a ↔ a < 0 := by
   rw [lt_neg_iff, neg_zero]
 
 theorem sub_nonneg_iff {a b : M} : 0 ≤ a - b ↔ b ≤ a := by
-  rw [add_le_left_iff b, IntModule.zero_add, sub_add_cancel]
+  rw [add_le_left_iff b, zero_add, sub_add_cancel]
 
 theorem sub_pos_iff {a b : M} : 0 < a - b ↔ b < a := by
-  rw [add_lt_left_iff b, IntModule.zero_add, sub_add_cancel]
+  rw [add_lt_left_iff b, zero_add, sub_add_cancel]
 
-theorem hmul_int_neg_iff (k : Int) {a : M} (h : a < 0) : k * a < 0 ↔ 0 < k := by
-  simpa [IntModule.hmul_neg, neg_pos_iff] using hmul_int_pos_iff k (neg_pos_iff.mpr h)
+end
 
-theorem hmul_int_nonpos {k : Int} {a : M} (hk : 0 ≤ k) (ha : a ≤ 0) : k * a ≤ 0 := by
-  simpa [IntModule.hmul_neg, neg_nonneg_iff] using hmul_int_nonneg hk (neg_nonneg_iff.mpr ha)
+section
 
-theorem hmul_int_le_hmul_int {a b : M} {k : Int} (hk : 0 ≤ k) (h : a ≤ b) : k * a ≤ k * b := by
-  simpa [hmul_sub, sub_nonneg_iff] using hmul_int_nonneg hk (sub_nonneg_iff.mpr h)
+variable {M : Type u} [Preorder M] [IntModule M] [OrderedAdd M]
+open IntModule
 
-theorem hmul_int_lt_hmul_int_iff (k : Int) {a b : M} (h : a < b) : k * a < k * b ↔ 0 < k := by
-  simpa [hmul_sub, sub_pos_iff] using hmul_int_pos_iff k (sub_pos_iff.mpr h)
+theorem zsmul_neg_iff (k : Int) {a : M} (h : a < 0) : k * a < 0 ↔ 0 < k := by
+  simpa [IntModule.zsmul_neg, neg_pos_iff] using zsmul_pos_iff k (neg_pos_iff.mpr h)
 
-theorem hmul_int_le_hmul_int_of_le_of_le_of_nonneg_of_nonneg
+theorem zsmul_nonpos {k : Int} {a : M} (hk : 0 ≤ k) (ha : a ≤ 0) : k * a ≤ 0 := by
+  simpa [IntModule.zsmul_neg, neg_nonneg_iff] using zsmul_nonneg hk (neg_nonneg_iff.mpr ha)
+
+theorem zsmul_le_zsmul {a b : M} {k : Int} (hk : 0 ≤ k) (h : a ≤ b) : k * a ≤ k * b := by
+  simpa [zsmul_sub, sub_nonneg_iff] using zsmul_nonneg hk (sub_nonneg_iff.mpr h)
+
+theorem zsmul_lt_zsmul_iff (k : Int) {a b : M} (h : a < b) : k * a < k * b ↔ 0 < k := by
+  simpa [zsmul_sub, sub_pos_iff] using zsmul_pos_iff k (sub_pos_iff.mpr h)
+
+theorem zsmul_le_zsmul_of_le_of_le_of_nonneg_of_nonneg
     {k₁ k₂ : Int} {x y : M} (hk : k₁ ≤ k₂) (h : x ≤ y) (w : 0 ≤ k₁) (w' : 0 ≤ x) :
     k₁ * x ≤ k₂ * y := by
   apply Preorder.le_trans
-  · have : 0 ≤ k₁ * (y - x) := hmul_int_nonneg w (sub_nonneg_iff.mpr h)
-    rwa [IntModule.hmul_sub, sub_nonneg_iff] at this
-  · have : 0 ≤ (k₂ - k₁) * y := hmul_int_nonneg (Int.sub_nonneg.mpr hk) (Preorder.le_trans w' h)
-    rwa [IntModule.sub_hmul, sub_nonneg_iff] at this
+  · have : 0 ≤ k₁ * (y - x) := zsmul_nonneg w (sub_nonneg_iff.mpr h)
+    rwa [IntModule.zsmul_sub, sub_nonneg_iff] at this
+  · have : 0 ≤ (k₂ - k₁) * y := zsmul_nonneg (Int.sub_nonneg.mpr hk) (Preorder.le_trans w' h)
+    rwa [IntModule.sub_zsmul, sub_nonneg_iff] at this
+
+end
 
 end OrderedAdd
 

src/Init/Grind/Ordered/Ring.lean

@@ -38,7 +38,7 @@ variable [Preorder R] [OrderedRing R]
 theorem neg_one_lt_zero : (-1 : R) < 0 := by
   have h := zero_lt_one (R := R)
   have := OrderedAdd.add_lt_left h (-1)
-  rw [Semiring.zero_add, Ring.add_neg_cancel] at this
+  rw [AddCommMonoid.zero_add, AddCommGroup.add_neg_cancel] at this
   assumption
 
 theorem ofNat_nonneg (x : Nat) : (OfNat.ofNat x : R) ≥ 0 := by
@@ -48,7 +48,7 @@ theorem ofNat_nonneg (x : Nat) : (OfNat.ofNat x : R) ≥ 0 := by
     have := OrderedRing.zero_lt_one (R := R)
     rw [Semiring.ofNat_succ]
     replace ih := OrderedAdd.add_le_left ih 1
-    rw [Semiring.zero_add] at ih
+    rw [AddCommMonoid.zero_add] at ih
     have := Preorder.lt_of_lt_of_le this ih
     exact Preorder.le_of_lt this
 
@@ -62,8 +62,8 @@ instance [Ring α] [Preorder α] [OrderedRing α] : IsCharP α 0 := IsCharP.mk'
     next x =>
       rw [Semiring.ofNat_succ] at h
       replace h := congrArg (· - 1) h; simp at h
-      rw [Ring.sub_eq_add_neg, Semiring.add_assoc, Ring.add_neg_cancel,
-          Ring.sub_eq_add_neg, Semiring.zero_add, Semiring.add_zero] at h
+      rw [Ring.sub_eq_add_neg, Semiring.add_assoc, AddCommGroup.add_neg_cancel,
+          Ring.sub_eq_add_neg, AddCommMonoid.zero_add, Semiring.add_zero] at h
       have h₁ : (OfNat.ofNat x : α) < 0 := by
         have := OrderedRing.neg_one_lt_zero (R := α)
         rw [h]; assumption
@@ -110,26 +110,26 @@ open OrderedAdd
 
 theorem mul_le_mul_of_nonpos_left {a b c : R} (h : a ≤ b) (h' : c ≤ 0) : c * b ≤ c * a := by
   have := mul_le_mul_of_nonneg_left h (neg_nonneg_iff.mpr h')
-  rwa [Ring.neg_mul, Ring.neg_mul, neg_le_iff, IntModule.neg_neg] at this
+  rwa [Ring.neg_mul, Ring.neg_mul, neg_le_iff, AddCommGroup.neg_neg] at this
 
 theorem mul_le_mul_of_nonpos_right {a b c : R} (h : a ≤ b) (h' : c ≤ 0) : b * c ≤ a * c := by
   have := mul_le_mul_of_nonneg_right h (neg_nonneg_iff.mpr h')
-  rwa [Ring.mul_neg, Ring.mul_neg, neg_le_iff, IntModule.neg_neg] at this
+  rwa [Ring.mul_neg, Ring.mul_neg, neg_le_iff, AddCommGroup.neg_neg] at this
 
 theorem mul_lt_mul_of_neg_left {a b c : R} (h : a < b) (h' : c < 0) : c * b < c * a := by
   have := mul_lt_mul_of_pos_left h (neg_pos_iff.mpr h')
-  rwa [Ring.neg_mul, Ring.neg_mul, neg_lt_iff, IntModule.neg_neg] at this
+  rwa [Ring.neg_mul, Ring.neg_mul, neg_lt_iff, AddCommGroup.neg_neg] at this
 
 theorem mul_lt_mul_of_neg_right {a b c : R} (h : a < b) (h' : c < 0) : b * c < a * c := by
   have := mul_lt_mul_of_pos_right h (neg_pos_iff.mpr h')
-  rwa [Ring.mul_neg, Ring.mul_neg, neg_lt_iff, IntModule.neg_neg] at this
+  rwa [Ring.mul_neg, Ring.mul_neg, neg_lt_iff, AddCommGroup.neg_neg] at this
 
 theorem mul_nonneg {a b : R} (h₁ : 0 ≤ a) (h₂ : 0 ≤ b) : 0 ≤ a * b := by
   simpa [Semiring.zero_mul] using mul_le_mul_of_nonneg_right h₁ h₂
 
 theorem mul_nonneg_of_nonpos_of_nonpos {a b : R} (h₁ : a ≤ 0) (h₂ : b ≤ 0) : 0 ≤ a * b := by
   have := mul_nonneg (neg_nonneg_iff.mpr h₁) (neg_nonneg_iff.mpr h₂)
-  simpa [Ring.neg_mul, Ring.mul_neg, Ring.neg_neg] using this
+  simpa [Ring.neg_mul, Ring.mul_neg, AddCommGroup.neg_neg] using this
 
 theorem mul_nonpos_of_nonneg_of_nonpos {a b : R} (h₁ : 0 ≤ a) (h₂ : b ≤ 0) : a * b ≤ 0 := by
   rw [← neg_nonneg_iff, ← Ring.mul_neg]
@@ -144,7 +144,7 @@ theorem mul_pos {a b : R} (h₁ : 0 < a) (h₂ : 0 < b) : 0 < a * b := by
 
 theorem mul_pos_of_neg_of_neg {a b : R} (h₁ : a < 0) (h₂ : b < 0) : 0 < a * b := by
   have := mul_pos (neg_pos_iff.mpr h₁) (neg_pos_iff.mpr h₂)
-  simpa [Ring.neg_mul, Ring.mul_neg, Ring.neg_neg] using this
+  simpa [Ring.neg_mul, Ring.mul_neg, AddCommGroup.neg_neg] using this
 
 theorem mul_neg_of_pos_of_neg {a b : R} (h₁ : 0 < a) (h₂ : b < 0) : a * b < 0 := by
   rw [← neg_pos_iff, ← Ring.mul_neg]

src/Init/Grind/Ring/Basic.lean

@@ -15,7 +15,7 @@ public import Init.Grind.Module.Basic
 public section
 
 /-!
-# A monolithic commutative ring typeclass for internal use in `grind`.
+# Commutative ring typeclasses for internal use in `grind`.
 
 The `Lean.Grind.CommRing` class will be used to convert expressions into the internal representation via polynomials,
 with coefficients expressed via `OfNat` and `Neg`.
@@ -41,7 +41,7 @@ Use `Ring` instead if the type also has negation,
 `CommSemiring` if the multiplication is commutative,
 or `CommRing` if the type has negation and multiplication is commutative.
 -/
-class Semiring (α : Type u) extends Add α, Mul α, HPow α Nat α where
+class Semiring (α : Type u) extends Add α, Mul α where
   /--
   In every semiring there is a canonical map from the natural numbers to the semiring,
   providing the values of `0` and `1`. Note that this function need not be injective.
@@ -52,12 +52,16 @@ class Semiring (α : Type u) extends Add α, Mul α, HPow α Nat α where
   The field `ofNat_eq_natCast` ensures that these are (propositionally) equal to the values of `natCast`.
   -/
   [ofNat : ∀ n, OfNat α n]
-  /-- Addition is associative. -/
-  add_assoc : ∀ a b c : α, a + b + c = a + (b + c)
-  /-- Addition is commutative. -/
-  add_comm : ∀ a b : α, a + b = b + a
+  /-- Scalar multiplication by natural numbers. -/
+  [nsmul : HMul Nat α α]
+  /-- Exponentiation by a natural number. -/
+  [npow : HPow α Nat α]
   /-- Zero is the right identity for addition. -/
   add_zero : ∀ a : α, a + 0 = a
+  /-- Addition is commutative. -/
+  add_comm : ∀ a b : α, a + b = b + a
+  /-- Addition is associative. -/
+  add_assoc : ∀ a b c : α, a + b + c = a + (b + c)
   /-- Multiplication is associative. -/
   mul_assoc : ∀ a b c : α, a * b * c = a * (b * c)
   /-- One is the right identity for multiplication. -/
@@ -80,6 +84,7 @@ class Semiring (α : Type u) extends Add α, Mul α, HPow α Nat α where
   ofNat_succ : ∀ a : Nat, OfNat.ofNat (α := α) (a + 1) = OfNat.ofNat a + 1 := by intros; rfl
   /-- Numerals are consistently defined with respect to the canonical map from natural numbers. -/
   ofNat_eq_natCast : ∀ n : Nat, OfNat.ofNat (α := α) n = Nat.cast n := by intros; rfl
+  nsmul_eq_natCast_mul : ∀ n : Nat, ∀ a : α, HMul.hMul (α := Nat) n a = Nat.cast n * a := by intros; rfl
 
 /--
 A ring, i.e. a type equipped with addition, negation, multiplication, and a map from the integers,
@@ -90,10 +95,16 @@ Use `CommRing` if the multiplication is commutative.
 class Ring (α : Type u) extends Semiring α, Neg α, Sub α where
   /-- In every ring there is a canonical map from the integers to the ring. -/
   [intCast : IntCast α]
+  /-- Scalar multiplication by integers. -/
+  [zsmul : HMul Int α α]
   /-- Negation is the left inverse of addition. -/
   neg_add_cancel : ∀ a : α, -a + a = 0
   /-- Subtraction is addition of the negative. -/
   sub_eq_add_neg : ∀ a b : α, a - b = a + -b
+  /-- Scalar multiplication by the negation of an integer is the negation of scalar multiplication by that integer. -/
+  neg_zsmul : ∀ (i : Int) (a : α), HMul.hMul (α := Int) (-i : Int) a = -(HMul.hMul (α := Int) i a)
+  /-- Scalar multiplication by natural numbers is consistent with scalar multiplication by integers. -/
+  zsmul_natCast_eq_nsmul : ∀ n : Nat, ∀ a : α, HMul.hMul (α := Int) (n : Int) a = HMul.hMul (α := Nat) n a := by intros; rfl
   /-- The canonical map from the integers is consistent with the canonical map from the natural numbers. -/
   intCast_ofNat : ∀ n : Nat, Int.cast (OfNat.ofNat (α := Int) n) = OfNat.ofNat (α := α) n := by intros; rfl
   /-- The canonical map from the integers is consistent with negation. -/
@@ -120,7 +131,7 @@ class CommRing (α : Type u) extends Ring α, CommSemiring α
 -- so that in downstream libraries with their own `CommRing` class,
 -- the path `CommRing -> Add` is found before `CommRing -> Lean.Grind.CommRing -> Add`.
 -- (And similarly for the other parents.)
-attribute [instance 100] Semiring.toAdd Semiring.toMul Semiring.toHPow Ring.toNeg Ring.toSub
+attribute [instance 100] Semiring.toAdd Semiring.toMul Semiring.npow Ring.toNeg Ring.toSub
 
 -- This is a low-priority instance, to avoid conflicts with existing `OfNat`, `NatCast`, and `IntCast` instances.
 attribute [instance 100] Semiring.ofNat
@@ -132,27 +143,30 @@ example [CommRing α] : (CommSemiring.toSemiring : Semiring α) = (Ring.toSemiri
 
 namespace Semiring
 
+open NatModule
+
 variable {α : Type u} [Semiring α]
 
-theorem natCast_zero : ((0 : Nat) : α) = 0 := (ofNat_eq_natCast 0).symm
+theorem natCast_zero : ((0 : Nat) : α) = 0 := by
+  rw [← ofNat_eq_natCast 0]
 theorem natCast_one : ((1 : Nat) : α) = 1 := (ofNat_eq_natCast 1).symm
 
 theorem ofNat_add (a b : Nat) : OfNat.ofNat (α := α) (a + b) = OfNat.ofNat a + OfNat.ofNat b := by
   induction b with
-  | zero => simp [Nat.add_zero, add_zero]
+  | zero => rw [Nat.add_zero, add_zero]
   | succ b ih => rw [Nat.add_succ, ofNat_succ, ih, ofNat_succ b, add_assoc]
 
+instance toNatModule [I : Semiring α] : NatModule α :=
+  { I with
+    zero_nsmul a := by rw [nsmul_eq_natCast_mul, ← ofNat_eq_natCast, zero_mul]
+    add_one_nsmul n a := by rw [nsmul_eq_natCast_mul, ← ofNat_eq_natCast, ofNat_add, right_distrib,
+      ofNat_eq_natCast, ← nsmul_eq_natCast_mul, ofNat_eq_natCast, natCast_one, one_mul] }
+
 theorem natCast_add (a b : Nat) : ((a + b : Nat) : α) = ((a : α) + (b : α)) := by
   rw [← ofNat_eq_natCast, ← ofNat_eq_natCast, ofNat_add, ofNat_eq_natCast, ofNat_eq_natCast]
 theorem natCast_succ (n : Nat) : ((n + 1 : Nat) : α) = ((n : α) + 1) := by
   rw [natCast_add, natCast_one]
 
-theorem zero_add (a : α) : 0 + a = a := by
-  rw [add_comm, add_zero]
-
-theorem add_left_comm (a b c : α) : a + (b + c) = b + (a + c) := by
-  rw [← add_assoc, ← add_assoc, add_comm a]
-
 theorem ofNat_mul (a b : Nat) : OfNat.ofNat (α := α) (a * b) = OfNat.ofNat a * OfNat.ofNat b := by
   induction b with
   | zero => simp [Nat.mul_zero, mul_zero]
@@ -177,84 +191,29 @@ theorem natCast_pow (x : Nat) (k : Nat) : ((x ^ k : Nat) : α) = (x : α) ^ k :=
   next => simp [pow_zero, Nat.pow_zero, natCast_one]
   next k ih => simp [pow_succ, Nat.pow_succ, natCast_mul, *]
 
-instance : NatModule α where
-  hMul a x := a * x
-  add_zero := by simp [add_zero]
-  add_assoc := by simp [add_assoc]
-  add_comm := by simp [add_comm]
-  zero_hmul := by simp [natCast_zero, zero_mul]
-  one_hmul := by simp [natCast_one, one_mul]
-  add_hmul := by simp [natCast_add, right_distrib]
-  hmul_zero := by simp [mul_zero]
-  hmul_add := by simp [left_distrib]
-
-theorem hmul_eq_natCast_mul {α} [Semiring α] {k : Nat} {a : α} : HMul.hMul (α := Nat) k a = (k : α) * a := rfl
-
-theorem hmul_eq_ofNat_mul {α} [Semiring α] {k : Nat} {a : α} : HMul.hMul (α := Nat) k a = OfNat.ofNat k * a := by
-  simp [ofNat_eq_natCast, hmul_eq_natCast_mul]
+theorem nsmul_eq_ofNat_mul {α} [Semiring α] {k : Nat} {a : α} : HMul.hMul (α := Nat) k a = OfNat.ofNat k * a := by
+  simp [ofNat_eq_natCast, nsmul_eq_natCast_mul]
 
 end Semiring
 
 namespace Ring
 
-open Semiring
+open AddCommMonoid AddCommGroup NatModule IntModule
+open Semiring hiding add_assoc add_comm
 
 variable {α : Type u} [Ring α]
 
-theorem add_neg_cancel (a : α) : a + -a = 0 := by
-  rw [add_comm, neg_add_cancel]
-
-theorem add_left_inj {a b : α} (c : α) : a + c = b + c ↔ a = b :=
-  ⟨fun h => by simpa [add_assoc, add_neg_cancel, add_zero] using (congrArg (· + -c) h),
-   fun g => congrArg (· + c) g⟩
-
-theorem add_right_inj (a b c : α) : a + b = a + c ↔ b = c := by
-  rw [add_comm a b, add_comm a c, add_left_inj]
-
-theorem neg_zero : (-0 : α) = 0 := by
-  rw [← add_left_inj 0, neg_add_cancel, add_zero]
-
-theorem neg_neg (a : α) : -(-a) = a := by
-  rw [← add_left_inj (-a), neg_add_cancel, add_neg_cancel]
-
-theorem neg_eq_zero (a : α) : -a = 0 ↔ a = 0 :=
-  ⟨fun h => by
-    replace h := congrArg (-·) h
-    simpa [neg_neg, neg_zero] using h,
-   fun h => by rw [h, neg_zero]⟩
-
-theorem neg_eq_iff (a b : α) : -a = b ↔ a = -b := by
-  constructor
-  · intro h
-    rw [← neg_neg a, h]
-  · intro h
-    rw [← neg_neg b, h]
-
-theorem neg_add (a b : α) : -(a + b) = -a + -b := by
-  rw [← add_left_inj (a + b), neg_add_cancel, add_assoc (-a), add_comm a b, ← add_assoc (-b),
-    neg_add_cancel, zero_add, neg_add_cancel]
-
-theorem neg_sub (a b : α) : -(a - b) = b - a := by
-  rw [sub_eq_add_neg, neg_add, neg_neg, sub_eq_add_neg, add_comm]
-
-theorem sub_self (a : α) : a - a = 0 := by
-  rw [sub_eq_add_neg, add_neg_cancel]
-
-theorem sub_eq_iff {a b c : α} : a - b = c ↔ a = c + b := by
-  rw [sub_eq_add_neg]
-  constructor
-  next => intro; subst c; rw [add_assoc, neg_add_cancel, add_zero]
-  next => intro; subst a; rw [add_assoc, add_comm b, neg_add_cancel, add_zero]
-
-theorem sub_eq_zero_iff {a b : α} : a - b = 0 ↔ a = b := by
-  simp [sub_eq_iff, zero_add]
-
-theorem intCast_zero : ((0 : Int) : α) = 0 := intCast_ofNat 0
-theorem intCast_one : ((1 : Int) : α) = 1 := intCast_ofNat 1
-theorem intCast_neg_one : ((-1 : Int) : α) = -1 := by rw [intCast_neg, intCast_ofNat]
 theorem intCast_natCast (n : Nat) : ((n : Int) : α) = (n : α) := by
   erw [intCast_ofNat]
   rw [ofNat_eq_natCast]
+
+instance toAddCommGroup [I : Ring α] : AddCommGroup α :=
+  { I with }
+
+theorem intCast_zero : ((0 : Int) : α) = 0 := by
+  rw [intCast_ofNat 0]
+theorem intCast_one : ((1 : Int) : α) = 1 := intCast_ofNat 1
+theorem intCast_neg_one : ((-1 : Int) : α) = -1 := by rw [intCast_neg, intCast_ofNat]
 theorem intCast_natCast_add_one (n : Nat) : ((n + 1 : Int) : α) = (n : α) + 1 := by
   rw [← Int.natCast_add_one, intCast_natCast, natCast_add, ofNat_eq_natCast]
 theorem intCast_negSucc (n : Nat) : ((-(n + 1) : Int) : α) = -((n : α) + 1) := by
@@ -273,7 +232,8 @@ theorem intCast_nat_sub {x y : Nat} (h : x ≥ y) : (((x - y : Nat) : Int) : α)
       rw [this, intCast_natCast_add_one]
       specialize ih (by omega)
       rw [intCast_natCast] at ih
-      rw [ih, natCast_succ, sub_eq_add_neg, sub_eq_add_neg, add_assoc, add_comm _ 1, ← add_assoc]
+      rw [ih, natCast_succ, sub_eq_add_neg, sub_eq_add_neg, add_assoc,
+        AddCommMonoid.add_comm _ 1, ← add_assoc]
 theorem intCast_add (x y : Int) : ((x + y : Int) : α) = ((x : α) + (y : α)) :=
   match x, y with
   | (x : Nat), (y : Nat) => by
@@ -323,19 +283,33 @@ theorem neg_mul (a b : α) : (-a) * b = -(a * b) := by
 theorem mul_neg (a b : α) : a * (-b) = -(a * b) := by
   rw [neg_eq_mul_neg_one b, neg_eq_mul_neg_one (a * b), mul_assoc]
 
-theorem intCast_nat_mul (x y : Nat) : ((x * y : Int) : α) = ((x : α) * (y : α)) := by
+attribute [local instance] Ring.zsmul in
+theorem zsmul_eq_intCast_mul {k : Int} {a : α} : (HMul.hMul (α := Int) (γ := α) k a : α) = (k : α) * a := by
+  match k with
+  | (k : Nat) =>
+    rw [intCast_natCast, zsmul_natCast_eq_nsmul, nsmul_eq_natCast_mul]
+  | -(k + 1 : Nat) =>
+    rw [intCast_neg, neg_mul, neg_zsmul, intCast_natCast, zsmul_natCast_eq_nsmul, nsmul_eq_natCast_mul]
+
+instance toIntModule [I : Ring α] : IntModule α :=
+  { I, Semiring.toNatModule (α := α) with
+    zero_zsmul a := by rw [← Int.natCast_zero, zsmul_natCast_eq_nsmul, zero_nsmul]
+    one_zsmul a := by rw [← Int.natCast_one, zsmul_natCast_eq_nsmul, one_nsmul]
+    add_zsmul n m a := by rw [zsmul_eq_intCast_mul, intCast_add, right_distrib, zsmul_eq_intCast_mul, zsmul_eq_intCast_mul] }
+
+private theorem intCast_mul_aux (x y : Nat) : ((x * y : Int) : α) = ((x : α) * (y : α)) := by
   rw [Int.ofNat_mul_ofNat, intCast_natCast, natCast_mul]
 
 theorem intCast_mul (x y : Int) : ((x * y : Int) : α) = ((x : α) * (y : α)) :=
   match x, y with
   | (x : Nat), (y : Nat) => by
-    rw [intCast_nat_mul, intCast_natCast, intCast_natCast]
+    rw [intCast_mul_aux, intCast_natCast, intCast_natCast]
   | (x : Nat), (-(y + 1 : Nat)) => by
-    rw [Int.mul_neg, intCast_neg, intCast_nat_mul, intCast_neg, mul_neg, intCast_natCast, intCast_natCast]
+    rw [Int.mul_neg, intCast_neg, intCast_mul_aux, intCast_neg, mul_neg, intCast_natCast, intCast_natCast]
   | (-(x + 1 : Nat)), (y : Nat) => by
-    rw [Int.neg_mul, intCast_neg, intCast_nat_mul, intCast_neg, neg_mul, intCast_natCast, intCast_natCast]
+    rw [Int.neg_mul, intCast_neg, intCast_mul_aux, intCast_neg, neg_mul, intCast_natCast, intCast_natCast]
   | (-(x + 1 : Nat)), (-(y + 1 : Nat)) => by
-    rw [Int.neg_mul_neg, intCast_neg, intCast_neg, neg_mul, mul_neg, neg_neg, intCast_nat_mul,
+    rw [Int.neg_mul_neg, intCast_neg, intCast_neg, neg_mul, mul_neg, neg_neg, intCast_mul_aux,
       intCast_natCast, intCast_natCast]
 
 theorem intCast_pow (x : Int) (k : Nat) : ((x ^ k : Int) : α) = (x : α) ^ k := by
@@ -343,27 +317,8 @@ theorem intCast_pow (x : Int) (k : Nat) : ((x ^ k : Int) : α) = (x : α) ^ k :=
   next => simp [pow_zero, Int.pow_zero, intCast_one]
   next k ih => simp [pow_succ, Int.pow_succ, intCast_mul, *]
 
-instance : IntModule α where
-  hmulInt := ⟨fun a x => a * x⟩
-  hmulNat := ⟨fun a x => a * x⟩
-  hmul_nat n x := by
-    change ((n : Int) : α) * x = (n : α) * x
-    rw [intCast_natCast]
-  add_zero := by simp [add_zero]
-  add_assoc := by simp [add_assoc]
-  add_comm := by simp [add_comm]
-  zero_hmul := by simp [intCast_zero, zero_mul]
-  one_hmul := by simp [intCast_one, one_mul]
-  add_hmul := by simp [intCast_add, right_distrib]
-  hmul_zero := by simp [mul_zero]
-  hmul_add := by simp [left_distrib]
-  neg_add_cancel := by simp [neg_add_cancel]
-  sub_eq_add_neg := by simp [sub_eq_add_neg]
-
-theorem hmul_eq_intCast_mul {α} [Ring α] {k : Int} {a : α} : HMul.hMul (α := Int) k a = (k : α) * a := rfl
-
 -- Verify that the diamond from `Ring` to `NatModule` via either `Semiring` or `IntModule` is defeq.
-example [Ring R] : (Semiring.instNatModule : NatModule R) = (IntModule.toNatModule R) := rfl
+example [Ring R] : (Semiring.toNatModule : NatModule R) = IntModule.toNatModule (M := R) := rfl
 
 end Ring
 
@@ -378,7 +333,9 @@ theorem mul_left_comm (a b c : α) : a * (b * c) = b * (a * c) := by
 
 end CommSemiring
 
-open Semiring Ring CommSemiring CommRing
+open Semiring hiding add_comm add_assoc add_zero
+open Ring hiding neg_add_cancel
+open CommSemiring CommRing
 
 /--
 A ring `α` has characteristic `p` if `OfNat.ofNat x = 0` iff `x % p = 0`.
@@ -450,6 +407,8 @@ end Semiring
 
 section Ring
 
+open AddCommMonoid AddCommGroup
+
 variable (p)  {α : Type u} [Ring α] [IsCharP α p]
 
 private theorem mk'_aux {x y : Nat} (p : Nat) (h : y ≤ x) :
@@ -525,7 +484,8 @@ theorem intCast_ext_iff {x y : Int} : (x : α) = (y : α) ↔ x % p = y % p := b
     have : ((x - y : Int) : α) = 0 :=
       (intCast_eq_zero_iff p _).mpr (by rw [Int.sub_emod, h, Int.sub_self, Int.zero_emod])
     replace this := congrArg (· + (y : α)) this
-    simpa [intCast_sub, zero_add, sub_eq_add_neg, add_assoc, neg_add_cancel, add_zero] using this
+    simpa [intCast_sub, zero_add, AddCommGroup.sub_eq_add_neg, add_assoc,
+      neg_add_cancel, add_zero] using this
 
 theorem intCast_emod (x : Int) : ((x % p : Int) : α) = (x : α) := by
   rw [intCast_ext_iff p, Int.emod_emod]
@@ -534,6 +494,8 @@ end Ring
 
 end IsCharP
 
+open AddCommGroup
+
 theorem no_int_zero_divisors {α : Type u} [IntModule α] [NoNatZeroDivisors α] {k : Int} {a : α}
     : k ≠ 0 → k * a = 0 → a = 0 := by
   match k with
@@ -541,15 +503,15 @@ theorem no_int_zero_divisors {α : Type u} [IntModule α] [NoNatZeroDivisors α]
     simp only [ne_eq, Int.natCast_eq_zero]
     intro h₁ h₂
     replace h₁ : k ≠ 0 := by intro h; simp [h] at h₁
-    rw [IntModule.hmul_nat] at h₂
+    rw [IntModule.zsmul_natCast_eq_nsmul] at h₂
     exact NoNatZeroDivisors.eq_zero_of_mul_eq_zero h₁ h₂
   | -(k+1 : Nat) =>
-    rw [IntModule.neg_hmul]
+    rw [IntModule.neg_zsmul]
     intro _ h
     replace h := congrArg (-·) h
     dsimp only at h
-    rw [IntModule.neg_neg, IntModule.neg_zero] at h
-    rw [IntModule.hmul_nat] at h
+    rw [neg_neg, neg_zero] at h
+    rw [IntModule.zsmul_natCast_eq_nsmul] at h
     exact NoNatZeroDivisors.eq_zero_of_mul_eq_zero (Nat.succ_ne_zero _) h
 
 end Lean.Grind

src/Init/Grind/Ring/Envelope.lean

@@ -141,7 +141,7 @@ def Q.ind {β : Q α → Prop} (mk : ∀ (a : α × α), β (Q.mk a)) (q : Q α)
         exact ⟨k, h.symm⟩)
 
 attribute [local simp]
-  Quot.liftOn Semiring.add_zero Semiring.zero_add Semiring.mul_one Semiring.one_mul
+  Quot.liftOn Semiring.add_zero AddCommMonoid.zero_add Semiring.mul_one Semiring.one_mul
   Semiring.natCast_zero Semiring.natCast_one Semiring.mul_zero Semiring.zero_mul
 
 theorem neg_add_cancel (a : Q α) : add (neg a) a = natCast 0 := by
@@ -227,25 +227,47 @@ theorem right_distrib (a b c : Q α) : mul (add a b) c = add (mul a c) (mul b c)
   cases a; cases b; cases c; simp; apply Quot.sound
   simp [Semiring.right_distrib]; refine ⟨0, ?_⟩; ac_rfl
 
-def hPow (a : Q α) (n : Nat)  : Q α :=
+def npow (a : Q α) (n : Nat)  : Q α :=
   match n with
   | 0 => natCast 1
-  | n+1 => mul (hPow a n) a
+  | n+1 => mul (npow a n) a
 
-private theorem pow_zero (a : Q α) : hPow a 0 = natCast 1 := rfl
+private theorem pow_zero (a : Q α) : npow a 0 = natCast 1 := rfl
 
-private theorem pow_succ (a : Q α) (n : Nat) : hPow a (n+1) = mul (hPow a n) a := rfl
+private theorem pow_succ (a : Q α) (n : Nat) : npow a (n+1) = mul (npow a n) a := rfl
+
+def nsmul (n : Nat) (a : Q α) : Q α :=
+  mul (natCast n) a
+
+def zsmul (i : Int) (a : Q α) : Q α :=
+  mul (intCast i) a
+
+theorem neg_zsmul (i : Int) (a : Q α) : zsmul (-i) a = neg (zsmul i a) := by
+  induction a using Quot.ind
+  next a =>
+  cases a; simp [zsmul]
+  split <;> rename_i h₁
+  · split <;> rename_i h₂
+    · omega
+    · simp
+  · split <;> rename_i h₂
+    · simp
+    · have : i = 0 := by omega
+      simp [this]
 
 def ofSemiring : Ring (Q α) := {
+  nsmul := ⟨nsmul⟩
+  zsmul := ⟨zsmul⟩
   ofNat   := fun n => ⟨natCast n⟩
   natCast := ⟨natCast⟩
   intCast := ⟨intCast⟩
-  add, sub, mul, neg, hPow
+  npow := ⟨npow⟩
+  add, sub, mul, neg,
   add_comm, add_assoc, add_zero
   neg_add_cancel, sub_eq_add_neg
   mul_one, one_mul, zero_mul, mul_zero, mul_assoc,
   left_distrib, right_distrib, pow_zero, pow_succ,
-  intCast_neg, ofNat_succ
+  intCast_neg, ofNat_succ, neg_zsmul
 }
 
 attribute [instance] ofSemiring
@@ -328,7 +350,8 @@ instance [Semiring α] [AddRightCancel α] [NoNatZeroDivisors α] : NoNatZeroDiv
     simp [r] at h₂
     rcases h₂ with ⟨k', h₂⟩
     replace h₂ := AddRightCancel.add_right_cancel _ _ _ h₂
-    simp [← Semiring.left_distrib] at h₂
+    simp only [← Semiring.left_distrib] at h₂
+    simp only [← Semiring.nsmul_eq_natCast_mul] at h₂
     replace h₂ := NoNatZeroDivisors.no_nat_zero_divisors k (a₁ + b₂) (a₂ + b₁) h₁ h₂
     apply Quot.sound; simp [r]; exists 0; simp [h₂]
 
@@ -400,7 +423,7 @@ instance [Preorder α] [OrderedAdd α] : Preorder (OfSemiring.Q α) where
 
 @[local simp] private theorem mk_pos [Preorder α] [OrderedAdd α] {a₁ a₂ : α} :
     0 < Q.mk (a₁, a₂) ↔ a₂ < a₁ := by
-  simp [← toQ_ofNat, toQ, mk_lt_mk, Semiring.zero_add]
+  simp [← toQ_ofNat, toQ, mk_lt_mk, AddCommMonoid.zero_add]
 
 @[local simp]
 theorem toQ_le [Preorder α] [OrderedAdd α] {a b : α} : toQ a ≤ toQ b ↔ a ≤ b := by

src/Init/Grind/Ring/Field.lean

@@ -16,6 +16,7 @@ namespace Lean.Grind
 A field is a commutative ring with inverses for all non-zero elements.
 -/
 class Field (α : Type u) extends CommRing α, Inv α, Div α where
+  [zpow : HPow α Int α]
   /-- Division is multiplication by the inverse. -/
   div_eq_mul_inv : ∀ a b : α, a / b = a * b⁻¹
   /-- Zero is not equal to one: fields are non trivial.-/
@@ -24,8 +25,14 @@ class Field (α : Type u) extends CommRing α, Inv α, Div α where
   inv_zero : (0 : α)⁻¹ = 0
   /-- The inverse of a non-zero element is a right inverse. -/
   mul_inv_cancel : ∀ {a : α}, a ≠ 0 → a * a⁻¹ = 1
+  /-- The zeroth power of any element is one. -/
+  zpow_zero : ∀ a : α, a ^ (0 : Int) = 1
+  /-- The first power of any element is the element itself. -/
+  zpow_one : ∀ a : α, a ^ (1 : Int) = a
+  /-- Power to a sum is the product of the powers. -/
+  zpow_add : ∀ a : α, ∀ n m : Int, a ^ (n + m) = a ^ n * a ^ m
 
-attribute [instance 100] Field.toInv Field.toDiv
+attribute [instance 100] Field.toInv Field.toDiv Field.zpow
 
 namespace Field
 
@@ -57,10 +64,10 @@ theorem inv_inv (a : α) : a⁻¹⁻¹ = a := by
 theorem inv_neg (a : α) : (-a)⁻¹ = -a⁻¹ := by
   by_cases h : a = 0
   · subst h
-    simp [Field.inv_zero, Ring.neg_zero]
+    simp [Field.inv_zero, AddCommGroup.neg_zero]
   · symm
     apply eq_inv_of_mul_eq_one
-    simp [Ring.neg_mul, Ring.mul_neg, Ring.neg_neg, Field.inv_mul_cancel h]
+    simp [Ring.neg_mul, Ring.mul_neg, AddCommGroup.neg_neg, Field.inv_mul_cancel h]
 
 theorem inv_eq_zero_iff {a : α} : a⁻¹ = 0 ↔ a = 0 := by
   constructor
@@ -119,6 +126,15 @@ theorem of_pow_eq_zero (a : α) (n : Nat) : a^n = 0 → a = 0 := by
     have := ih h
     contradiction
 
+theorem zpow_neg (a : α) (n : Int) : a ^ (-n) = (a ^ n)⁻¹ := by
+  apply eq_inv_of_mul_eq_one
+  rw [← zpow_add, Int.add_left_neg, zpow_zero]
+
+theorem zpow_natCast (a : α) (n : Nat) : a ^ (n : Int) = a ^ n := by
+  induction n
+  next => simp [zpow_zero, Semiring.pow_zero]
+  next n ih => rw [Int.natCast_add_one, zpow_add, ih, zpow_one, Semiring.pow_succ]
+
 instance [IsCharP α 0] : NoNatZeroDivisors α := NoNatZeroDivisors.mk' <| by
   intro a b h w
   have := IsCharP.natCast_eq_zero_iff (α := α) 0 a
@@ -129,7 +145,7 @@ instance [IsCharP α 0] : NoNatZeroDivisors α := NoNatZeroDivisors.mk' <| by
     rw [Semiring.ofNat_eq_natCast] at w
     replace w := congrArg (fun x => x * b⁻¹) w
     dsimp only [] at w
-    rw [Semiring.hmul_eq_ofNat_mul, Semiring.mul_assoc, Field.mul_inv_cancel h, Semiring.mul_one,
+    rw [Semiring.nsmul_eq_ofNat_mul, Semiring.mul_assoc, Field.mul_inv_cancel h, Semiring.mul_one,
       Semiring.natCast_zero, Semiring.zero_mul, Semiring.ofNat_eq_natCast] at w
     contradiction
 

src/Init/Grind/Ring/OfSemiring.lean

@@ -80,7 +80,9 @@ end Ring.OfSemiring
 
 namespace CommRing
 attribute [local instance] Semiring.natCast Ring.intCast
-open Semiring Ring CommSemiring
+open AddCommMonoid AddCommGroup
+open Semiring hiding add_zero add_comm add_assoc
+open Ring CommSemiring
 
 inductive Poly.NonnegCoeffs : Poly → Prop
   | num (c : Int) : c ≥ 0 → NonnegCoeffs (.num c)

src/Init/Grind/Ring/Poly.lean

@@ -245,7 +245,7 @@ instance : LawfulBEq Poly where
 def Poly.denote [Ring α] (ctx : Context α) (p : Poly) : α :=
   match p with
   | .num k => Int.cast k
-  | .add k m p => Int.cast k * m.denote ctx + denote ctx p
+  | .add k m p => HMul.hMul (α := Int) k (m.denote ctx) + denote ctx p
 
 @[expose]
 def Poly.denote' [Ring α] (ctx : Context α) (p : Poly) : α :=
@@ -257,7 +257,7 @@ where
     bif k == 1 then
       m.denote' ctx
     else
-      Int.cast k * m.denote' ctx
+      HMul.hMul (α := Int) k (m.denote' ctx)
 
   go (p : Poly) (acc : α) : α :=
     match p with
@@ -598,7 +598,10 @@ def NullCert.toPolyC (nc : NullCert) (c : Nat) : Poly :=
 Theorems for justifying the procedure for commutative rings in `grind`.
 -/
 
-open Semiring Ring CommSemiring
+open AddCommMonoid AddCommGroup NatModule IntModule
+open Semiring hiding add_zero add_comm add_assoc
+open Ring hiding sub_eq_add_neg
+open CommSemiring
 
 theorem denoteInt_eq {α} [CommRing α] (k : Int) : denoteInt (α := α) k = k := by
   simp [denoteInt, cond_eq_if] <;> split
@@ -700,18 +703,18 @@ theorem Mon.eq_of_grevlex {m₁ m₂ : Mon} : grevlex m₁ m₂ = .eq → m₁ =
   simp [grevlex]; intro; apply eq_of_revlex
 
 theorem Poly.denoteTerm_eq  {α} [Ring α] (ctx : Context α) (k : Int) (m : Mon) : denote'.denoteTerm ctx k m = k * m.denote ctx := by
-  simp [denote'.denoteTerm, Mon.denote'_eq_denote, cond_eq_if]; intro; subst k; rw [Ring.intCast_one, Semiring.one_mul]
+  simp [denote'.denoteTerm, Mon.denote'_eq_denote, cond_eq_if, zsmul_eq_intCast_mul]; intro; subst k; rw [Ring.intCast_one, Semiring.one_mul]
 
 theorem Poly.denote'_eq_denote {α} [Ring α] (ctx : Context α) (p : Poly) : p.denote' ctx = p.denote ctx := by
-  cases p <;> simp [denote', denote, denoteTerm_eq]
+  cases p <;> simp [denote', denote, denoteTerm_eq, zsmul_eq_intCast_mul]
   next k m p =>
     generalize k * m.denote ctx = acc
     fun_induction denote'.go <;> simp [denote, *, Ring.intCast_zero, Semiring.add_zero, denoteTerm_eq]
-    next ih => simp [denoteTerm_eq] at ih; simp [ih, Semiring.add_assoc]
+    next ih => simp [denoteTerm_eq] at ih; simp [ih, Semiring.add_assoc, zsmul_eq_intCast_mul]
 
 theorem Poly.denote_ofMon {α} [CommRing α] (ctx : Context α) (m : Mon)
     : denote ctx (ofMon m) = m.denote ctx := by
-  simp [ofMon, denote, intCast_one, intCast_zero, one_mul, add_zero]
+  simp [ofMon, denote, intCast_one, intCast_zero, one_mul, add_zero, zsmul_eq_intCast_mul]
 
 theorem Poly.denote_ofVar {α} [CommRing α] (ctx : Context α) (x : Var)
     : denote ctx (ofVar x) = x.denote ctx := by
@@ -734,7 +737,7 @@ theorem Poly.denote_insert {α} [CommRing α] (ctx : Context α) (k : Int) (m :
     next h =>
       simp at h <;> simp [*, Mon.denote, denote_addConst, mul_one, add_comm]
     next =>
-      fun_induction insert.go <;> simp_all +zetaDelta [denote]
+      fun_induction insert.go <;> simp_all +zetaDelta [denote, zsmul_eq_intCast_mul]
       next h₁ h₂ =>
         rw [← add_assoc, Mon.eq_of_grevlex h₁, ← right_distrib, ← intCast_add, h₂, intCast_zero, zero_mul, zero_add]
       next h₁ _ =>
@@ -756,7 +759,7 @@ theorem Poly.denote_mulConst {α} [CommRing α] (ctx : Context α) (k : Int) (p
     split <;> try simp [*, intCast_one, one_mul]
     fun_induction mulConst.go <;> simp [denote, *]
     next => rw [intCast_mul]
-    next => rw [intCast_mul, left_distrib, mul_assoc]
+    next => rw [left_distrib, ← zsmul_eq_intCast_mul, ← zsmul_eq_intCast_mul, mul_zsmul]
 
 theorem Poly.denote_mulMon {α} [CommRing α] (ctx : Context α) (k : Int) (m : Mon) (p : Poly)
     : (mulMon k m p).denote ctx = k * m.denote ctx * p.denote ctx := by
@@ -767,7 +770,7 @@ theorem Poly.denote_mulMon {α} [CommRing α] (ctx : Context α) (k : Int) (m :
     next h =>
       simp at h; simp [*, Mon.denote, mul_one, denote_mulConst]
     next =>
-      fun_induction mulMon.go <;> simp [denote, *]
+      fun_induction mulMon.go <;> simp [denote, zsmul_eq_intCast_mul, *]
       next h => simp +zetaDelta at h; simp [*, intCast_zero, mul_zero]
       next => simp [intCast_mul, intCast_zero, add_zero, mul_comm, mul_left_comm, mul_assoc]
       next => simp [Mon.denote_mul, intCast_mul, left_distrib, mul_left_comm, mul_assoc]
@@ -776,7 +779,7 @@ theorem Poly.denote_combine {α} [CommRing α] (ctx : Context α) (p₁ p₂ : P
     : (combine p₁ p₂).denote ctx = p₁.denote ctx + p₂.denote ctx := by
   unfold combine; generalize hugeFuel = fuel
   fun_induction combine.go
-    <;> simp [*, denote_concat, denote_addConst, denote, intCast_add, add_comm, add_left_comm, add_assoc]
+    <;> simp [*, denote_concat, denote_addConst, denote, intCast_add, add_comm, add_left_comm, add_assoc, zsmul_eq_intCast_mul]
   case case5 hg _ h _ =>
     simp +zetaDelta at h
     rw [← add_assoc, Mon.eq_of_grevlex hg, ← right_distrib, ← intCast_add, h, intCast_zero, zero_mul, zero_add]
@@ -787,7 +790,7 @@ theorem Poly.denote_combine {α} [CommRing α] (ctx : Context α) (p₁ p₂ : P
 theorem Poly.denote_mul_go {α} [CommRing α] (ctx : Context α) (p₁ p₂ acc : Poly)
     : (mul.go p₂ p₁ acc).denote ctx = acc.denote ctx + p₁.denote ctx * p₂.denote ctx := by
   fun_induction mul.go
-    <;> simp [denote_combine, denote_mulConst, denote, *, right_distrib, denote_mulMon, add_assoc]
+    <;> simp [denote_combine, denote_mulConst, denote, *, right_distrib, denote_mulMon, add_assoc, zsmul_eq_intCast_mul]
 
 theorem Poly.denote_mul {α} [CommRing α] (ctx : Context α) (p₁ p₂ : Poly)
     : (mul p₁ p₂).denote ctx = p₁.denote ctx * p₂.denote ctx := by
@@ -860,7 +863,7 @@ theorem NullCert.eq_nzdiv {α} [CommRing α] [NoNatZeroDivisors α] (ctx : Conte
   apply eqsImplies_helper
   intro h₃
   replace h₂ := congrArg (Poly.denote ctx) h₂
-  simp [Expr.denote_toPoly, Poly.denote_mulConst, denote_toPoly, h₃, Expr.denote] at h₂
+  simp [Expr.denote_toPoly, Poly.denote_mulConst, denote_toPoly, h₃, Expr.denote, ← zsmul_eq_intCast_mul] at h₂
   replace h₂ := no_int_zero_divisors h₁ h₂
   rw [sub_eq_zero_iff] at h₂
   assumption
@@ -902,7 +905,7 @@ theorem Poly.denote_insertC {α c} [CommRing α] [IsCharP α c] (ctx : Context
     rw [← IsCharP.intCast_emod (p := c)]
     simp +zetaDelta [*, intCast_zero, zero_mul, zero_add]
   next =>
-    fun_induction insertC.go <;> simp_all +zetaDelta [denote]
+    fun_induction insertC.go <;> simp_all +zetaDelta [denote, zsmul_eq_intCast_mul]
     next h₁ _ h₂ => rw [IsCharP.intCast_emod]
     next h₁ _ h₂ =>
       rw [← add_assoc, Mon.eq_of_grevlex h₁, ← right_distrib, ← intCast_add, ← IsCharP.intCast_emod (p := c), h₂,
@@ -928,10 +931,10 @@ theorem Poly.denote_mulConstC {α c} [CommRing α] [IsCharP α c] (ctx : Context
       next => rw [intCast_mul]
       next h _ =>
         simp +zetaDelta at h
-        rw [left_distrib, ← mul_assoc, ← intCast_mul, ← IsCharP.intCast_emod (x := k * _) (p := c),
+        rw [left_distrib, zsmul_eq_intCast_mul, ← mul_assoc, ← intCast_mul, ← IsCharP.intCast_emod (x := k * _) (p := c),
             h, intCast_zero, zero_mul, zero_add]
       next h _ =>
-        simp +zetaDelta [IsCharP.intCast_emod, intCast_mul, mul_assoc, left_distrib]
+        simp +zetaDelta [IsCharP.intCast_emod, intCast_mul, mul_assoc, left_distrib, zsmul_eq_intCast_mul]
 
 theorem Poly.denote_mulMonC {α c} [CommRing α] [IsCharP α c] (ctx : Context α) (k : Int) (m : Mon) (p : Poly)
     : (mulMonC k m p c).denote ctx = k * m.denote ctx * p.denote ctx := by
@@ -950,23 +953,23 @@ theorem Poly.denote_mulMonC {α c} [CommRing α] [IsCharP α c] (ctx : Context
         rw [mul_assoc, mul_left_comm, ← intCast_mul, ← IsCharP.intCast_emod (x := k * _) (p := c), h]
         simp [intCast_zero, mul_zero]
       next h =>
-        simp +zetaDelta [IsCharP.intCast_emod, intCast_mul, intCast_zero, add_zero, mul_comm, mul_left_comm, mul_assoc]
+        simp +zetaDelta [IsCharP.intCast_emod, intCast_mul, intCast_zero, add_zero, mul_comm, mul_left_comm, mul_assoc, zsmul_eq_intCast_mul]
       next h _ =>
-        simp +zetaDelta at h; simp [*, left_distrib]
+        simp +zetaDelta at h; simp [*, left_distrib, zsmul_eq_intCast_mul]
         rw [mul_left_comm]
         conv => rhs; rw [← mul_assoc, ← mul_assoc, ← intCast_mul, ← IsCharP.intCast_emod (p := c)]
         rw [Int.mul_comm] at h
         simp [h, intCast_zero, zero_mul, zero_add]
       next h _ =>
         simp +zetaDelta [*, IsCharP.intCast_emod, Mon.denote_mul, intCast_mul, left_distrib,
-          mul_left_comm, mul_assoc]
+          mul_left_comm, mul_assoc, zsmul_eq_intCast_mul]
 
 theorem Poly.denote_combineC {α c} [CommRing α] [IsCharP α c] (ctx : Context α) (p₁ p₂ : Poly)
     : (combineC p₁ p₂ c).denote ctx = p₁.denote ctx + p₂.denote ctx := by
   unfold combineC; generalize hugeFuel = fuel
   fun_induction combineC.go
     <;> simp [*, denote_concat, denote_addConstC, denote, intCast_add,
-          add_comm, add_left_comm, add_assoc, IsCharP.intCast_emod]
+          add_comm, add_left_comm, add_assoc, IsCharP.intCast_emod, zsmul_eq_intCast_mul]
   next hg _ h _ =>
     simp +zetaDelta at h
     rw [← add_assoc, Mon.eq_of_grevlex hg, ← right_distrib, ← intCast_add,
@@ -979,7 +982,7 @@ theorem Poly.denote_combineC {α c} [CommRing α] [IsCharP α c] (ctx : Context
 theorem Poly.denote_mulC_go {α c} [CommRing α] [IsCharP α c] (ctx : Context α) (p₁ p₂ acc : Poly)
     : (mulC.go p₂ c p₁ acc).denote ctx = acc.denote ctx + p₁.denote ctx * p₂.denote ctx := by
   fun_induction mulC.go
-    <;> simp [denote_combineC, denote_mulConstC, denote, *, right_distrib, denote_mulMonC, add_assoc]
+    <;> simp [denote_combineC, denote_mulConstC, denote, *, right_distrib, denote_mulMonC, add_assoc, zsmul_eq_intCast_mul]
 
 theorem Poly.denote_mulC {α c} [CommRing α] [IsCharP α c] (ctx : Context α) (p₁ p₂ : Poly)
     : (mulC p₁ p₂ c).denote ctx = p₁.denote ctx * p₂.denote ctx := by
@@ -1043,7 +1046,7 @@ theorem NullCert.eq_nzdivC {α c} [CommRing α] [IsCharP α c] [NoNatZeroDivisor
   apply eqsImplies_helper
   intro h₃
   replace h₂ := congrArg (Poly.denote ctx) h₂
-  simp [Expr.denote_toPolyC, Poly.denote_mulConstC, denote_toPolyC, h₃, Expr.denote] at h₂
+  simp [Expr.denote_toPolyC, Poly.denote_mulConstC, denote_toPolyC, h₃, Expr.denote, ← zsmul_eq_intCast_mul] at h₂
   replace h₂ := no_int_zero_divisors h₁ h₂
   rw [sub_eq_zero_iff] at h₂
   assumption
@@ -1119,7 +1122,7 @@ def div_cert (p₁ : Poly) (k : Int) (p : Poly) : Bool :=
 def div {α} [CommRing α] (ctx : Context α) [NoNatZeroDivisors α] (p₁ : Poly) (k : Int) (p : Poly)
     : div_cert p₁ k p → p₁.denote ctx = 0 → p.denote ctx = 0 := by
   simp [div_cert]; intro hnz _ h; subst p₁
-  simp [Poly.denote_mulConst] at h
+  simp [Poly.denote_mulConst, ← zsmul_eq_intCast_mul] at h
   exact no_int_zero_divisors hnz h
 
 @[expose]
@@ -1172,7 +1175,7 @@ def imp_keq_cert (lhs rhs : Expr) (k : Int) (p₁ p₂ : Poly) : Bool :=
 theorem imp_keq  {α} [CommRing α] (ctx : Context α) [NoNatZeroDivisors α] (k : Int) (lhs rhs : Expr) (p₁ p₂ : Poly)
     : imp_keq_cert lhs rhs k p₁ p₂ → k * p₁.denote ctx = p₂.denote ctx → lhs.denote ctx = rhs.denote ctx := by
   simp [imp_keq_cert]; intro hnz _ _; subst p₁ p₂
-  simp [Expr.denote_toPoly, Expr.denote, Poly.denote, intCast_zero]
+  simp [Expr.denote_toPoly, Expr.denote, Poly.denote, intCast_zero, ← zsmul_eq_intCast_mul]
   intro h; replace h := no_int_zero_divisors hnz h
   rw [← sub_eq_zero_iff, h]
 
@@ -1213,7 +1216,7 @@ def div_certC (p₁ : Poly) (k : Int) (p : Poly) (c : Nat) : Bool :=
 def divC {α c} [CommRing α] [IsCharP α c] (ctx : Context α) [NoNatZeroDivisors α] (p₁ : Poly) (k : Int) (p : Poly)
     : div_certC p₁ k p c → p₁.denote ctx = 0 → p.denote ctx = 0 := by
   simp [div_certC]; intro hnz _ h; subst p₁
-  simp [Poly.denote_mulConstC] at h
+  simp [Poly.denote_mulConstC, ← zsmul_eq_intCast_mul] at h
   exact no_int_zero_divisors hnz h
 
 @[expose]
@@ -1272,7 +1275,7 @@ def imp_keq_certC (lhs rhs : Expr) (k : Int) (p₁ p₂ : Poly) (c : Nat) : Bool
 theorem imp_keqC {α c} [CommRing α] [IsCharP α c] (ctx : Context α) [NoNatZeroDivisors α] (k : Int) (lhs rhs : Expr) (p₁ p₂ : Poly)
     : imp_keq_certC lhs rhs k p₁ p₂ c → k * p₁.denote ctx = p₂.denote ctx → lhs.denote ctx = rhs.denote ctx := by
   simp [imp_keq_certC]; intro hnz _ _; subst p₁ p₂
-  simp [Expr.denote_toPolyC, Expr.denote, Poly.denote, intCast_zero]
+  simp [Expr.denote_toPolyC, Expr.denote, Poly.denote, intCast_zero, ← zsmul_eq_intCast_mul]
   intro h; replace h := no_int_zero_divisors hnz h
   rw [← sub_eq_zero_iff, h]
 
@@ -1294,8 +1297,8 @@ where
 @[expose]
 def Poly.denoteAsIntModule [CommRing α] (ctx : Context α) (p : Poly) : α :=
   match p with
-  | .num k => Int.cast k * One.one
-  | .add k m p => Int.cast k * m.denoteAsIntModule ctx + denoteAsIntModule ctx p
+  | .num k => HMul.hMul (α := Int) k (One.one : α)
+  | .add k m p => HMul.hMul (α := Int) k (m.denoteAsIntModule ctx) + denoteAsIntModule ctx p
 
 theorem Mon.denoteAsIntModule_go_eq_denote {α} [CommRing α] (ctx : Context α) (m : Mon) (acc : α)
     : denoteAsIntModule.go ctx m acc = acc * m.denote ctx := by
@@ -1306,7 +1309,7 @@ theorem Mon.denoteAsIntModule_eq_denote {α} [CommRing α] (ctx : Context α) (m
   cases m <;> simp [denoteAsIntModule, denote, denoteAsIntModule_go_eq_denote]; rfl
 
 theorem Poly.denoteAsIntModule_eq_denote {α} [CommRing α] (ctx : Context α) (p : Poly) : p.denoteAsIntModule ctx = p.denote ctx := by
-  induction p <;> simp [*, denoteAsIntModule, denote, mul_one, One.one, Mon.denoteAsIntModule_eq_denote]
+  induction p <;> simp [*, denoteAsIntModule, denote, mul_one, One.one, Mon.denoteAsIntModule_eq_denote, Ring.zsmul_eq_intCast_mul]
 
 open Stepwise
 
@@ -1404,7 +1407,7 @@ theorem one_eq_zero_unsat {α} [Field α] (ctx : Context α) (p : Poly) : one_eq
 theorem diseq_to_eq {α} [Field α] (a b : α) : a ≠ b → (a - b)*(a - b)⁻¹ = 1 := by
   intro h
   have : a - b ≠ 0 := by
-    intro h'; rw [Ring.sub_eq_zero_iff.mp h'] at h
+    intro h'; rw [sub_eq_zero_iff.mp h'] at h
     contradiction
   exact Field.mul_inv_cancel this
 
@@ -1429,8 +1432,8 @@ theorem Poly.normEq0_eq {α} [CommRing α] (ctx : Context α) (p : Poly) (c : Na
     simp [denote, normEq0]; split <;> simp [denote]
     next h' => rw [of_mod_eq_0 h h', Ring.intCast_zero]
   next a m p ih =>
-    simp [denote, normEq0]; split <;> simp [denote, *]
-    next h' => rw [of_mod_eq_0 h h', Semiring.zero_mul, Semiring.zero_add]
+    simp [denote, normEq0]; split <;> simp [denote, zsmul_eq_intCast_mul, *]
+    next h' => rw [of_mod_eq_0 h h', Semiring.zero_mul, zero_add]
 
 @[expose]
 def eq_normEq0_cert (c : Nat) (p₁ p₂ p : Poly) : Bool :=
@@ -1449,7 +1452,7 @@ theorem gcd_eq_0 [CommRing α] (g n m a b : Int) (h : g = a * n + b * m)
   replace h₂ := congrArg (Int.cast (R := α) b * ·) h₂; simp at h₂
   rw [← Ring.intCast_mul, Ring.intCast_zero, Semiring.mul_zero] at h₂
   replace h₁ := congrArg (· + Int.cast (b * m)) h₁; simp at h₁
-  rw [← Ring.intCast_add, h₂, Semiring.zero_add, ← h] at h₁
+  rw [← Ring.intCast_add, h₂, zero_add, ← h] at h₁
   rw [Ring.intCast_zero, h₁]
 
 @[expose]

src/Init/Grind/Tactics.lean

@@ -6,91 +6,11 @@ Authors: Leonardo de Moura
 module
 
 prelude
-public import Init.Tactics
+public import Init.Grind.Attr
+public import Init.Core
 
 public section
 
-namespace Lean.Grind
-/--
-Gadget for representing generalization steps `h : x = val` in patterns
-This gadget is used to represent patterns in theorems that have been generalized to reduce the
-number of casts introduced during E-matching based instantiation.
-
-For example, consider the theorem
-```
-Option.pbind_some {α1 : Type u_1} {a : α1} {α2 : Type u_2}
-    {f : (a_1 : α1) → some a = some a_1 → Option α2}
-    : (some a).pbind f = f a rfl
-```
-Now, suppose we have a goal containing the term `c.pbind g` and the equivalence class
-`{c, some b}`. The E-matching module generates the instance
-```
-(some b).pbind (cast ⋯ g)
-```
-The `cast` is necessary because `g`'s type contains `c` instead of `some b.
-This `cast` problematic because we don't have a systematic way of pushing casts over functions
-to its arguments. Moreover, heterogeneous equality is not effective because the following theorem
-is not provable in DTT:
-```
-theorem hcongr (h₁ : f ≍ g) (h₂ : a ≍ b)  : f a ≍ g b := ...
-```
-The standard solution is to generalize the theorem above and write it as
-```
-theorem Option.pbind_some'
-        {α1 : Type u_1} {a : α1} {α2 : Type u_2}
-        {x : Option α1}
-        {f : (a_1 : α1) → x = some a_1 → Option α2}
-        (h : x = some a)
-        : x.pbind f = f a h := by
-  subst h
-  apply Option.pbind_some
-```
-Internally, we use this gadget to mark the E-matching pattern as
-```
-(genPattern h x (some a)).pbind f
-```
-This pattern is matched in the same way we match `(some a).pbind f`, but it saves the proof
-for the actual term to the `some`-application in `f`, and the actual term in `x`.
-
-In the example above, `c.pbind g` also matches the pattern `(genPattern h x (some a)).pbind f`,
-and stores `c` in `x`, `b` in `a`, and the proof that `c = some b` in `h`.
--/
-def genPattern {α : Sort u} (_h : Prop) (x : α) (_val : α) : α := x
-
-/-- Similar to `genPattern` but for the heterogeneous case -/
-def genHEqPattern {α β : Sort u} (_h : Prop) (x : α) (_val : β) : α := x
-end Lean.Grind
-
-namespace Lean.Parser
-/--
-Reset all `grind` attributes. This command is intended for testing purposes only and should not be used in applications.
--/
-syntax (name := resetGrindAttrs) "reset_grind_attrs%" : command
-
-namespace Attr
-syntax grindGen    := ppSpace &"gen"
-syntax grindEq     := "=" (grindGen)?
-syntax grindEqBoth := atomic("_" "=" "_") (grindGen)?
-syntax grindEqRhs  := atomic("=" "_") (grindGen)?
-syntax grindEqBwd  := patternIgnore(atomic("←" "=") <|> atomic("<-" "="))
-syntax grindBwd    := patternIgnore("←" <|> "<-") (grindGen)?
-syntax grindFwd    := patternIgnore("→" <|> "->")
-syntax grindRL     := patternIgnore("⇐" <|> "<=")
-syntax grindLR     := patternIgnore("⇒" <|> "=>")
-syntax grindUsr    := &"usr"
-syntax grindCases  := &"cases"
-syntax grindCasesEager := atomic(&"cases" &"eager")
-syntax grindIntro  := &"intro"
-syntax grindExt    := &"ext"
-syntax grindMod :=
-    grindEqBoth <|> grindEqRhs <|> grindEq <|> grindEqBwd <|> grindBwd
-    <|> grindFwd <|> grindRL <|> grindLR <|> grindUsr <|> grindCasesEager
-    <|> grindCases <|> grindIntro <|> grindExt <|> grindGen
-syntax (name := grind) "grind" (ppSpace grindMod)? : attr
-syntax (name := grind?) "grind?" (ppSpace grindMod)? : attr
-end Attr
-end Lean.Parser
-
 namespace Lean.Grind
 /--
 The configuration for `grind`.
@@ -195,6 +115,11 @@ structure Config where
   When `true` (default: `true`), uses procedure for handling linear integer arithmetic for `Int` and `Nat`.
   -/
   cutsat := true
+  /--
+  Maximum exponent eagerly evaluated while computing bounds for `ToInt` and
+  the characteristic of a ring.
+  -/
+  exp : Nat := 2^20
   deriving Inhabited, BEq
 
 end Lean.Grind
@@ -491,4 +416,15 @@ syntax (name := grindTrace)
   (" [" withoutPosition(grindParam,*) "]")?
   (&" on_failure " term)? : tactic
 
+/-!
+Sets symbol priorities for the E-matching pattern inference procedure used in `grind`
+-/
+
+-- The following symbols are never used in E-matching patterns
+attribute [grind symbol 0] Eq HEq Iff And Or Not
+-- The following symbols are only used as the root pattern symbol if there isn't another option
+attribute [grind symbol low] HAdd.hAdd HSub.hSub HMul.hMul Dvd.dvd HDiv.hDiv HMod.hMod
+
+-- TODO: improve pattern inference heuristics and reduce priority for LT.lt and LE.le
+-- attribute [grind symbol low] LT.lt LE.le
 end Lean.Parser.Tactic

src/Init/Grind/ToInt.lean

@@ -37,7 +37,7 @@ inductive IntInterval : Type where
     io (hi : Int)
   | /-- The infinite interval `(-∞, ∞)`. -/
     ii
-  deriving BEq, DecidableEq
+  deriving BEq, DecidableEq, Inhabited
 
 instance : LawfulBEq IntInterval where
    rfl := by intro a; cases a <;> simp_all! [BEq.beq]

src/Init/Grind/Util.lean

@@ -16,6 +16,11 @@ namespace Lean.Grind
 /-- A helper gadget for annotating nested proofs in goals. -/
 def nestedProof (p : Prop) {h : p} : p := h
 
+/-- A helper gadget for annotating nested decidable instances in goals. -/
+-- Remark: we currently have special gadgets for the two most common subsingletons in Lean, and are the only
+-- currently supported in `grind`. We may add a generic `nestedSubsingleton` inn the future.
+@[expose] def nestedDecidable {p : Prop} (h : Decidable p) : Decidable p := h
+
 /--
 Gadget for marking `match`-expressions that should not be reduced by the `grind` simplifier, but the discriminants should be normalized.
 We use it when adding instances of `match`-equations to prevent them from being simplified to true.
@@ -53,11 +58,14 @@ abbrev MatchCond (p : Prop) : Prop := p
 Similar to `MatchCond`, but not reducible. We use it to ensure `simp`
 will not eliminate it. After we apply `simp`, we replace it with `MatchCond`.
 -/
-def PreMatchCond (p : Prop) : Prop := p
+@[expose] def PreMatchCond (p : Prop) : Prop := p
 
 theorem nestedProof_congr (p q : Prop) (h : p = q) (hp : p) (hq : q) : @nestedProof p hp ≍ @nestedProof q hq := by
   subst h; apply HEq.refl
 
+theorem nestedDecidable_congr (p q : Prop) (h : p = q) (hp : Decidable p) (hq : Decidable q) : @nestedDecidable p hp ≍ @nestedDecidable q hq := by
+  subst h; cases hp <;> cases hq <;> simp <;> contradiction
+
 @[app_unexpander nestedProof]
 meta def nestedProofUnexpander : PrettyPrinter.Unexpander := fun stx => do
   match stx with

src/Init/GrindInstances/Ring/BitVec.lean

@@ -16,6 +16,8 @@ public section
 namespace Lean.Grind
 
 instance : CommRing (BitVec w) where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := BitVec.add_assoc
   add_comm := BitVec.add_comm
   add_zero := BitVec.add_zero
@@ -33,6 +35,12 @@ instance : CommRing (BitVec w) where
   pow_succ _ _ := BitVec.pow_succ
   ofNat_succ x := BitVec.ofNat_add x 1
   intCast_neg _ := BitVec.ofInt_neg
+  neg_zsmul i x := by
+    change (BitVec.ofInt _ (-i) * x = _)
+    rw [BitVec.ofInt_neg]
+    rw [BitVec.neg_mul]
+    rfl
+  zsmul_natCast_eq_nsmul _ _ := rfl
 
 instance : IsCharP (BitVec w) (2 ^ w) := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by simp [BitVec.toNat_eq])

src/Init/GrindInstances/Ring/Fin.lean

@@ -74,6 +74,29 @@ private theorem neg_neg [NeZero n] (a : Fin n) : - - a = a := by
    have : NeZero (n - (a + 1)) := ⟨by omega⟩
    rw [Nat.self_sub_mod, Nat.sub_sub_eq_min, Nat.min_eq_right (Nat.le_of_lt h)]
 
+theorem _root_.Nat.sub_sub_right (a : Nat) {b c : Nat} (h : c ≤ b) : a - (b - c) = a + c - b := by omega
+
+theorem neg_mul [NeZero n] (a b : Fin n) : (-a) * b = -(a * b) := by
+  rcases a with ⟨a, ha⟩; rcases b with ⟨b, hb⟩
+  ext
+  simp only [Fin.neg_def, Fin.mul_def, Nat.mod_mul_mod]
+  rw [Nat.sub_mul]
+  rw [Nat.mod_eq_mod_iff]
+  match b with
+  | 0 => refine ⟨1, 0, by simp⟩
+  | b+1 =>
+    refine ⟨a*(b+1)/n, b, ?_⟩
+    rw [Nat.mod_def, Nat.mul_add_one, Nat.mul_comm _ n, Nat.mul_comm b n]
+    have : n * (a * (b + 1) / n) ≤ a * (b + 1) := Nat.mul_div_le (a * (b + 1)) n
+    have := Nat.lt_mul_div_succ (a * (b + 1)) (show 0 < n by omega)
+    rw [Nat.mul_add_one n] at this
+    have : a * (b + 1) ≤ n * b + n := by
+      rw [Nat.mul_add_one]
+      have := Nat.mul_le_mul_right b ha
+      rw [Nat.succ_mul] at this
+      omega
+    omega
+
 open Fin.NatCast Fin.IntCast in
 theorem intCast_neg [NeZero n] (i : Int) : Int.cast (R := Fin n) (-i) = - Int.cast (R := Fin n) i := by
   simp [Int.cast, IntCast.intCast, Fin.intCast]
@@ -81,7 +104,10 @@ theorem intCast_neg [NeZero n] (i : Int) : Int.cast (R := Fin n) (-i) = - Int.ca
   next h₁ h₂ => simp [Int.le_antisymm h₁ h₂, Fin.neg_def]
   next => simp [Fin.neg_neg]
 
+open Fin.NatCast Fin.IntCast in
 instance (n : Nat) [NeZero n] : CommRing (Fin n) where
+  nsmul := ⟨fun k i => (k : Fin n) * i⟩
+  zsmul := ⟨fun k i => (k : Fin n) * i⟩
   natCast := Fin.NatCast.instNatCast n
   intCast := Fin.IntCast.instIntCast n
   add_assoc := Fin.add_assoc
@@ -98,6 +124,8 @@ instance (n : Nat) [NeZero n] : CommRing (Fin n) where
   ofNat_succ := Fin.ofNat_succ
   sub_eq_add_neg := Fin.sub_eq_add_neg
   intCast_neg := Fin.intCast_neg
+  neg_zsmul i a := by simp [intCast_neg, neg_mul]
+  zsmul_natCast_eq_nsmul _ _ := rfl
 
 instance (n : Nat) [NeZero n] : IsCharP (Fin n) n := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by

src/Init/GrindInstances/Ring/Int.lean

@@ -14,6 +14,7 @@ public section
 namespace Lean.Grind
 
 instance : CommRing Int where
+  nsmul := ⟨(· * ·)⟩
   add_assoc := Int.add_assoc
   add_comm := Int.add_comm
   add_zero := Int.add_zero
@@ -30,6 +31,7 @@ instance : CommRing Int where
   pow_succ _ _ := by rfl
   ofNat_succ _ := by rfl
   sub_eq_add_neg _ _ := Int.sub_eq_add_neg
+  neg_zsmul := Int.neg_mul
 
 instance : IsCharP Int 0 := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by erw [Int.ofNat_eq_zero]; simp)

src/Init/GrindInstances/Ring/SInt.lean

@@ -17,13 +17,25 @@ public section
 
 namespace Lean.Grind
 
-instance : NatCast Int8 where
+@[expose]
+def Int8.natCast : NatCast Int8 where
   natCast x := Int8.ofNat x
 
-instance : IntCast Int8 where
+@[expose]
+def Int8.intCast : IntCast Int8 where
   intCast x := Int8.ofInt x
 
+attribute [local instance] Int8.intCast in
+theorem Int8.intCast_neg (i : Int) : ((-i : Int) : Int8) = -(i : Int8) :=
+  Int8.ofInt_neg _
+
+attribute [local instance] Int8.intCast in
+theorem Int8.intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : Int8) = OfNat.ofNat x := Int8.ofInt_eq_ofNat
+
+attribute [local instance] Int8.natCast Int8.intCast in
 instance : CommRing Int8 where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := Int8.add_assoc
   add_comm := Int8.add_comm
   add_zero := Int8.add_zero
@@ -41,6 +53,8 @@ instance : CommRing Int8 where
   pow_succ := Int8.pow_succ
   ofNat_succ x := Int8.ofNat_add x 1
   intCast_neg := Int8.ofInt_neg
+  neg_zsmul i x := by simp [Int8.intCast_neg, Int8.neg_mul]
+  zsmul_natCast_eq_nsmul n a := congrArg (· * a) (Int8.intCast_ofNat _)
 
 instance : IsCharP Int8 (2 ^ 8) := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by
@@ -56,13 +70,25 @@ example : ToInt.Sub Int8 (.sint 8) := inferInstance
 
 instance : ToInt.Pow Int8 (.sint 8) := ToInt.pow_of_semiring (by simp)
 
-instance : NatCast Int16 where
+@[expose]
+def Int16.natCast : NatCast Int16 where
   natCast x := Int16.ofNat x
 
-instance : IntCast Int16 where
+@[expose]
+def Int16.intCast : IntCast Int16 where
   intCast x := Int16.ofInt x
 
+attribute [local instance] Int16.intCast in
+theorem Int16.intCast_neg (i : Int) : ((-i : Int) : Int16) = -(i : Int16) :=
+  Int16.ofInt_neg _
+
+attribute [local instance] Int16.intCast in
+theorem Int16.intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : Int16) = OfNat.ofNat x := Int16.ofInt_eq_ofNat
+
+attribute [local instance] Int16.natCast Int16.intCast in
 instance : CommRing Int16 where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := Int16.add_assoc
   add_comm := Int16.add_comm
   add_zero := Int16.add_zero
@@ -80,6 +106,8 @@ instance : CommRing Int16 where
   pow_succ := Int16.pow_succ
   ofNat_succ x := Int16.ofNat_add x 1
   intCast_neg := Int16.ofInt_neg
+  neg_zsmul i x := by simp [Int16.intCast_neg, Int16.neg_mul]
+  zsmul_natCast_eq_nsmul n a := congrArg (· * a) (Int16.intCast_ofNat _)
 
 instance : IsCharP Int16 (2 ^ 16) := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by
@@ -95,13 +123,25 @@ example : ToInt.Sub Int16 (.sint 16) := inferInstance
 
 instance : ToInt.Pow Int16 (.sint 16) := ToInt.pow_of_semiring (by simp)
 
-instance : NatCast Int32 where
+@[expose]
+def Int32.natCast : NatCast Int32 where
   natCast x := Int32.ofNat x
 
-instance : IntCast Int32 where
+@[expose]
+def Int32.intCast : IntCast Int32 where
   intCast x := Int32.ofInt x
 
+attribute [local instance] Int32.intCast in
+theorem Int32.intCast_neg (i : Int) : ((-i : Int) : Int32) = -(i : Int32) :=
+  Int32.ofInt_neg _
+
+attribute [local instance] Int32.intCast in
+theorem Int32.intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : Int32) = OfNat.ofNat x := Int32.ofInt_eq_ofNat
+
+attribute [local instance] Int32.natCast Int32.intCast in
 instance : CommRing Int32 where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := Int32.add_assoc
   add_comm := Int32.add_comm
   add_zero := Int32.add_zero
@@ -119,6 +159,8 @@ instance : CommRing Int32 where
   pow_succ := Int32.pow_succ
   ofNat_succ x := Int32.ofNat_add x 1
   intCast_neg := Int32.ofInt_neg
+  neg_zsmul i x := by simp [Int32.intCast_neg, Int32.neg_mul]
+  zsmul_natCast_eq_nsmul n a := congrArg (· * a) (Int32.intCast_ofNat _)
 
 instance : IsCharP Int32 (2 ^ 32) := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by
@@ -134,13 +176,25 @@ example : ToInt.Sub Int32 (.sint 32) := inferInstance
 
 instance : ToInt.Pow Int32 (.sint 32) := ToInt.pow_of_semiring (by simp)
 
-instance : NatCast Int64 where
+@[expose]
+def Int64.natCast : NatCast Int64 where
   natCast x := Int64.ofNat x
 
-instance : IntCast Int64 where
+@[expose]
+def Int64.intCast : IntCast Int64 where
   intCast x := Int64.ofInt x
 
+attribute [local instance] Int64.intCast in
+theorem Int64.intCast_neg (i : Int) : ((-i : Int) : Int64) = -(i : Int64) :=
+  Int64.ofInt_neg _
+
+attribute [local instance] Int64.intCast in
+theorem Int64.intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : Int64) = OfNat.ofNat x := Int64.ofInt_eq_ofNat
+
+attribute [local instance] Int64.natCast Int64.intCast in
 instance : CommRing Int64 where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := Int64.add_assoc
   add_comm := Int64.add_comm
   add_zero := Int64.add_zero
@@ -158,6 +212,8 @@ instance : CommRing Int64 where
   pow_succ := Int64.pow_succ
   ofNat_succ x := Int64.ofNat_add x 1
   intCast_neg := Int64.ofInt_neg
+  neg_zsmul i x := by simp [Int64.intCast_neg, Int64.neg_mul]
+  zsmul_natCast_eq_nsmul n a := congrArg (· * a) (Int64.intCast_ofNat _)
 
 instance : IsCharP Int64 (2 ^ 64) := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by
@@ -173,13 +229,25 @@ example : ToInt.Sub Int64 (.sint 64) := inferInstance
 
 instance : ToInt.Pow Int64 (.sint 64) := ToInt.pow_of_semiring (by simp)
 
-instance : NatCast ISize where
+@[expose]
+def ISize.natCast : NatCast ISize where
   natCast x := ISize.ofNat x
 
-instance : IntCast ISize where
+@[expose]
+def ISize.intCast : IntCast ISize where
   intCast x := ISize.ofInt x
 
+attribute [local instance] ISize.intCast in
+theorem ISize.intCast_neg (i : Int) : ((-i : Int) : ISize) = -(i : ISize) :=
+  ISize.ofInt_neg _
+
+attribute [local instance] ISize.intCast in
+theorem ISize.intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : ISize) = OfNat.ofNat x := ISize.ofInt_eq_ofNat
+
+attribute [local instance] ISize.natCast ISize.intCast in
 instance : CommRing ISize where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := ISize.add_assoc
   add_comm := ISize.add_comm
   add_zero := ISize.add_zero
@@ -197,6 +265,9 @@ instance : CommRing ISize where
   pow_succ := ISize.pow_succ
   ofNat_succ x := ISize.ofNat_add x 1
   intCast_neg := ISize.ofInt_neg
+  neg_zsmul i x := by simp [ISize.intCast_neg, ISize.neg_mul]
+  zsmul_natCast_eq_nsmul n a := congrArg (· * a) (ISize.intCast_ofNat _)
+
 open System.Platform (numBits)
 
 instance : IsCharP ISize (2 ^ numBits) := IsCharP.mk' _ _

src/Init/GrindInstances/Ring/UInt.lean

@@ -18,12 +18,19 @@ namespace UInt8
 /-- Variant of `UInt8.ofNat_mod_size` replacing `2 ^ 8` with `256`.-/
 theorem ofNat_mod_size' : ofNat (x % 256) = ofNat x := ofNat_mod_size
 
-instance : NatCast UInt8 where
+@[expose]
+def natCast : NatCast UInt8 where
   natCast x := UInt8.ofNat x
 
-instance : IntCast UInt8 where
+@[expose]
+def intCast : IntCast UInt8 where
   intCast x := UInt8.ofInt x
 
+attribute [local instance] natCast intCast
+
+theorem intCast_neg (x : Int) : ((-x : Int) : UInt8) = - (x : UInt8) := by
+  simp only [Int.cast, IntCast.intCast, UInt8.ofInt_neg]
+
 theorem intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : UInt8) = OfNat.ofNat x := by
     -- A better proof would be welcome!
     simp only [Int.cast, IntCast.intCast]
@@ -41,12 +48,19 @@ namespace UInt16
 /-- Variant of `UInt16.ofNat_mod_size` replacing `2 ^ 16` with `65536`.-/
 theorem ofNat_mod_size' : ofNat (x % 65536) = ofNat x := ofNat_mod_size
 
-instance : NatCast UInt16 where
+@[expose]
+def natCast : NatCast UInt16 where
   natCast x := UInt16.ofNat x
 
-instance : IntCast UInt16 where
+@[expose]
+def intCast : IntCast UInt16 where
   intCast x := UInt16.ofInt x
 
+attribute [local instance] natCast intCast
+
+theorem intCast_neg (x : Int) : ((-x : Int) : UInt16) = - (x : UInt16) := by
+  simp only [Int.cast, IntCast.intCast, UInt16.ofInt_neg]
+
 theorem intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : UInt16) = OfNat.ofNat x := by
     -- A better proof would be welcome!
     simp only [Int.cast, IntCast.intCast]
@@ -64,12 +78,19 @@ namespace UInt32
 /-- Variant of `UInt32.ofNat_mod_size` replacing `2 ^ 32` with `4294967296`.-/
 theorem ofNat_mod_size' : ofNat (x % 4294967296) = ofNat x := ofNat_mod_size
 
-instance : NatCast UInt32 where
+@[expose]
+def natCast : NatCast UInt32 where
   natCast x := UInt32.ofNat x
 
-instance : IntCast UInt32 where
+@[expose]
+def intCast : IntCast UInt32 where
   intCast x := UInt32.ofInt x
 
+attribute [local instance] natCast intCast
+
+theorem intCast_neg (x : Int) : ((-x : Int) : UInt32) = - (x : UInt32) := by
+  simp only [Int.cast, IntCast.intCast, UInt32.ofInt_neg]
+
 theorem intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : UInt32) = OfNat.ofNat x := by
     -- A better proof would be welcome!
     simp only [Int.cast, IntCast.intCast]
@@ -87,12 +108,19 @@ namespace UInt64
 /-- Variant of `UInt64.ofNat_mod_size` replacing `2 ^ 64` with `18446744073709551616`.-/
 theorem ofNat_mod_size' : ofNat (x % 18446744073709551616) = ofNat x := ofNat_mod_size
 
-instance : NatCast UInt64 where
+@[expose]
+def natCast : NatCast UInt64 where
   natCast x := UInt64.ofNat x
 
-instance : IntCast UInt64 where
+@[expose]
+def intCast : IntCast UInt64 where
   intCast x := UInt64.ofInt x
 
+attribute [local instance] natCast intCast
+
+theorem intCast_neg (x : Int) : ((-x : Int) : UInt64) = - (x : UInt64) := by
+  simp only [Int.cast, IntCast.intCast, UInt64.ofInt_neg]
+
 theorem intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : UInt64) = OfNat.ofNat x := by
     -- A better proof would be welcome!
     simp only [Int.cast, IntCast.intCast]
@@ -107,12 +135,19 @@ end UInt64
 
 namespace USize
 
-instance : NatCast USize where
+@[expose]
+def natCast : NatCast USize where
   natCast x := USize.ofNat x
 
-instance : IntCast USize where
+@[expose]
+def intCast : IntCast USize where
   intCast x := USize.ofInt x
 
+attribute [local instance] natCast intCast
+
+theorem intCast_neg (x : Int) : ((-x : Int) : USize) = - (x : USize) := by
+  simp only [Int.cast, IntCast.intCast, USize.ofInt_neg]
+
 theorem intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : USize) = OfNat.ofNat x := by
     -- A better proof would be welcome!
     simp only [Int.cast, IntCast.intCast]
@@ -127,7 +162,10 @@ theorem intCast_ofNat (x : Nat) : (OfNat.ofNat (α := Int) x : USize) = OfNat.of
 end USize
 namespace Lean.Grind
 
+attribute [local instance] UInt8.natCast UInt8.intCast in
 instance : CommRing UInt8 where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := UInt8.add_assoc
   add_comm := UInt8.add_comm
   add_zero := UInt8.add_zero
@@ -146,6 +184,8 @@ instance : CommRing UInt8 where
   ofNat_succ x := UInt8.ofNat_add x 1
   intCast_neg := UInt8.ofInt_neg
   intCast_ofNat := UInt8.intCast_ofNat
+  neg_zsmul i a := by simp [UInt8.intCast_neg, UInt8.neg_mul]
+  zsmul_natCast_eq_nsmul n a := congrArg (· * a) (UInt8.intCast_ofNat _)
 
 instance : IsCharP UInt8 256 := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by
@@ -159,7 +199,10 @@ example : ToInt.Sub UInt8 (.uint 8) := inferInstance
 
 instance : ToInt.Pow UInt8 (.uint 8) := ToInt.pow_of_semiring (by simp)
 
+attribute [local instance] UInt16.natCast UInt16.intCast in
 instance : CommRing UInt16 where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := UInt16.add_assoc
   add_comm := UInt16.add_comm
   add_zero := UInt16.add_zero
@@ -178,6 +221,8 @@ instance : CommRing UInt16 where
   ofNat_succ x := UInt16.ofNat_add x 1
   intCast_neg := UInt16.ofInt_neg
   intCast_ofNat := UInt16.intCast_ofNat
+  neg_zsmul i a := by simp [UInt16.intCast_neg, UInt16.neg_mul]
+  zsmul_natCast_eq_nsmul n a := congrArg (· * a) (UInt16.intCast_ofNat _)
 
 instance : IsCharP UInt16 65536 := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by
@@ -191,7 +236,10 @@ example : ToInt.Sub UInt16 (.uint 16) := inferInstance
 
 instance : ToInt.Pow UInt16 (.uint 16) := ToInt.pow_of_semiring (by simp)
 
+attribute [local instance] UInt32.natCast UInt32.intCast in
 instance : CommRing UInt32 where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := UInt32.add_assoc
   add_comm := UInt32.add_comm
   add_zero := UInt32.add_zero
@@ -210,6 +258,8 @@ instance : CommRing UInt32 where
   ofNat_succ x := UInt32.ofNat_add x 1
   intCast_neg := UInt32.ofInt_neg
   intCast_ofNat := UInt32.intCast_ofNat
+  neg_zsmul i a := by simp [UInt32.intCast_neg, UInt32.neg_mul]
+  zsmul_natCast_eq_nsmul n a := congrArg (· * a) (UInt32.intCast_ofNat _)
 
 instance : IsCharP UInt32 4294967296 := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by
@@ -223,7 +273,10 @@ example : ToInt.Sub UInt32 (.uint 32) := inferInstance
 
 instance : ToInt.Pow UInt32 (.uint 32) := ToInt.pow_of_semiring (by simp)
 
+attribute [local instance] UInt64.natCast UInt64.intCast in
 instance : CommRing UInt64 where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := UInt64.add_assoc
   add_comm := UInt64.add_comm
   add_zero := UInt64.add_zero
@@ -242,6 +295,8 @@ instance : CommRing UInt64 where
   ofNat_succ x := UInt64.ofNat_add x 1
   intCast_neg := UInt64.ofInt_neg
   intCast_ofNat := UInt64.intCast_ofNat
+  neg_zsmul i a := by simp [UInt64.intCast_neg, UInt64.neg_mul]
+  zsmul_natCast_eq_nsmul n a := congrArg (· * a) (UInt64.intCast_ofNat _)
 
 instance : IsCharP UInt64 18446744073709551616 := IsCharP.mk' _ _
   (ofNat_eq_zero_iff := fun x => by
@@ -255,7 +310,10 @@ example : ToInt.Sub UInt64 (.uint 64) := inferInstance
 
 instance : ToInt.Pow UInt64 (.uint 64) := ToInt.pow_of_semiring (by simp)
 
+attribute [local instance] USize.natCast USize.intCast in
 instance : CommRing USize where
+  nsmul := ⟨(· * ·)⟩
+  zsmul := ⟨(· * ·)⟩
   add_assoc := USize.add_assoc
   add_comm := USize.add_comm
   add_zero := USize.add_zero
@@ -274,6 +332,8 @@ instance : CommRing USize where
   ofNat_succ x := USize.ofNat_add x 1
   intCast_neg := USize.ofInt_neg
   intCast_ofNat := USize.intCast_ofNat
+  neg_zsmul i a := by simp [USize.intCast_neg, USize.neg_mul]
+  zsmul_natCast_eq_nsmul n a := congrArg (· * a) (USize.intCast_ofNat _)
 
 open System.Platform
 

src/Init/MetaTypes.lean

@@ -140,7 +140,7 @@ def defaultMaxSteps := 100000
 
 /--
 The configuration for `simp`.
-Passed to `simp` using, for example, the `simp (config := {contextual := true})` syntax.
+Passed to `simp` using, for example, the `simp +contextual` or `simp (maxSteps := 100000)` syntax.
 
 See also `Lean.Meta.Simp.neutralConfig` and `Lean.Meta.DSimp.Config`.
 -/
@@ -161,7 +161,7 @@ structure Config where
   -/
   contextual        : Bool := false
   /--
-  When true (default: `true`) then the simplifier caches the result of simplifying each subexpression, if possible.
+  When true (default: `true`) then the simplifier caches the result of simplifying each sub-expression, if possible.
   -/
   memoize           : Bool := true
   /--
@@ -252,14 +252,14 @@ structure Config where
   -/
   implicitDefEqProofs : Bool := true
   /--
-  When `true` (default : `true`), then `simp` will remove unused `let` and `have` expressions:
+  When `true` (default : `true`), then `simp` removes unused `let` and `have` expressions:
   `let x := v; e` simplifies to `e` when `x` does not occur in `e`.
   This option takes precedence over `zeta` and `zetaHave`.
   -/
   zetaUnused : Bool := true
   /--
-  When `true` (default : `true`), then simps will catch runtime exceptions and
-  convert them into `simp` exceptions.
+  When `true` (default : `true`), then `simp` catches runtime exceptions and
+  converts them into `simp` exceptions.
   -/
   catchRuntime : Bool := true
   /--
@@ -273,6 +273,14 @@ structure Config where
   if they are non-dependent. This only applies when `zeta := false`.
   -/
   letToHave : Bool := true
+  /--
+  When `true` (default : `true`), `simp` tries to realize constant `f.congr_simp`
+  when constructing an auxiliary congruence proof for `f`.
+  This option exists because the termination prover uses `simp` and `withoutModifyingEnv`
+  while constructing the termination proof. Thus, any constant realized by `simp`
+  is deleted.
+  -/
+  congrConsts : Bool := true
   deriving Inhabited, BEq
 
 -- Configuration object for `simp_all`

src/Init/Notation.lean

@@ -763,7 +763,7 @@ and checks that they match the contents of the docstring.
 Basic example:
 ```lean
 /--
-error: unknown identifier 'x'
+error: Unknown identifier `x`
 -/
 #guard_msgs in
 example : α := x