completely different approach

This PR changes the CI check when the `awaiting-mathlib` label is
present. If `breaks-mathlib` is present, it shows a red cross, but if
neither `breaks-mathlib` nor `builds-mathlib` is present it shows a
yellow circle.

.github/workflows/awaiting-mathlib.yml

@@ -0,0 +1,38 @@
+name: Check awaiting-mathlib label
+
+on:
+  merge_group:
+  pull_request:
+    types: [opened, synchronize, reopened, labeled, unlabeled]
+
+jobs:
+  check-awaiting-mathlib:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check awaiting-mathlib label
+        id: check-awaiting-mathlib-label
+        if: github.event_name == 'pull_request'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const { labels, number: prNumber } = context.payload.pull_request;
+            const hasAwaiting = labels.some(label => label.name == "awaiting-mathlib");
+            const hasBreaks = labels.some(label => label.name == "breaks-mathlib");
+            const hasBuilds = labels.some(label => label.name == "builds-mathlib");
+
+            if (hasAwaiting && hasBreaks) {
+              core.setFailed('PR has both "awaiting-mathlib" and "breaks-mathlib" labels.');
+            } else if (hasAwaiting && !hasBreaks && !hasBuilds) {
+              core.info('PR is marked "awaiting-mathlib" but neither "breaks-mathlib" nor "builds-mathlib" labels are present.');
+              core.setOutput('awaiting', 'true');
+            }
+      
+      - name: Wait for mathlib compatibility
+        if: github.event_name == 'pull_request' && steps.check-awaiting-mathlib-label.outputs.awaiting == 'true'
+        run: |
+          echo "::notice title=Awaiting mathlib::PR is marked 'awaiting-mathlib' but neither 'breaks-mathlib' nor 'builds-mathlib' labels are present."
+          echo "This check will remain in progress until the PR is updated with appropriate mathlib compatibility labels."
+          # Keep the job running indefinitely to show "in progress" status
+          while true; do
+            sleep 3600  # Sleep for 1 hour at a time
+          done

.github/workflows/build-template.yml

@@ -0,0 +1,250 @@
+# instantiated by ci.yml
+name: build-template
+on:
+  workflow_call:
+    inputs:
+      check-level:
+        type: string
+        required: true
+      config:
+        type: string
+        required: true
+      nightly:
+        type: string
+        required: true
+      LEAN_VERSION_MAJOR:
+        type: string
+        required: true
+      LEAN_VERSION_MINOR:
+        type: string
+        required: true
+      LEAN_VERSION_PATCH:
+        type: string
+        required: true
+      LEAN_SPECIAL_VERSION_DESC:
+        type: string
+        required: true
+      RELEASE_TAG:
+        type: string
+        required: true
+
+jobs:
+  build:
+    if: github.event_name != 'schedule' || github.repository == 'leanprover/lean4'
+    strategy:
+      matrix:
+        include: ${{fromJson(inputs.config)}}
+      # complete all jobs
+      fail-fast: false
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        shell: ${{ matrix.shell || 'nix develop -c bash -euxo pipefail {0}' }}
+    name: ${{ matrix.name }}
+    env:
+      # must be inside workspace
+      CCACHE_DIR: ${{ github.workspace }}/.ccache
+      CCACHE_COMPRESS: true
+      # current cache limit
+      CCACHE_MAXSIZE: 400M
+      # squelch error message about missing nixpkgs channel
+      NIX_BUILD_SHELL: bash
+      LSAN_OPTIONS: max_leaks=10
+      # somehow MinGW clang64 (or cmake?) defaults to `g++` even though it doesn't exist
+      CXX: c++
+      MACOSX_DEPLOYMENT_TARGET: 10.15
+    steps:
+      - name: Install Nix
+        uses: DeterminateSystems/nix-installer-action@main
+        if: runner.os == 'Linux' && !matrix.cmultilib
+      - name: Install MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: clang64
+          # `:` means do not prefix with msystem
+          pacboy: "make: python: cmake clang ccache gmp libuv git: zip: unzip: diffutils: binutils: tree: zstd tar:"
+        if: runner.os == 'Windows'
+      - name: Install Brew Packages
+        run: |
+          brew install ccache tree zstd coreutils gmp libuv
+        if: runner.os == 'macOS'
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          # the default is to use a virtual merge commit between the PR and master: just use the PR
+          ref: ${{ github.event.pull_request.head.sha }}
+      - name: Open Nix shell once
+        run: true
+        if: runner.os == 'Linux'
+      # Do check out some CI-relevant files from virtual merge commit to accommodate CI changes on
+      # master (as the workflow files themselves are always taken from the merge)
+      # (needs to be after "Install *" to use the right shell)
+      - name: CI Merge Checkout
+        run: |
+          git fetch --depth=1 origin ${{ github.sha }}
+          git checkout FETCH_HEAD flake.nix flake.lock script/prepare-*
+        if: github.event_name == 'pull_request'
+      # (needs to be after "Checkout" so files don't get overridden)
+      - name: Setup emsdk
+        uses: mymindstorm/setup-emsdk@v14
+        with:
+          version: 3.1.44
+          actions-cache-folder: emsdk
+        if: matrix.wasm
+      - name: Install 32bit c libs
+        run: |
+          sudo dpkg --add-architecture i386
+          sudo apt-get update
+          sudo apt-get install -y gcc-multilib g++-multilib ccache libuv1-dev:i386 pkgconf:i386
+        if: matrix.cmultilib
+      - name: Cache
+        id: restore-cache
+        uses: actions/cache/restore@v4
+        with:
+          # NOTE: must be in sync with `save` below
+          path: |
+            .ccache
+            ${{ matrix.name == 'Linux Lake' && 'build/stage1/**/*.trace
+            build/stage1/**/*.olean
+            build/stage1/**/*.ilean
+            build/stage1/**/*.c
+            build/stage1/**/*.c.o*' || '' }}
+          key: ${{ matrix.name }}-build-v3-${{ github.event.pull_request.head.sha }}
+          # fall back to (latest) previous cache
+          restore-keys: |
+            ${{ matrix.name }}-build-v3
+      # open nix-shell once for initial setup
+      - name: Setup
+        run: |
+          ccache --zero-stats
+        if: runner.os == 'Linux'
+      - name: Set up NPROC
+        run: |
+          echo "NPROC=$(nproc 2>/dev/null || sysctl -n hw.logicalcpu 2>/dev/null || echo 4)" >> $GITHUB_ENV
+      - name: Build
+        run: |
+          ulimit -c unlimited  # coredumps
+          [ -d build ] || mkdir build
+          cd build
+          # arguments passed to `cmake`
+          # this also enables githash embedding into stage 1 library
+          OPTIONS=(-DCHECK_OLEAN_VERSION=ON)
+          OPTIONS+=(-DLEAN_EXTRA_MAKE_OPTS=-DwarningAsError=true)
+          if [[ -n '${{ matrix.cross_target }}' ]]; then
+            # used by `prepare-llvm`
+            export EXTRA_FLAGS=--target=${{ matrix.cross_target }}
+            OPTIONS+=(-DLEAN_PLATFORM_TARGET=${{ matrix.cross_target }})
+          fi
+          if [[ -n '${{ matrix.prepare-llvm }}' ]]; then
+            wget -q ${{ matrix.llvm-url }}
+            PREPARE="$(${{ matrix.prepare-llvm }})"
+            eval "OPTIONS+=($PREPARE)"
+          fi
+          if [[ -n '${{ matrix.release }}' && -n '${{ inputs.nightly }}' ]]; then
+            OPTIONS+=(-DLEAN_SPECIAL_VERSION_DESC=${{ inputs.nightly }})
+          fi
+          if [[ -n '${{ matrix.release }}' && -n '${{ inputs.RELEASE_TAG }}' ]]; then
+            OPTIONS+=(-DLEAN_VERSION_MAJOR=${{ inputs.LEAN_VERSION_MAJOR }})
+            OPTIONS+=(-DLEAN_VERSION_MINOR=${{ inputs.LEAN_VERSION_MINOR }})
+            OPTIONS+=(-DLEAN_VERSION_PATCH=${{ inputs.LEAN_VERSION_PATCH }})
+            OPTIONS+=(-DLEAN_VERSION_IS_RELEASE=1)
+            OPTIONS+=(-DLEAN_SPECIAL_VERSION_DESC=${{ inputs.LEAN_SPECIAL_VERSION_DESC }})
+          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
+      - name: Install
+        run: |
+          make -C build install
+      - name: Check Binaries
+        run: ${{ matrix.binary-check }} lean-*/bin/* || true
+      - name: Count binary symbols
+        run: |
+          for f in lean-*/bin/*; do
+            echo "$f: $(nm $f | grep " T " | wc -l) exported symbols"
+          done
+        if: matrix.name == 'Windows'
+      - name: List Install Tree
+        run: |
+          # omit contents of Init/, ...
+          tree --du -h lean-*-* | grep -E ' (Init|Lean|Lake|LICENSE|[a-z])'
+      - name: Pack
+        run: |
+          dir=$(echo lean-*-*)
+          mkdir pack
+          # high-compression tar.zst + zip for release, fast tar.zst otherwise
+          if [[ '${{ startsWith(github.ref, 'refs/tags/') && matrix.release }}' == true || -n '${{ inputs.nightly }}' || -n '${{ inputs.RELEASE_TAG }}' ]]; then
+            ${{ matrix.tar || 'tar' }} cf - $dir | zstd -T0 --no-progress -19 -o pack/$dir.tar.zst
+            zip -rq pack/$dir.zip $dir
+          else
+            ${{ matrix.tar || 'tar' }} cf - $dir | zstd -T0 --no-progress -o pack/$dir.tar.zst
+          fi
+      - uses: actions/upload-artifact@v4
+        if: matrix.release
+        with:
+          name: build-${{ matrix.name }}
+          path: pack/*
+      - name: Lean stats
+        run: |
+          build/stage1/bin/lean --stats src/Lean.lean
+        if: ${{ !matrix.cross }}
+      - name: Test
+        id: test
+        run: |
+          ulimit -c unlimited  # coredumps
+          time ctest --preset ${{ matrix.CMAKE_PRESET || 'release' }} --test-dir build/stage1 -j$NPROC --output-junit test-results.xml ${{ matrix.CTEST_OPTIONS }}
+        if: (matrix.wasm || !matrix.cross) && (inputs.check-level >= 1 || matrix.name == 'Linux release')
+      - name: Test Summary
+        uses: test-summary/action@v2
+        with:
+          paths: build/stage1/test-results.xml
+        # prefix `if` above with `always` so it's run even if tests failed
+        if: always() && steps.test.conclusion != 'skipped'
+      - name: Check Test Binary
+        run: ${{ matrix.binary-check }} tests/compiler/534.lean.out
+        if: (!matrix.cross) && steps.test.conclusion != 'skipped'
+      - name: Build Stage 2
+        run: |
+          make -C build -j$NPROC stage2
+        if: matrix.test-speedcenter
+      - name: Check Stage 3
+        run: |
+          make -C build -j$NPROC check-stage3
+        if: matrix.test-speedcenter
+      - name: Test Speedcenter Benchmarks
+        run: |
+          # Necessary for some timing metrics but does not work on Namespace runners
+          # and we just want to test that the benchmarks run at all here
+          #echo -1 | sudo tee /proc/sys/kernel/perf_event_paranoid
+          export BUILD=$PWD/build PATH=$PWD/build/stage1/bin:$PATH
+          cd tests/bench
+          nix shell .#temci -c temci exec --config speedcenter.yaml --included_blocks fast --runs 1
+        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
+        if: matrix.name == 'Linux' && inputs.check-level >= 1
+      - name: CCache stats
+        if: always()
+        run: ccache -s
+      - name: Show stacktrace for coredumps
+        if: failure() && runner.os == 'Linux'
+        run: |
+          for c in $(find . -name core); do
+            progbin="$(file $c | sed "s/.*execfn: '\([^']*\)'.*/\1/")"
+            echo bt | $GDB/bin/gdb -q $progbin $c || true
+          done
+      - name: Save Cache
+        if: always() && steps.restore-cache.outputs.cache-hit != 'true'
+        uses: actions/cache/save@v4
+        with:
+          # NOTE: must be in sync with `restore` above
+          path: |
+            .ccache
+            ${{ matrix.name == 'Linux Lake' && 'build/stage1/**/*.trace
+            build/stage1/**/*.olean
+            build/stage1/**/*.ilean
+            build/stage1/**/*.c
+            build/stage1/**/*.c.o*' || '' }}
+          key: ${{ steps.restore-cache.outputs.cache-primary-key }}

.github/workflows/check-stage0.yml

@@ -20,9 +20,7 @@ jobs:
 
     - name: Identify stage0 changes
       run: |
-        git diff "${BASE:-HEAD^}..HEAD" --name-only -- stage0 |
-          grep -v -x -F $'stage0/src/stdlib_flags.h\nstage0/src/lean.mk.in' \
-          > "$RUNNER_TEMP/stage0" || true
+        git diff "${BASE:-HEAD^}..HEAD" --name-only -- stage0/stdlib > "$RUNNER_TEMP/stage0" || true
         if test -s "$RUNNER_TEMP/stage0"
         then
           echo "CHANGES=yes" >> "$GITHUB_ENV"

.github/workflows/ci.yml

@@ -36,7 +36,9 @@ jobs:
       # 2: PRs with `release-ci` label, releases (incl. nightlies)
       check-level: ${{ steps.set-level.outputs.check-level }}
       # The build matrix, dynamically generated here
-      matrix: ${{ steps.set-matrix.outputs.result }}
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+      # secondary build jobs that should not block the CI success/merge queue
+      matrix-secondary: ${{ steps.set-matrix.outputs.matrix-secondary }}
       # Should we make a nightly release? If so, this output contains the lean version string, else it is empty
       nightly: ${{ steps.set-nightly.outputs.nightly }}
       # Should this be the CI for a tagged release?
@@ -135,21 +137,23 @@ jobs:
             console.log(`level: ${level}`);
             // use large runners where available (original repo)
             let large = ${{ github.repository == 'leanprover/lean4' }};
+            const isPr = "${{ github.event_name }}" == "pull_request";
             let matrix = [
+              /* TODO: to be updated to new LLVM
               {
                 "name": "Linux LLVM",
                 "os": "ubuntu-latest",
                 "release": false,
                 "check-level": 2,
                 "shell": "nix develop .#oldGlibc -c bash -euxo pipefail {0}",
-                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/15.0.1/lean-llvm-x86_64-linux-gnu.tar.zst",
+                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/19.1.2/lean-llvm-x86_64-linux-gnu.tar.zst",
                 "prepare-llvm": "../script/prepare-llvm-linux.sh lean-llvm*",
                 "binary-check": "ldd -v",
                 // foreign code may be linked against more recent glibc
                 // reverse-ffi needs to be updated to link to LLVM libraries
                 "CTEST_OPTIONS": "-E 'foreign|leanlaketest_reverse-ffi'",
                 "CMAKE_OPTIONS": "-DLLVM=ON -DLLVM_CONFIG=${GITHUB_WORKSPACE}/build/llvm-host/bin/llvm-config"
-              },
+              }, */
               {
                 // portable release build: use channel with older glibc (2.26)
                 "name": "Linux release",
@@ -157,12 +161,23 @@ jobs:
                 "release": true,
                 "check-level": 0,
                 "shell": "nix develop .#oldGlibc -c bash -euxo pipefail {0}",
-                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/15.0.1/lean-llvm-x86_64-linux-gnu.tar.zst",
+                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/19.1.2/lean-llvm-x86_64-linux-gnu.tar.zst",
                 "prepare-llvm": "../script/prepare-llvm-linux.sh lean-llvm*",
                 "binary-check": "ldd -v",
                 // foreign code may be linked against more recent glibc
                 "CTEST_OPTIONS": "-E 'foreign'"
               },
+              {
+                "name": "Linux Lake",
+                "os": large ? "nscloud-ubuntu-22.04-amd64-4x8" : "ubuntu-latest",
+                "check-level": 0,
+                // just a secondary build job for now until false positives can be excluded
+                "secondary": true,
+                "CMAKE_OPTIONS": "-DUSE_LAKE=ON",
+                // TODO: importStructure is not compatible with .olean caching
+                // TODO: why does scopedMacros fail?
+                "CTEST_OPTIONS": "-E 'scopedMacros|importStructure'"
+              },
               {
                 "name": "Linux",
                 "os": large ? "nscloud-ubuntu-22.04-amd64-4x8" : "ubuntu-latest",
@@ -171,10 +186,10 @@ jobs:
                 "check-level": 1,
               },
               {
-                "name": "Linux Debug",
+                "name": "Linux Reldebug",
                 "os": "ubuntu-latest",
                 "check-level": 2,
-                "CMAKE_PRESET": "debug",
+                "CMAKE_PRESET": "reldebug",
                 // exclude seriously slow/stackoverflowing tests
                 "CTEST_OPTIONS": "-E 'interactivetest|leanpkgtest|laketest|benchtest|bv_bitblast_stress|3807'"
               },
@@ -194,7 +209,7 @@ jobs:
                 "release": true,
                 "check-level": 2,
                 "shell": "bash -euxo pipefail {0}",
-                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/15.0.1/lean-llvm-x86_64-apple-darwin.tar.zst",
+                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/19.1.2/lean-llvm-x86_64-apple-darwin.tar.zst",
                 "prepare-llvm": "../script/prepare-llvm-macos.sh lean-llvm*",
                 "binary-check": "otool -L",
                 "tar": "gtar" // https://github.com/actions/runner-images/issues/2619
@@ -204,12 +219,18 @@ jobs:
                 "os": "macos-14",
                 "CMAKE_OPTIONS": "-DLEAN_INSTALL_SUFFIX=-darwin_aarch64",
                 "release": true,
-                "check-level": 0,
                 "shell": "bash -euxo pipefail {0}",
-                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/15.0.1/lean-llvm-aarch64-apple-darwin.tar.zst",
+                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/19.1.2/lean-llvm-aarch64-apple-darwin.tar.zst",
                 "prepare-llvm": "../script/prepare-llvm-macos.sh lean-llvm*",
                 "binary-check": "otool -L",
-                "tar": "gtar" // https://github.com/actions/runner-images/issues/2619
+                "tar": "gtar", // https://github.com/actions/runner-images/issues/2619
+                // Special handling for MacOS aarch64, we want:
+                // 1. To run it in PRs so Mac devs get PR toolchains (so secondary is sufficient)
+                // 2. To skip it in merge queues as it takes longer than the Linux build and adds
+                //    little value in the merge queue
+                // 3. To run it in release (obviously)
+                "check-level": isPr ? 0 : 2,
+                "secondary": isPr,
               },
               {
                 "name": "Windows",
@@ -220,7 +241,7 @@ jobs:
                 "CMAKE_OPTIONS": "-G \"Unix Makefiles\"",
                 // for reasons unknown, interactivetests are flaky on Windows
                 "CTEST_OPTIONS": "--repeat until-pass:2",
-                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/15.0.1/lean-llvm-x86_64-w64-windows-gnu.tar.zst",
+                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/19.1.2/lean-llvm-x86_64-w64-windows-gnu.tar.zst",
                 "prepare-llvm": "../script/prepare-llvm-mingw.sh lean-llvm*",
                 "binary-check": "ldd"
               },
@@ -231,20 +252,21 @@ jobs:
                 "release": true,
                 "check-level": 2,
                 "shell": "nix develop .#oldGlibcAArch -c bash -euxo pipefail {0}",
-                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/15.0.1/lean-llvm-aarch64-linux-gnu.tar.zst",
+                "llvm-url": "https://github.com/leanprover/lean-llvm/releases/download/19.1.2/lean-llvm-aarch64-linux-gnu.tar.zst",
                 "prepare-llvm": "../script/prepare-llvm-linux.sh lean-llvm*"
               },
-              {
-                "name": "Linux 32bit",
-                "os": "ubuntu-latest",
-                // Use 32bit on stage0 and stage1 to keep oleans compatible
-                "CMAKE_OPTIONS": "-DSTAGE0_USE_GMP=OFF -DSTAGE0_LEAN_EXTRA_CXX_FLAGS='-m32' -DSTAGE0_LEANC_OPTS='-m32' -DSTAGE0_MMAP=OFF -DUSE_GMP=OFF -DLEAN_EXTRA_CXX_FLAGS='-m32' -DLEANC_OPTS='-m32' -DMMAP=OFF -DLEAN_INSTALL_SUFFIX=-linux_x86 -DCMAKE_LIBRARY_PATH=/usr/lib/i386-linux-gnu/ -DSTAGE0_CMAKE_LIBRARY_PATH=/usr/lib/i386-linux-gnu/ -DPKG_CONFIG_EXECUTABLE=/usr/bin/i386-linux-gnu-pkg-config",
-                "cmultilib": true,
-                "release": true,
-                "check-level": 2,
-                "cross": true,
-                "shell": "bash -euxo pipefail {0}"
-              }
+              // Started running out of memory building expensive modules, a 2GB heap is just not that much even before fragmentation
+              //{
+              //  "name": "Linux 32bit",
+              //  "os": "ubuntu-latest",
+              //  // Use 32bit on stage0 and stage1 to keep oleans compatible
+              //  "CMAKE_OPTIONS": "-DSTAGE0_USE_GMP=OFF -DSTAGE0_LEAN_EXTRA_CXX_FLAGS='-m32' -DSTAGE0_LEANC_OPTS='-m32' -DSTAGE0_MMAP=OFF -DUSE_GMP=OFF -DLEAN_EXTRA_CXX_FLAGS='-m32' -DLEANC_OPTS='-m32' -DMMAP=OFF -DLEAN_INSTALL_SUFFIX=-linux_x86 -DCMAKE_LIBRARY_PATH=/usr/lib/i386-linux-gnu/ -DSTAGE0_CMAKE_LIBRARY_PATH=/usr/lib/i386-linux-gnu/ -DPKG_CONFIG_EXECUTABLE=/usr/bin/i386-linux-gnu-pkg-config",
+              //  "cmultilib": true,
+              //  "release": true,
+              //  "check-level": 2,
+              //  "cross": true,
+              //  "shell": "bash -euxo pipefail {0}"
+              //}
               // {
               //   "name": "Web Assembly",
               //   "os": "ubuntu-latest",
@@ -260,196 +282,41 @@ jobs:
               //   "CTEST_OPTIONS": "-R \"leantest_1007\\.lean|leantest_Format\\.lean|leanruntest\\_1037.lean|leanruntest_ac_rfl\\.lean|leanruntest_tempfile.lean\\.|leanruntest_libuv\\.lean\""
               // }
             ];
-            console.log(`matrix:\n${JSON.stringify(matrix, null, 2)}`)
-            return matrix.filter((job) => level >= job["check-level"])
+            console.log(`matrix:\n${JSON.stringify(matrix, null, 2)}`);
+            matrix = matrix.filter((job) => level >= job["check-level"]);
+            core.setOutput('matrix', matrix.filter((job) => !job["secondary"]));
+            core.setOutput('matrix-secondary', matrix.filter((job) => job["secondary"]));
 
   build:
-    needs: [configure]
     if: github.event_name != 'schedule' || github.repository == 'leanprover/lean4'
-    strategy:
-      matrix:
-        include: ${{fromJson(needs.configure.outputs.matrix)}}
-      # complete all jobs
-      fail-fast: false
-    runs-on: ${{ matrix.os }}
-    defaults:
-      run:
-        shell: ${{ matrix.shell || 'nix develop -c bash -euxo pipefail {0}' }}
-    name: ${{ matrix.name }}
-    env:
-      # must be inside workspace
-      CCACHE_DIR: ${{ github.workspace }}/.ccache
-      CCACHE_COMPRESS: true
-      # current cache limit
-      CCACHE_MAXSIZE: 200M
-      # squelch error message about missing nixpkgs channel
-      NIX_BUILD_SHELL: bash
-      LSAN_OPTIONS: max_leaks=10
-      # somehow MinGW clang64 (or cmake?) defaults to `g++` even though it doesn't exist
-      CXX: c++
-      MACOSX_DEPLOYMENT_TARGET: 10.15
-    steps:
-      - name: Install Nix
-        uses: DeterminateSystems/nix-installer-action@main
-        if: runner.os == 'Linux' && !matrix.cmultilib
-      - name: Install MSYS2
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: clang64
-          # `:` means do not prefix with msystem
-          pacboy: "make: python: cmake clang ccache gmp libuv git: zip: unzip: diffutils: binutils: tree: zstd tar:"
-        if: runner.os == 'Windows'
-      - name: Install Brew Packages
-        run: |
-          brew install ccache tree zstd coreutils gmp libuv
-        if: runner.os == 'macOS'
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          # the default is to use a virtual merge commit between the PR and master: just use the PR
-          ref: ${{ github.event.pull_request.head.sha }}
-      # Do check out some CI-relevant files from virtual merge commit to accommodate CI changes on
-      # master (as the workflow files themselves are always taken from the merge)
-      # (needs to be after "Install *" to use the right shell)
-      - name: CI Merge Checkout
-        run: |
-          git fetch --depth=1 origin ${{ github.sha }}
-          git checkout FETCH_HEAD flake.nix flake.lock
-        if: github.event_name == 'pull_request'
-      # (needs to be after "Checkout" so files don't get overridden)
-      - name: Setup emsdk
-        uses: mymindstorm/setup-emsdk@v14
-        with:
-          version: 3.1.44
-          actions-cache-folder: emsdk
-        if: matrix.wasm
-      - name: Install 32bit c libs
-        run: |
-          sudo dpkg --add-architecture i386
-          sudo apt-get update
-          sudo apt-get install -y gcc-multilib g++-multilib ccache libuv1-dev:i386 pkgconf:i386
-        if: matrix.cmultilib
-      - name: Cache
-        uses: actions/cache@v4
-        with:
-          path: .ccache
-          key: ${{ matrix.name }}-build-v3-${{ github.event.pull_request.head.sha }}
-          # fall back to (latest) previous cache
-          restore-keys: |
-            ${{ matrix.name }}-build-v3
-          save-always: true
-      # open nix-shell once for initial setup
-      - name: Setup
-        run: |
-          ccache --zero-stats
-        if: runner.os == 'Linux'
-      - name: Set up NPROC
-        run: |
-          echo "NPROC=$(nproc 2>/dev/null || sysctl -n hw.logicalcpu 2>/dev/null || echo 4)" >> $GITHUB_ENV
-      - name: Build
-        run: |
-          mkdir build
-          cd build
-          # arguments passed to `cmake`
-          # this also enables githash embedding into stage 1 library
-          OPTIONS=(-DCHECK_OLEAN_VERSION=ON)
-          OPTIONS+=(-DLEAN_EXTRA_MAKE_OPTS=-DwarningAsError=true)
-          if [[ -n '${{ matrix.cross_target }}' ]]; then
-            # used by `prepare-llvm`
-            export EXTRA_FLAGS=--target=${{ matrix.cross_target }}
-            OPTIONS+=(-DLEAN_PLATFORM_TARGET=${{ matrix.cross_target }})
-          fi
-          if [[ -n '${{ matrix.prepare-llvm }}' ]]; then
-            wget -q ${{ matrix.llvm-url }}
-            PREPARE="$(${{ matrix.prepare-llvm }})"
-            eval "OPTIONS+=($PREPARE)"
-          fi
-          if [[ -n '${{ matrix.release }}' && -n '${{ needs.configure.outputs.nightly }}' ]]; then
-            OPTIONS+=(-DLEAN_SPECIAL_VERSION_DESC=${{ needs.configure.outputs.nightly }})
-          fi
-          if [[ -n '${{ matrix.release }}' && -n '${{ needs.configure.outputs.RELEASE_TAG }}' ]]; then
-            OPTIONS+=(-DLEAN_VERSION_MAJOR=${{ needs.configure.outputs.LEAN_VERSION_MAJOR }})
-            OPTIONS+=(-DLEAN_VERSION_MINOR=${{ needs.configure.outputs.LEAN_VERSION_MINOR }})
-            OPTIONS+=(-DLEAN_VERSION_PATCH=${{ needs.configure.outputs.LEAN_VERSION_PATCH }})
-            OPTIONS+=(-DLEAN_VERSION_IS_RELEASE=1)
-            OPTIONS+=(-DLEAN_SPECIAL_VERSION_DESC=${{ needs.configure.outputs.LEAN_SPECIAL_VERSION_DESC }})
-          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
-      - name: Install
-        run: |
-          make -C build install
-      - name: Check Binaries
-        run: ${{ matrix.binary-check }} lean-*/bin/* || true
-      - name: Count binary symbols
-        run: |
-          for f in lean-*/bin/*; do
-            echo "$f: $(nm $f | grep " T " | wc -l) exported symbols"
-          done
-        if: matrix.name == 'Windows'
-      - name: List Install Tree
-        run: |
-          # omit contents of Init/, ...
-          tree --du -h lean-*-* | grep -E ' (Init|Lean|Lake|LICENSE|[a-z])'
-      - name: Pack
-        run: |
-          dir=$(echo lean-*-*)
-          mkdir pack
-          # high-compression tar.zst + zip for release, fast tar.zst otherwise
-          if [[ '${{ startsWith(github.ref, 'refs/tags/') && matrix.release }}' == true || -n '${{ needs.configure.outputs.nightly }}' || -n '${{ needs.configure.outputs.RELEASE_TAG }}' ]]; then
-            ${{ matrix.tar || 'tar' }} cf - $dir | zstd -T0 --no-progress -19 -o pack/$dir.tar.zst
-            zip -rq pack/$dir.zip $dir
-          else
-            ${{ matrix.tar || 'tar' }} cf - $dir | zstd -T0 --no-progress -o pack/$dir.tar.zst
-          fi
-      - uses: actions/upload-artifact@v4
-        if: matrix.release
-        with:
-          name: build-${{ matrix.name }}
-          path: pack/*
-      - name: Lean stats
-        run: |
-          build/stage1/bin/lean --stats src/Lean.lean
-        if: ${{ !matrix.cross }}
-      - name: Test
-        id: test
-        run: |
-          time ctest --preset ${{ matrix.CMAKE_PRESET || 'release' }} --test-dir build/stage1 -j$NPROC --output-junit test-results.xml ${{ matrix.CTEST_OPTIONS }}
-        if: (matrix.wasm || !matrix.cross) && needs.configure.outputs.check-level >= 1
-      - name: Test Summary
-        uses: test-summary/action@v2
-        with:
-          paths: build/stage1/test-results.xml
-        # prefix `if` above with `always` so it's run even if tests failed
-        if: always() && steps.test.conclusion != 'skipped'
-      - name: Check Test Binary
-        run: ${{ matrix.binary-check }} tests/compiler/534.lean.out
-        if: (!matrix.cross) && steps.test.conclusion != 'skipped'
-      - name: Build Stage 2
-        run: |
-          make -C build -j$NPROC stage2
-        if: matrix.test-speedcenter
-      - name: Check Stage 3
-        run: |
-          make -C build -j$NPROC check-stage3
-        if: matrix.test-speedcenter
-      - name: Test Speedcenter Benchmarks
-        run: |
-          # Necessary for some timing metrics but does not work on Namespace runners
-          # and we just want to test that the benchmarks run at all here
-          #echo -1 | sudo tee /proc/sys/kernel/perf_event_paranoid
-          export BUILD=$PWD/build PATH=$PWD/build/stage1/bin:$PATH
-          cd tests/bench
-          nix shell .#temci -c temci exec --config speedcenter.yaml --included_blocks fast --runs 1
-        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
-        if: matrix.name == 'Linux' && needs.configure.outputs.check-level >= 1
-      - name: CCache stats
-        run: ccache -s
+    needs: [configure]
+    uses: ./.github/workflows/build-template.yml
+    with:
+      config: ${{needs.configure.outputs.matrix}}
+      check-level: ${{ needs.configure.outputs.check-level }}
+      nightly: ${{ needs.configure.outputs.nightly }}
+      LEAN_VERSION_MAJOR: ${{ needs.configure.outputs.LEAN_VERSION_MAJOR }}
+      LEAN_VERSION_MINOR: ${{ needs.configure.outputs.LEAN_VERSION_MINOR }}
+      LEAN_VERSION_PATCH: ${{ needs.configure.outputs.LEAN_VERSION_PATCH }}
+      LEAN_SPECIAL_VERSION_DESC: ${{ needs.configure.outputs.LEAN_SPECIAL_VERSION_DESC }}
+      RELEASE_TAG: ${{ needs.configure.outputs.RELEASE_TAG }}
+    secrets: inherit
+
+  # build jobs that should not be considered by `all-done` below
+  build-secondary:
+    needs: [configure]
+    if: needs.configure.outputs.matrix-secondary != '[]'
+    uses: ./.github/workflows/build-template.yml
+    with:
+      config: ${{needs.configure.outputs.matrix-secondary}}
+      check-level: ${{ needs.configure.outputs.check-level }}
+      nightly: ${{ needs.configure.outputs.nightly }}
+      LEAN_VERSION_MAJOR: ${{ needs.configure.outputs.LEAN_VERSION_MAJOR }}
+      LEAN_VERSION_MINOR: ${{ needs.configure.outputs.LEAN_VERSION_MINOR }}
+      LEAN_VERSION_PATCH: ${{ needs.configure.outputs.LEAN_VERSION_PATCH }}
+      LEAN_SPECIAL_VERSION_DESC: ${{ needs.configure.outputs.LEAN_SPECIAL_VERSION_DESC }}
+      RELEASE_TAG: ${{ needs.configure.outputs.RELEASE_TAG }}
+    secrets: inherit
 
   # This job collects results from all the matrix jobs
   # This can be made the "required" job, instead of listing each
@@ -481,8 +348,6 @@ jobs:
 
   # This job creates releases from tags
   # (whether they are "unofficial" releases for experiments, or official releases when the tag is "v" followed by a semver string.)
-  # We do not attempt to automatically construct a changelog here:
-  # unofficial releases don't need them, and official release notes will be written by a human.
   release:
     if: startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest

.github/workflows/nix-ci.yml

@@ -1,142 +0,0 @@
-name: Nix CI
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - '*'
-  pull_request:
-  merge_group:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  # see ci.yml
-  configure:
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.result }}
-    steps:
-      - name: Configure build matrix
-        id: set-matrix
-        uses: actions/github-script@v7
-        with:
-          script: |
-            let large = ${{ github.repository == 'leanprover/lean4' }};
-            let matrix = [
-              {
-                "name": "Nix Linux",
-                "os": large ? "nscloud-ubuntu-22.04-amd64-8x8" : "ubuntu-latest",
-              }
-            ];
-            console.log(`matrix:\n${JSON.stringify(matrix, null, 2)}`);
-            return matrix;
-
-  Build:
-    needs: [configure]
-    runs-on: ${{ matrix.os }}
-    defaults:
-      run:
-        shell: nix run .#ciShell -- bash -euxo pipefail {0}
-    strategy:
-      matrix:
-        include: ${{fromJson(needs.configure.outputs.matrix)}}
-      # complete all jobs
-      fail-fast: false
-    name: ${{ matrix.name }}
-    env:
-      NIX_BUILD_ARGS: --print-build-logs --fallback
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          # the default is to use a virtual merge commit between the PR and master: just use the PR
-          ref: ${{ github.event.pull_request.head.sha }}
-      - name: Set Up Nix Cache
-        uses: actions/cache@v4
-        with:
-          path: nix-store-cache
-          key: ${{ matrix.name }}-nix-store-cache-${{ github.sha }}
-          # fall back to (latest) previous cache
-          restore-keys: |
-            ${{ matrix.name }}-nix-store-cache
-          save-always: true
-      - name: Further Set Up Nix Cache
-        shell: bash -euxo pipefail {0}
-        run: |
-          # Nix seems to mutate the cache, so make a copy
-          cp -r nix-store-cache nix-store-cache-copy || true
-      - name: Install Nix
-        uses: DeterminateSystems/nix-installer-action@main
-        with:
-          extra-conf: |
-            extra-sandbox-paths = /nix/var/cache/ccache?
-            substituters = file://${{ github.workspace }}/nix-store-cache-copy?priority=10&trusted=true https://cache.nixos.org  
-      - name: Prepare CCache Cache
-        run: |
-          sudo mkdir -m0770 -p /nix/var/cache/ccache
-          sudo chown -R $USER /nix/var/cache/ccache
-      - name: Setup CCache Cache
-        uses: actions/cache@v4
-        with:
-          path: /nix/var/cache/ccache
-          key: ${{ matrix.name }}-nix-ccache-${{ github.sha }}
-          # fall back to (latest) previous cache
-          restore-keys: |
-            ${{ matrix.name }}-nix-ccache
-          save-always: true
-      - name: Further Set Up CCache Cache
-        run: |
-          sudo chown -R root:nixbld /nix/var/cache
-          sudo chmod -R 770 /nix/var/cache
-      - name: Build
-        run: |
-          nix build $NIX_BUILD_ARGS .#cacheRoots -o push-build
-      - name: Test
-        run: |
-          nix build --keep-failed $NIX_BUILD_ARGS .#test -o push-test || (ln -s /tmp/nix-build-*/build/source/src/build ./push-test; false)
-      - name: Test Summary
-        uses: test-summary/action@v2
-        with:
-          paths: push-test/test-results.xml
-        if: always()
-        continue-on-error: true
-      - name: Build manual
-        run: |
-          nix build $NIX_BUILD_ARGS --update-input lean --no-write-lock-file ./doc#{lean-mdbook,leanInk,alectryon,inked} -o push-doc
-          nix build $NIX_BUILD_ARGS --update-input lean --no-write-lock-file ./doc
-          # https://github.com/netlify/cli/issues/1809
-          cp -r --dereference ./result ./dist
-        if: matrix.name == 'Nix Linux'
-      - name: Rebuild Nix Store Cache
-        run: |
-          rm -rf nix-store-cache || true
-          nix copy ./push-* --to file://$PWD/nix-store-cache?compression=none
-      - id: deploy-info
-        name: Compute Deployment Metadata
-        run: |
-          set -e
-          python3 -c 'import base64; print("alias="+base64.urlsafe_b64encode(bytes.fromhex("${{github.sha}}")).decode("utf-8").rstrip("="))' >> "$GITHUB_OUTPUT"
-          echo "message=`git log -1 --pretty=format:"%s"`" >> "$GITHUB_OUTPUT"
-      - name: Publish manual to Netlify
-        uses: nwtgck/actions-netlify@v3.0
-        id: publish-manual
-        with:
-          publish-dir: ./dist
-          production-branch: master
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          deploy-message: |
-            ${{ github.event_name == 'pull_request' && format('pr#{0}: {1}', github.event.number, github.event.pull_request.title) || format('ref/{0}: {1}', github.ref_name, steps.deploy-info.outputs.message) }}
-          alias: ${{ steps.deploy-info.outputs.alias }}
-          enable-commit-comment: false
-          enable-pull-request-comment: false
-          github-deployment-environment: "lean-lang.org/lean4/doc"
-          fails-without-credentials: false
-        env:
-          NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
-          NETLIFY_SITE_ID: "b8e805d2-7e9b-4f80-91fb-a84d72fc4a68"
-      - name: Fixup CCache Cache
-        run: |
-          sudo chown -R $USER /nix/var/cache

.github/workflows/pr-release.yml

@@ -34,7 +34,7 @@ jobs:
       - name: Download artifact from the previous workflow.
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
         id: download-artifact
-        uses: dawidd6/action-download-artifact@v8 # https://github.com/marketplace/actions/download-workflow-artifact
+        uses: dawidd6/action-download-artifact@v9 # https://github.com/marketplace/actions/download-workflow-artifact
         with:
           run_id: ${{ github.event.workflow_run.id }}
           path: artifacts
@@ -111,7 +111,7 @@ jobs:
 
       - name: 'Setup jq'
         if: ${{ steps.workflow-info.outputs.pullRequestNumber != '' }}
-        uses: dcarbone/install-jq-action@v3.0.1
+        uses: dcarbone/install-jq-action@v3.1.1
 
       # Check that the most recently nightly coincides with 'git merge-base HEAD master'
       - name: Check merge-base and nightly-testing-YYYY-MM-DD
@@ -155,6 +155,20 @@ jobs:
           fi
 
           if [[ -n "$MESSAGE" ]]; then
+            # Check if force-mathlib-ci label is present
+            LABELS="$(curl --retry 3 --location --silent \
+                          -H "Authorization: token ${{ secrets.MATHLIB4_COMMENT_BOT }}" \
+                          -H "Accept: application/vnd.github.v3+json" \
+                          "https://api.github.com/repos/leanprover/lean4/issues/${{ steps.workflow-info.outputs.pullRequestNumber }}/labels" \
+                          | jq -r '.[].name')"
+            
+            if echo "$LABELS" | grep -q "^force-mathlib-ci$"; then
+              echo "force-mathlib-ci label detected, forcing CI despite issues"
+              MESSAGE="Forcing Mathlib CI because the \`force-mathlib-ci\` label is present, despite problem: $MESSAGE"
+              FORCE_CI=true
+            else
+              MESSAGE="$MESSAGE You can force Mathlib CI using the \`force-mathlib-ci\` label."
+            fi
 
             echo "Checking existing messages"
 
@@ -201,7 +215,12 @@ jobs:
             else
               echo "The message already exists in the comment body."
             fi
-            echo "mathlib_ready=false" >> "$GITHUB_OUTPUT"
+
+            if [[ "$FORCE_CI" == "true" ]]; then
+              echo "mathlib_ready=true" >> "$GITHUB_OUTPUT"
+            else
+              echo "mathlib_ready=false" >> "$GITHUB_OUTPUT"
+            fi
           else
             echo "mathlib_ready=true" >> "$GITHUB_OUTPUT"
           fi
@@ -252,7 +271,7 @@ jobs:
           if git ls-remote --heads --tags --exit-code origin "nightly-testing-${MOST_RECENT_NIGHTLY}" >/dev/null; then
             BASE="nightly-testing-${MOST_RECENT_NIGHTLY}"
           else
-            echo "This shouldn't be possible: couldn't find a 'nightly-testing-${MOST_RECENT_NIGHTLY}' tag at Batteries. Falling back to 'nightly-testing'."
+            echo "Couldn't find a 'nightly-testing-${MOST_RECENT_NIGHTLY}' tag at Batteries. Falling back to 'nightly-testing'."
             BASE=nightly-testing
           fi
 
@@ -316,7 +335,7 @@ jobs:
           if git ls-remote --heads --tags --exit-code origin "nightly-testing-${MOST_RECENT_NIGHTLY}" >/dev/null; then
             BASE="nightly-testing-${MOST_RECENT_NIGHTLY}"
           else
-            echo "This shouldn't be possible: couldn't find a 'nightly-testing-${MOST_RECENT_NIGHTLY}' branch at Mathlib. Falling back to 'nightly-testing'."
+            echo "Couldn't find a 'nightly-testing-${MOST_RECENT_NIGHTLY}' branch at Mathlib. Falling back to 'nightly-testing'."
             BASE=nightly-testing
           fi
 

.github/workflows/update-stage0.yml

@@ -40,34 +40,24 @@ jobs:
       run: |
           git config --global user.name "Lean stage0 autoupdater"
           git config --global user.email "<>"
-    # Would be nice, but does not work yet:
-    # https://github.com/DeterminateSystems/magic-nix-cache/issues/39
-    # This action does not run that often and building runs in a few minutes, so ok for now
-    #- if: env.should_update_stage0 == 'yes'
-    #  uses: DeterminateSystems/magic-nix-cache-action@v2
-    - if: env.should_update_stage0 == 'yes'
-      name: Restore Build Cache
-      uses: actions/cache/restore@v4
-      with:
-        path: nix-store-cache
-        key: Nix Linux-nix-store-cache-${{ github.sha }}
-        # fall back to (latest) previous cache
-        restore-keys: |
-          Nix Linux-nix-store-cache
-    - if: env.should_update_stage0 == 'yes'
-      name: Further Set Up Nix Cache
-      shell: bash -euxo pipefail {0}
-      run: |
-        # Nix seems to mutate the cache, so make a copy
-        cp -r nix-store-cache nix-store-cache-copy || true
     - if: env.should_update_stage0 == 'yes'
       name: Install Nix
       uses: DeterminateSystems/nix-installer-action@main
-      with:
-        extra-conf: |
-          substituters = file://${{ github.workspace }}/nix-store-cache-copy?priority=10&trusted=true https://cache.nixos.org  
+    - name: Open Nix shell once
+      if: env.should_update_stage0 == 'yes'
+      run: true
+      shell: 'nix develop -c bash -euxo pipefail {0}'
+    - name: Set up NPROC
+      if: env.should_update_stage0 == 'yes'
+      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}'
     - if: env.should_update_stage0 == 'yes'
-      run: nix run .#update-stage0-commit
+      run: cmake --preset release
+      shell: 'nix develop -c bash -euxo pipefail {0}'
+    - if: env.should_update_stage0 == 'yes'
+      run: make -j$NPROC -C build/release  update-stage0-commit
+      shell: 'nix develop -c bash -euxo pipefail {0}'
     - if: env.should_update_stage0 == 'yes'
       run: git show --stat
     - if: env.should_update_stage0 == 'yes' && github.event_name == 'push'

.gitignore

@@ -22,6 +22,7 @@ settings.json
 .gdb_history
 .vscode/*
 !.vscode/settings.json
+script/__pycache__
 *.produced.out
 CMakeSettings.json
 CppProperties.json

CMakeLists.txt

@@ -1,26 +1,30 @@
 cmake_minimum_required(VERSION 3.11)
+
+option(USE_MIMALLOC "use mimalloc" ON)
+
 # store all variables passed on the command line into CL_ARGS so we can pass them to the stage builds
 # https://stackoverflow.com/a/48555098/161659
 # MUST be done before call to 'project'
-# Use standard release build (discarding LEAN_CXX_EXTRA_FLAGS etc.) for stage0 by default since it is assumed to be "good", but still pass through CMake platform arguments (compiler, toolchain file, ..).
+# Use standard release build (discarding LEAN_EXTRA_CXX_FLAGS etc.) for stage0 by default since it is assumed to be "good", but still pass through CMake platform arguments (compiler, toolchain file, ..).
 # Use `STAGE0_` prefix to pass variables to stage0 explicitly.
 get_cmake_property(vars CACHE_VARIABLES)
 foreach(var ${vars})
   get_property(currentHelpString CACHE "${var}" PROPERTY HELPSTRING)
   if("${var}" MATCHES "STAGE0_(.*)")
     list(APPEND STAGE0_ARGS "-D${CMAKE_MATCH_1}=${${var}}")
+  elseif("${var}" MATCHES "STAGE1_(.*)")
+    list(APPEND STAGE1_ARGS "-D${CMAKE_MATCH_1}=${${var}}")
   elseif("${currentHelpString}" MATCHES "No help, variable specified on the command line." OR "${currentHelpString}" STREQUAL "")
     list(APPEND CL_ARGS "-D${var}=${${var}}")
     if("${var}" MATCHES "USE_GMP|CHECK_OLEAN_VERSION")
       # must forward options that generate incompatible .olean format
       list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
-    endif()
-    if("${var}" MATCHES "LLVM*")
-      list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
-    endif()
-    if("${var}" MATCHES "PKG_CONFIG*")
+    elseif("${var}" MATCHES "LLVM*|PKG_CONFIG|USE_LAKE|USE_MIMALLOC")
       list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
     endif()
+  elseif("${var}" MATCHES "USE_MIMALLOC")
+    list(APPEND CL_ARGS "-D${var}=${${var}}")
+    list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
   elseif(("${var}" MATCHES "CMAKE_.*") AND NOT ("${var}" MATCHES "CMAKE_BUILD_TYPE") AND NOT ("${var}" MATCHES "CMAKE_HOME_DIRECTORY"))
     list(APPEND PLATFORM_ARGS "-D${var}=${${var}}")
   endif()
@@ -35,10 +39,14 @@ endif()
 
 # Don't do anything with cadical on wasm
 if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
-  # On CI Linux, we source cadical from Nix instead; see flake.nix
   find_program(CADICAL cadical)
   if(NOT CADICAL)
     set(CADICAL_CXX c++)
+    if (CADICAL_USE_CUSTOM_CXX)
+      set(CADICAL_CXX ${CMAKE_CXX_COMPILER})
+      set(CADICAL_CXXFLAGS "${LEAN_EXTRA_CXX_FLAGS}")
+      set(CADICAL_LDFLAGS "-Wl,-rpath=\\$$ORIGIN/../lib")
+    endif()
     find_program(CCACHE ccache)
     if(CCACHE)
       set(CADICAL_CXX "${CCACHE} ${CADICAL_CXX}")
@@ -47,41 +55,61 @@ if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
     if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
       string(APPEND CADICAL_CXXFLAGS " -DNUNLOCKED")
     endif()
+    string(APPEND CADICAL_CXXFLAGS " -DNCLOSEFROM")
     ExternalProject_add(cadical
       PREFIX cadical
       GIT_REPOSITORY https://github.com/arminbiere/cadical
-      GIT_TAG rel-1.9.5
+      GIT_TAG rel-2.1.2
       CONFIGURE_COMMAND ""
-      # https://github.com/arminbiere/cadical/blob/master/BUILD.md#manual-build
-      BUILD_COMMAND $(MAKE) -f ${CMAKE_SOURCE_DIR}/src/cadical.mk CMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX} CXX=${CADICAL_CXX} CXXFLAGS=${CADICAL_CXXFLAGS}
+      BUILD_COMMAND $(MAKE) -f ${CMAKE_SOURCE_DIR}/src/cadical.mk
+        CMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX}
+        CXX=${CADICAL_CXX}
+        CXXFLAGS=${CADICAL_CXXFLAGS}
+        LDFLAGS=${CADICAL_LDFLAGS}
       BUILD_IN_SOURCE ON
       INSTALL_COMMAND "")
     set(CADICAL ${CMAKE_BINARY_DIR}/cadical/cadical${CMAKE_EXECUTABLE_SUFFIX} CACHE FILEPATH "path to cadical binary" FORCE)
-    set(EXTRA_DEPENDS "cadical")
+    list(APPEND EXTRA_DEPENDS cadical)
   endif()
   list(APPEND CL_ARGS -DCADICAL=${CADICAL})
 endif()
 
-ExternalProject_add(stage0
-  SOURCE_DIR "${LEAN_SOURCE_DIR}/stage0"
-  SOURCE_SUBDIR src
-  BINARY_DIR stage0
-  # do not rebuild stage0 when git hash changes; it's not from this commit anyway
-  # (however, `CHECK_OLEAN_VERSION=ON` in CI will override this as we need to
-  # embed the githash into the stage 1 library built by stage 0)
-  CMAKE_ARGS -DSTAGE=0 -DUSE_GITHASH=OFF ${PLATFORM_ARGS} ${STAGE0_ARGS}
-  BUILD_ALWAYS ON  # cmake doesn't auto-detect changes without a download method
-  INSTALL_COMMAND ""  # skip install
-  DEPENDS ${EXTRA_DEPENDS}
-)
+if (USE_MIMALLOC)
+  ExternalProject_add(mimalloc
+    PREFIX mimalloc
+    GIT_REPOSITORY https://github.com/microsoft/mimalloc
+    GIT_TAG v2.2.3
+    # just download, we compile it as part of each stage as it is small
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND "")
+  list(APPEND EXTRA_DEPENDS mimalloc)
+endif()
+
+if (NOT STAGE1_PREV_STAGE)
+  ExternalProject_add(stage0
+    SOURCE_DIR "${LEAN_SOURCE_DIR}/stage0"
+    SOURCE_SUBDIR src
+    BINARY_DIR stage0
+    # do not rebuild stage0 when git hash changes; it's not from this commit anyway
+    # (however, CI will override this as we need to embed the githash into the stage 1 library built
+    # by stage 0)
+    CMAKE_ARGS -DSTAGE=0 -DUSE_GITHASH=OFF ${PLATFORM_ARGS} ${STAGE0_ARGS}
+    BUILD_ALWAYS ON  # cmake doesn't auto-detect changes without a download method
+    INSTALL_COMMAND ""  # skip install
+    DEPENDS ${EXTRA_DEPENDS}
+  )
+  list(APPEND EXTRA_DEPENDS stage0)
+endif()
 ExternalProject_add(stage1
   SOURCE_DIR "${LEAN_SOURCE_DIR}"
   SOURCE_SUBDIR src
   BINARY_DIR stage1
-  CMAKE_ARGS -DSTAGE=1 -DPREV_STAGE=${CMAKE_BINARY_DIR}/stage0 -DPREV_STAGE_CMAKE_EXECUTABLE_SUFFIX=${STAGE0_CMAKE_EXECUTABLE_SUFFIX} ${CL_ARGS}
+  CMAKE_ARGS -DSTAGE=1 -DPREV_STAGE=${CMAKE_BINARY_DIR}/stage0 -DPREV_STAGE_CMAKE_EXECUTABLE_SUFFIX=${STAGE0_CMAKE_EXECUTABLE_SUFFIX} ${CL_ARGS} ${STAGE1_ARGS}
   BUILD_ALWAYS ON
   INSTALL_COMMAND ""
-  DEPENDS stage0
+  DEPENDS ${EXTRA_DEPENDS}
+  STEP_TARGETS configure
 )
 ExternalProject_add(stage2
   SOURCE_DIR "${LEAN_SOURCE_DIR}"
@@ -92,6 +120,7 @@ ExternalProject_add(stage2
   INSTALL_COMMAND ""
   DEPENDS stage1
   EXCLUDE_FROM_ALL ON
+  STEP_TARGETS configure
 )
 ExternalProject_add(stage3
   SOURCE_DIR "${LEAN_SOURCE_DIR}"

CMakePresets.json

@@ -16,26 +16,39 @@
       "name": "debug",
       "displayName": "Debug build config",
       "cacheVariables": {
+        "LEAN_EXTRA_CXX_FLAGS": "-DLEAN_DEFAULT_THREAD_STACK_SIZE=16*1024*1024",
         "CMAKE_BUILD_TYPE": "Debug"
       },
       "generator": "Unix Makefiles",
       "binaryDir": "${sourceDir}/build/debug"
     },
+    {
+      "name": "reldebug",
+      "displayName": "Release with assertions enabled",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "RelWithAssert"
+      },
+      "generator": "Unix Makefiles",
+      "binaryDir": "${sourceDir}/build/reldebug"
+    },
     {
       "name": "sanitize",
       "displayName": "Sanitize build config",
       "cacheVariables": {
-        "LEAN_EXTRA_CXX_FLAGS": "-fsanitize=address,undefined",
-        "LEANC_EXTRA_CC_FLAGS": "-fsanitize=address,undefined -fsanitize-link-c++-runtime",
+        "LEAN_EXTRA_CXX_FLAGS": "-fsanitize=address,undefined -DLEAN_DEFAULT_THREAD_STACK_SIZE=16*1024*1024",
+        "LEANC_EXTRA_CC_FLAGS": "-fsanitize=address,undefined",
+        "LEAN_EXTRA_LINKER_FLAGS": "-fsanitize=address,undefined -fsanitize-link-c++-runtime",
         "SMALL_ALLOCATOR": "OFF",
-        "BSYMBOLIC": "OFF"
+        "USE_MIMALLOC": "OFF",
+        "BSYMBOLIC": "OFF",
+        "LEAN_TEST_VARS": "MAIN_STACK_SIZE=16000"
       },
       "generator": "Unix Makefiles",
       "binaryDir": "${sourceDir}/build/sanitize"
     },
     {
       "name": "sandebug",
-      "inherits": ["debug", "sanitize"],
+      "inherits": ["sanitize", "debug"],
       "displayName": "Sanitize+debug build config",
       "binaryDir": "${sourceDir}/build/sandebug"
     }
@@ -49,6 +62,10 @@
       "name": "debug",
       "configurePreset": "debug"
     },
+    {
+      "name": "reldebug",
+      "configurePreset": "reldebug"
+    },
     {
       "name": "sanitize",
       "configurePreset": "sanitize"
@@ -69,6 +86,11 @@
       "configurePreset": "debug",
       "inherits": "release"
     },
+    {
+      "name": "reldebug",
+      "configurePreset": "reldebug",
+      "inherits": "release"
+    },
     {
       "name": "sanitize",
       "configurePreset": "sanitize",

CODEOWNERS

@@ -7,8 +7,9 @@
 /.github/ @kim-em
 /RELEASES.md @kim-em
 /src/kernel/ @leodemoura
+/src/library/compiler/ @zwarich
 /src/lake/ @tydeu
-/src/Lean/Compiler/ @leodemoura
+/src/Lean/Compiler/ @leodemoura @zwarich
 /src/Lean/Data/Lsp/ @mhuisi
 /src/Lean/Elab/Deriving/ @kim-em
 /src/Lean/Elab/Tactic/ @kim-em

README.md

@@ -2,20 +2,19 @@ This is the repository for **Lean 4**.
 
 # About
 
-- [Quickstart](https://lean-lang.org/lean4/doc/quickstart.html)
+- [Quickstart](https://lean-lang.org/documentation/setup/)
 - [Homepage](https://lean-lang.org)
 - [Theorem Proving Tutorial](https://lean-lang.org/theorem_proving_in_lean4/)
 - [Functional Programming in Lean](https://lean-lang.org/functional_programming_in_lean/)
-- [Documentation Overview](https://lean-lang.org/lean4/doc/)
+- [Documentation Overview](https://lean-lang.org/documentation/)
 - [Language Reference](https://lean-lang.org/doc/reference/latest/)
 - [Release notes](RELEASES.md) starting at v4.0.0-m3
-- [Examples](https://lean-lang.org/lean4/doc/examples.html)
+- [Examples](https://lean-lang.org/documentation/examples/)
 - [External Contribution Guidelines](CONTRIBUTING.md)
-- [FAQ](https://lean-lang.org/lean4/doc/faq.html)
 
 # Installation
 
-See [Setting Up Lean](https://lean-lang.org/lean4/doc/setup.html).
+See [Setting Up Lean](https://lean-lang.org/documentation/setup/).
 
 # Contributing
 
@@ -23,4 +22,4 @@ Please read our [Contribution Guidelines](CONTRIBUTING.md) first.
 
 # Building from Source
 
-See [Building Lean](https://lean-lang.org/lean4/doc/make/index.html) (documentation source: [doc/make/index.md](doc/make/index.md)).
+See [Building Lean](doc/make/index.md).

RELEASES.md

@@ -4,9 +4,6 @@ We intend to provide regular "minor version" releases of the Lean language at ap
 There is not yet a strong guarantee of backwards compatibility between versions,
 only an expectation that breaking changes will be documented in the release notes.
 
-The folder [releases/](https://github.com/leanprover/lean4/tree/master/releases)
-contains work-in-progress notes for the upcoming release, as well as previous stable releases.
-
-Please check the [releases](https://github.com/leanprover/lean4/releases) page for the current status
-of each version.
+[Release notes](https://lean-lang.org/doc/reference/latest/releases/#release-notes) are available in the Lean language reference.
 
+Release notes for the current release candidate are available on the GitHub [releases](https://github.com/leanprover/lean4/releases) page.

doc/README.md

@@ -0,0 +1,10 @@
+# Developer Documentation and Examples
+
+This directory contains documentation that describes how to work on
+Lean itself, as well as examples that are included in documentation
+that's hosted on the Lean website.  The `make` directory contains
+information on building Lean, and the `dev` directory describes how to
+work on Lean.
+
+The [documentation section](https://lean-lang.org/documentation) has
+links to documentation that describes how to use Lean itself.

doc/SUMMARY.md

@@ -1,46 +0,0 @@
-# Summary
-
-- [What is Lean](./whatIsLean.md)
-- [Tour of Lean](./tour.md)
-- [Setting Up Lean](./quickstart.md)
-  - [Extended Setup Notes](./setup.md)
-- [Theorem Proving in Lean](./tpil.md)
-- [Functional Programming in Lean](fplean.md)
-- [Examples](./examples.md)
-  - [Palindromes](examples/palindromes.lean.md)
-  - [Binary Search Trees](examples/bintree.lean.md)
-  - [A Certified Type Checker](examples/tc.lean.md)
-  - [The Well-Typed Interpreter](examples/interp.lean.md)
-  - [Dependent de Bruijn Indices](examples/deBruijn.lean.md)
-  - [Parametric Higher-Order Abstract Syntax](examples/phoas.lean.md)
-  - [Syntax Examples](./syntax_examples.md)
-    - [Balanced Parentheses](./syntax_example.md)
-    - [Arithmetic DSL](./metaprogramming-arith.md)
-
-# Language Manual
-
-- [The Lean Reference Manual](./reference.md)
-
-# Other
-
-- [Frequently Asked Questions](./faq.md)
-- [Significant Changes from Lean 3](./lean3changes.md)
-- [Syntax Highlighting Lean in LaTeX](./syntax_highlight_in_latex.md)
-- [User Widgets](examples/widgets.lean.md)
-- [Semantic Highlighting](./semantic_highlighting.md)
-
-# Development
-
-- [Development Guide](./dev/index.md)
-- [Building Lean](./make/index.md)
-  - [Ubuntu Setup](./make/ubuntu.md)
-  - [macOS Setup](./make/osx-10.9.md)
-  - [Windows MSYS2 Setup](./make/msys2.md)
-  - [Windows with WSL](./make/wsl.md)
-- [Bootstrapping](./dev/bootstrap.md)
-- [Testing](./dev/testing.md)
-- [Debugging](./dev/debugging.md)
-- [Commit Convention](./dev/commit_convention.md)
-- [Release checklist](./dev/release_checklist.md)
-- [Building This Manual](./dev/mdbook.md)
-- [Foreign Function Interface](./dev/ffi.md)

doc/alectryon.css

@@ -1,786 +0,0 @@
-@charset "UTF-8";
-/*
-Copyright © 2019 Clément Pit-Claudel
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/
-
-/*******************************/
-/* CSS reset for .alectryon-io */
-/*******************************/
-
-.content {
-    /*
-    Use `initial` instead of `contents` to avoid a browser bug which removes
-    the element from the accessibility tree.
-    https://developer.mozilla.org/en-US/docs/Web/CSS/display#display_contents
-     */
-    display: initial;
-}
-
-.alectryon-io blockquote {
-    line-height: inherit;
-}
-
-.alectryon-io blockquote:after {
-    display: none;
-}
-
-.alectryon-io label {
-    display: inline;
-    font-size: inherit;
-    margin: 0;
-}
-
-.alectryon-io a {
-    text-decoration: none !important;
-    font-style: oblique !important;
-    color: unset;
-}
-
-/* Undo <small> and <blockquote>, added to improve RSS rendering. */
-
-.alectryon-io small.alectryon-output,
-.alectryon-io small.alectryon-type-info {
-    font-size: inherit;
-}
-
-.alectryon-io blockquote.alectryon-goal,
-.alectryon-io blockquote.alectryon-message {
-    font-weight: normal;
-    font-size: inherit;
-}
-
-/***************/
-/* Main styles */
-/***************/
-
-.alectryon-coqdoc .doc .code,
-.alectryon-coqdoc .doc .comment,
-.alectryon-coqdoc .doc .inlinecode,
-.alectryon-mref,
-.alectryon-block, .alectryon-io,
-.alectryon-toggle-label, .alectryon-banner {
-    font-family: "Source Code Pro", Consolas, "Ubuntu Mono", Menlo, "DejaVu Sans Mono", monospace, monospace !important;
-    font-size: 0.875em;
-    font-feature-settings: "COQX" 1 /* Coq ligatures */, "XV00" 1 /* Legacy */, "calt" 1 /* Fallback */;
-    line-height: initial;
-}
-
-.alectryon-io, .alectryon-block, .alectryon-toggle-label, .alectryon-banner {
-    overflow: visible;
-    overflow-wrap: break-word;
-    position: relative;
-    white-space: pre-wrap;
-}
-
-/*
-CoqIDE doesn't turn off the unicode bidirectional algorithm (and PG simply
-respects the user's `bidi-display-reordering` setting), so don't turn it off
-here either.  But beware unexpected results like `Definition test_אב := 0.`
-
-.alectryon-io span {
-    direction: ltr;
-    unicode-bidi: bidi-override;
-}
-
-In any case, make an exception for comments:
-
-.highlight .c {
-    direction: embed;
-    unicode-bidi: initial;
-}
-*/
-
-.alectryon-mref,
-.alectryon-mref-marker {
-    align-self: center;
-    box-sizing: border-box;
-    display: inline-block;
-    font-size: 80%;
-    font-weight: bold;
-    line-height: 1;
-    box-shadow: 0 0 0 1pt black;
-    padding: 1pt 0.3em;
-    text-decoration: none;
-}
-
-.alectryon-block .alectryon-mref-marker,
-.alectryon-io .alectryon-mref-marker {
-    user-select: none;
-    margin: -0.25em 0 -0.25em 0.5em;
-}
-
-.alectryon-inline .alectryon-mref-marker {
-    margin: -0.25em 0.15em -0.25em 0.625em; /* 625 = 0.5em / 80% */
-}
-
-.alectryon-mref {
-    color: inherit;
-    margin: -0.5em 0.25em;
-}
-
-.alectryon-goal:target .goal-separator .alectryon-mref-marker,
-:target > .alectryon-mref-marker {
-    animation: blink 0.2s step-start 0s 3 normal none;
-    background-color: #fcaf3e;
-    position: relative;
-}
-
-@keyframes blink {
-    50% {
-        box-shadow: 0 0 0 3pt #fcaf3e, 0 0 0 4pt black;
-        z-index: 10;
-    }
-}
-
-.alectryon-toggle,
-.alectryon-io .alectryon-extra-goal-toggle {
-    display: none;
-}
-
-.alectryon-bubble,
-.alectryon-io label,
-.alectryon-toggle-label {
-    cursor: pointer;
-}
-
-.alectryon-toggle-label {
-    display: block;
-    font-size: 0.8em;
-}
-
-.alectryon-io .alectryon-input {
-    padding: 0.1em 0; /* Enlarge the hitbox slightly to fill interline gaps */
-}
-
-.alectryon-io .alectryon-token {
-    white-space: pre-wrap;
-    display: inline;
-}
-
-.alectryon-io .alectryon-sentence.alectryon-target .alectryon-input {
-    /* FIXME if keywords were ‘bolder’ we wouldn't need !important */
-    font-weight: bold !important; /* Use !important to avoid a * selector */
-}
-
-.alectryon-bubble:before,
-.alectryon-toggle-label:before,
-.alectryon-io label.alectryon-input:after,
-.alectryon-io .alectryon-goal > label:before {
-    border: 1px solid #babdb6;
-    border-radius: 1em;
-    box-sizing: border-box;
-    content: '';
-    display: inline-block;
-    font-weight: bold;
-    height: 0.25em;
-    margin-bottom: 0.15em;
-    vertical-align: middle;
-    width: 0.75em;
-}
-
-.alectryon-toggle-label:before,
-.alectryon-io .alectryon-goal > label:before {
-    margin-right: 0.25em;
-}
-
-.alectryon-io .alectryon-goal > label:before {
-    margin-top: 0.125em;
-}
-
-.alectryon-io label.alectryon-input {
-    padding-right: 1em; /* Prevent line wraps before the checkbox bubble */
-}
-
-.alectryon-io label.alectryon-input:after {
-    margin-left: 0.25em;
-    margin-right: -1em; /* Compensate for the anti-wrapping space */
-}
-
-.alectryon-failed {
-    /* Underlines are broken in Chrome (they reset at each element boundary)… */
-    /* text-decoration: red wavy underline; */
-    /* … but it isn't too noticeable with dots */
-    text-decoration: red dotted underline;
-    text-decoration-skip-ink: none;
-    /* Chrome prints background images in low resolution, yielding a blurry underline */
-    /* background: bottom / 0.3em auto repeat-x url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyLjY0NiAxLjg1MiIgaGVpZ2h0PSI4IiB3aWR0aD0iMTAiPjxwYXRoIGQ9Ik0wIC4yNjVjLjc5NCAwIC41MyAxLjMyMiAxLjMyMyAxLjMyMi43OTQgMCAuNTMtMS4zMjIgMS4zMjMtMS4zMjIiIGZpbGw9Im5vbmUiIHN0cm9rZT0icmVkIiBzdHJva2Utd2lkdGg9Ii41MjkiLz48L3N2Zz4=); */
-}
-
-/* Wrapping :hover rules in a media query ensures that tapping a Coq sentence
-   doesn't trigger its :hover state (otherwise, on mobile, tapping a sentence to
-   hide its output causes it to remain visible (its :hover state gets triggered.
-   We only do it for the default style though, since other styles don't put the
-   output over the main text, so showing too much is not an issue. */
-@media (any-hover: hover) {
-    .alectryon-bubble:hover:before,
-    .alectryon-toggle-label:hover:before,
-    .alectryon-io label.alectryon-input:hover:after {
-        background: #eeeeec;
-    }
-
-    .alectryon-io label.alectryon-input:hover {
-        text-decoration: underline dotted #babdb6;
-	    text-shadow: 0 0 1px rgb(46, 52, 54, 0.3); /* #2e3436 + opacity */
-    }
-
-    .alectryon-io .alectryon-sentence:hover .alectryon-output,
-    .alectryon-io .alectryon-token:hover .alectryon-type-info-wrapper,
-    .alectryon-io .alectryon-token:hover .alectryon-type-info-wrapper {
-        z-index: 2; /* Place hovered goals above .alectryon-sentence.alectryon-target ones */
-    }
-}
-
-.alectryon-toggle:checked + .alectryon-toggle-label:before,
-.alectryon-io .alectryon-sentence > .alectryon-toggle:checked + label.alectryon-input:after,
-.alectryon-io .alectryon-extra-goal-toggle:checked + .alectryon-goal > label:before {
-    background-color: #babdb6;
-    border-color: #babdb6;
-}
-
-/* Disable clicks on sentences when the document-wide toggle is set. */
-.alectryon-toggle:checked + label + .alectryon-container label.alectryon-input {
-    cursor: unset;
-    pointer-events: none;
-}
-
-/* Hide individual checkboxes when the document-wide toggle is set. */
-.alectryon-toggle:checked + label + .alectryon-container label.alectryon-input:after {
-    display: none;
-}
-
-/* .alectryon-output is displayed by toggles, :hover, and .alectryon-target rules */
-.alectryon-io .alectryon-output {
-    box-sizing: border-box;
-    display: none;
-    left: 0;
-    right: 0;
-    position: absolute;
-    padding: 0.25em 0;
-    overflow: visible; /* Let box-shadows overflow */
-    z-index: 1; /* Default to an index lower than that used by :hover */
-}
-
-.alectryon-io .alectryon-type-info-wrapper {
-    position: absolute;
-    display: inline-block;
-    width: 100%;
-}
-
-.alectryon-io .alectryon-type-info-wrapper.full-width {
-    left: 0;
-    min-width: 100%;
-    max-width: 100%;
-}
-
-.alectryon-io .alectryon-type-info .goal-separator {
-    height: unset;
-    margin-top: 0em;
-}
-
-.alectryon-io .alectryon-type-info-wrapper .alectryon-type-info {
-    box-sizing: border-box;
-    bottom: 100%;
-    position: absolute;
-    /*padding: 0.25em 0;*/
-    visibility: hidden;
-    overflow: visible; /* Let box-shadows overflow */
-    z-index: 1; /* Default to an index lower than that used by :hover */
-    white-space: pre-wrap !important;
-}
-
-.alectryon-io .alectryon-type-info-wrapper .alectryon-type-info .alectryon-goal.alectryon-docstring {
-    white-space: pre-wrap !important;
-}
-
-@media (any-hover: hover) { /* See note above about this @media query */
-    .alectryon-io .alectryon-sentence:hover .alectryon-output:not(:hover) {
-        display: block;
-    }
-
-    .alectryon-io.output-hidden .alectryon-sentence:hover .alectryon-output:not(:hover) {
-        display: none !important;
-    }
-
-    .alectryon-io.type-info-hidden .alectryon-token:hover .alectryon-type-info-wrapper .alectryon-type-info,
-    .alectryon-io.type-info-hidden .alectryon-token:hover .alectryon-type-info-wrapper .alectryon-type-info {
-        /*visibility: hidden !important;*/
-    }
-
-    .alectryon-io .alectryon-token:hover .alectryon-type-info-wrapper .alectryon-type-info,
-    .alectryon-io .alectryon-token:hover .alectryon-type-info-wrapper .alectryon-type-info {
-        visibility: visible;
-        transition-delay: 0.5s;
-    }
-}
-
-.alectryon-io .alectryon-sentence.alectryon-target .alectryon-output {
-    display: block;
-}
-
-/* Indicate active (hovered or targeted) goals with a shadow. */
-.alectryon-io .alectryon-sentence:hover .alectryon-output:not(:hover) .alectryon-messages,
-.alectryon-io .alectryon-sentence.alectryon-target .alectryon-output  .alectryon-messages,
-.alectryon-io .alectryon-sentence:hover .alectryon-output:not(:hover) .alectryon-goals,
-.alectryon-io .alectryon-sentence.alectryon-target .alectryon-output  .alectryon-goals,
-.alectryon-io .alectryon-token:hover .alectryon-type-info-wrapper .alectryon-type-info {
-    box-shadow: 2px 2px 2px gray;
-}
-
-.alectryon-io .alectryon-extra-goals .alectryon-goal .goal-hyps {
-    display: none;
-}
-
-.alectryon-io .alectryon-extra-goals .alectryon-extra-goal-toggle:not(:checked) + .alectryon-goal label.goal-separator hr {
-    /* Dashes indicate that the hypotheses are hidden */
-    border-top-style: dashed;
-}
-
-
-/* Show just a small preview of the other goals; this is undone by the
-   "extra-goal" toggle and by :hover and .alectryon-target in windowed mode. */
-.alectryon-io .alectryon-extra-goals .alectryon-goal .goal-conclusion {
-    max-height: 5.2em;
-    overflow-y: auto;
-    /* Combining ‘overflow-y: auto’ with ‘display: inline-block’ causes extra space
-       to be added below the box. ‘vertical-align: middle’ gets rid of it. */
-    vertical-align: middle;
-}
-
-.alectryon-io .alectryon-goals,
-.alectryon-io .alectryon-messages {
-    background: #f6f7f6;
-	/*border: thin solid #d3d7cf; /* Convenient when pre's background is already #EEE */
-    display: block;
-    padding: 0.25em;
-}
-
-.alectryon-message::before {
-    content: '';
-    float: right;
-    /* etc/svg/square-bubble-xl.svg */
-    background: url("data:image/svg+xml,%3Csvg width='14' height='14' viewBox='0 0 3.704 3.704' xmlns='http://www.w3.org/2000/svg'%3E%3Cg fill-rule='evenodd' stroke='%23000' stroke-width='.264'%3E%3Cpath d='M.794.934h2.115M.794 1.463h1.455M.794 1.992h1.852'/%3E%3C/g%3E%3Cpath d='M.132.14v2.646h.794v.661l.926-.661h1.72V.14z' fill='none' stroke='%23000' stroke-width='.265'/%3E%3C/svg%3E") top right no-repeat;
-    height: 14px;
-    width: 14px;
-}
-
-.alectryon-toggle:checked + label + .alectryon-container {
-    width: unset;
-}
-
-/* Show goals when a toggle is set */
-.alectryon-toggle:checked + label + .alectryon-container label.alectryon-input + .alectryon-output,
-.alectryon-io .alectryon-sentence > .alectryon-toggle:checked ~ .alectryon-output {
-    display: block;
-    position: static;
-    width: unset;
-    background: unset; /* Override the backgrounds set in floating in windowed mode */
-    padding: 0.25em 0; /* Re-assert so that later :hover rules don't override this padding */
-}
-
-.alectryon-toggle:checked + label + .alectryon-container label.alectryon-input + .alectryon-output .goal-hyps,
-.alectryon-io .alectryon-sentence > .alectryon-toggle:checked ~ .alectryon-output .goal-hyps {
-    /* Overridden back in windowed style */
-    flex-flow: row wrap;
-    justify-content: flex-start;
-}
-
-.alectryon-toggle:checked + label + .alectryon-container .alectryon-sentence .alectryon-output > div,
-.alectryon-io .alectryon-sentence > .alectryon-toggle:checked ~ .alectryon-output > div {
-    display: block;
-}
-
-.alectryon-io .alectryon-extra-goal-toggle:checked + .alectryon-goal .goal-hyps {
-    display: flex;
-}
-
-.alectryon-io .alectryon-extra-goal-toggle:checked + .alectryon-goal .goal-conclusion {
-    max-height: unset;
-    overflow-y: unset;
-}
-
-.alectryon-toggle:checked + label + .alectryon-container .alectryon-sentence > .alectryon-toggle ~ .alectryon-wsp,
-.alectryon-io .alectryon-sentence > .alectryon-toggle:checked ~ .alectryon-wsp {
-    display: none;
-}
-
-.alectryon-io .alectryon-messages,
-.alectryon-io .alectryon-message,
-.alectryon-io .alectryon-goals,
-.alectryon-io .alectryon-goal,
-.alectryon-io .goal-hyps > span,
-.alectryon-io .goal-conclusion {
-    border-radius: 0.15em;
-}
-
-.alectryon-io .alectryon-goal,
-.alectryon-io .alectryon-message {
-    align-items: center;
-    background: #f6f7f6;
-    border: 0em;
-    display: block;
-    flex-direction: column;
-    margin: 0.25em;
-    padding: 0.5em;
-    position: relative;
-}
-
-.alectryon-io .goal-hyps {
-    align-content: space-around;
-    align-items: baseline;
-    display: flex;
-    flex-flow: column nowrap; /* re-stated in windowed mode */
-    justify-content: space-around;
-    /* LATER use a ‘gap’ property instead of margins once supported */
-    margin: -0.15em -0.25em; /* -0.15em to cancel the item spacing */
-    padding-bottom: 0.35em; /* 0.5em-0.15em to cancel the 0.5em of .goal-separator */
-}
-
-.alectryon-io .goal-hyps > br {
-    display: none; /* Only for RSS readers */
-}
-
-.alectryon-io .goal-hyps > span,
-.alectryon-io .goal-conclusion {
-    /*background: #eeeeec;*/
-    display: inline-block;
-    padding: 0.15em 0.35em;
-}
-
-.alectryon-io .goal-hyps > span {
-    align-items: baseline;
-    display: inline-flex;
-    margin: 0.15em 0.25em;
-}
-
-.alectryon-block var,
-.alectryon-inline var,
-.alectryon-io .goal-hyps > span > var {
-    font-weight: 600;
-    font-style: unset;
-}
-
-.alectryon-io .goal-hyps > span > var {
-    /* Shrink the list of names, but let it grow as long as space is available. */
-    flex-basis: min-content;
-    flex-grow: 1;
-}
-
-.alectryon-io .goal-hyps > span b {
-    font-weight: 600;
-    margin: 0 0 0 0.5em;
-    white-space: pre;
-}
-
-.alectryon-io .hyp-body,
-.alectryon-io .hyp-type {
-    display: flex;
-    align-items: baseline;
-}
-
-.alectryon-io .goal-separator {
-    align-items: center;
-    display: flex;
-    flex-direction: row;
-    height: 1em; /* Fixed height to ignore goal name and markers */
-    margin-top: -0.5em; /* Compensated in .goal-hyps when shown */
-}
-
-.alectryon-io .goal-separator hr {
-    border: none;
-    border-top: thin solid #555753;
-    display: block;
-    flex-grow: 1;
-    margin: 0;
-}
-
-.alectryon-io .goal-separator .goal-name {
-    font-size: 0.75em;
-    margin-left: 0.5em;
-}
-
-/**********/
-/* Banner */
-/**********/
-
-.alectryon-banner {
-    background: #eeeeec;
-    border: 1px solid #babcbd;
-    font-size: 0.75em;
-    padding: 0.25em;
-    text-align: center;
-    margin: 1em 0;
-}
-
-.alectryon-banner a {
-    cursor: pointer;
-    text-decoration: underline;
-}
-
-.alectryon-banner kbd {
-    background: #d3d7cf;
-    border-radius: 0.15em;
-    border: 1px solid #babdb6;
-    box-sizing: border-box;
-    display: inline-block;
-    font-family: inherit;
-    font-size: 0.9em;
-    height: 1.3em;
-    line-height: 1.2em;
-    margin: -0.25em 0;
-    padding: 0 0.25em;
-    vertical-align: middle;
-}
-
-/**********/
-/* Toggle */
-/**********/
-
-.alectryon-toggle-label {
-    margin: 1rem 0;
-}
-
-/******************/
-/* Floating style */
-/******************/
-
-/* If there's space, display goals to the right of the code, not below it. */
-@media (min-width: 80rem) {
-    /* Unlike the windowed case, we don't want to move output blocks to the side
-       when they are both :checked and -targeted, since it gets confusing as
-       things jump around; hence the commented-output part of the selector,
-       which would otherwise increase specificity */
-    .alectryon-floating .alectryon-sentence.alectryon-target /* > .alectryon-toggle ~ */ .alectryon-output,
-    .alectryon-floating .alectryon-sentence:hover .alectryon-output {
-        top: 0;
-        left: 100%;
-        right: -100%;
-        padding: 0 0.5em;
-        position:  absolute;
-    }
-
-    .alectryon-floating .alectryon-output {
-        min-height: 100%;
-    }
-
-    .alectryon-floating .alectryon-sentence:hover .alectryon-output {
-        background: white; /* Ensure that short goals hide long ones */
-    }
-
-    /* This odd margin-bottom property prevents the sticky div from bumping
-       against the bottom of its container (.alectryon-output).  The alternative
-       would be enlarging .alectryon-output, but that would cause overflows,
-       enlarging scrollbars and yielding scrolling towards the bottom of the
-       page.  Doing things this way instead makes it possible to restrict
-       .alectryon-output to a reasonable size (100%, through top = bottom = 0).
-       See also https://stackoverflow.com/questions/43909940/. */
-    /* See note on specificity above */
-    .alectryon-floating .alectryon-sentence.alectryon-target /* > .alectryon-toggle ~ */ .alectryon-output > div,
-    .alectryon-floating .alectryon-sentence:hover .alectryon-output > div {
-        margin-bottom: -200%;
-        position: sticky;
-        top: 0;
-    }
-
-    .alectryon-floating .alectryon-toggle:checked + label + .alectryon-container .alectryon-sentence .alectryon-output > div,
-    .alectryon-floating .alectryon-io .alectryon-sentence > .alectryon-toggle:checked ~ .alectryon-output > div {
-        margin-bottom: unset; /* Undo the margin */
-    }
-
-    /* Float underneath the current fragment
-    @media (max-width: 80rem) {
-        .alectryon-floating .alectryon-output {
-            top: 100%;
-        }
-    } */
-}
-
-/********************/
-/* Multi-pane style */
-/********************/
-
-.alectryon-windowed {
-    border: 0 solid #2e3436;
-    box-sizing: border-box;
-}
-
-.alectryon-windowed .alectryon-sentence:hover .alectryon-output {
-    background: white; /* Ensure that short goals hide long ones */
-}
-
-.alectryon-windowed .alectryon-output {
-    position: fixed; /* Overwritten by the ‘:checked’ rules */
-}
-
-/* See note about specificity below */
-.alectryon-windowed .alectryon-sentence:hover .alectryon-output,
-.alectryon-windowed .alectryon-sentence.alectryon-target > .alectryon-toggle ~ .alectryon-output {
-    padding: 0.5em;
-    overflow-y: auto; /* Windowed contents may need to scroll */
-}
-
-.alectryon-windowed .alectryon-io .alectryon-sentence:hover .alectryon-output:not(:hover) .alectryon-messages,
-.alectryon-windowed .alectryon-io .alectryon-sentence.alectryon-target .alectryon-output  .alectryon-messages,
-.alectryon-windowed .alectryon-io .alectryon-sentence:hover .alectryon-output:not(:hover) .alectryon-goals,
-.alectryon-windowed .alectryon-io .alectryon-sentence.alectryon-target .alectryon-output  .alectryon-goals {
-    box-shadow: none; /* A shadow is unnecessary here and incompatible with overflow-y set to auto */
-}
-
-.alectryon-windowed .alectryon-io .alectryon-sentence.alectryon-target .alectryon-output .goal-hyps {
-    /* Restated to override the :checked style */
-    flex-flow: column nowrap;
-    justify-content: space-around;
-}
-
-
-.alectryon-windowed .alectryon-sentence.alectryon-target .alectryon-extra-goals .alectryon-goal .goal-conclusion
-/* Like .alectryon-io .alectryon-extra-goal-toggle:checked + .alectryon-goal .goal-conclusion */ {
-    max-height: unset;
-    overflow-y: unset;
-}
-
-.alectryon-windowed .alectryon-output > div {
-    display: flex; /* Put messages after goals */
-    flex-direction: column-reverse;
-}
-
-/*********************/
-/* Standalone styles */
-/*********************/
-
-.alectryon-standalone {
-    font-family: 'IBM Plex Serif', 'PT Serif', 'Merriweather', 'DejaVu Serif', serif;
-    line-height: 1.5;
-}
-
-@media screen and (min-width: 50rem) {
-    html.alectryon-standalone {
-        /* Prevent flickering when hovering a block causes scrollbars to appear. */
-        margin-left: calc(100vw - 100%);
-        margin-right: 0;
-    }
-}
-
-/* Coqdoc */
-
-.alectryon-coqdoc .doc .code,
-.alectryon-coqdoc .doc .inlinecode,
-.alectryon-coqdoc .doc .comment {
-    display: inline;
-}
-
-.alectryon-coqdoc .doc .comment {
-    color: #eeeeec;
-}
-
-.alectryon-coqdoc .doc .paragraph {
-    height: 0.75em;
-}
-
-/* Centered, Floating */
-
-.alectryon-standalone .alectryon-centered,
-.alectryon-standalone .alectryon-floating {
-    max-width: 50rem;
-    margin: auto;
-}
-
-@media (min-width: 80rem) {
-    .alectryon-standalone .alectryon-floating {
-        max-width: 80rem;
-    }
-
-    .alectryon-standalone .alectryon-floating > * {
-        width: 50%;
-        margin-left: 0;
-    }
-}
-
-/* Windowed */
-
-.alectryon-standalone .alectryon-windowed {
-    display: block;
-    margin: 0;
-    overflow-y: auto;
-    position: absolute;
-    padding: 0 1em;
-}
-
-.alectryon-standalone .alectryon-windowed > * {
-    /* Override properties of docutils_basic.css */
-    margin-left: 0;
-    max-width: unset;
-}
-
-.alectryon-standalone .alectryon-windowed .alectryon-io {
-    box-sizing: border-box;
-    width: 100%;
-}
-
-/* No need to predicate the ‘:hover’ rules below on ‘:not(:checked)’, since ‘left’,
-   ‘right’, ‘top’, and ‘bottom’ will be inactived by the :checked rules setting
-   ‘position’ to ‘static’ */
-
-
-/* Specificity: We want the output to stay inline when hovered while unfolded
-   (:checked), but we want it to move when it's targeted (i.e. when the user
-   is browsing goals one by one using the keyboard, in which case we want to
-   goals to appear in consistent locations).  The selectors below ensure
-   that :hover < :checked < -targeted in terms of specificity. */
-/* LATER: Reimplement this stuff with CSS variables */
-.alectryon-windowed .alectryon-sentence.alectryon-target > .alectryon-toggle ~ .alectryon-output {
-    position: fixed;
-}
-
-@media screen and (min-width: 60rem) {
-    .alectryon-standalone .alectryon-windowed {
-        border-right-width: thin;
-        bottom: 0;
-        left: 0;
-        right: 50%;
-        top: 0;
-    }
-
-    .alectryon-standalone .alectryon-windowed .alectryon-sentence:hover .alectryon-output,
-    .alectryon-standalone .alectryon-windowed .alectryon-sentence.alectryon-target .alectryon-output {
-        bottom: 0;
-        left: 50%;
-        right: 0;
-        top: 0;
-    }
-}
-
-@media screen and (max-width: 60rem) {
-    .alectryon-standalone .alectryon-windowed {
-        border-bottom-width: 1px;
-        bottom: 40%;
-        left: 0;
-        right: 0;
-        top: 0;
-    }
-
-    .alectryon-standalone .alectryon-windowed .alectryon-sentence:hover .alectryon-output,
-    .alectryon-standalone .alectryon-windowed .alectryon-sentence.alectryon-target .alectryon-output {
-        bottom: 0;
-        left: 0;
-        right: 0;
-        top: 60%;
-    }
-}

doc/alectryon.js

@@ -1,190 +0,0 @@
-var Alectryon;
-(function(Alectryon) {
-    (function (slideshow) {
-        function anchor(sentence) { return "#" + sentence.id; }
-
-        function current_sentence() { return slideshow.sentences[slideshow.pos]; }
-
-        function unhighlight() {
-            var sentence = current_sentence();
-            if (sentence) sentence.classList.remove("alectryon-target");
-            slideshow.pos = -1;
-        }
-
-        function highlight(sentence) {
-            sentence.classList.add("alectryon-target");
-        }
-
-        function scroll(sentence) {
-            // Put the top of the current fragment close to the top of the
-            // screen, but scroll it out of view if showing it requires pushing
-            // the sentence past half of the screen.  If sentence is already in
-            // a reasonable position, don't move.
-            var parent = sentence.parentElement;
-            /* We want to scroll the whole document, so start at root… */
-            while (parent && !parent.classList.contains("alectryon-root"))
-                parent = parent.parentElement;
-            /* … and work up from there to find a scrollable element.
-               parent.scrollHeight can be greater than parent.clientHeight
-               without showing scrollbars, so we add a 10px buffer. */
-            while (parent && parent.scrollHeight <= parent.clientHeight + 10)
-                parent = parent.parentElement;
-            /* <body> and <html> elements can have their client rect overflow
-             * the window if their height is unset, so scroll the window
-             * instead */
-            if (parent && (parent.nodeName == "BODY" || parent.nodeName == "HTML"))
-                parent = null;
-
-            var rect = function(e) { return e.getBoundingClientRect(); };
-            var parent_box = parent ? rect(parent) : { y: 0, height: window.innerHeight },
-                sentence_y = rect(sentence).y - parent_box.y,
-                fragment_y = rect(sentence.parentElement).y - parent_box.y;
-
-            // The assertion below sometimes fails for the first element in a block.
-            // console.assert(sentence_y >= fragment_y);
-
-            if (sentence_y < 0.1 * parent_box.height ||
-                sentence_y > 0.7 * parent_box.height) {
-                (parent || window).scrollBy(
-                    0, Math.max(sentence_y - 0.5 * parent_box.height,
-                                fragment_y - 0.1 * parent_box.height));
-            }
-        }
-
-        function highlighted(pos) {
-            return slideshow.pos == pos;
-        }
-
-        function navigate(pos, inhibitScroll) {
-            unhighlight();
-            slideshow.pos = Math.min(Math.max(pos, 0), slideshow.sentences.length - 1);
-            var sentence = current_sentence();
-            highlight(sentence);
-            if (!inhibitScroll)
-                scroll(sentence);
-        }
-
-        var keys = {
-            PAGE_UP: 33,
-            PAGE_DOWN: 34,
-            ARROW_UP: 38,
-            ARROW_DOWN: 40,
-            h: 72, l: 76, p: 80, n: 78
-        };
-
-        function onkeydown(e) {
-            e = e || window.event;
-            if (e.ctrlKey || e.metaKey) {
-                if (e.keyCode == keys.ARROW_UP)
-                    slideshow.previous();
-                else if (e.keyCode == keys.ARROW_DOWN)
-                    slideshow.next();
-                else
-                    return;
-            } else {
-                // if (e.keyCode == keys.PAGE_UP || e.keyCode == keys.p || e.keyCode == keys.h)
-                //     slideshow.previous();
-                // else if (e.keyCode == keys.PAGE_DOWN || e.keyCode == keys.n || e.keyCode == keys.l)
-                //     slideshow.next();
-                // else
-                return;
-            }
-            e.preventDefault();
-        }
-
-        function start() {
-            slideshow.navigate(0);
-        }
-
-        function toggleHighlight(idx) {
-            if (highlighted(idx))
-                unhighlight();
-            else
-                navigate(idx, true);
-        }
-
-        function handleClick(evt) {
-            if (evt.ctrlKey || evt.metaKey) {
-                var sentence = evt.currentTarget;
-
-                // Ensure that the goal is shown on the side, not inline
-                var checkbox = sentence.getElementsByClassName("alectryon-toggle")[0];
-                if (checkbox)
-                    checkbox.checked = false;
-
-                toggleHighlight(sentence.alectryon_index);
-                evt.preventDefault();
-            }
-        }
-
-        function init() {
-            document.onkeydown = onkeydown;
-            slideshow.pos = -1;
-            slideshow.sentences = Array.from(document.getElementsByClassName("alectryon-sentence"));
-            slideshow.sentences.forEach(function (s, idx) {
-                s.addEventListener('click', handleClick, false);
-                s.alectryon_index = idx;
-            });
-        }
-
-        slideshow.start = start;
-        slideshow.end = unhighlight;
-        slideshow.navigate = navigate;
-        slideshow.next = function() { navigate(slideshow.pos + 1); };
-        slideshow.previous = function() { navigate(slideshow.pos + -1); };
-        window.addEventListener('DOMContentLoaded', init);
-    })(Alectryon.slideshow || (Alectryon.slideshow = {}));
-
-    (function (styles) {
-        var styleNames = ["centered", "floating", "windowed"];
-
-        function className(style) {
-            return "alectryon-" + style;
-        }
-
-        function setStyle(style) {
-            var root = document.getElementsByClassName("alectryon-root")[0];
-            styleNames.forEach(function (s) {
-                root.classList.remove(className(s)); });
-            root.classList.add(className(style));
-        }
-
-        function init() {
-            var banner = document.getElementsByClassName("alectryon-banner")[0];
-            if (banner) {
-                banner.append(" Style: ");
-                styleNames.forEach(function (styleName, idx) {
-                    var s = styleName;
-                    var a = document.createElement("a");
-                    a.onclick = function() { setStyle(s); };
-                    a.append(styleName);
-                    if (idx > 0) banner.append("; ");
-                    banner.appendChild(a);
-                });
-                banner.append(".");
-            }
-        }
-
-        window.addEventListener('DOMContentLoaded', init);
-
-        styles.setStyle = setStyle;
-    })(Alectryon.styles || (Alectryon.styles = {}));
-})(Alectryon || (Alectryon = {}));
-
-function setHidden(elements, isVisible, token) {
-    for (let i = 0; i < elements.length; i++) {
-        if (isVisible) {
-            elements[i].classList.remove(token)
-        } else {
-            elements[i].classList.add(token)
-        }
-    }
-}
-
-function toggleShowTypes(checkbox) {
-    setHidden(document.getElementsByClassName("alectryon-io"), checkbox.checked, "type-info-hidden")
-}
-
-function toggleShowGoals(checkbox) {
-    setHidden(document.getElementsByClassName("alectryon-io"), checkbox.checked, "output-hidden")
-}

doc/bin/README.md

@@ -1,14 +0,0 @@
-Lean binary distribution
-------------------------
-
-The binary distribution package contains:
-
-- Lean executable (located in the sub-directory bin)
-- Standard library (located in the sub-directory lib/lean/library)
-
-Assuming you are in the same directory this file is located,
-the following command executes a simple set of examples
-
-% bin/lean examples/ex.lean
-
-For more information on Lean and supported editors, please see https://lean-lang.org/documentation/.

doc/book.toml

@@ -1,21 +0,0 @@
-[book]
-authors = ["Leonardo de Moura", "Sebastian Ullrich"]
-language = "en"
-multilingual = false
-src = "."
-title = "Lean Documentation Overview"
-
-[build]
-build-dir = "out"
-
-[output.html]
-git-repository-url = "https://github.com/leanprover/lean4"
-additional-css = ["alectryon.css", "pygments.css"]
-additional-js = ["alectryon.js"]
-
-[output.html.fold]
-enable = true
-level = 0
-
-[output.html.playground.boring-prefixes]
-lean = "# "

doc/bool.md

@@ -1 +0,0 @@
-# Booleans

doc/declarations.md

@@ -1,885 +0,0 @@
-# Declarations
-
--- TODO (fix)
-
-Declaration Names
-=================
-
-A declaration name is a hierarchical [identifier](lexical_structure.md#identifiers) that is interpreted relative to the current namespace as well as (during lookup) to the set of open namespaces.
-
-```lean
-namespace A
-  opaque B.c : Nat
-  #print B.c -- opaque A.B.c : Nat
-end A
-
-#print A.B.c -- opaque A.B.c : Nat
-open A
-#print B.c -- opaque A.B.c : Nat
-```
-
-Declaration names starting with an underscore are reserved for internal use. Names starting with the special atomic name ``_root_`` are interpreted as absolute names.
-
-```lean
-opaque a : Nat
-namespace A
-  opaque a : Int
-  #print _root_.a -- opaque a : Nat
-  #print A.a      -- opaque A.a : Int
-end A
-```
-
-Contexts and Telescopes
-=======================
-
-When processing user input, Lean first parses text to a raw expression format. It then uses background information and type constants to disambiguate overloaded symbols and infer implicit arguments, resulting in a fully-formed expression. This process is known as *elaboration*.
-
-As hinted in [Expression Syntax](expressions.md#expression_syntax),
-expressions are parsed and elaborated with respect to an *environment*
-and a *local context*. Roughly speaking, an environment represents the
-state of Lean at the point where an expression is parsed, including
-previously declared axioms, constants, definitions, and theorems. In a
-given environment, a *local context* consists of a sequence ``(a₁ :
-α₁) (a₂ : α₂) ... (aₙ : αₙ)`` where each ``aᵢ`` is a name denoting a
-local constant and each ``αᵢ`` is an expression of type ``Sort u`` for
-some ``u`` which can involve elements of the environment and the local
-constants ``aⱼ`` for ``j < i``.
-
-Intuitively, a local context is a list of variables that are held constant while an expression is being elaborated. Consider the following
-
-```lean
-def f (a b : Nat) : Nat → Nat := fun c => a + (b + c)
-```
-
-Here the expression ``fun c => a + (b + c)`` is elaborated in the context ``(a : Nat) (b : Nat)`` and the expression ``a + (b + c)`` is elaborated in the context ``(a : Nat) (b : Nat) (c : Nat)``. If you replace the expression ``a + (b + c)`` with an underscore, the error message from Lean will include the current *goal*:
-
-```
-a b c : Nat
-⊢ Nat
-```
-
-Here ``a b c : Nat`` indicates the local context, and the second ``Nat`` indicates the expected type of the result.
-
-A *context* is sometimes called a *telescope*, but the latter is used more generally to include a sequence of declarations occurring relative to a given context. For example, relative to the context ``(a₁ : α₁) (a₂ : α₂) ... (aₙ : αₙ)``, the types ``βᵢ`` in a telescope ``(b₁ : β₁) (b₂ : β₂) ... (bₙ : βₙ)`` can refer to ``a₁, ..., aₙ``. Thus a context can be viewed as a telescope relative to the empty context.
-
-Telescopes are often used to describe a list of arguments, or parameters, to a declaration. In such cases, it is often notationally convenient to let ``(a : α)`` stand for a telescope rather than just a single argument. In general, the annotations described in [Implicit Arguments](expressions.md#implicit_arguments) can be used to mark arguments as implicit.
-
-.. _basic_declarations:
-
-Basic Declarations
-==================
-
-Lean provides ways of adding new objects to the environment. The following provide straightforward ways of declaring new objects:
-
-* ``axiom c : α`` :  declare a constant named ``c`` of type ``α``, it is postulating that `α` is not an empty type.
-* ``def c : α := v`` : defines ``c`` to denote ``v``, which should have type ``α``.
-* ``theorem c : p := v`` : similar to ``def``, but intended to be used when ``p`` is a proposition.
-* ``opaque c : α (:= v)?`` : declares a opaque constant named ``c`` of type ``α``, the optional value `v` is must have type `α`
-  and can be viewed as a certificate that ``α`` is not an empty type. If the value is not provided, Lean tries to find one
-  using a procedure based on type class resolution. The value `v` is hidden from the type checker. You can assume that
-  Lean "forgets" `v` after type checking this kind of declaration.
-
-It is sometimes useful to be able to simulate a definition or theorem without naming it or adding it to the environment.
-
-* ``example : α := t`` : elaborates ``t`` and checks that it has sort ``α`` (often a proposition), without adding it to the environment.
-
-In ``def``, the type (``α`` or ``p``, respectively) can be omitted when it can be inferred by Lean. Constants declared with ``theorem`` are marked as ``irreducible``.
-
-Any of ``def``, ``theorem``, ``axiom``, or ``example`` can take a list of arguments (that is, a context) before the colon. If ``(a : α)`` is a context, the definition ``def foo (a : α) : β := t``
-is interpreted as ``def foo : (a : α) → β := fun a : α => t``. Similarly, a theorem ``theorem foo (a : α) : p := t`` is interpreted as ``theorem foo : ∀ a : α, p := fun a : α => t``.
-
-```lean
-opaque c : Nat
-opaque d : Nat
-axiom cd_eq : c = d
-
-def foo : Nat := 5
-def bar := 6
-def baz (x y : Nat) (s : List Nat) := [x, y] ++ s
-
-theorem foo_eq_five : foo = 5 := rfl
-theorem baz_theorem (x y : Nat) : baz x y [] = [x, y] := rfl
-
-example (x y : Nat) : baz x y [] = [x, y] := rfl
-```
-
-Inductive Types
-===============
-
-Lean's axiomatic foundation allows users to declare arbitrary
-inductive families, following the pattern described by [Dybjer]_. To
-make the presentation more manageable, we first describe inductive
-*types*, and then describe the generalization to inductive *families*
-in the next section. The declaration of an inductive type has the
-following form:
-
-```
-inductive Foo (a : α) where
-  | constructor₁ : (b : β₁) → Foo a
-  | constructor₂ : (b : β₂) → Foo a
-  ...
-  | constructorₙ : (b : βₙ) → Foo a
-```
-
-Here ``(a : α)`` is a context and each ``(b : βᵢ)`` is a telescope in the context ``(a : α)`` together with ``Foo``, subject to the following constraints.
-
-Suppose the telescope ``(b : βᵢ)`` is ``(b₁ : βᵢ₁) ... (bᵤ : βᵢᵤ)``. Each argument in the telescope is either *nonrecursive* or *recursive*.
-
-- An argument ``(bⱼ : βᵢⱼ)`` is *nonrecursive* if ``βᵢⱼ`` does not refer to ``foo,`` the inductive type being defined. In that case, ``βᵢⱼ`` can be any type, so long as it does not refer to any nonrecursive arguments.
-
-- An argument ``(bⱼ : βᵢⱼ)`` is *recursive* if it ``βᵢⱼ`` of the form ``Π (d : δ), foo`` where ``(d : δ)`` is a telescope which does not refer to ``foo`` or any nonrecursive arguments.
-
-The inductive type ``foo`` represents a type that is freely generated by the constructors. Each constructor can take arbitrary data and facts as arguments (the nonrecursive arguments), as well as indexed sequences of elements of ``foo`` that have been previously constructed (the recursive arguments). In set theoretic models, such sets can be represented by well-founded trees labeled by the constructor data, or they can defined using other transfinite or impredicative means.
-
-The declaration of the type ``foo`` as above results in the addition of the following constants to the environment:
-
-- the *type former* ``foo : Π (a : α), Sort u``
-- for each ``i``, the *constructor* ``foo.constructorᵢ : Π (a : α) (b : βᵢ), foo a``
-- the *eliminator* ``foo.rec``, which takes arguments
-
-  + ``(a : α)`` (the parameters)
-  + ``{C : foo a → Type u}`` (the *motive* of the elimination)
-  + for each ``i``, the *minor premise* corresponding to ``constructorᵢ``
-  + ``(x : foo)`` (the *major premise*)
-
-  and returns an element of ``C x``. Here, The ith minor premise is a function which takes
-
-  +  ``(b : βᵢ)`` (the arguments to the constructor)
-  + an argument of type ``Π (d : δ), C (bⱼ d)`` corresponding to each recursive argument ``(bⱼ : βᵢⱼ)``, where ``βᵢⱼ``  is of the form ``Π (d : δ), foo`` (the recursive values of the function being defined)
-
-  and returns an element of ``C (constructorᵢ a b)``, the intended value of the function at ``constructorᵢ a b``.
-
-The eliminator represents a principle of recursion: to construct an element of ``C x`` where ``x : foo a``, it suffices to consider each of the cases where ``x`` is of the form ``constructorᵢ a b`` and to provide an auxiliary construction in each case. In the case where some of the arguments to ``constructorᵢ`` are recursive, we can assume that we have already constructed values of ``C y`` for each value ``y`` constructed at an earlier stage.
-
-Under the propositions-as-type correspondence, when ``C x`` is an element of ``Prop``, the eliminator represents a principle of induction. In order to show ``∀ x, C x``, it suffices to show that ``C`` holds for each constructor, under the inductive hypothesis that it holds for all recursive inputs to the constructor.
-
-The eliminator and constructors satisfy the following identities, in which all the arguments are shown explicitly. Suppose we set ``F := foo.rec a C f₁ ... fₙ``. Then for each constructor, we have the definitional reduction:
-
-```
-F (constructorᵢ a b) = fᵢ b ... (fun d : δᵢⱼ => F (bⱼ d)) ...
-```
-
-where the ellipses include one entry for each recursive argument.
-
-Below are some common examples of inductive types, many of which are defined in the core library.
-
-```lean
-namespace Hide
-universe u v
-
--- BEGIN
-inductive Empty : Type
-
-inductive Unit : Type
-| unit : Unit
-
-inductive Bool : Type
-| false : Bool
-| true : Bool
-
-inductive Prod (α : Type u) (β : Type v) : Type (max u v)
-| mk : α → β → Prod α β
-
-inductive Sum (α : Type u) (β : Type v)
-| inl : α → Sum α β
-| inr : β → Sum α β
-
-inductive Sigma (α : Type u) (β : α → Type v)
-| mk : (a : α) → β a → Sigma α β
-
-inductive false : Prop
-
-inductive True : Prop
-| trivial : True
-
-inductive And (p q : Prop) : Prop
-| intro : p → q → And p q
-
-inductive Or (p q : Prop) : Prop
-| inl : p → Or p q
-| inr : q → Or p q
-
-inductive Exists (α : Type u) (p : α → Prop) : Prop
-| intro : ∀ x : α, p x → Exists α p
-
-inductive Subtype (α : Type u) (p : α → Prop) : Type u
-| intro : ∀ x : α, p x → Subtype α p
-
-inductive Nat : Type
-| zero : Nat
-| succ : Nat → Nat
-
-inductive List (α : Type u)
-| nil : List α
-| cons : α → List α → List α
-
--- full binary tree with nodes and leaves labeled from α
-inductive BinTree (α : Type u)
-| leaf : α → BinTree α
-| node : BinTree α → α → BinTree α → BinTree α
-
--- every internal node has subtrees indexed by Nat
-inductive CBT (α : Type u)
-| leaf : α → CBT α
-| node : (Nat → CBT α) → CBT α
--- END
-end Hide
-```
-
-Note that in the syntax of the inductive definition ``Foo``, the context ``(a : α)`` is left implicit. In other words, constructors and recursive arguments are written as though they have return type ``Foo`` rather than ``Foo a``.
-
-Elements of the context ``(a : α)`` can be marked implicit as described in [Implicit Arguments](#implicit.md#implicit_arguments). These annotations bear only on the type former, ``Foo``. Lean uses a heuristic to determine which arguments to the constructors should be marked implicit, namely, an argument is marked implicit if it can be inferred from the type of a subsequent argument. If the annotation ``{}`` appears after the constructor, a argument is marked implicit if it can be inferred from the type of a subsequent argument *or the return type*. For example, it is useful to let ``nil`` denote the empty list of any type, since the type can usually be inferred in the context in which it appears. These heuristics are imperfect, and you may sometimes wish to define your own constructors in terms of the default ones. In that case, use the ``[match_pattern]`` [attribute](TODO: missing link) to ensure that these will be used appropriately by the [Equation Compiler](#the-equation-compiler).
-
-There are restrictions on the universe ``u`` in the return type ``Sort u`` of the type former. There are also restrictions on the universe ``u`` in the return type ``Sort u`` of the motive of the eliminator. These will be discussed in the next section in the more general setting of inductive families.
-
-Lean allows some additional syntactic conveniences. You can omit the return type of the type former, ``Sort u``, in which case Lean will infer the minimal possible nonzero value for ``u``. As with function definitions, you can list arguments to the constructors before the colon. In an enumerated type (that is, one where the constructors have no arguments), you can also leave out the return type of the constructors.
-
-```lean
-namespace Hide
-universe u
-
--- BEGIN
-inductive Weekday
-| sunday | monday | tuesday | wednesday
-| thursday | friday | saturday
-
-inductive Nat
-| zero
-| succ (n : Nat) : Nat
-
-inductive List (α : Type u)
-| nil : List α
-| cons (a : α) (l : List α) : List α
-
-@[match_pattern]
-def List.nil' (α : Type u) : List α := List.nil
-
-def length {α : Type u} : List α → Nat
-| (List.nil' _) => 0
-| (List.cons a l) => 1 + length l
--- END
-
-end Hide
-```
-
-The type former, constructors, and eliminator are all part of Lean's axiomatic foundation, which is to say, they are part of the trusted kernel. In addition to these axiomatically declared constants, Lean automatically defines some additional objects in terms of these, and adds them to the environment. These include the following:
-
-- ``Foo.recOn`` : a variant of the eliminator, in which the major premise comes first
-- ``Foo.casesOn`` : a restricted version of the eliminator which omits any recursive calls
-- ``Foo.noConfusionType``, ``Foo.noConfusion`` : functions which witness the fact that the inductive type is freely generated, i.e. that the constructors are injective and that distinct constructors produce distinct objects
-- ``Foo.below``, ``Foo.ibelow`` : functions used by the equation compiler to implement structural recursion
-- ``instance : SizeOf Foo`` : a measure which can be used for well-founded recursion
-
-Note that it is common to put definitions and theorems related to a datatype ``foo`` in a namespace of the same name. This makes it possible to use projection notation described in [Structures](struct.md#structures) and [Namespaces](namespaces.md#namespaces).
-
-```lean
-namespace Hide
-universe u
-
--- BEGIN
-inductive Nat
-| zero
-| succ (n : Nat) : Nat
-
-#check Nat
-#check @Nat.rec
-#check Nat.zero
-#check Nat.succ
-
-#check @Nat.recOn
-#check @Nat.casesOn
-#check @Nat.noConfusionType
-#check @Nat.noConfusion
-#check @Nat.brecOn
-#check Nat.below
-#check Nat.ibelow
-#check Nat._sizeOf_1
-
--- END
-
-end Hide
-```
-
-.. _inductive_families:
-
-Inductive Families
-==================
-
-In fact, Lean implements a slight generalization of the inductive types described in the previous section, namely, inductive *families*. The declaration of an inductive family in Lean has the following form:
-
-```
-inductive Foo (a : α) : Π (c : γ), Sort u
-| constructor₁ : Π (b : β₁), Foo t₁
-| constructor₂ : Π (b : β₂), Foo t₂
-...
-| constructorₙ : Π (b : βₙ), Foo tₙ
-```
-
-Here ``(a : α)`` is a context, ``(c : γ)`` is a telescope in context ``(a : α)``, each ``(b : βᵢ)`` is a telescope in the context ``(a : α)`` together with ``(Foo : Π (c : γ), Sort u)`` subject to the constraints below, and each ``tᵢ`` is a tuple of terms in the context ``(a : α) (b : βᵢ)`` having the types ``γ``. Instead of defining a single inductive type ``Foo a``, we are now defining a family of types ``Foo a c`` indexed by elements ``c : γ``.  Each constructor, ``constructorᵢ``, places its result in the type ``Foo a tᵢ``, the member of the family with index ``tᵢ``.
-
-The modifications to the scheme in the previous section are straightforward. Suppose the telescope ``(b : βᵢ)`` is ``(b₁ : βᵢ₁) ... (bᵤ : βᵢᵤ)``.
-
-- As before, an argument ``(bⱼ : βᵢⱼ)`` is *nonrecursive* if ``βᵢⱼ`` does not refer to ``Foo,`` the inductive type being defined. In that case, ``βᵢⱼ`` can be any type, so long as it does not refer to any nonrecursive arguments.
-
-- An argument ``(bⱼ : βᵢⱼ)`` is *recursive* if ``βᵢⱼ`` is of the form ``Π (d : δ), Foo s`` where ``(d : δ)`` is a telescope which does not refer to ``Foo`` or any nonrecursive arguments and ``s`` is a tuple of terms in context ``(a : α)`` and the previous nonrecursive ``bⱼ``'s with types ``γ``.
-
-The declaration of the type ``Foo`` as above results in the addition of the following constants to the environment:
-
-- the *type former* ``Foo : Π (a : α) (c : γ), Sort u``
-- for each ``i``, the *constructor* ``Foo.constructorᵢ : Π (a : α) (b : βᵢ), Foo a tᵢ``
-- the *eliminator* ``Foo.rec``, which takes arguments
-
-  + ``(a : α)`` (the parameters)
-  + ``{C : Π (c : γ), Foo a c → Type u}`` (the motive of the elimination)
-  + for each ``i``, the minor premise corresponding to ``constructorᵢ``
-  + ``(x : Foo a)`` (the major premise)
-
-  and returns an element of ``C x``. Here, The ith minor premise is a function which takes
-
-  +  ``(b : βᵢ)`` (the arguments to the constructor)
-  + an argument of type ``Π (d : δ), C s (bⱼ d)`` corresponding to each recursive argument ``(bⱼ : βᵢⱼ)``, where ``βᵢⱼ``  is of the form ``Π (d : δ), Foo s``
-
-  and returns an element of ``C tᵢ (constructorᵢ a b)``.
-
-Suppose we set ``F := Foo.rec a C f₁ ... fₙ``. Then for each constructor, we have the definitional reduction, as before:
-
-```
-F (constructorᵢ a b) = fᵢ b ... (fun d : δᵢⱼ => F (bⱼ d)) ...
-```
-
-where the ellipses include one entry for each recursive argument.
-
-The following are examples of inductive families.
-
-```lean
-namespace Hide
-universe u
-
--- BEGIN
-inductive Vector (α : Type u) : Nat → Type u
-| nil  : Vector 0
-| succ : Π n, Vector n → Vector (n + 1)
-
--- 'IsProd s n' means n is a product of elements of s
-inductive IsProd (s : Set Nat) : Nat → Prop
-| base : ∀ n ∈ s, IsProd n
-| step : ∀ m n, IsProd m → IsProd n → IsProd (m * n)
-
-inductive Eq {α : Sort u} (a : α) : α → Prop
-| refl : Eq a
--- END
-
-end Hide
-```
-
-We can now describe the constraints on the return type of the type former, ``Sort u``. We can always take ``u`` to be ``0``, in which case we are defining an inductive family of propositions. If ``u`` is nonzero, however, it must satisfy the following constraint: for each type ``βᵢⱼ : Sort v`` occurring in the constructors, we must have ``u ≥ v``. In the set-theoretic interpretation, this ensures that the universe in which the resulting type resides is large enough to contain the inductively generated family, given the number of distinctly-labeled constructors. The restriction does not hold for inductively defined propositions, since these contain no data.
-
-Putting an inductive family in ``Prop``, however, does impose a restriction on the eliminator. Generally speaking, for an inductive family in ``Prop``, the motive in the eliminator is required to be in ``Prop``. But there is an exception to this rule: you are allowed to eliminate from an inductively defined ``Prop`` to an arbitrary ``Sort`` when there is only one constructor, and each argument to that constructor is either in ``Prop`` or an index. The intuition is that in this case the elimination does not make use of any information that is not already given by the mere fact that the type of argument is inhabited. This special case is known as *singleton elimination*.
-
-.. _mutual_and_nested_inductive_definitions:
-
-Mutual and Nested Inductive Definitions
-=======================================
-
-Lean supports two generalizations of the inductive families described above, namely, *mutual* and *nested* inductive definitions. These are *not* implemented natively in the kernel. Rather, the definitions are compiled down to the primitive inductive types and families.
-
-The first generalization allows for multiple inductive types to be defined simultaneously.
-
-```
-mutual
-
-inductive Foo (a : α) : Π (c : γ₁), Sort u
-| constructor₁₁ : Π (b : β₁₁), Foo a t₁₁
-| constructor₁₂ : Π (b : β₁₂), Foo a t₁₂
-...
-| constructor₁ₙ : Π (b : β₁ₙ), Foo a t₁ₙ
-
-inductive Bar (a : α) : Π (c : γ₂), Sort u
-| constructor₂₁ : Π (b : β₂₁), Bar a t₂₁
-| constructor₂₂ : Π (b : β₂₂), Bar a t₂₂
-...
-| constructor₂ₘ : Π (b : β₂ₘ), Bar a t₂ₘ
-
-end
-```
-
-Here the syntax is shown for defining two inductive families, ``Foo`` and ``Bar``, but any number is allowed. The restrictions are almost the same as for ordinary inductive families. For example, each ``(b : βᵢⱼ)`` is a telescope relative to the context ``(a : α)``. The difference is that the constructors can now have recursive arguments whose return types are any of the inductive families currently being defined, in this case ``Foo`` and ``Bar``. Note that all of the inductive definitions share the same parameters ``(a : α)``, though they may have different indices.
-
-A mutual inductive definition is compiled down to an ordinary inductive definition using an extra finite-valued index to distinguish the components. The details of the internal construction are meant to be hidden from most users. Lean defines the expected type formers ``Foo`` and ``Bar`` and constructors ``constructorᵢⱼ`` from the internal inductive definition. There is no straightforward elimination principle, however. Instead, Lean defines an appropriate ``sizeOf`` measure, meant for use with well-founded recursion, with the property that the recursive arguments to a constructor are smaller than the constructed value.
-
-The second generalization relaxes the restriction that in the recursive definition of ``Foo``, ``Foo`` can only occur strictly positively in the type of any of its recursive arguments. Specifically, in a nested inductive definition, ``Foo`` can appear as an argument to another inductive type constructor, so long as the corresponding parameter occurs strictly positively in the constructors for *that* inductive type. This process can be iterated, so that additional type constructors can be applied to those, and so on.
-
-A nested inductive definition is compiled down to an ordinary inductive definition using a mutual inductive definition to define copies of all the nested types simultaneously. Lean then constructs isomorphisms between the mutually defined nested types and their independently defined counterparts. Once again, the internal details are not meant to be manipulated by users. Rather, the type former and constructors are made available and work as expected, while an appropriate ``sizeOf`` measure is generated for use with well-founded recursion.
-
-```lean
-universe u
--- BEGIN
-mutual
-inductive Even : Nat → Prop
-| even_zero : Even 0
-| even_succ : ∀ n, Odd n → Even (n + 1)
-inductive Odd : Nat → Prop
-| odd_succ : ∀ n, Even n → Odd (n + 1)
-end
-
-inductive Tree (α : Type u)
-| mk : α → List (Tree α) → Tree α
-
-inductive DoubleTree (α : Type u)
-| mk : α → List (DoubleTree α) × List (DoubleTree α) → DoubleTree α
--- END
-```
-
-.. _the_equation_compiler:
-
-The Equation Compiler
-=====================
-
-The equation compiler takes an equational description of a function or proof and tries to define an object meeting that specification. It expects input with the following syntax:
-
-```
-def foo (a : α) : Π (b : β), γ
-| [patterns₁] => t₁
-...
-| [patternsₙ] => tₙ
-```
-
-Here ``(a : α)`` is a telescope, ``(b : β)`` is a telescope in the context ``(a : α)``, and ``γ`` is an expression in the context ``(a : α) (b : β)`` denoting a ``Type`` or a ``Prop``.
-
-Each ``patternsᵢ`` is a sequence of patterns of the same length as ``(b : β)``. A pattern is either:
-
-- a variable, denoting an arbitrary value of the relevant type,
-- an underscore, denoting a *wildcard* or *anonymous variable*,
-- an inaccessible term (see below), or
-- a constructor for the inductive type of the corresponding argument, applied to a sequence of patterns.
-
-In the last case, the pattern must be enclosed in parentheses.
-
-Each term ``tᵢ`` is an expression in the context ``(a : α)`` together with the variables introduced on the left-hand side of the token ``=>``. The term ``tᵢ`` can also include recursive calls to ``foo``, as described below. The equation compiler does case splitting on the variables ``(b : β)`` as necessary to match the patterns, and defines ``foo`` so that it has the value ``tᵢ`` in each of the cases. In ideal circumstances (see below), the equations hold definitionally. Whether they hold definitionally or only propositionally, the equation compiler proves the relevant equations and assigns them internal names. They are accessible by the ``rewrite`` and ``simp`` tactics under the name ``foo`` (see [Rewrite](tactics.md#rewrite) and _[TODO: where is simplifier tactic documented?]_. If some of the patterns overlap, the equation compiler interprets the definition so that the first matching pattern applies in each case. Thus, if the last pattern is a variable, it covers all the remaining cases. If the patterns that are presented do not cover all possible cases, the equation compiler raises an error.
-
-When identifiers are marked with the ``[match_pattern]`` attribute, the equation compiler unfolds them in the hopes of exposing a constructor. For example, this makes it possible to write ``n+1`` and ``0`` instead of ``Nat.succ n`` and ``Nat.zero`` in patterns.
-
-For a nonrecursive definition involving case splits, the defining equations will hold definitionally. With inductive types like ``Char``, ``String``, and ``Fin n``, a case split would produce definitions with an inordinate number of cases. To avoid this, the equation compiler uses ``if ... then ... else`` instead of ``casesOn`` when defining the function. In this case, the defining equations hold definitionally as well.
-
-```lean
-open Nat
-
-def sub2 : Nat → Nat
-| zero          => 0
-| succ zero     => 0
-| succ (succ a) => a
-
-def bar : Nat → List Nat → Bool → Nat
-| 0,   _,      false => 0
-| 0,   b :: _, _     => b
-| 0,   [],     true  => 7
-| a+1, [],     false => a
-| a+1, [],     true  => a + 1
-| a+1, b :: _, _     => a + b
-
-def baz : Char → Nat
-| 'A' => 1
-| 'B' => 2
-| _   => 3
-```
-
-The case where patterns are matched against an argument whose type is an inductive family is known as *dependent pattern matching*. This is more complicated, because the type of the function being defined can impose constraints on the patterns that are matched. In this case, the equation compiler will detect inconsistent cases and rule them out.
-
-```lean
-universe u
-
-inductive Vector (α : Type u) : Nat → Type u
-  | nil  : Vector α 0
-  | cons : α → Vector α n → Vector α (n+1)
-
-namespace Vector
-
-def head : Vector α (n+1) → α
-  | cons h t => h
-
-def tail : Vector α (n+1) → Vector α n
-  | cons h t => t
-
-def map (f : α → β → γ) : Vector α n → Vector β n → Vector γ n
-  | nil, nil => nil
-  | cons a va, cons b vb => cons (f a b) (map f va vb)
-
-end Vector
-```
-
-.. _recursive_functions:
-
-Recursive functions
-===================
-
-Lean must ensure that a recursive function terminates, for which there are two strategies: _structural recursion_, in which all recursive calls are made on smaller parts of the input data, and _well-founded recursion_, in which recursive calls are justified by showing that arguments to recursive calls are smaller according to some other measure.
-
-Structural recursion
---------------------
-
-If the definition of a function contains recursive calls, Lean first tries to interpret the definition as a structural recursion. In order for that to succeed, the recursive arguments must be subterms of the corresponding arguments on the left-hand side.
-
-The function is then defined using a *course of values* recursion, using automatically generated functions ``below`` and ``brec`` in the namespace corresponding to the inductive type of the recursive argument. In this case the defining equations hold definitionally, possibly with additional case splits.
-
-```lean
-namespace Hide
-
--- BEGIN
-def fib : Nat → Nat
-| 0     => 1
-| 1     => 1
-| (n+2) => fib (n+1) + fib n
-
-def append {α : Type} : List α → List α → List α
-| [],   l => l
-| h::t, l => h :: append t l
-
-example : append [(1 : Nat), 2, 3] [4, 5] = [1, 2, 3, 4, 5] => rfl
--- END
-
-end Hide
-```
-
-Well-founded recursion
----------------------
-
-If structural recursion fails, the equation compiler falls back on well-founded recursion. It tries to infer an instance of ``SizeOf`` for the type of each argument, and then tries to find a permutation of the arguments such that each recursive call is decreasing under the lexicographic order with respect to ``sizeOf`` measures.  Lean uses information in the local context, so you can often provide the relevant proof manually using ``have`` in the body of the definition.
-
-In the case of well-founded recursion, the equation used to declare the function holds only propositionally, but not definitionally, and can be accessed using ``unfold``, ``simp`` and ``rewrite`` with the function name (for example ``unfold foo`` or ``simp [foo]``, where ``foo`` is the function defined with well-founded recursion).
-
-```lean
-namespace Hide
-open Nat
-
--- BEGIN
-def div : Nat → Nat → Nat
-| x, y =>
-  if h : 0 < y ∧ y ≤ x then
-    have : x - y < x :=
-      sub_lt (Nat.lt_of_lt_of_le h.left h.right) h.left
-    div (x - y) y + 1
-  else
-    0
-
-example (x y : Nat) :
-  div x y = if 0 < y ∧ y ≤ x then div (x - y) y + 1 else 0 :=
-by rw [div]; rfl
--- END
-
-end Hide
-```
-
-If Lean cannot find a permutation of the arguments for which all recursive calls are decreasing, it will print a table that contains, for every recursive call, which arguments Lean could prove to be decreasing. For example, a function with three recursive calls and four parameters might cause the following message to be printed
-
-```
-example.lean:37:0-43:31: error: Could not find a decreasing measure.
-The arguments relate at each recursive call as follows:
-(<, ≤, =: relation proved, ? all proofs failed, _: no proof attempted)
-           x1 x2 x3 x4
-1) 39:6-27  =  =  _  =
-2) 40:6-25  =  ?  _  <
-3) 41:6-25  <  _  _  _
-Please use `termination_by` to specify a decreasing measure.
-```
-
-This table should be read as follows:
-
- * In the first recursive call, in line 39, arguments 1, 2 and 4 are equal to the function's parameters.
- * The second recursive call, in line 40, has an equal first argument, a smaller fourth argument, and nothing could be inferred for the second argument.
- * The third recursive call, in line 41, has a decreasing first argument.
- * No other proofs were attempted, either because the parameter has a type without a non-trivial ``WellFounded`` instance (parameter 3), or because it is already clear that no decreasing measure can be found.
-
-
-Lean will print the termination measure it found if ``set_option showInferredTerminationBy true`` is set.
-
-If Lean does not find the termination measure, or if you want to be explicit, you can append a `termination_by` clause to the function definition, after the function's body, but before the `where` clause if present. It is of the form
-```
-termination_by e
-```
-where ``e`` is an expression that depends on the parameters of the function and should be decreasing at each recursive call. The type of `e` should be an instance of the class ``WellFoundedRelation``, which determines how to compare two values of that type.
-
-If ``f`` has parameters “after the ``:``” (for example when defining functions via patterns using `|`), then these can be brought into scope using the syntax
-```
-termination_by a₁ … aₙ => e
-```
-
-By default, Lean uses the tactic ``decreasing_tactic`` when proving that an argument is decreasing; see its documentation for how to globally extend it. You can also choose to use a different tactic for a given function definition with the clause
-```
-decreasing_by <tac>
-```
-which should come after ``termination_by`, if present.
-
-
-Note that recursive definitions can in general require nested recursions, that is, recursion on different arguments of ``foo`` in the template above. The equation compiler handles this by abstracting later arguments, and recursively defining higher-order functions to meet the specification.
-
-Mutual recursion
-----------------
-
-The equation compiler also allows mutual recursive definitions, with a syntax similar to that of [Mutual and Nested Inductive Definitions](#mutual-and-nested-inductive-definitions). Mutual definitions are always compiled using well-founded recursion, and so once again the defining equations hold only propositionally.
-
-```lean
-mutual
-def even : Nat → Bool
-| 0   => true
-| a+1 => odd a
-def odd : Nat → Bool
-| 0   => false
-| a+1 => even a
-end
-
-example (a : Nat) : even (a + 1) = odd a :=
-by simp [even]
-
-example (a : Nat) : odd (a + 1) = even a :=
-by simp [odd]
-```
-
-Well-founded recursion is especially useful with [Mutual and Nested Inductive Definitions](#mutual-and-nested-inductive-definitions), since it provides the canonical way of defining functions on these types.
-
-```lean
-mutual
-inductive Even : Nat → Prop
-| even_zero : Even 0
-| even_succ : ∀ n, Odd n → Even (n + 1)
-inductive Odd : Nat → Prop
-| odd_succ : ∀ n, Even n → Odd (n + 1)
-end
-
-open Even Odd
-
-theorem not_odd_zero : ¬ Odd 0 := fun x => nomatch x
-
-mutual
-theorem even_of_odd_succ : ∀ n, Odd (n + 1) → Even n
-| _, odd_succ n h => h
-theorem odd_of_even_succ : ∀ n, Even (n + 1) → Odd n
-| _, even_succ n h => h
-end
-
-inductive Term
-| const : String → Term
-| app   : String → List Term → Term
-
-open Term
-
-mutual
-def num_consts : Term → Nat
-| .const n  => 1
-| .app n ts => num_consts_lst ts
-def num_consts_lst : List Term → Nat
-| []    => 0
-| t::ts => num_consts t + num_consts_lst ts
-end
-```
-
-In a set of mutually recursive function, either all or no functions must have an explicit termination measure (``termination_by``). A change of the default termination tactic (``decreasing_by``) only affects the proofs about the recursive calls of that function, not the other functions in the group.
-
-```
-mutual
-theorem even_of_odd_succ : ∀ n, Odd (n + 1) → Even n
-| _, odd_succ n h => h
-termination_by n h => h
-decreasing_by decreasing_tactic
-
-theorem odd_of_even_succ : ∀ n, Even (n + 1) → Odd n
-| _, even_succ n h => h
-termination_by n h => h
-end
-```
-
-Another way to express mutual recursion is using local function definitions in ``where`` or ``let rec`` clauses: these can be mutually recursive with each other and their containing function:
-
-```
-theorem even_of_odd_succ : ∀ n, Odd (n + 1) → Even n
-  | _, odd_succ n h => h
-termination_by n h => h
-  where
-    theorem odd_of_even_succ : ∀ n, Even (n + 1) → Odd n
-      | _, even_succ n h => h
-    termination_by n h => h
-```
-
-.. _match_expressions:
-
-Match Expressions
-=================
-
-Lean supports a ``match ... with ...`` construct similar to ones found in most functional programming languages. The syntax is as follows:
-
-```
-match t₁, ..., tₙ with
-| p₁₁, ..., p₁ₙ => s₁
-...
-| pₘ₁, ..., pₘₙ => sₘ
-```
-
-Here ``t₁, ..., tₙ`` are any terms in the context in which the expression appears, the expressions ``pᵢⱼ`` are patterns, and the terms ``sᵢ`` are expressions in the local context together with variables introduced by the patterns on the left-hand side. Each ``sᵢ`` should have the expected type of the entire ``match`` expression.
-
-Any ``match`` expression is interpreted using the equation compiler, which generalizes ``t₁, ..., tₙ``, defines an internal function meeting the specification, and then applies it to ``t₁, ..., tₙ``. In contrast to the definitions in [The Equation Compiler](declarations.md#the-equation-compiler), the terms ``tᵢ`` are arbitrary terms rather than just variables, and the expression can occur anywhere within a Lean expression, not just at the top level of a definition. Note that the syntax here is somewhat different: both the terms ``tᵢ`` and the patterns ``pᵢⱼ`` are separated by commas.
-
-```lean
-def foo (n : Nat) (b c : Bool) :=
-5 + match n - 5, b && c with
-    | 0,   true  => 0
-    | m+1, true  => m + 7
-    | 0,   false => 5
-    | m+1, false => m + 3
-```
-
-When a ``match`` has only one line, Lean provides alternative syntax with a destructuring ``let``, as well as a destructuring lambda abstraction. Thus the following definitions all have the same net effect.
-
-```lean
-def bar₁ : Nat × Nat → Nat
-| (m, n) => m + n
-
-def bar₂ (p : Nat × Nat) : Nat :=
-match p with | (m, n) => m + n
-
-def bar₃ : Nat × Nat → Nat :=
-fun ⟨m, n⟩ => m + n
-
-def bar₄ (p : Nat × Nat) : Nat :=
-let ⟨m, n⟩ := p; m + n
-```
-
-Information about the term being matched can be preserved in each branch using the syntax `match h : t with`. For example, a user may want to match a term `ns ++ ms : List Nat`, while tracking the hypothesis `ns ++ ms = []` or `ns ++ ms= h :: t` in the respective match arm:
-
-```lean
-def foo (ns ms : List Nat) (h1 : ns ++ ms ≠ []) (k : Nat -> Char) : Char :=
-  match h2 : ns ++ ms with
-  -- in this arm, we have the hypothesis `h2 : ns ++ ms = []`
-  | [] => absurd h2 h1
-  -- in this arm, we have the hypothesis `h2 : ns ++ ms = h :: t`
-  | h :: t => k h
-
--- '7'
-#eval foo [7, 8, 9] [] (by decide) Nat.digitChar
-```
-
-.. _structures_and_records:
-
-Structures and Records
-======================
-
-The ``structure`` command in Lean is used to define an inductive data type with a single constructor and to define its projections at the same time. The syntax is as follows:
-
-```
-structure Foo (a : α) : Sort u extends Bar, Baz :=
-constructor :: (field₁ : β₁) ... (fieldₙ : βₙ)
-```
-
-Here ``(a : α)`` is a telescope, that is, the parameters to the inductive definition. The name ``constructor`` followed by the double colon is optional; if it is not present, the name ``mk`` is used by default. The keyword ``extends`` followed by a list of previously defined structures is also optional; if it is present, an instance of each of these structures is included among the fields to ``Foo``, and the types ``βᵢ`` can refer to their fields as well. The output type, ``Sort u``, can be omitted, in which case Lean infers to smallest non-``Prop`` sort possible (unless all the fields are ``Prop``, in which case it infers ``Prop``).
-Finally, ``(field₁ : β₁) ... (fieldₙ : βₙ)`` is a telescope relative to ``(a : α)`` and the fields in ``bar`` and ``baz``.
-
-The declaration above is syntactic sugar for an inductive type declaration, and so results in the addition of the following constants to the environment:
-
-- the type former : ``Foo : Π (a : α), Sort u``
-- the single constructor :
-
-```
-Foo.constructor : Π (a : α) (toBar : Bar) (toBaz : Baz)
-  (field₁ : β₁) ... (fieldₙ : βₙ), Foo a
-```
-
-- the eliminator ``Foo.rec`` for the inductive type with that constructor
-
-In addition, Lean defines
-
-- the projections : ``fieldᵢ : Π (a : α) (c : Foo) : βᵢ`` for each ``i``
-
-where any other fields mentioned in ``βᵢ`` are replaced by the relevant projections from ``c``.
-
-Given ``c : Foo``, Lean offers the following convenient syntax for the projection ``Foo.fieldᵢ c``:
-
-- *anonymous projections* : ``c.fieldᵢ``
-- *numbered projections* : ``c.i``
-
-These can be used in any situation where Lean can infer that the type of ``c`` is of the form ``Foo a``. The convention for anonymous projections is extended to any function ``f`` defined in the namespace ``Foo``, as described in [Namespaces](namespaces.md).
-
-Similarly, Lean offers the following convenient syntax for constructing elements of ``Foo``. They are equivalent to ``Foo.constructor b₁ b₂ f₁ f₁ ... fₙ``, where ``b₁ : Bar``, ``b₂ : Baz``, and each ``fᵢ : βᵢ`` :
-
-- *anonymous constructor*: ``⟨ b₁, b₂, f₁, ..., fₙ ⟩``
-- *record notation*:
-
-```
-{ toBar := b₁, toBaz := b₂, field₁ := f₁, ...,
-    fieldₙ := fₙ :  Foo a }
-```
-
-The anonymous constructor can be used in any context where Lean can infer that the expression should have a type of the form ``Foo a``. The unicode brackets are entered as ``\<`` and ``\>`` respectively.
-
-When using record notation, you can omit the annotation ``: Foo a`` when Lean can infer that the expression should have a type of the form ``Foo a``. You can replace either ``toBar`` or ``toBaz`` by assignments to *their* fields as well, essentially acting as though the fields of ``Bar`` and ``Baz`` are simply imported into ``Foo``. Finally, record notation also supports
-
-- *record updates*: ``{ t with ... fieldᵢ := fᵢ ...}``
-
-Here ``t`` is a term of type ``Foo a`` for some ``a``. The notation instructs Lean to take values from ``t`` for any field assignment that is omitted from the list.
-
-Lean also allows you to specify a default value for any field in a structure by writing ``(fieldᵢ : βᵢ := t)``. Here ``t`` specifies the value to use when the field ``fieldᵢ`` is left unspecified in an instance of record notation.
-
-```lean
-universe u v
-
-structure Vec (α : Type u) (n : Nat) :=
-(l : List α) (h : l.length = n)
-
-structure Foo (α : Type u) (β : Nat → Type v) : Type (max u v) :=
-(a : α) (n : Nat) (b : β n)
-
-structure Bar :=
-(c : Nat := 8) (d : Nat)
-
-structure Baz extends Foo Nat (Vec Nat), Bar :=
-(v : Vec Nat n)
-
-#check Foo
-#check @Foo.mk
-#check @Foo.rec
-
-#check Foo.a
-#check Foo.n
-#check Foo.b
-
-#check Baz
-#check @Baz.mk
-#check @Baz.rec
-
-#check Baz.toFoo
-#check Baz.toBar
-#check Baz.v
-
-def bzz := Vec.mk [1, 2, 3] rfl
-
-#check Vec.l bzz
-#check Vec.h bzz
-#check bzz.l
-#check bzz.h
-#check bzz.1
-#check bzz.2
-
-example : Vec Nat 3 := Vec.mk [1, 2, 3] rfl
-example : Vec Nat 3 := ⟨[1, 2, 3], rfl⟩
-example : Vec Nat 3 := { l := [1, 2, 3], h := rfl : Vec Nat 3 }
-example : Vec Nat 3 := { l := [1, 2, 3], h := rfl }
-
-example : Foo Nat (Vec Nat) := ⟨1, 3, bzz⟩
-
-example : Baz := ⟨⟨1, 3, bzz⟩, ⟨5, 7⟩, bzz⟩
-example : Baz := { a := 1, n := 3, b := bzz, c := 5, d := 7, v := bzz}
-def fzz : Foo Nat (Vec Nat) := {a := 1, n := 3, b := bzz}
-
-example : Foo Nat (Vec Nat) := { fzz with a := 7 }
-example : Baz := { fzz with c := 5, d := 7, v := bzz }
-
-example : Bar := { c := 8, d := 9 }
-example : Bar := { d := 9 }  -- uses the default value for c
-```
-
-.. _type_classes:
-
-Type Classes
-============
-
-(Classes and instances. Anonymous instances. Local instances.)
-
-
-.. [Dybjer] Dybjer, Peter, *Inductive Families*. Formal Aspects of Computing 6, 1994, pages 440-465.

doc/definitions.md

@@ -1 +0,0 @@
-# Definitions

doc/dep.md

@@ -1,66 +0,0 @@
-## What makes dependent type theory dependent?
-
-The short explanation is that what makes dependent type theory dependent is that types can depend on parameters.
-You have already seen a nice example of this: the type ``List α`` depends on the argument ``α``, and
-this dependence is what distinguishes ``List Nat`` and ``List Bool``.
-For another example, consider the type ``Vector α n``, the type of vectors of elements of ``α`` of length ``n``.
-This type depends on *two* parameters: the type ``α : Type`` of the elements in the vector and the length ``n : Nat``.
-
-Suppose we wish to write a function ``cons`` which inserts a new element at the head of a list.
-What type should ``cons`` have? Such a function is *polymorphic*: we expect the ``cons`` function for ``Nat``, ``Bool``,
-or an arbitrary type ``α`` to behave the same way.
-So it makes sense to take the type to be the first argument to ``cons``, so that for any type, ``α``, ``cons α``
-is the insertion function for lists of type ``α``. In other words, for every ``α``, ``cons α`` is the function that takes an element ``a : α``
-and a list ``as : List α``, and returns a new list, so we have ``cons α a as : list α``.
-
-It is clear that ``cons α`` should have type ``α → List α → List α``. But what type should ``cons`` have?
-A first guess might be ``Type → α → list α → list α``, but, on reflection, this does not make sense:
-the ``α`` in this expression does not refer to anything, whereas it should refer to the argument of type ``Type``.
-In other words, *assuming* ``α : Type`` is the first argument to the function, the type of the next two elements are ``α`` and ``List α``.
-These types vary depending on the first argument, ``α``.
-
-This is an instance of a *dependent function type*, or *dependent arrow type*. Given ``α : Type`` and ``β : α → Type``,
-think of ``β`` as a family of types over ``α``, that is, a type ``β a`` for each ``a : α``.
-In that case, the type ``(a : α) → β a`` denotes the type of functions ``f`` with the property that,
-for each ``a : α``, ``f a`` is an element of ``β a``. In other words, the type of the value returned by ``f`` depends on its input.
-
-Notice that ``(a : α) → β`` makes sense for any expression ``β : Type``. When the value of ``β`` depends on ``a``
-(as does, for example, the expression ``β a`` in the previous paragraph), ``(a : α) → β`` denotes a dependent function type.
-When ``β`` doesn't depend on ``a``, ``(a : α) → β`` is no different from the type ``α → β``.
-Indeed, in dependent type theory (and in Lean), ``α → β`` is just notation for ``(a : α) → β`` when ``β`` does not depend on ``a``.
-
-Returning to the example of lists, we can use the command `#check` to inspect the type of the following `List` functions
-We will explain the ``@`` symbol and the difference between the round and curly braces momentarily.
-
-```lean
-#check @List.cons    -- {α : Type u_1} → α → List α → List α
-#check @List.nil     -- {α : Type u_1} → List α
-#check @List.length  -- {α : Type u_1} → List α → Nat
-#check @List.append  -- {α : Type u_1} → List α → List α → List α
-```
-
-Just as dependent function types ``(a : α) → β a`` generalize the notion of a function type ``α → β`` by allowing ``β`` to depend on ``α``,
-dependent Cartesian product types ``(a : α) × β a`` generalize the Cartesian product ``α × β`` in the same way. Dependent products are also
-called *sigma* types, and you can also write them as `Σ a : α, β a`. You can use `⟨a, b⟩` or `Sigma.mk a b` to create a dependent pair.
-
-```lean
-universe u v
-
-def f (α : Type u) (β : α → Type v) (a : α) (b : β a) : (a : α) × β a :=
-  ⟨a, b⟩
-
-def g (α : Type u) (β : α → Type v) (a : α) (b : β a) : Σ a : α, β a :=
-  Sigma.mk a b
-
-#reduce f
-#reduce g
-
-#reduce f Type (fun α => α) Nat 10
-#reduce g Type (fun α => α) Nat 10
-
-#reduce (f Type (fun α => α) Nat 10).1 -- Nat
-#reduce (g Type (fun α => α) Nat 10).1 -- Nat
-#reduce (f Type (fun α => α) Nat 10).2 -- 10
-#reduce (g Type (fun α => α) Nat 10).2 -- 10
-```
-The function `f` and `g` above denote the same function.

doc/deptypes.md

@@ -1,3 +0,0 @@
-# Dependent Types
-
-In this section, we introduce simple type theory, types as objects, definitions, and explain what makes dependent type theory *dependent*.

doc/dev/mdbook.md

@@ -1,109 +0,0 @@
-# Documentation
-
-The Lean `doc` folder contains the [Lean Manual](https://lean-lang.org/lean4/doc/) and is
-authored in a combination of markdown (`*.md`) files and literate Lean files.  The .lean files are
-preprocessed using a tool called [LeanInk](https://github.com/leanprover/leanink) and
-[Alectryon](https://github.com/Kha/alectryon) which produces a generated markdown file.  We then run
-`mdbook` on the result to generate the html pages.
-
-
-## Settings
-
-We are using the following settings while editing the markdown docs.
-
-```json
-{
-    "files.insertFinalNewline": true,
-    "files.trimTrailingWhitespace": true,
-    "[markdown]": {
-        "rewrap.wrappingColumn": 70
-    }
-}
-```
-
-## Build
-
-### Using Nix
-
-Building the manual using Nix (which is what the CI does) is as easy as
-```bash
-$ nix build --update-input lean ./doc
-```
-You can also open a shell with `mdbook` for running the commands mentioned below with
-`nix develop ./doc#book`. Otherwise, read on.
-
-### Manually
-
-To build and test the book you have to preprocess the .lean files with Alectryon then use our own
-fork of the Rust tool named [mdbook](https://github.com/leanprover/mdbook). We have our own fork of
-mdBook with the following additional features:
-
-* Add support for hiding lines in other languages
-  [#1339](https://github.com/rust-lang/mdBook/pull/1339)
-* Make `mdbook test` call the `lean` compiler to test the snippets.
-* Ability to test a single chapter at a time which is handy when you
-are working on that chapter.  See the `--chapter` option.
-
-So you need to setup these tools before you can run `mdBook`.
-
-1. install [Rust](https://www.rust-lang.org/tools/install)
-which provides you with the `cargo` tool for building rust packages.
-Then run the following:
-    ```bash
-    cargo install --git https://github.com/leanprover/mdBook mdbook
-    ```
-
-1. Clone https://github.com/leanprover/LeanInk.git and run `lake build` then make the resulting
-   binary available to Alectryon using e.g.
-    ```bash
-    # make `leanInk` available in the current shell
-    export PATH=$PWD/build/bin:$PATH
-    ```
-
-1. Create a Python 3.10 environment.
-
-1. Install Alectryon:
-    ```
-    python3 -m pip install git+https://github.com/Kha/alectryon.git@typeid
-    ```
-
-1. Now you are ready to process the `*.lean` files using Alectryon as follows:
-
-    ```
-    cd lean4/doc
-    alectryon --frontend lean4+markup examples/palindromes.lean --backend webpage -o palindromes.lean.md
-    ```
-
-    Repeat this for the other .lean files you care about or write a script to process them all.
-
-1. Now you can build the book using:
-    ```
-    cd lean4/doc
-    mdbook build
-    ```
-
-This will put the HTML in a `out` folder so you can load `out/index.html` in your web browser and
-it should look like https://lean-lang.org/lean4/doc/.
-
-1. It is also handy to use e.g. [`mdbook watch`](https://rust-lang.github.io/mdBook/cli/watch.html)
-   in the `doc/` folder so that it keeps the html up to date while you are editing.
-
-    ```bash
-    mdbook watch --open  # opens the output in `out/` in your default browser
-    ```
-
-## Testing Lean Snippets
-
-You can run the following in the `doc/` folder to test all the lean code snippets.
-
-    ```bash
-    mdbook test
-    ```
-
-and you can use the `--chapter` option to test a specific chapter that you are working on:
-
-    ```bash
-    mdbook test --chapter Array
-    ```
-
-Use chapter name `?` to get a list of all the chapter names.

doc/dev/release_checklist.md

@@ -5,125 +5,75 @@ See below for the checklist for release candidates.
 
 We'll use `v4.6.0` as the intended release version as a running example.
 
-- Run `scripts/release_checklist.py v4.6.0` to check the status of the release.
-  This script is purely informational, idempotent, and safe to run at any stage of the release process.
+- Run `script/release_checklist.py v4.6.0` to check the status of the release.
+  This script is idempotent, and should be safe to run at any stage of the release process.
+  Note that as of v4.19.0, this script takes some autonomous actions, which can be prevented via `--dry-run`.
 - `git checkout releases/v4.6.0`
   (This branch should already exist, from the release candidates.)
 - `git pull`
 - In `src/CMakeLists.txt`, verify you see
   - `set(LEAN_VERSION_MINOR 6)` (for whichever `6` is appropriate)
   - `set(LEAN_VERSION_IS_RELEASE 1)`
-  - (both of these should already be in place from the release candidates)
+  - (all of these should already be in place from the release candidates)
 - `git tag v4.6.0`
 - `git push $REMOTE v4.6.0`, where `$REMOTE` is the upstream Lean repository (e.g., `origin`, `upstream`)
 - Now wait, while CI runs.
   - You can monitor this at `https://github.com/leanprover/lean4/actions/workflows/ci.yml`,
     looking for the `v4.6.0` tag.
-  - This step can take up to an hour.
+  - This step can take up to two hours.
   - If you are intending to cut the next release candidate on the same day,
     you may want to start on the release candidate checklist now.
 - Next we need to prepare the release notes.
   - If the stable release is identical to the last release candidate (this should usually be the case),
-    you can reuse the release notes from `RELEASES.md`.
+    you can reuse the release notes that are already in the Lean Language Reference.
   - If you want to regenerate the release notes,
-    use `script/release_notes.py --since v4.5.0`, run on the `releases/v4.6.0` branch,
+    run `script/release_notes.py --since v4.5.0` on the `releases/v4.6.0` branch,
     and see the section "Writing the release notes" below for more information.
-  - Release notes should go in `RELEASES.md` on the `releases/v4.6.0` branch,
-    and should also be PR'd to `master` (suggested title: "chore: update release notes for v4.6.0").
+  - Release notes live in https://github.com/leanprover/reference-manual, in e.g. `Manual/Releases/v4.6.0.lean`.
+    It's best if you update these at the same time as a you update the `lean-toolchain` for the `reference-manual` repository, see below.
 - Go to https://github.com/leanprover/lean4/releases and verify that the `v4.6.0` release appears.
   - Verify on Github that "Set as the latest release" is checked.
-  - Copy the generated release note into the text box, adding the header
-    ```
-    v4.6.0
-    ----------
-    ```
 - Next, we will move a curated list of downstream repos to the latest stable release.
   - In order to have the access rights to push to these repositories and merge PRs,
     you will need to be a member of the `lean-release-managers` team at both `leanprover-community` and `leanprover`.
     Contact Kim Morrison (@kim-em) to arrange access.
-  - For each of the repositories listed below:
-    - Make a PR to `master`/`main` changing the toolchain to `v4.6.0`
-      - The usual branch name would be `bump_to_v4.6.0`.
-      - Update the toolchain file
-      - In the Lakefile, if there are dependencies on specific version tags of dependencies that you've already pushed as part of this process, update them to the new tag.
-        If they depend on `main` or `master`, don't change this; you've just updated the dependency, so it will work and be saved in the manifest
+  - For each of the repositories listed in `script/release_repos.yml`,
+    - Run `script/release_steps.py v4.6.0 <repo>` (e.g. replacing `<repo>` with `batteries`), which will walk you through the following steps:
+      - Create a new branch off `master`/`main` (as specified in the `branch` field), called `bump_to_v4.6.0`.
+      - Update the contents of `lean-toolchain` to `leanprover/lean4:v4.6.0`.
+      - In the `lakefile.toml` or `lakefile.lean`, if there are dependencies on specific version tags of dependencies, update them to the new tag.
+        If they depend on `main` or `master`, don't change this; you've just updated the dependency, so `lake update` will take care of modifying the manifest.
       - Run `lake update`
-      - The PR title should be "chore: bump toolchain to v4.6.0".
+      - Commit the changes as `chore: bump toolchain to v4.6.0` and push.
+      - Create a PR with title "chore: bump toolchain to v4.6.0".
     - Merge the PR once CI completes.
-    - Create the tag `v4.6.0` from `master`/`main` and push it.
-    - Merge the tag `v4.6.0` into the `stable` branch and push it.
-  - We do this for the repositories:
-    - [Batteries](https://github.com/leanprover-community/batteries)
-      - No dependencies
-      - Toolchain bump PR
-      - Create and push the tag
-      - Merge the tag into `stable`
-    - [lean4checker](https://github.com/leanprover/lean4checker)
-      - No dependencies
-      - Toolchain bump PR
-      - Create and push the tag
-      - Merge the tag into `stable`
-    - [quote4](https://github.com/leanprover-community/quote4)
-      - No dependencies
-      - Toolchain bump PR
-      - Create and push the tag
-      - Merge the tag into `stable`
-    - [doc-gen4](https://github.com/leanprover/doc-gen4)
-      - Dependencies: exist, but they're not part of the release workflow
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - There is no `stable` branch; skip this step
-    - [Verso](https://github.com/leanprover/verso)
-      - Dependencies: exist, but they're not part of the release workflow
-      - The `SubVerso` dependency should be compatible with _every_ Lean release simultaneously, rather than following this workflow
+    - Re-running `script/release_checklist.py` will then create the tag `v4.6.0` from `master`/`main` and push it (unless `toolchain-tag: false` in the `release_repos.yml` file)
+    - `script/release_checklist.py` will then merge the tag `v4.6.0` into the `stable` branch and push it (unless `stable-branch: false` in the `release_repos.yml` file).
+  - Special notes on repositories with exceptional requirements:
+    - `doc-gen4` has addition dependencies which we do not update at each toolchain release, although occasionally these break and need to be updated manually.
+    - `verso`:
+      - The `subverso` dependency is unusual in that it needs to be compatible with _every_ Lean release simultaneously.
+        Usually you don't need to do anything.
+        If you think something is wrong here please contact David Thrane Christiansen (@david-christiansen)
       - Warnings during `lake update` and `lake build` are expected.
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - There is no `stable` branch; skip this step
-    - [Cli](https://github.com/leanprover/lean4-cli)
-      - No dependencies
-      - Toolchain bump PR
-      - Create and push the tag
-      - There is no `stable` branch; skip this step
-    - [ProofWidgets4](https://github.com/leanprover-community/ProofWidgets4)
-      - Dependencies: `Batteries`
-      - Note on versions and branches:
-        - `ProofWidgets` uses a sequential version tagging scheme, e.g. `v0.0.29`,
-          which does not refer to the toolchain being used.
-        - Make a new release in this sequence after merging the toolchain bump PR.
-        - `ProofWidgets` does not maintain a `stable` branch.
-      - Toolchain bump PR
-      - Create and push the tag, following the version convention of the repository
-    - [Aesop](https://github.com/leanprover-community/aesop)
-      - Dependencies: `Batteries`
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - Merge the tag into `stable`
-    - [import-graph](https://github.com/leanprover-community/import-graph)
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - There is no `stable` branch; skip this step
-    - [plausible](https://github.com/leanprover-community/plausible)
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - There is no `stable` branch; skip this step
-    - [Mathlib](https://github.com/leanprover-community/mathlib4)
-      - Dependencies: `Aesop`, `ProofWidgets4`, `lean4checker`, `Batteries`, `doc-gen4`, `quote4`, `import-graph`
-      - Toolchain bump PR notes:
-        - Upstream dependencies should use their `main` or `master` branch, not toolchain tags.
-          (Unlike for other repos.)
-        - Push the PR branch to the main Mathlib repository rather than a fork, or CI may not work reliably
-        - Create and push the tag
-        - Create a new branch from the tag, push it, and open a pull request against `stable`.
-          Coordinate with a Mathlib maintainer to get this merged.
-    - [REPL](https://github.com/leanprover-community/repl)
-      - Dependencies: `Mathlib` (for test code)
-      - Note that there are two copies of `lean-toolchain`/`lakefile.lean`:
-        in the root, and in `test/Mathlib/`. Edit both, and run `lake update` in both directories.
-      - Toolchain bump PR including updated Lake manifest
-      - Create and push the tag
-      - Merge the tag into `stable`
-- Run `script/release_checklist.py v4.6.0` again to check that everything is in order.
+    - `reference-manual`: the release notes generated by `script/release_notes.py` as described above must be included in
+      `Manual/Releases/v4.6.0.lean`, and `import` and `include` statements adding in `Manual/Releases.lean`. 
+    - `ProofWidgets4` uses a non-standard sequential version tagging scheme, e.g. `v0.0.29`, which does not refer to the toolchain being used.
+      You will need to identify the next available version number from https://github.com/leanprover-community/ProofWidgets4/releases,
+      and push a new tag after merging the PR to `main`.
+    - `mathlib4`:
+      - The `lakefile.toml` should always refer to dependencies via their `main` or `master` branch,
+        not a toolchain tag
+        (with the exception of `ProofWidgets4`, which *must* use a sequential version tag).
+      - Push the PR branch to the main Mathlib repository rather than a fork, or CI may not work reliably
+    - `repl`:
+      There are two copies of `lean-toolchain`/`lakefile.lean`:
+      in the root, and in `test/Mathlib/`. Edit both, and run `lake update` in both directories.
+- An awkward situation that sometimes occurs (e.g. with Verso) is that the `master`/`main` branch has already been moved
+  to a nightly toolchain that comes *after* the stable toolchain we are
+  targeting. In this case it is necessary to create a branch `releases/v4.6.0` from the last commit which was on
+  an earlier toolchain, move that branch to the stable toolchain, and create the toolchain tag from that branch.
+- Run `script/release_checklist.py v4.6.0` one last time to check that everything is in order.
 - Finally, make an announcement!
   This should go in https://leanprover.zulipchat.com/#narrow/stream/113486-announce, with topic `v4.6.0`.
   Please see previous announcements for suggested language.
@@ -131,14 +81,14 @@ We'll use `v4.6.0` as the intended release version as a running example.
   If there is a blog post, link to that from the zulip announcement.
 - Make sure that whoever is handling social media knows the release is out.
 
-## Optimistic(?) time estimates:
-- Initial checks and push the tag: 30 minutes.
-- Waiting for the release: 60 minutes.
-- Fixing release notes: 10 minutes.
-- Bumping toolchains in downstream repositories, up to creating the Mathlib PR: 30 minutes.
+## Time estimates:
+- Initial checks and push the tag: 10 minutes.
+- Waiting for the release: 120 minutes.
+- Preparing release notes: 10 minutes.
+- Bumping toolchains in downstream repositories, up to creating the Mathlib PR: 60 minutes.
 - Waiting for Mathlib CI and bors: 120 minutes.
-- Finalizing Mathlib tags and stable branch, and updating REPL: 15 minutes.
-- Posting announcement and/or blog post: 20 minutes.
+- Finalizing Mathlib tags and stable branch, and updating REPL: 20 minutes.
+- Posting announcement and/or blog post: 30 minutes.
 
 # Creating a release candidate.
 
@@ -150,6 +100,8 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
   We will use `nightly-2024-02-29` in this example.
 - It is essential to choose the nightly that will become the release candidate as early as possible, to avoid confusion.
 - Throughout this process you can use `script/release_checklist.py v4.7.0-rc1` to track progress.
+  This script will also try to do some steps autonomously. It is idempotent and safe to run at any point.
+  You can prevent it taking any actions using `--dry-run`.
 - It is essential that Batteries and Mathlib already have reviewed branches compatible with this nightly.
   - Check that both Batteries and Mathlib's `bump/v4.7.0` branch contain `nightly-2024-02-29`
     in their `lean-toolchain`.
@@ -160,8 +112,8 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
     git fetch nightly tag nightly-2024-02-29
     git checkout nightly-2024-02-29
     git checkout -b releases/v4.7.0
+    git push --set-upstream origin releases/v4.18.0
     ```
-- In `RELEASES.md` replace `Development in progress` in the `v4.7.0` section with `Release notes to be written.`
 - In `src/CMakeLists.txt`,
   - verify that you see `set(LEAN_VERSION_MINOR 7)` (for whichever `7` is appropriate); this should already have been updated when the development cycle began.
   - change the `LEAN_VERSION_IS_RELEASE` line to `set(LEAN_VERSION_IS_RELEASE 1)` (this should be a change; on `master` and nightly releases it is always `0`).
@@ -169,66 +121,59 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
 - `git tag v4.7.0-rc1`
 - `git push origin v4.7.0-rc1`
 - Now wait, while CI runs.
+  - The CI setup parses the tag to discover the `-rc1` special description, and passes it to `cmake` using a `-D` option. The `-rc1` doesn't need to be placed in the configuration file.
   - You can monitor this at `https://github.com/leanprover/lean4/actions/workflows/ci.yml`, looking for the `v4.7.0-rc1` tag.
-  - This step can take up to an hour.
-- (GitHub release notes) Once the release appears at https://github.com/leanprover/lean4/releases/
-  - Verify that the release is marked as a prerelease (this should have been done automatically by the CI release job).
-  - Generate release notes by running `script/release_notes.py --since v4.6.0` on the `releases/v4.7.0` branch.
+  - This step can take up to two hours.
+- Verify that the release appears at https://github.com/leanprover/lean4/releases/, marked as a prerelease (this should have been done automatically by the CI release job).
+- Next we need to prepare the release notes.
+  - Run `script/release_notes.py --since v4.6.0` on the `releases/v4.7.0` branch,
+    which will report diagnostic messages on `stderr`
+    (including reporting commits that it couldn't associate with a PR, and hence will be omitted)
+    and then a chunk of markdown on `stdout`.
     See the section "Writing the release notes" below for more information.
+  - Release notes live in https://github.com/leanprover/reference-manual, in e.g. `Manual/Releases/v4.7.0.lean`.
+    It's best if you update these at the same time as a you update the `lean-toolchain` for the `reference-manual` repository, see below. 
 - Next, we will move a curated list of downstream repos to the release candidate.
   - This assumes that for each repository either:
     * There is already a *reviewed* branch `bump/v4.7.0` containing the required adaptations.
       The preparation of this branch is beyond the scope of this document.
     * The repository does not need any changes to move to the new version.
-  - For each of the target repositories:
-    - If the repository does not need any changes (i.e. `bump/v4.7.0` does not exist) then create
-      a new PR updating `lean-toolchain` to `leanprover/lean4:v4.7.0-rc1` and running `lake update`.
-    - Otherwise:
-      - Checkout the `bump/v4.7.0` branch.
-      - Verify that the `lean-toolchain` is set to the nightly from which the release candidate was created.
-      - `git merge origin/master`
-      - Change the `lean-toolchain` to `leanprover/lean4:v4.7.0-rc1`
-      - In `lakefile.lean`, change any dependencies which were using `nightly-testing` or `bump/v4.7.0` branches
-        back to `master` or `main`, and run `lake update` for those dependencies.
-      - Run `lake build` to ensure that dependencies are found (but it's okay to stop it after a moment).
-      - `git commit`
-      - `git push`
-      - Open a PR from `bump/v4.7.0` to `master`, and either merge it yourself after CI, if appropriate,
-        or notify the maintainers that it is ready to go.
-    - Once the PR has been merged, tag `master` with `v4.7.0-rc1` and push this tag.
-  - We do this for the same list of repositories as for stable releases, see above.
+    * Note that sometimes there are *unreviewed* but necessary changes on the `nightly-testing` branch of the repository.
+      If so, you will need to merge these into the `bump_to_v4.7.0-rc1` branch manually.
+  - For each of the repositories listed in `script/release_repos.yml`,
+    - Run `script/release_steps.py v4.7.0-rc1 <repo>` (e.g. replacing `<repo>` with `batteries`), which will walk you through the following steps:
+      - Create a new branch off `master`/`main` (as specified in the `branch` field), called `bump_to_v4.7.0-rc1`.
+      - Merge `origin/bump/v4.7.0` if relevant (i.e. `bump-branch: true` appears in `release_repos.yml`).
+      - Otherwise, you *may* need to merge `origin/nightly-testing`.
+      - Note that for `verso` and `reference-manual` development happens on `nightly-testing`, so
+        we will merge that branch into `bump_to_v4.7.0-rc1`, but it is essential in the GitHub interface that we do a rebase merge,
+        in order to preserve the history.
+      - Update the contents of `lean-toolchain` to `leanprover/lean4:v4.7.0-rc1`.
+      - In the `lakefile.toml` or `lakefile.lean`, if there are dependencies on `nightly-testing`, `bump/v4.7.0`, or specific version tags, update them to the new tag.
+        If they depend on `main` or `master`, don't change this; you've just updated the dependency, so `lake update` will take care of modifying the manifest.
+      - Run `lake update`
+      - Run `lake build && if lake check-test; then lake test; fi` to check things are working.
+      - Commit the changes as `chore: bump toolchain to v4.7.0-rc1` and push.
+      - Create a PR with title "chore: bump toolchain to v4.7.0-rc1".
+    - Merge the PR once CI completes. (Recall: for `verso` and `reference-manual` you will need to do a rebase merge.)
+    - Re-running `script/release_checklist.py` will then create the tag `v4.7.0-rc1` from `master`/`main` and push it (unless `toolchain-tag: false` in the `release_repos.yml` file)
+  - We do this for the same list of repositories as for stable releases, see above for notes about special cases.
     As above, there are dependencies between these, and so the process above is iterative.
     It greatly helps if you can merge the `bump/v4.7.0` PRs yourself!
   - It is essential for Mathlib and Batteries CI that you then create the next `bump/v4.8.0` branch
     for the next development cycle.
     Set the `lean-toolchain` file on this branch to same `nightly` you used for this release.
-  - (Note: we're currently uncertain if we really want to do this step. Check with Kim Morrison if you're unsure.)
-    For Batteries/Aesop/Mathlib, which maintain a `nightly-testing` branch, make sure there is a tag
-    `nightly-testing-2024-02-29` with date corresponding to the nightly used for the release
-    (create it if not), and then on the `nightly-testing` branch `git reset --hard master`, and force push.
+- Run `script/release_checklist.py v4.7.0-rc1` one last time to check that everything is in order.
 - Make an announcement!
   This should go in https://leanprover.zulipchat.com/#narrow/stream/113486-announce, with topic `v4.7.0-rc1`.
   Please see previous announcements for suggested language.
   You will want a few bullet points for main topics from the release notes.
   Please also make sure that whoever is handling social media knows the release is out.
 - Begin the next development cycle (i.e. for `v4.8.0`) on the Lean repository, by making a PR that:
+  - Uses branch name `dev_cycle_v4.8`.
   - Updates `src/CMakeLists.txt` to say `set(LEAN_VERSION_MINOR 8)`
-  - Replaces the "release notes will be copied" text in the `v4.6.0` section of `RELEASES.md` with the
-    finalized release notes from the `releases/v4.6.0` branch.
-  - Replaces the "development in progress" in the `v4.7.0` section of `RELEASES.md` with
-    ```
-    Release candidate, release notes will be copied from the branch `releases/v4.7.0` once completed.
-    ```
-    and inserts the following section before that section:
-    ```
-    v4.8.0
-    ----------
-    Development in progress.
-    ```
-  - Removes all the entries from the `./releases_drafts/` folder.
   - Titled "chore: begin development cycle for v4.8.0"
 
-
 ## Time estimates:
 Slightly longer than the corresponding steps for a stable release.
 Similar process, but more things go wrong.
@@ -273,7 +218,7 @@ Run this as `script/release_notes.py --since v4.6.0`, where `v4.6.0` is the *pre
 This script should be run on the `releases/v4.7.0` branch.
 This will generate output for all commits since that tag.
 Note that there is output on both stderr, which should be manually reviewed,
-and on stdout, which should be manually copied to `RELEASES.md`.
+and on stdout, which should be manually copied into the `reference-manual` repository, in the file `Manual/Releases/v4.7.0.lean`.
 
 The output on stderr should mostly be about commits for which the script could not find an associated PR,
 usually because a PR was rebase-merged because it contained an update to stage0.
@@ -281,12 +226,4 @@ Some judgement is required here: ignore commits which look minor,
 but manually add items to the release notes for significant PRs that were rebase-merged.
 
 There can also be pre-written entries in `./releases_drafts`, which should be all incorporated in the release notes and then deleted from the branch.
-  See `./releases_drafts/README.md` for more information.
-
-# `release_checklist.py`
-
-The script `script/release_checklist.py` attempts to automate checking the status of the release.
-
-Future improvements:
-* We check the release notes have been posted on Github,
-  but do not check that they are present in `RELEASES.md` on the release branch or on `master`.
+See `./releases_drafts/README.md` for more information.

doc/examples.md

@@ -1,9 +0,0 @@
-Examples
-========
-
-- [Palindromes](examples/palindromes.lean.md)
-- [Binary Search Trees](examples/bintree.lean.md)
-- [A Certified Type Checker](examples/tc.lean.md)
-- [The Well-Typed Interpreter](examples/interp.lean.md)
-- [Dependent de Bruijn Indices](examples/deBruijn.lean.md)
-- [Parametric Higher-Order Abstract Syntax](examples/phoas.lean.md)

doc/examples/README.md

@@ -0,0 +1,4 @@
+These examples are checked in Lean's CI to ensure that they continue
+to work. They are included in the documentation section of the Lean
+website via a script that copies the latest version, in order to
+ensure that the website tracks Lean releases rather than `master`.

doc/examples/bintree.lean.md

@@ -1,5 +0,0 @@
-(this example is rendered by Alectryon in the CI)
-
-```lean
-{{#include bintree.lean}}
-```

doc/examples/deBruijn.lean.md

@@ -1,5 +0,0 @@
-(this example is rendered by Alectryon in the CI)
-
-```lean
-{{#include deBruijn.lean}}
-```

doc/examples/interp.lean.md

@@ -1,5 +0,0 @@
-(this example is rendered by Alectryon in the CI)
-
-```lean
-{{#include interp.lean}}
-```

doc/examples/palindromes.lean.md

@@ -1,5 +0,0 @@
-(this example is rendered by Alectryon in the CI)
-
-```lean
-{{#include palindromes.lean}}
-```

doc/examples/phoas.lean.md

@@ -1,5 +0,0 @@
-(this example is rendered by Alectryon in the CI)
-
-```lean
-{{#include phoas.lean}}
-```

doc/examples/tc.lean.md

@@ -1,5 +0,0 @@
-(this example is rendered by Alectryon in the CI)
-
-```lean
-{{#include tc.lean}}
-```

doc/examples/widgets.lean.md

@@ -1,5 +0,0 @@
-(this chapter is rendered by Alectryon in the CI)
-
-```lean
-{{#include widgets.lean}}
-```

doc/expressions.md

@@ -1,550 +0,0 @@
-Expressions
-===========
-
-Every expression in Lean has a [Type](types.md). Every type is also an
-expression of type `Sort u` for some universe level u. See [Type
-Universes](types.md#type_universes).
-
-Expression Syntax
-=================
-
-The set of expressions in Lean is defined inductively as follows:
-
-* ``Sort u`` : the universe of types at universe level ``u``
-* ``c`` : where ``c`` is an identifier denoting a declared constant or a defined object
-* ``x`` : where ``x`` is a variable in the local context in which the expression is interpreted
-* `m?`  : where `m?` is a metavariable in the metavariable context in which the expression is interpreted,
-  you can view metavariable as a "hole" that still needs to be synthesized
-* ``(x : α) → β`` : the type of functions taking an element ``x`` of ``α`` to an element of ``β``,
-  where ``β`` is an expression whose type is a ``Sort``
-* ``s t`` : the result of applying ``s`` to ``t``, where ``s`` and ``t`` are expressions
-* ``fun x : α => t`` or `λ x : α => t`: the function mapping any value ``x`` of type ``α`` to ``t``, where ``t`` is an expression
-* ``let x := t; s`` : a local definition, denotes the value of ``s`` when ``x`` is replaced by ``t``
-* `s.i`   : a projection, denotes the value of the `i`-th field of `s`
-* `lit`   : a natural number or string literal
-* `mdata k s` : the expression `s` decorated with metadata `k`, where is a key-value map
-
-Every well formed term in Lean has a *type*, which itself is an expression of type ``Sort u`` for some ``u``. The fact that a term ``t`` has type ``α`` is written ``t : α``.
-
-For an expression to be well formed, its components have to satisfy certain typing constraints. These, in turn, determine the type of the resulting term, as follows:
-
-* ``Sort u : Sort (u + 1)``
-* ``c : α``, where ``α`` is the type that ``c`` has been declared or defined to have
-* ``x : α``, where ``α`` is the type that ``x`` has been assigned in the local context where it is interpreted
-* ``?m : α``, where ``α`` is the type that ``?m`` has been declared in the metavariable context where it is interpreted
-* ``(x : α) → β : Sort (imax u v)`` where ``α : Sort u``, and ``β : Sort v`` assuming ``x : α``
-* ``s t : β[t/x]`` where ``s`` has type ``(x : α) → β`` and ``t`` has type ``α``
-* ``(fun x : α => t) : (x : α) → β`` if ``t`` has type ``β`` whenever ``x`` has type ``α``
-* ``(let x := t; s) : β[t/x]`` where ``t`` has type ``α`` and ``s`` has type ``β`` assuming ``x : α``
-* `lit : Nat` if `lit` is a numeral
-* `lit : String` if `lit` is a string literal
-* `mdata k s : α` if `s : α`
-* `s.i : α` if `s : β` and `β` is an inductive datatype with only one constructor, and `i`-th field has type `α`
-
-``Prop`` abbreviates ``Sort 0``, ``Type`` abbreviates ``Sort 1``, and
-``Type u`` abbreviates ``Sort (u + 1)`` when ``u`` is a universe
-variable. We say "``α`` is a type" to express ``α : Type u`` for some
-``u``, and we say "``p`` is a proposition" to express
-``p : Prop``. Using the *propositions as types* correspondence, given
-``p : Prop``, we refer to an expression ``t : p`` as a *proof* of ``p``. In
-contrast, given ``α : Type u`` for some ``u`` and ``t : α``, we
-sometimes refer to ``t`` as *data*.
-
-When the expression ``β`` in ``(x : α) → β`` does not depend on ``x``,
-it can be written ``α → β``. As usual, the variable ``x`` is bound in
-``(x : α) →  β``, ``fun x : α => t``, and ``let x := t; s``. The
-expression ``∀ x : α, β`` is alternative syntax for ``(x : α) →  β``,
-and is intended to be used when ``β`` is a proposition. An underscore
-can be used to generate an internal variable in a binder, as in
-``fun _ : α => t``.
-
-*Metavariables*, that is, temporary placeholders, are used in the
-process of constructing terms. Terms that are added to the
-environment contain neither metavariable nor variables, which is to
-say, they are fully elaborated and make sense in the empty context.
-
-Axioms can be declared using the ``axiom`` keyword.
-Similarly, objects can be defined in various ways, such as using ``def`` and ``theorem`` keywords.
-See [Chapter Declarations](./declarations.md) for more information.
-
-Writing an expression ``(t : α)`` forces Lean to elaborate ``t`` so that it has type ``α`` or report an error if it fails.
-
-Lean supports anonymous constructor notation, anonymous projections,
-and various forms of match syntax, including destructuring ``fun`` and
-``let``. These, as well as notation for common data types (like pairs,
-lists, and so on) are discussed in [Chapter Declarations](./declarations.md)
-in connection with inductive types.
-
-```lean
-universe u
-
-#check Sort 0
-#check Prop
-#check Sort 1
-#check Type
-#check Sort u
-#check Sort (u+1)
-
-#check Nat → Bool
-#check (α : Type u) → List α
-#check (α : Type u) → (β : Type u) → Sum α β
-#check fun x : Nat => x
-#check fun (α : Type u) (x : α) => x
-#check let x := 5; x * 2
-#check "hello"
-#check (fun x => x) true
-```
-
-Implicit Arguments
-==================
-
-When declaring arguments to defined objects in Lean (for example, with
-``def``, ``theorem``, ``axiom``, ``constant``, ``inductive``, or
-``structure``; see [Chapter Declarations](./declarations.md) or when
-declaring variables in sections (see [Other Commands](./other_commands.md)),
-arguments can be annotated as *explicit* or *implicit*.
-This determines how expressions containing the object are interpreted.
-
-* ``(x : α)`` : an explicit argument of type ``α``
-* ``{x : α}`` : an implicit argument, eagerly inserted
-* ``⦃x : α⦄`` or ``{{x : α}}`` : an implicit argument, weakly inserted
-* ``[x : α]`` : an implicit argument that should be inferred by type class resolution
-* ``(x : α := v)`` : an optional argument, with default value ``v``
-* ``(x : α := by tac)`` : an implicit argument, to be synthesized by tactic ``tac``
-
-The name of the variable can be omitted from a class resolution
-argument, in which case an internal name is generated.
-
-When a function has an explicit argument, you can nonetheless ask
-Lean's elaborator to infer the argument automatically, by entering it
-as an underscore (``_``). Conversely, writing ``@foo`` indicates that
-all of the arguments to be ``foo`` are to be given explicitly,
-independent of how ``foo`` was declared.  You can also provide a value
-for an implicit parameter using named arguments.  Named arguments
-enable you to specify an argument for a parameter by matching the
-argument with its name rather than with its position in the parameter
-list.  If you don't remember the order of the parameters but know
-their names, you can send the arguments in any order.  You may also
-provide the value for an implicit parameter whenLean failed to infer
-it. Named arguments also improve the readability of your code by
-identifying what each argument represents.
-
-
-```lean
-def add (x y : Nat) : Nat :=
-  x + y
-
-#check add 2 3 -- Nat
-#eval add 2 3  -- 5
-
-def id1 (α : Type u) (x : α) : α := x
-
-#check id1 Nat 3
-#check id1 _ 3
-
-def id2 {α : Type u} (x : α) : α := x
-
-#check id2 3
-#check @id2 Nat 3
-#check id2 (α := Nat) 3
-#check id2
-#check id2 (α := Nat)
-
-def id3 {{α : Type u}} (x : α) : α := x
-
-#check id3 3
-#check @id3 Nat 3
-#check (id3 : (α : Type) → α → α)
-
-class Cls where
-  val : Nat
-
-instance Cls_five : Cls where
-  val := 5
-
-def ex2 [c : Cls] : Nat := c.val
-
-example : ex2 = 5 := rfl
-
-def ex2a [Cls] : Nat := ex2
-
-example : ex2a = 5 := rfl
-
-def ex3 (x : Nat := 5) := x
-
-#check ex3 2
-#check ex3
-
-example : ex3 = 5 := rfl
-
-def ex4 (x : Nat) (y : Nat := x) : Nat :=
-  x * y
-
-example : ex4 x = x * x :=
-  rfl
-```
-
-Basic Data Types and Assertions
-===============================
-
-The core library contains a number of basic data types, such as the
-natural numbers (`Nat`), the integers (`Int`), the
-booleans (``Bool``), and common operations on these, as well as the
-usual logical quantifiers and connectives. Some example are given
-below. A list of common notations and their precedences can be found
-in a [file](https://github.com/leanprover/lean4/blob/master/src/Init/Notation.lean)
-in the core library. The core library also contains a number of basic
-data type constructors. Definitions can also be found the
-[Data](https://github.com/leanprover/lean4/blob/master/src/Init/Data)
-directory of the core library. For more information, see also [Chapter libraries](./libraries.md).
-
-```
-/- numbers -/
-def f1 (a b c : Nat) : Nat :=
-  a^2 + b^2 + c^2
-
-def p1 (a b c d : Nat) : Prop :=
-  (a + b)^c ≤ d
-
-def p2 (i j k : Int) : Prop :=
-  i % (j * k) = 0
-
-
-/- booleans -/
-
-def f2 (a b c : Bool) : Bool :=
-  a && (b || c)
-
-/- pairs -/
-
-#eval (1, 2)
-
-def p : Nat × Bool := (1, false)
-
-section
-variable (a b c : Nat) (p : Nat × bool)
-
-#check (1, 2)
-#check p.1 * 2
-#check p.2 && tt
-#check ((1, 2, 3) : Nat × Nat × Nat)
-end
-
-/- lists -/
-section
-variable x y z : Nat
-variable xs ys zs : list Nat
-open list
-
-#check (1 :: xs) ++ (y :: zs) ++ [1,2,3]
-#check append (cons 1 xs) (cons y zs)
-#check map (λ x, x^2) [1, 2, 3]
-end
-
-/- sets -/
-section
-variable s t u : set Nat
-
-#check ({1, 2, 3} ∩ s) ∪ ({x | x < 7} ∩ t)
-end
-
-/- strings and characters -/
-#check "hello world"
-#check 'a'
-
-/- assertions -/
-#check ∀ a b c n : Nat,
-  a ≠ 0 ∧ b ≠ 0 ∧ c ≠ 0 ∧ n > 2 → a^n + b^n ≠ c^n
-
-def unbounded (f : Nat → Nat) : Prop := ∀ M, ∃ n, f n ≥ M
-```
-.. _constructors_projections_and_matching:
-
-Constructors, Projections, and Matching
-=======================================
-
-Lean's foundation, the *Calculus of Inductive Constructions*, supports the declaration of *inductive types*. Such types can have any number of *constructors*, and an associated *eliminator* (or *recursor*). Inductive types with one constructor, known as *structures*, have *projections*. The full syntax of inductive types is described in [Declarations](declarations.md), but here we describe some syntactic elements that facilitate their use in expressions.
-
-When Lean can infer the type of an expression and it is an inductive type with one constructor, then one can write ``⟨a1, a2, ..., an⟩`` to apply the constructor without naming it. For example, ``⟨a, b⟩`` denotes ``prod.mk a b`` in a context where the expression can be inferred to be a pair, and ``⟨h₁, h₂⟩`` denotes ``and.intro h₁ h₂`` in a context when the expression can be inferred to be a conjunction. The notation will nest constructions automatically, so ``⟨a1, a2, a3⟩`` is interpreted as ``prod.mk a1 (prod.mk a2 a3)`` when the expression is expected to have a type of the form ``α1 × α2 × α3``. (The latter is interpreted as ``α1 × (α2 × α3)``, since the product associates to the right.)
-
-Similarly, one can use "dot notation" for projections: one can write ``p.fst`` and ``p.snd`` for ``prod.fst p`` and ``prod.snd p`` when Lean can infer that ``p`` is an element of a product, and ``h.left`` and ``h.right`` for ``and.left h`` and ``and.right h`` when ``h`` is a conjunction.
-
-The anonymous projector notation can used more generally for any objects defined in a *namespace* (see [Other Commands](other_commands.md)). For example, if ``l`` has type ``list α`` then ``l.map f`` abbreviates ``list.map f l``, in which ``l`` has been placed at the first argument position where ``list.map`` expects a ``list``.
-
-Finally, for data types with one constructor, one destruct an element by pattern matching using the ``let`` and ``assume`` constructs, as in the examples below. Internally, these are interpreted using the ``match`` construct, which is in turn compiled down for the eliminator for the inductive type, as described in [Declarations](declarations.md).
-
-.. code-block:: lean
-
-    universes u v
-    variable {α : Type u} {β : Type v}
-
-    def p : Nat × ℤ := ⟨1, 2⟩
-    #check p.fst
-    #check p.snd
-
-    def p' : Nat × ℤ × bool := ⟨1, 2, tt⟩
-    #check p'.fst
-    #check p'.snd.fst
-    #check p'.snd.snd
-
-    def swap_pair (p : α × β) : β × α :=
-    ⟨p.snd, p.fst⟩
-
-    theorem swap_conj {a b : Prop} (h : a ∧ b) : b ∧ a :=
-    ⟨h.right, h.left⟩
-
-    #check [1, 2, 3].append [2, 3, 4]
-    #check [1, 2, 3].map (λ x, x^2)
-
-    example (p q : Prop) : p ∧ q → q ∧ p :=
-    λ h, ⟨h.right, h.left⟩
-
-    def swap_pair' (p : α × β) : β × α :=
-    let (x, y) := p in (y, x)
-
-    theorem swap_conj' {a b : Prop} (h : a ∧ b) : b ∧ a :=
-    let ⟨ha, hb⟩ := h in ⟨hb, ha⟩
-
-    def swap_pair'' : α × β → β × α :=
-    λ ⟨x, y⟩, (y, x)
-
-    theorem swap_conj'' {a b : Prop} : a ∧ b → b ∧ a :=
-    assume ⟨ha, hb⟩, ⟨hb, ha⟩
-
-Structured Proofs
-=================
-
-Syntactic sugar is provided for writing structured proof terms:
-
-* ``have h : p := s; t`` is sugar for ``(fun h : p => t) s``
-* ``suffices h : p from s; t`` is sugar for ``(λ h : p => s) t``
-* ``suffices h : p by s; t`` is sugar for ``(suffixes h : p from by s; t)``
-* ``show p from t`` is sugar for ``(have this : p := t; this)``
-* ``show p by tac`` is sugar for ``(show p from by tac)``
-
-Types can be omitted when they can be inferred by Lean. Lean also
-allows ``have : p := t; s``, which gives the assumption the
-name ``this`` in the local context.  Similarly, Lean recognizes the
-variant ``suffices p from s; t``, which use the name ``this`` for the new hypothesis.
-
-The notation ``‹p›`` is notation for ``(by assumption : p)``, and can
-therefore be used to apply hypotheses in the local context.
-
-As noted in [Constructors, Projections and Matching](#constructors_projections_and_matching),
-anonymous constructors and projections and match syntax can be used in proofs just as in expressions that denote data.
-
-.. code-block:: lean
-
-    example (p q r : Prop) : p → (q ∧ r) → p ∧ q :=
-    assume h₁ : p,
-    assume h₂ : q ∧ r,
-    have h₃ : q, from and.left h₂,
-    show p ∧ q, from and.intro h₁ h₃
-
-    example (p q r : Prop) : p → (q ∧ r) → p ∧ q :=
-    assume : p,
-    assume : q ∧ r,
-    have q, from and.left this,
-    show p ∧ q, from and.intro ‹p› this
-
-    example (p q r : Prop) : p → (q ∧ r) → p ∧ q :=
-    assume h₁ : p,
-    assume h₂ : q ∧ r,
-    suffices h₃ : q, from and.intro h₁ h₃,
-    show q, from and.left h₂
-
-Lean also supports a calculational environment, which is introduced with the keyword ``calc``. The syntax is as follows:
-
-.. code-block:: text
-
-    calc
-      <expr>_0  'op_1'  <expr>_1  ':'  <proof>_1
-        '...'   'op_2'  <expr>_2  ':'  <proof>_2
-         ...
-        '...'   'op_n'  <expr>_n  ':'  <proof>_n
-
-Each ``<proof>_i`` is a proof for ``<expr>_{i-1} op_i <expr>_i``.
-
-Here is an example:
-
-.. code-block:: lean
-
-    variable (a b c d e : Nat)
-    variable h1 : a = b
-    variable h2 : b = c + 1
-    variable h3 : c = d
-    variable h4 : e = 1 + d
-
-    theorem T : a = e :=
-    calc
-      a     = b      : h1
-        ... = c + 1  : h2
-        ... = d + 1  : congr_arg _ h3
-        ... = 1 + d  : add_comm d (1 : Nat)
-        ... =  e     : eq.symm h4
-
-The style of writing proofs is most effective when it is used in conjunction with the ``simp`` and ``rewrite`` tactics.
-
-.. _computation:
-
-Computation
-===========
-
-Two expressions that differ up to a renaming of their bound variables are said to be *α-equivalent*, and are treated as syntactically equivalent by Lean.
-
-Every expression in Lean has a natural computational interpretation, unless it involves classical elements that block computation, as described in the next section. The system recognizes the following notions of *reduction*:
-
-* *β-reduction* : An expression ``(λ x, t) s`` β-reduces to ``t[s/x]``, that is, the result of replacing ``x`` by ``s`` in ``t``.
-* *ζ-reduction* : An expression ``let x := s in t`` ζ-reduces to ``t[s/x]``.
-* *δ-reduction* : If ``c`` is a defined constant with definition ``t``, then ``c`` δ-reduces to ``t``.
-* *ι-reduction* : When a function defined by recursion on an inductive type is applied to an element given by an explicit constructor, the result ι-reduces to the specified function value, as described in [Inductive Types](inductive.md).
-
-The reduction relation is transitive, which is to say, is ``s`` reduces to ``s'`` and ``t`` reduces to ``t'``, then ``s t`` reduces to ``s' t'``, ``λ x, s`` reduces to ``λ x, s'``, and so on. If ``s`` and ``t`` reduce to a common term, they are said to be *definitionally equal*. Definitional equality is defined to be the smallest equivalence relation that satisfies all these properties and also includes α-equivalence and the following two relations:
-
-* *η-equivalence* : An expression ``(λx, t x)`` is η-equivalent to ``t``, assuming ``x`` does not occur in ``t``.
-* *proof irrelevance* : If ``p : Prop``, ``s : p``, and ``t : p``, then ``s`` and ``t`` are  considered to be equivalent.
-
-This last fact reflects the intuition that once we have proved a proposition ``p``, we only care that is has been proved; the proof does nothing more than witness the fact that ``p`` is true.
-
-Definitional equality is a strong notion of equality of values. Lean's logical foundations sanction treating definitionally equal terms as being the same when checking that a term is well-typed and/or that it has a given type.
-
-The reduction relation is believed to be strongly normalizing, which is to say, every sequence of reductions applied to a term will eventually terminate. The property guarantees that Lean's type-checking algorithm terminates, at least in principle. The consistency of Lean and its soundness with respect to set-theoretic semantics do not depend on either of these properties.
-
-Lean provides two commands to compute with expressions:
-
-* ``#reduce t`` : use the kernel type-checking procedures to carry out reductions on ``t`` until no more reductions are possible, and show the result
-* ``#eval t`` : evaluate ``t`` using a fast bytecode evaluator, and show the result
-
-Every computable definition in Lean is compiled to bytecode at definition time. Bytecode evaluation is more liberal than kernel evaluation: types and all propositional information are erased, and functions are evaluated using a stack-based virtual machine. As a result, ``#eval`` is more efficient than ``#reduce,`` and can be used to execute complex programs. In contrast, ``#reduce`` is designed to be small and reliable, and to produce type-correct terms at each step. Bytecode is never used in type checking, so as far as soundness and consistency are concerned, only kernel reduction is part of the trusted computing base.
-
-.. code-block:: lean
-
-    #reduce (fun x => x + 3) 5
-    #eval   (fun x => x + 3) 5
-
-    #reduce let x := 5; x + 3
-    #eval   let x := 5; x + 3
-
-    def f x := x + 3
-
-    #reduce f 5
-    #eval   f 5
-
-    #reduce @Nat.rec (λ n => Nat) (0 : Nat)
-                     (λ n recval : Nat => recval + n + 1) (5 : Nat)
-
-    def g : Nat → Nat
-    | 0     => 0
-    | (n+1) => g n + n + 1
-
-    #reduce g 5
-    #eval   g 5
-
-    #eval   g 5000
-
-    example : (fun x => x + 3) 5 = 8 := rfl
-    example : (fun x => f x) = f := rfl
-    example (p : Prop) (h₁ h₂ : p) : h₁ = h₂ := rfl
-
-Note: the combination of proof irrelevance and singleton ``Prop`` elimination in ι-reduction renders the ideal version of definitional equality, as described above, undecidable. Lean's procedure for checking definitional equality is only an approximation to the ideal. It is not transitive, as illustrated by the example below. Once again, this does not compromise the consistency or soundness of Lean; it only means that Lean is more conservative in the terms it recognizes as well typed, and this does not cause problems in practice. Singleton elimination will be discussed in greater detail in [Inductive Types](inductive.md).
-
-.. code-block:: lean
-
-    def R (x y : unit) := false
-    def accrec := @acc.rec unit R (λ_, unit) (λ _ a ih, ()) ()
-    example (h) : accrec h = accrec (acc.intro _ (λ y, acc.inv h)) :=
-                  rfl
-    example (h) : accrec (acc.intro _ (λ y, acc.inv h)) = () := rfl
-    example (h) : accrec h = () := sorry   -- rfl fails
-
-
-Axioms
-======
-
-Lean's foundational framework consists of:
-
-- type universes and dependent function types, as described above
-
-- inductive definitions, as described in [Inductive Types](inductive.md) and
-[Inductive Families](declarations.md#inductive-families).
-
-In addition, the core library defines (and trusts) the following axiomatic extensions:
-
-- propositional extensionality:
-
-  .. code-block:: lean
-
-     namespace hide
-
-     -- BEGIN
-     axiom propext {a b : Prop} : (a ↔ b) → a = b
-     -- END
-
-     end hide
-
-- quotients:
-
-  .. code-block:: lean
-
-     namespace hide
-     -- BEGIN
-     universes u v
-
-     constant quot      : Π {α : Sort u}, (α → α → Prop) → Sort u
-
-     constant quot.mk   : Π {α : Sort u} (r : α → α → Prop),
-                          α → quot r
-
-     axiom    quot.ind  : ∀ {α : Sort u} {r : α → α → Prop}
-                            {β : quot r → Prop},
-                          (∀ a, β (quot.mk r a)) →
-                            ∀ (q : quot r), β q
-
-     constant quot.lift : Π {α : Sort u} {r : α → α → Prop}
-                            {β : Sort u} (f : α → β),
-                          (∀ a b, r a b → f a = f b) → quot r → β
-
-     axiom quot.sound   : ∀ {α : Type u} {r : α → α → Prop}
-                            {a b : α},
-                          r a b → quot.mk r a = quot.mk r b
-     -- END
-     end hide
-
-  ``quot r`` represents the quotient of ``α`` by the smallest equivalence relation containing ``r``. ``quot.mk`` and ``quot.lift`` satisfy the following computation rule:
-
-  .. code-block:: text
-
-     quot.lift f h (quot.mk r a) = f a
-
-- choice:
-
-  .. code-block:: lean
-
-     namespace hide
-     universe u
-
-     -- BEGIN
-     axiom choice {α : Sort u} : nonempty α → α
-     -- END
-
-     end hide
-
-  Here ``nonempty α`` is defined as follows:
-
-  .. code-block:: lean
-
-     namespace hide
-     universe u
-
-     -- BEGIN
-     class inductive nonempty (α : Sort u) : Prop
-     | intro : α → nonempty
-     -- END
-
-     end hide
-
-  It is equivalent to  ``∃ x : α, true``.
-
-The quotient construction implies function extensionality. The ``choice`` principle, in conjunction with the others, makes the axiomatic foundation classical; in particular, it implies the law of the excluded middle and propositional decidability. Functions that make use of ``choice`` to produce data are incompatible with a computational interpretation, and do not produce bytecode. They have to be declared ``noncomputable``.
-
-For metaprogramming purposes, Lean also allows the definition of objects which stand outside the object language. These are denoted with the ``meta`` keyword, as described in [Metaprogramming](metaprogramming.md).

doc/faq.md

@@ -1,55 +0,0 @@
-Frequently Asked Questions
-==========================
-
-### What is Lean?
-
-Lean is a new open source theorem prover being developed at Microsoft Research.
-It is a research project that aims to bridge the gap between interactive and automated theorem proving.
-Lean can be also used as a programming language. Actually, some Lean features are implemented in Lean itself.
-
-### Should I use Lean?
-
-Lean is under heavy development, and we are constantly trying new
-ideas and tweaking the system.  It is a research project and not a product.
-Things change rapidly, and we constantly break backward compatibility.
-Lean comes "as is", you should not expect we will fix bugs and/or add new features for your project.
-We have our own priorities, and will not change them to accommodate your needs.
-Even if you implement a new feature or fix a bug, we may not want to merge it because
-it may conflict with our plans for Lean, it may not be performant, we may not want to maintain it,
-we may be busy, etc. If you really need this new feature or bug fix, we suggest you create your own fork and maintain it yourself.
-
-### Where is the documentation?
-
-This is the Lean 4 manual. It is a work in progress, but it will eventually cover the whole language.
-A public and very active chat room dedicated to Lean is open on [Zulip](https://leanprover.zulipchat.com).
-It is a good place to interact with other Lean users.
-
-### Should I use Lean to teach a course?
-
-Lean has been used to teach courses on logic, type theory and programming languages at CMU and the University of Washington.
-The lecture notes for the CMU course [Logic and Proof](https://lean-lang.org/logic_and_proof) are available online,
-but they are for Lean 3.
-If you decide to teach a course using Lean, we suggest you prepare all material before the beginning of the course, and
-make sure that Lean attends all your needs. You should not expect we will fix bugs and/or add features needed for your course.
-
-### Are there IDEs for Lean?
-
-Yes, see [Setting Up Lean](./setup.md).
-
-### Is Lean sound? How big is the kernel? Should I trust it?
-
-Lean has a relatively small kernel.
-Several independent checkers have been implemented for Lean 3. Two of them are
-[tc](https://github.com/leanprover/tc) and [trepplein](https://github.com/gebner/trepplein).
-We expect similar independent checkers will be built for Lean 4.
-
-### Should I open a new issue?
-
-We use [GitHub](https://github.com/leanprover/lean4/issues) to track bugs and new features.
-Bug reports are always welcome, but nitpicking issues are not (e.g., the error message is confusing).
-See also our [contribution guidelines](https://github.com/leanprover/lean4/blob/master/CONTRIBUTING.md).
-
-### Is it Lean, LEAN, or L∃∀N?
-
-We always use "Lean" in writing.
-When specifying a major version number, we append it together with a single space: Lean 4.

doc/flake.lock

@@ -1,151 +0,0 @@
-{
-  "nodes": {
-    "alectryon": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1654613606,
-        "narHash": "sha256-IGCn1PzTyw8rrwmyWUiw3Jo/dyZVGkMslnHYW7YB8yk=",
-        "owner": "Kha",
-        "repo": "alectryon",
-        "rev": "c3b16f650665745e1da4ddfcc048d3bd639f71d5",
-        "type": "github"
-      },
-      "original": {
-        "owner": "Kha",
-        "ref": "typeid",
-        "repo": "alectryon",
-        "type": "github"
-      }
-    },
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1710146030,
-        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "lean": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs",
-        "nixpkgs-old": "nixpkgs-old"
-      },
-      "locked": {
-        "lastModified": 0,
-        "narHash": "sha256-saRAtQ6VautVXKDw1XH35qwP0KEBKTKZbg/TRa4N9Vw=",
-        "path": "../.",
-        "type": "path"
-      },
-      "original": {
-        "path": "../.",
-        "type": "path"
-      }
-    },
-    "leanInk": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1704976501,
-        "narHash": "sha256-FSBUsbX0HxakSnYRYzRBDN2YKmH9EkA0q9p7TSPEJTI=",
-        "owner": "leanprover",
-        "repo": "LeanInk",
-        "rev": "51821e3c2c032c88e4b2956483899d373ec090c4",
-        "type": "github"
-      },
-      "original": {
-        "owner": "leanprover",
-        "ref": "refs/pull/57/merge",
-        "repo": "LeanInk",
-        "type": "github"
-      }
-    },
-    "mdBook": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1660074464,
-        "narHash": "sha256-W30G7AeWBjdJE/CQZJU5vJjaDGZtpmxEKNMEvaYtuF8=",
-        "owner": "leanprover",
-        "repo": "mdBook",
-        "rev": "9321c10c502cd59eea8afc4325a84eab3ddf9391",
-        "type": "github"
-      },
-      "original": {
-        "owner": "leanprover",
-        "repo": "mdBook",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1710889954,
-        "narHash": "sha256-Pr6F5Pmd7JnNEMHHmspZ0qVqIBVxyZ13ik1pJtm2QXk=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "7872526e9c5332274ea5932a0c3270d6e4724f3b",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs-old": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1581379743,
-        "narHash": "sha256-i1XCn9rKuLjvCdu2UeXKzGLF6IuQePQKFt4hEKRU5oc=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "34c7eb7545d155cc5b6f499b23a7cb1c96ab4d59",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-19.03",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "alectryon": "alectryon",
-        "flake-utils": [
-          "lean",
-          "flake-utils"
-        ],
-        "lean": "lean",
-        "leanInk": "leanInk",
-        "mdBook": "mdBook"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

doc/flake.nix

@@ -1,93 +0,0 @@
-{
-  description = "Lean documentation";
-
-  inputs.lean.url = path:../.;
-  inputs.flake-utils.follows = "lean/flake-utils";
-  inputs.mdBook = {
-    url = "github:leanprover/mdBook";
-    flake = false;
-  };
-  inputs.alectryon = {
-    url = "github:Kha/alectryon/typeid";
-    flake = false;
-  };
-  inputs.leanInk = {
-    url = "github:leanprover/LeanInk/refs/pull/57/merge";
-    flake = false;
-  };
-
-  outputs = inputs@{ self, ... }: inputs.flake-utils.lib.eachDefaultSystem (system:
-    with inputs.lean.packages.${system}.deprecated; with nixpkgs;
-    let
-      doc-src = lib.sourceByRegex ../. ["doc.*" "tests(/lean(/beginEndAsMacro.lean)?)?"];
-    in {
-    packages = rec {
-      lean-mdbook = mdbook.overrideAttrs (drv: rec {
-        name = "lean-${mdbook.name}";
-        src = inputs.mdBook;
-        cargoDeps = drv.cargoDeps.overrideAttrs (_: {
-          inherit src;
-          outputHash = "sha256-CO3A9Kpp4sIvkT9X3p+GTidazk7Fn4jf0AP2PINN44A=";
-        });
-        doCheck = false;
-      });
-      book = stdenv.mkDerivation {
-        name ="lean-doc";
-        src = doc-src;
-        buildInputs = [ lean-mdbook ];
-        buildCommand = ''
-          mkdir $out
-          # necessary for `additional-css`...?
-          cp -r --no-preserve=mode $src/doc/* .
-          # overwrite stub .lean.md files
-          cp -r ${inked}/* .
-          mdbook build -d $out
-        '';
-      };
-      leanInk = (buildLeanPackage {
-        name = "Main";
-        src = inputs.leanInk;
-        deps = [ (buildLeanPackage {
-          name = "LeanInk";
-          src = inputs.leanInk;
-        }) ];
-        executableName = "leanInk";
-        linkFlags = ["-rdynamic"];
-      }).executable;
-      alectryon = python3Packages.buildPythonApplication {
-        name = "alectryon";
-        src = inputs.alectryon;
-        propagatedBuildInputs =
-          [ leanInk lean-all ] ++
-          # https://github.com/cpitclaudel/alectryon/blob/master/setup.cfg
-          (with python3Packages; [ pygments dominate beautifulsoup4 docutils ]);
-        doCheck = false;
-      };
-      renderLeanMod = mod: mod.overrideAttrs (final: prev: {
-        name = "${prev.name}.md";
-        buildInputs = prev.buildInputs ++ [ alectryon ];
-        outputs = [ "out" ];
-        buildCommand = ''
-          dir=$(dirname $relpath)
-          mkdir -p $dir out/$dir
-          if [ -d $src ]; then cp -r $src/. $dir/; else cp $src $leanPath; fi
-          alectryon --frontend lean4+markup $leanPath --backend webpage -o $out/$leanPath.md
-        '';
-      });
-      renderPackage = pkg: symlinkJoin {
-        name = "${pkg.name}-mds";
-        paths = map renderLeanMod (lib.attrValues pkg.mods);
-      };
-      literate = buildLeanPackage {
-        name = "literate";
-        src = ./.;
-        roots = [
-          { mod = "examples"; glob = "submodules"; }
-        ];
-      };
-      inked = renderPackage literate;
-      doc = book;
-    };
-    defaultPackage = self.packages.${system}.doc;
-  });
-}

doc/fplean.md

@@ -1,7 +0,0 @@
-Functional Programming in Lean
-=======================
-
-The goal of [this book](https://lean-lang.org/functional_programming_in_lean/) is to be an accessible introduction to using Lean 4 as a programming language.
-It should be useful both to people who want to use Lean as a general-purpose programming language and to mathematicians who want to develop larger-scale proof automation but do not have a background in functional programming.
-It does not assume any background with functional programming, though it's probably not a good first book on programming in general.
-New content will be added once per month until it's done.

doc/funabst.md

@@ -1,145 +0,0 @@
-## Function Abstraction and Evaluation
-
-We have seen that if we have ``m n : Nat``, then we have ``(m, n) : Nat × Nat``.
-This gives us a way of creating pairs of natural numbers.
-Conversely, if we have ``p : Nat × Nat``, then
-we have ``p.1 : Nat`` and ``p.2 : Nat``.
-This gives us a way of "using" a pair, by extracting its two components.
-
-We already know how to "use" a function ``f : α → β``, namely,
-we can apply it to an element ``a : α`` to obtain ``f a : β``.
-But how do we create a function from another expression?
-
-The companion to application is a process known as "lambda abstraction."
-Suppose that giving a variable ``x : α`` we can construct an expression ``t : β``.
-Then the expression ``fun (x : α) => t``, or, equivalently, ``λ (x : α) => t``, is an object of type ``α → β``.
-Think of this as the function from ``α`` to ``β`` which maps any value ``x`` to the value ``t``,
-which may depend on ``x``.
-
-```lean
-#check fun (x : Nat) => x + 5
-#check λ (x : Nat) => x + 5
-#check fun x : Nat => x + 5
-#check λ x : Nat => x + 5
-```
-
-Here are some more examples:
-
-```lean
-constant f : Nat → Nat
-constant h : Nat → Bool → Nat
-
-#check fun x : Nat => fun y : Bool => h (f x) y   -- Nat → Bool → Nat
-#check fun (x : Nat) (y : Bool) => h (f x) y      -- Nat → Bool → Nat
-#check fun x y => h (f x) y                       -- Nat → Bool → Nat
-```
-
-Lean interprets the final three examples as the same expression; in the last expression,
-Lean infers the type of ``x`` and ``y`` from the types of ``f`` and ``h``.
-
-Some mathematically common examples of operations of functions can be described in terms of lambda abstraction:
-
-```lean
-constant f : Nat → String
-constant g : String → Bool
-constant b : Bool
-
-#check fun x : Nat => x        -- Nat → Nat
-#check fun x : Nat => b        -- Nat → Bool
-#check fun x : Nat => g (f x)  -- Nat → Bool
-#check fun x => g (f x)        -- Nat → Bool
-```
-
-Think about what these expressions mean. The expression ``fun x : Nat => x`` denotes the identity function on ``Nat``,
-the expression ``fun x : α => b`` denotes the constant function that always returns ``b``,
-and ``fun x : Nat => g (f x)``, denotes the composition of ``f`` and ``g``.
-We can, in general, leave off the type annotation on a variable and let Lean infer it for us.
-So, for example, we can write ``fun x => g (f x)`` instead of ``fun x : Nat => g (f x)``.
-
-We can abstract over the constants `f` and `g` in the previous definitions:
-
-```lean
-#check fun (g : String → Bool) (f : Nat → String) (x : Nat) => g (f x)
--- (String → Bool) → (Nat → String) → Nat → Bool
-```
-
-We can also abstract over types:
-
-```lean
-#check fun (α β γ : Type) (g : β → γ) (f : α → β) (x : α) => g (f x)
-```
-The last expression, for example, denotes the function that takes three types, ``α``, ``β``, and ``γ``, and two functions, ``g : β → γ`` and ``f : α → β``, and returns the composition of ``g`` and ``f``. (Making sense of the type of this function requires an understanding of dependent products, which we will explain below.) Within a lambda expression ``fun x : α => t``, the variable ``x`` is a "bound variable": it is really a placeholder, whose "scope" does not extend beyond ``t``.
-For example, the variable ``b`` in the expression ``fun (b : β) (x : α) => b`` has nothing to do with the constant ``b`` declared earlier.
-In fact, the expression denotes the same function as ``fun (u : β) (z : α), u``. Formally, the expressions that are the same up to a renaming of bound variables are called *alpha equivalent*, and are considered "the same." Lean recognizes this equivalence.
-
-Notice that applying a term ``t : α → β`` to a term ``s : α`` yields an expression ``t s : β``.
-Returning to the previous example and renaming bound variables for clarity, notice the types of the following expressions:
-
-```lean
-#check (fun x : Nat => x) 1     -- Nat
-#check (fun x : Nat => true) 1  -- Bool
-
-constant f : Nat → String
-constant g : String → Bool
-
-#check
-  (fun (α β γ : Type) (g : β → γ) (f : α → β) (x : α) => g (f x)) Nat String Bool g f 0
-  -- Bool
-```
-
-As expected, the expression ``(fun x : Nat =>  x) 1`` has type ``Nat``.
-In fact, more should be true: applying the expression ``(fun x : Nat => x)`` to ``1`` should "return" the value ``1``. And, indeed, it does:
-
-```lean
-#reduce (fun x : Nat => x) 1     -- 1
-#reduce (fun x : Nat => true) 1  -- true
-
-constant f : Nat → String
-constant g : String → Bool
-
-#reduce
-  (fun (α β γ : Type) (g : β → γ) (f : α → β) (x : α) => g (f x)) Nat String Bool g f 0
-  -- g (f 0)
-```
-
-The command ``#reduce`` tells Lean to evaluate an expression by *reducing* it to its normal form,
-which is to say, carrying out all the computational reductions that are sanctioned by its kernel.
-The process of simplifying an expression ``(fun x => t) s`` to ``t[s/x]`` -- that is, ``t`` with ``s`` substituted for the variable ``x`` --
-is known as *beta reduction*, and two terms that beta reduce to a common term are called *beta equivalent*.
-But the ``#reduce`` command carries out other forms of reduction as well:
-
-```lean
-constant m : Nat
-constant n : Nat
-constant b : Bool
-
-#reduce (m, n).1        -- m
-#reduce (m, n).2        -- n
-
-#reduce true && false   -- false
-#reduce false && b      -- false
-#reduce b && false      -- Bool.rec false false b
-
-#reduce n + 0           -- n
-#reduce n + 2           -- Nat.succ (Nat.succ n)
-#reduce 2 + 3           -- 5
-```
-
-We explain later how these terms are evaluated.
-For now, we only wish to emphasize that this is an important feature of dependent type theory:
-every term has a computational behavior, and supports a notion of reduction, or *normalization*.
-In principle, two terms that reduce to the same value are called *definitionally equal*.
-They are considered "the same" by Lean's type checker, and Lean does its best to recognize and support these identifications.
-The `#reduce` command is mainly useful to understand why two terms are considered the same.
-
-Lean is also a programming language. It has a compiler to native code and an interpreter.
-You can use the command `#eval` to execute expressions, and it is the preferred way of testing your functions.
-Note that `#eval` and `#reduce` are *not* equivalent. The command `#eval` first compiles Lean expressions
-into an intermediate representation (IR) and then uses an interpreter to execute the generated IR.
-Some builtin types (e.g., `Nat`, `String`, `Array`) have a more efficient representation in the IR.
-The IR has support for using foreign functions that are opaque to Lean.
-
-In contrast, the ``#reduce`` command relies on a reduction engine similar to the one used in Lean's trusted kernel,
-the part of Lean that is responsible for checking and verifying the correctness of expressions and proofs.
-It is less efficient than ``#eval``, and treats all foreign functions as opaque constants.
-We later discuss other differences between the two commands.

doc/introdef.md

@@ -1,66 +0,0 @@
-## Introducing Definitions
-
-The ``def`` command provides one important way of defining new objects.
-
-```lean
-
-def foo : (Nat → Nat) → Nat :=
-  fun f => f 0
-
-#check foo   -- (Nat → Nat) → Nat
-#print foo
-```
-
-We can omit the type when Lean has enough information to infer it:
-
-```lean
-def foo :=
-  fun (f : Nat → Nat) => f 0
-```
-
-The general form of a definition is ``def foo : α := bar``. Lean can usually infer the type ``α``, but it is often a good idea to write it explicitly.
-This clarifies your intention, and Lean will flag an error if the right-hand side of the definition does not have the right type.
-
-Lean also allows us to use an alternative format that puts the abstracted variables before the colon and omits the lambda:
-```lean
-def double (x : Nat) : Nat :=
-  x + x
-
-#print double
-#check double 3
-#reduce double 3  -- 6
-#eval double 3    -- 6
-
-def square (x : Nat) :=
-  x * x
-
-#print square
-#check square 3
-#reduce square 3  -- 9
-#eval square 3    -- 9
-
-def doTwice (f : Nat → Nat) (x : Nat) : Nat :=
-  f (f x)
-
-#eval doTwice double 2   -- 8
-```
-
-These definitions are equivalent to the following:
-
-```lean
-def double : Nat → Nat :=
-  fun x => x + x
-
-def square : Nat → Nat :=
-  fun x => x * x
-
-def doTwice : (Nat → Nat) → Nat → Nat :=
-  fun f x => f (f x)
-```
-
-We can even use this approach to specify arguments that are types:
-
-```lean
-def compose (α β γ : Type) (g : β → γ) (f : α → β) (x : α) : γ :=
-  g (f x)
-```

doc/lean3changes.md

@@ -1,369 +0,0 @@
-# Significant changes from Lean 3
-
-Lean 4 is not backward compatible with Lean 3.
-We have rewritten most of the system, and took the opportunity to cleanup the syntax,
-metaprogramming framework, and elaborator. In this section, we go over the most significant
-changes.
-
-## Lambda expressions
-
-We do not use `,` anymore to separate the binders from the lambda expression body.
-The Lean 3 syntax for lambda expressions was unconventional, and `,` has been overused in Lean 3.
-For example, we believe a list of lambda expressions is quite confusing in Lean 3, since `,` is used
-to separate the elements of a list, and in the lambda expression itself. We now use `=>` as the separator,
-as an example, `fun x => x` is the identity function. One may still use the symbol `λ` as a shorthand for `fun`.
-The lambda expression notation has many new features that are not supported in Lean 3.
-
-## Pattern matching
-
-In Lean 4, one can easily create new notation that abbreviates commonly used idioms. One of them is a
-`fun` followed by a `match`. In the following examples, we define a few functions using `fun`+`match` notation.
-
-```lean
-# namespace ex1
-def Prod.str : Nat × Nat → String :=
-  fun (a, b) => "(" ++ toString a ++ ", " ++ toString b ++ ")"
-
-structure Point where
-  x : Nat
-  y : Nat
-  z : Nat
-
-def Point.addX : Point → Point → Nat :=
-  fun { x := a, .. } { x := b, .. } =>  a+b
-
-def Sum.str : Option Nat → String :=
-  fun
-    | some a => "some " ++ toString a
-    | none   => "none"
-# end ex1
-```
-
-## Implicit lambdas
-
-In Lean 3 stdlib, we find many [instances](https://github.com/leanprover/lean/blob/master/library/init/category/reader.lean#L39) of the dreadful `@`+`_` idiom.
-It is often used when the expected type is a function type with implicit arguments,
-and we have a constant (`reader_t.pure` in the example) which also takes implicit arguments. In Lean 4, the elaborator automatically introduces lambdas
-for consuming implicit arguments. We are still exploring this feature and analyzing its impact, but the experience so far has been very positive. As an example,
-here is the example in the link above using Lean 4 implicit lambdas.
-
-```lean
-# variable (ρ : Type) (m : Type → Type) [Monad m]
-instance : Monad (ReaderT ρ m) where
-  pure := ReaderT.pure
-  bind := ReaderT.bind
-```
-
-Users can disable the implicit lambda feature by using `@` or writing a lambda expression with `{}` or `[]` binder annotations.
-Here are few examples
-
-```lean
-# namespace ex2
-def id1 : {α : Type} → α → α :=
-  fun x => x
-
-def listId : List ({α : Type} → α → α) :=
-  (fun x => x) :: []
-
--- In this example, implicit lambda introduction has been disabled because
--- we use `@` before `fun`
-def id2 : {α : Type} → α → α :=
-  @fun α (x : α) => id1 x
-
-def id3 : {α : Type} → α → α :=
-  @fun α x => id1 x
-
-def id4 : {α : Type} → α → α :=
-  fun x => id1 x
-
--- In this example, implicit lambda introduction has been disabled
--- because we used the binder annotation `{...}`
-def id5 : {α : Type} → α → α :=
-  fun {α} x => id1 x
-# end ex2
-```
-
-## Sugar for simple functions
-
-In Lean 3, we can create simple functions from infix operators by using parentheses. For example, `(+1)` is sugar for `fun x, x + 1`. In Lean 4, we generalize this notation using `·` as a placeholder. Here are a few examples:
-
-```lean
-# namespace ex3
-#check (· + 1)
--- fun a => a + 1
-#check (2 - ·)
--- fun a => 2 - a
-#eval [1, 2, 3, 4, 5].foldl (·*·) 1
--- 120
-
-def f (x y z : Nat) :=
-  x + y + z
-
-#check (f · 1 ·)
--- fun a b => f a 1 b
-
-#eval [(1, 2), (3, 4), (5, 6)].map (·.1)
--- [1, 3, 5]
-# end ex3
-```
-
-As in Lean 3, the notation is activated using parentheses, and the lambda abstraction is created by collecting the nested `·`s.
-The collection is interrupted by nested parentheses. In the following example, two different lambda expressions are created.
-
-```lean
-#check (Prod.mk · (· + 1))
--- fun a => (a, fun b => b + 1)
-```
-
-## Function applications
-
-In Lean 4, we have support for named arguments.
-Named arguments enable you to specify an argument for a parameter by matching the argument with
-its name rather than with its position in the parameter list.
-If you don't remember the order of the parameters but know their names,
-you can send the arguments in any order. You may also provide the value for an implicit parameter when
-Lean failed to infer it. Named arguments also improve the readability of your code by identifying what
-each argument represents.
-
-```lean
-def sum (xs : List Nat) :=
-  xs.foldl (init := 0) (·+·)
-
-#eval sum [1, 2, 3, 4]
--- 10
-
-example {a b : Nat} {p : Nat → Nat → Nat → Prop} (h₁ : p a b b) (h₂ : b = a)
-    : p a a b :=
-  Eq.subst (motive := fun x => p a x b) h₂ h₁
-```
-In the following examples, we illustrate the interaction between named and default arguments.
-
-```lean
-def f (x : Nat) (y : Nat := 1) (w : Nat := 2) (z : Nat) :=
-  x + y + w - z
-
-example (x z : Nat) : f (z := z) x = x + 1 + 2 - z := rfl
-
-example (x z : Nat) : f x (z := z) = x + 1 + 2 - z := rfl
-
-example (x y : Nat) : f x y = fun z => x + y + 2 - z := rfl
-
-example : f = (fun x z => x + 1 + 2 - z) := rfl
-
-example (x : Nat) : f x = fun z => x + 1 + 2 - z := rfl
-
-example (y : Nat) : f (y := 5) = fun x z => x + 5 + 2 - z := rfl
-
-def g {α} [Add α] (a : α) (b? : Option α := none) (c : α) : α :=
-  match b? with
-  | none   => a + c
-  | some b => a + b + c
-
-variable {α} [Add α]
-
-example : g = fun (a c : α) => a + c := rfl
-
-example (x : α) : g (c := x) = fun (a : α) => a + x := rfl
-
-example (x : α) : g (b? := some x) = fun (a c : α) => a + x + c := rfl
-
-example (x : α) : g x = fun (c : α) => x + c := rfl
-
-example (x y : α) : g x y = fun (c : α) => x + y + c := rfl
-```
-
-In Lean 4, we can use `..` to provide missing explicit arguments as `_`.
-This feature combined with named arguments is useful for writing patterns. Here is an example:
-```lean
-inductive Term where
-  | var    (name : String)
-  | num    (val : Nat)
-  | add    (fn : Term) (arg : Term)
-  | lambda (name : String) (type : Term) (body : Term)
-
-def getBinderName : Term → Option String
-  | Term.lambda (name := n) .. => some n
-  | _ => none
-
-def getBinderType : Term → Option Term
-  | Term.lambda (type := t) .. => some t
-  | _ => none
-```
-Ellipsis are also useful when explicit argument can be automatically inferred by Lean, and we want
-to avoid a sequence of `_`s.
-```lean
-example (f : Nat → Nat) (a b c : Nat) : f (a + b + c) = f (a + (b + c)) :=
-  congrArg f (Nat.add_assoc ..)
-```
-
-In Lean 4, writing `f(x)` in place of `f x` is no longer allowed, you must use whitespace between the function and its arguments (e.g., `f (x)`).
-
-## Dependent function types
-
-Given `α : Type` and `β : α → Type`, `(x : α) → β x` denotes the type of functions `f` with the property that,
-for each `a : α`, `f a` is an element of `β a`. In other words, the type of the value returned by `f` depends on its input.
-We say `(x : α) → β x` is a dependent function type. In Lean 3, we write the dependent function type `(x : α) → β x` using
-one of the following three equivalent notations:
-`forall x : α, β x` or `∀ x : α, β x` or `Π x : α, β x`.
-The first two were intended to be used for writing propositions, and the latter for writing code.
-Although the notation `Π x : α, β x` has historical significance, we have removed it from Lean 4 because
-it is awkward to use and often confuses new users. We can still write `forall x : α, β x` and `∀ x : α, β x`.
-
-```lean
-#check forall (α : Type), α → α
-#check ∀ (α : Type), α → α
-#check ∀ α : Type, α → α
-#check ∀ α, α → α
-#check (α : Type) → α → α
-#check {α : Type} → (a : Array α) → (i : Nat) → i < a.size → α
-#check {α : Type} → [ToString α] → α → String
-#check forall {α : Type} (a : Array α) (i : Nat), i < a.size → α
-#check {α β : Type} → α → β → α × β
-```
-
-## The `meta` keyword
-
-In Lean 3, the keyword `meta` is used to mark definitions that can use primitives implemented in C/C++.
-These metadefinitions can also call themselves recursively, relaxing the termination
-restriction imposed by ordinary type theory. Metadefinitions may also use unsafe primitives such as
-`eval_expr (α : Type u) [reflected α] : expr → tactic α`, or primitives that break referential transparency
-`tactic.unsafe_run_io`.
-
-The keyword `meta` has been currently removed from Lean 4. However, we may re-introduce it in the future,
-but with a much more limited purpose: marking meta code that should not be included in the executables produced by Lean.
-
-The keyword `constant` has been deleted in Lean 4, and `axiom` should be used instead. In Lean 4, the new command `opaque` is used to define an opaque definition. Here are two simple examples:
-```lean
-# namespace meta1
-opaque x : Nat := 1
--- The following example will not type check since `x` is opaque
--- example : x = 1 := rfl
-
--- We can evaluate `x`
-#eval x
--- 1
-
--- When no value is provided, the elaborator tries to build one automatically for us
--- using the `Inhabited` type class
-opaque y : Nat
-# end meta1
-```
-
-We can instruct Lean to use a foreign function as the implementation for any definition
-using the attribute `@[extern "foreign_function"]`. It is the user's responsibility to ensure the
-foreign implementation is correct.
-However, a user mistake here will only impact the code generated by Lean, and
-it will **not** compromise the logical soundness of the system.
-That is, you cannot prove `False` using the `@[extern]` attribute.
-We use `@[extern]` with definitions when we want to provide a reference implementation in Lean
-that can be used for reasoning. When we write a definition such as
-```lean
-@[extern "lean_nat_add"]
-def add : Nat → Nat → Nat
-  | a, Nat.zero   => a
-  | a, Nat.succ b => Nat.succ (add a b)
-```
-Lean assumes that the foreign function `lean_nat_add` implements the reference implementation above.
-
-The `unsafe` keyword allows us to define functions using unsafe features such as general recursion,
-and arbitrary type casting. Regular (safe) functions cannot directly use `unsafe` ones since it would
-compromise the logical soundness of the system. As in regular programming languages, programs written
-using unsafe features may crash at runtime. Here are a few unsafe examples:
-```lean
-unsafe def unsound : False :=
-  unsound
-
-#check @unsafeCast
--- {α : Type _} → {β : Type _} → α → β
-
-unsafe def nat2String (x : Nat) : String :=
-  unsafeCast x
-
--- The following definition doesn't type check because it is not marked as `unsafe`
--- def nat2StringSafe (x : Nat) : String :=
---   unsafeCast x
-```
-
-The `unsafe` keyword is particularly useful when we want to take advantage of an implementation detail of the
-Lean execution runtime. For example, we cannot prove in Lean that arrays have a maximum size, but
-the runtime used to execute Lean programs guarantees that an array cannot have more than 2^64 (2^32) elements
-in a 64-bit (32-bit) machine. We can take advantage of this fact to provide a more efficient implementation for
-array functions. However, the efficient version would not be very useful if it can only be used in
-unsafe code. Thus, Lean 4 provides the attribute `@[implemented_by functionName]`. The idea is to provide
-an unsafe (and potentially more efficient) version of a safe definition or constant. The function `f`
-at the attribute `@[implemented_by f]` is very similar to an extern/foreign function,
-the key difference is that it is implemented in Lean itself. Again, the logical soundness of the system
-cannot be compromised by using the attribute `implemented_by`, but if the implementation is incorrect your
-program may crash at runtime. In the following example, we define `withPtrUnsafe a k h` which
-executes `k` using the memory address where `a` is stored in memory. The argument `h` is proof
-that `k` is a constant function. Then, we "seal" this unsafe implementation at `withPtr`. The proof `h`
-ensures the reference implementation `k 0` is correct. For more information, see the article
-"Sealing Pointer-Based Optimizations Behind Pure Functions".
-```lean
-unsafe
-def withPtrUnsafe {α β : Type} (a : α) (k : USize → β) (h : ∀ u, k u = k 0) : β :=
-  k (ptrAddrUnsafe a)
-
-@[implemented_by withPtrUnsafe]
-def withPtr {α β : Type} (a : α) (k : USize → β) (h : ∀ u, k u = k 0) : β :=
-  k 0
-```
-
-General recursion is very useful in practice, and it would be impossible to implement Lean 4 without it.
-The keyword `partial` implements a very simple and efficient approach for supporting general recursion.
-Simplicity was key here because of the bootstrapping problem. That is, we had to implement Lean in Lean before
-many of its features were implemented (e.g., the tactic framework or support for wellfounded recursion).
-Another requirement for us was performance. Functions tagged with `partial` should be as efficient as the ones implemented in mainstream functional programming
-languages such as OCaml. When the `partial` keyword is used, Lean generates an auxiliary `unsafe` definition that
-uses general recursion, and then defines an opaque constant that is implemented by this auxiliary definition.
-This is very simple, efficient, and is sufficient for users that want to use Lean as a regular programming language.
-A `partial` definition cannot use unsafe features such as `unsafeCast` and `ptrAddrUnsafe`, and it can only be used to
-implement types we already known to be inhabited. Finally, since we "seal" the auxiliary definition using an opaque
-constant, we cannot reason about `partial` definitions.
-
-We are aware that proof assistants such as Isabelle provide a framework for defining partial functions that does not
-prevent users from proving properties about them. This kind of framework can be implemented in Lean 4. Actually,
-it can be implemented by users since Lean 4 is an extensible system. The developers current have no plans to implement
-this kind of support for Lean 4. However, we remark that users can implement it using a function that traverses
-the auxiliary unsafe definition generated by Lean, and produces a safe one using an approach similar to the one used in Isabelle.
-
-```lean
-# namespace partial1
-partial def f (x : Nat) : IO Unit := do
-  IO.println x
-  if x < 100 then
-     f (x+1)
-
-#eval f 98
-# end partial1
-```
-
-## Library changes
-
-These are changes to the library which may trip up Lean 3 users:
-
-- `List` is no longer a monad.
-
-## Style changes
-
-Coding style changes have also been made:
-
-- Term constants and variables are now `lowerCamelCase` rather than `snake_case`
-- Type constants are now `UpperCamelCase`, eg `Nat`, `List`. Type variables are still lower case greek letters. Functors are still lower case latin `(m : Type → Type) [Monad m]`.
-- When defining typeclasses, prefer not to use "has". Eg `ToString` or `Add` instead of `HasToString` or `HasAdd`.
-- Prefer `return` to `pure` in monad expressions.
-- Pipes `<|` are preferred to dollars `$` for function application.
-- Declaration bodies should always be indented:
-  ```lean
-  inductive Hello where
-    | foo
-    | bar
-
-  structure Point where
-    x : Nat
-    y : Nat
-
-  def Point.addX : Point → Point → Nat :=
-    fun { x := a, .. } { x := b, .. } => a + b
-  ```
-- In structures and typeclass definitions, prefer `where` to `:=` and don't surround fields with parentheses. (Shown in `Point` above)

doc/lexical_structure.md

@@ -1,180 +0,0 @@
-Lexical Structure
-=================
-
-This section describes the detailed lexical structure of the Lean
-language.
-
-A Lean program consists of a stream of UTF-8 tokens where each token
-is one of the following:
-
-```
-   token: symbol | command | ident | string | raw_string | char | numeral |
-        : decimal | doc_comment | mod_doc_comment | field_notation
-```
-
-Tokens can be separated by the whitespace characters space, tab, line
-feed, and carriage return, as well as comments. Single-line comments
-start with ``--``, whereas multi-line comments are enclosed by ``/-``
-and ``-/`` and can be nested.
-
-Symbols and Commands
-====================
-
-.. *(TODO: list built-in symbols and command tokens?)*
-
-Symbols are static tokens that are used in term notations and
-commands. They can be both keyword-like (e.g. the `have
-<structured_proofs>` keyword) or use arbitrary Unicode characters.
-
-Command tokens are static tokens that prefix any top-level declaration
-or action. They are usually keyword-like, with transitory commands
-like `#print <instructions>` prefixed by the ``#`` character. The set
-of built-in commands is listed in [Other Commands](./other_commands.md).
-
-Users can dynamically extend the sets of both symbols (via the
-commands listed in [Quoted Symbols](#quoted-symbols) and command
-tokens (via the `[user_command] <attributes>` attribute).
-
-.. _identifiers:
-
-Identifiers
-===========
-
-An *atomic identifier*, or *atomic name*, is (roughly) an alphanumeric
-string that does not begin with a numeral. A (hierarchical)
-*identifier*, or *name*, consists of one or more atomic names
-separated by periods.
-
-Parts of atomic names can be escaped by enclosing them in pairs of French double quotes ``«»``.
-
-```lean
-   def Foo.«bar.baz» := 0  -- name parts ["Foo", "bar.baz"]
-```
-
-```
-   ident: atomic_ident | ident "." atomic_ident
-   atomic_ident: atomic_ident_start atomic_ident_rest*
-   atomic_ident_start: letterlike | "_" | escaped_ident_part
-   letterlike: [a-zA-Z] | greek | coptic | letterlike_symbols
-   greek: <[α-ωΑ-Ωἀ-῾] except for [λΠΣ]>
-   coptic: [ϊ-ϻ]
-   letterlike_symbols: [℀-⅏]
-   escaped_ident_part: "«" [^«»\r\n\t]* "»"
-   atomic_ident_rest: atomic_ident_start | [0-9'ⁿ] | subscript
-   subscript: [₀-₉ₐ-ₜᵢ-ᵪⱼ]
-```
-
-String Literals
-===============
-
-String literals are enclosed by double quotes (``"``). They may contain line breaks, which are conserved in the string value.  Backslash (`\`) is a special escape character which can be used to the following
-special characters:
-- `\\` represents an escaped backslash, so this escape causes one backslash to be included in the string.
-- `\"` puts a double quote in the string.
-- `\'` puts an apostrophe in the string.
-- `\n` puts a new line character in the string.
-- `\t` puts a tab character in the string.
-- `\xHH` puts the character represented by the 2 digit hexadecimal into the string.  For example
-"this \x26 that" which become "this & that".  Values above 0x80 will be interpreted according to the
-[Unicode table](https://unicode-table.com/en/) so "\xA9 Copyright 2021" is "© Copyright 2021".
-- `\uHHHH` puts the character represented by the 4 digit hexadecimal into the string, so the following
-string "\u65e5\u672c" will become "日本" which means "Japan".
-- `\` followed by a newline and then any amount of whitespace is a "gap" that is equivalent to the empty string,
-useful for letting a string literal span across multiple lines. Gaps spanning multiple lines can be confusing,
-so the parser raises an error if the trailing whitespace contains any newlines.
-
-So the complete syntax is:
-
-```
-   string       : '"' string_item '"'
-   string_item  : string_char | char_escape | string_gap
-   string_char  : [^"\\]
-   char_escape  : "\" ("\" | '"' | "'" | "n" | "t" | "x" hex_char{2} | "u" hex_char{4})
-   hex_char     : [0-9a-fA-F]
-   string_gap   : "\" newline whitespace*
-```
-
-Raw String Literals
-===================
-
-Raw string literals are string literals without any escape character processing.
-They begin with `r##...#"` (with zero or more `#` characters) and end with `"#...##` (with the same number of `#` characters).
-The contents of a raw string literal may contain `"##..#` so long as the number of `#` characters
-is less than the number of `#` characters used to begin the raw string literal.
-
-```
-   raw_string          : raw_string_aux(0) | raw_string_aux(1) | raw_string_aux(2) | ...
-   raw_string_aux(n)   : 'r' '#'{n} '"' raw_string_item '"' '#'{n}
-   raw_string_item(n)  : raw_string_char | raw_string_quote(n)
-   raw_string_char     : [^"]
-   raw_string_quote(n) : '"' '#'{0..n-1}
-```
-
-Char Literals
-=============
-
-Char literals are enclosed by single quotes (``'``).
-
-```
-   char      : "'" char_item "'"
-   char_item : char_char | char_escape
-   char_char : [^'\\]
-```
-
-Numeric Literals
-================
-
-Numeric literals can be specified in various bases.
-
-```
-   numeral    : numeral10 | numeral2 | numeral8 | numeral16
-   numeral10  : [0-9]+ ("_"+ [0-9]+)*
-   numeral2   : "0" [bB] ("_"* [0-1]+)+
-   numeral8   : "0" [oO] ("_"* [0-7]+)+
-   numeral16  : "0" [xX] ("_"* hex_char+)+
-```
-
-Floating point literals are also possible with optional exponent:
-
-```
-   float    : numeral10 "." numeral10? [eE[+-]numeral10]
-```
-
-For example:
-
-```
-constant w : Int := 55
-constant x : Nat := 26085
-constant y : Nat := 0x65E5
-constant z : Float := 2.548123e-05
-constant b : Bool := 0b_11_01_10_00
-```
-
-Note: that negative numbers are created by applying the "-" negation prefix operator to the number, for example:
-
-```
-constant w : Int := -55
-```
-
-Doc Comments
-============
-
-A special form of comments, doc comments are used to document modules
-and declarations.
-
-```
-   doc_comment: "/--" ([^-] | "-" [^/])* "-/"
-   mod_doc_comment: "/-!" ([^-] | "-" [^/])* "-/"
-```
-
-Field Notation
-==============
-
-Trailing field notation tokens are used in expressions such as
-``(1+1).to_string``. Note that ``a.toString`` is a single
-[Identifier](#identifiers), but may be interpreted as a field
-notation expression by the parser.
-
-```
-   field_notation: "." ([0-9]+ | atomic_ident)
-```

doc/metaprogramming-arith.md

@@ -1,134 +0,0 @@
-# Arithmetic as an embedded domain-specific language
-
-Let's parse another classic grammar, the grammar of arithmetic expressions with
-addition, multiplication, integers, and variables.  In the process, we'll learn
-how to:
-
-- Convert identifiers such as `x` into strings within a macro.
-- add the ability to "escape" the macro context from within the macro. This is useful to interpret identifiers with their _original_ meaning (predefined values)
-  instead of their new meaning within a macro (treat as a symbol).
-
-Let's begin with the simplest thing possible. We'll define an AST, and use operators `+` and `*` to denote
-building an arithmetic AST.
-
-
-Here's the AST that we will be parsing:
-
-```lean,ignore
-{{#include metaprogramming-arith.lean:1:5}}
-```
-
-We declare a syntax category to describe the grammar that we will be parsing.
-See that we control the precedence of `+` and `*` by writing `syntax:50` for addition and `syntax:60` for multiplication,
-indicating that multiplication binds tighter than addition (higher the number, tighter the binding).
-This allows us to declare _precedence_ when defining new syntax.
-
-```lean,ignore
-{{#include metaprogramming-arith.lean:7:13}}
-```
-
-Further, if we look at `syntax:60  arith:60 "+" arith:61 : arith`, the
-precedence declarations at `arith:60 "+" arith:61` conveys that the left
-argument must have precedence at least `60` or greater, and the right argument
-must have precedence at least`61` or greater.  Note that this forces left
-associativity. To understand this, let's compare two hypothetical parses:
-
-```
--- syntax:60  arith:60 "+" arith:61 : arith -- Arith.add
--- a + b + c
-(a:60 + b:61):60 + c
-a + (b:60 + c:61):60
-```
-
-In the parse tree of `a + (b:60 + c:61):60`, we see that the right argument `(b + c)` is given the precedence `60`. However,
-the rule for addition expects the right argument to have a precedence of **at least** 61, as witnessed by the `arith:61` at
-the right-hand-side of `syntax:60 arith:60 "+" arith:61 : arith`. Thus, the rule `syntax:60  arith:60 "+" arith:61 : arith`
-ensures that addition is left associative.
-
-Since addition is declared arguments of precedence `60/61` and multiplication with `70/71`, this causes multiplication to bind
-tighter than addition. Once again, let's compare two hypothetical parses:
-
-```
--- syntax:60  arith:60 "+" arith:61 : arith -- Arith.add
--- syntax:70 arith:70 "*" arith:71 : arith -- Arith.mul
--- a * b + c
-a * (b:60 + c:61):60
-(a:70 * b:71):70 + c
-```
-
-While parsing `a * (b + c)`, `(b + c)` is assigned a precedence `60` by the addition rule. However, multiplication expects
-the right argument to have precedence **at least** 71. Thus, this parse is invalid. In contrast, `(a * b) + c` assigns
-a precedence of `70` to `(a * b)`. This is compatible with addition which expects the left argument to have precedence
-**at least `60` ** (`70` is greater than `60`). Thus, the string `a * b + c` is parsed as `(a * b) + c`.
-For more details, please look at the [Lean manual on syntax extensions](./notation.md#notations-and-precedence).
-
-To go from strings into `Arith`, we define a macro to
-translate the syntax category `arith` into an `Arith` inductive value that
-lives in `term`:
-
-
-```lean,ignore
-{{#include metaprogramming-arith.lean:15:16}}
-```
-
-Our macro rules perform the "obvious" translation:
-
-```lean,ignore
-{{#include metaprogramming-arith.lean:18:23}}
-```
-
-And some examples:
-
-```lean,ignore
-{{#include metaprogramming-arith.lean:25:41}}
-```
-
-Writing variables as strings, such as `"x"`  gets old; wouldn't it be so much
-prettier if we could write `x * y`, and have the macro translate this into `Arith.mul (Arith.Symbol "x") (Arith.mul "y")`?
-We can do this, and this will be our first taste of manipulating macro variables --- we'll use `x.getId` instead of directly evaluating `$x`.
-We also write a macro rule for `Arith|` that translates an identifier into
-a string, using `$(Lean.quote (toString x.getId))`:
-
-```lean,ignore
-{{#include metaprogramming-arith.lean:43:46}}
-```
-
-Let's test and see that we can now write expressions such as `x * y` directly instead of having to write `"x" * "y"`:
-
-```lean,ignore
-{{#include metaprogramming-arith.lean:48:51}}
-```
-
-We now show an unfortunate consequence of the above definitions. Suppose we want to build `(x + y) + z`.
-Since we already have defined `xPlusY` as `x + y`, perhaps we should reuse it! Let's try:
-
-```lean,ignore
-#check `[Arith| xPlusY + z]  -- Arith.add (Arith.symbol "xPlusY") (Arith.symbol "z")
-```
-
-Whoops, that didn't work! What happened? Lean treats `xPlusY` _itself_ as an identifier! So we need to add some syntax
-to be able to "escape" the `Arith|` context. Let's use the syntax `<[ $e:term ]>` to mean: evaluate `$e` as a real term,
-not an identifier. The macro looks like follows:
-
-```lean,ignore
-{{#include metaprogramming-arith.lean:53:56}}
-```
-
-Let's try our previous example:
-
-```lean,ignore
-{{#include metaprogramming-arith.lean:58:58}}
-```
-
-Perfect!
-
-In this tutorial, we expanded on the previous tutorial to parse a more
-realistic grammar with multiple levels of precedence, how to parse identifiers directly
-within a macro, and how to provide an escape from within the macro context.
-
-#### Full code listing
-
-```lean
-{{#include metaprogramming-arith.lean}}
-```
-

doc/mission.md

@@ -1,12 +0,0 @@
-Mission
-=======
-
-Empower software developers to design, develop, and reason about programs.
-Empower mathematicians and scientists to design, develop, and reason about formal models.
-
-How
----
-
-Lean is an efficient functional programming language based on dependent type theory.
-It is under heavy development, but it already generates very efficient code.
-It also has a powerful meta-programming framework, extensible parser, and IDE support based on LSP.

doc/other_commands.md

@@ -1 +0,0 @@
-# Other Commands

doc/pygments.css

@@ -1,83 +0,0 @@
-/* Pygments stylesheet generated by Alectryon (style=None) */
-td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
-span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
-td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
-span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
-.highlight .hll, .code .hll { background-color: #ffffcc }
-.highlight .c, .code .c { color: #555753; font-style: italic } /* Comment */
-.highlight .err, .code .err { color: #a40000; border: 1px solid #cc0000 } /* Error */
-.highlight .g, .code .g { color: #000000 } /* Generic */
-.highlight .k, .code .k { color: #8f5902 } /* Keyword */
-.highlight .l, .code .l { color: #2e3436 } /* Literal */
-.highlight .n, .code .n { color: #000000 } /* Name */
-.highlight .o, .code .o { color: #000000 } /* Operator */
-.highlight .x, .code .x { color: #2e3436 } /* Other */
-.highlight .p, .code .p { color: #000000 } /* Punctuation */
-.highlight .ch, .code .ch { color: #555753; font-weight: bold; font-style: italic } /* Comment.Hashbang */
-.highlight .cm, .code .cm { color: #555753; font-style: italic } /* Comment.Multiline */
-.highlight .cp, .code .cp { color: #3465a4; font-style: italic } /* Comment.Preproc */
-.highlight .cpf, .code .cpf { color: #555753; font-style: italic } /* Comment.PreprocFile */
-.highlight .c1, .code .c1 { color: #555753; font-style: italic } /* Comment.Single */
-.highlight .cs, .code .cs { color: #3465a4; font-weight: bold; font-style: italic } /* Comment.Special */
-.highlight .gd, .code .gd { color: #a40000 } /* Generic.Deleted */
-.highlight .ge, .code .ge { color: #000000; font-style: italic } /* Generic.Emph */
-.highlight .gr, .code .gr { color: #a40000 } /* Generic.Error */
-.highlight .gh, .code .gh { color: #a40000; font-weight: bold } /* Generic.Heading */
-.highlight .gi, .code .gi { color: #4e9a06 } /* Generic.Inserted */
-.highlight .go, .code .go { color: #000000; font-style: italic } /* Generic.Output */
-.highlight .gp, .code .gp { color: #8f5902 } /* Generic.Prompt */
-.highlight .gs, .code .gs { color: #000000; font-weight: bold } /* Generic.Strong */
-.highlight .gu, .code .gu { color: #000000; font-weight: bold } /* Generic.Subheading */
-.highlight .gt, .code .gt { color: #000000; font-style: italic } /* Generic.Traceback */
-.highlight .kc, .code .kc { color: #204a87; font-weight: bold } /* Keyword.Constant */
-.highlight .kd, .code .kd { color: #4e9a06; font-weight: bold } /* Keyword.Declaration */
-.highlight .kn, .code .kn { color: #4e9a06; font-weight: bold } /* Keyword.Namespace */
-.highlight .kp, .code .kp { color: #204a87 } /* Keyword.Pseudo */
-.highlight .kr, .code .kr { color: #8f5902 } /* Keyword.Reserved */
-.highlight .kt, .code .kt { color: #204a87 } /* Keyword.Type */
-.highlight .ld, .code .ld { color: #2e3436 } /* Literal.Date */
-.highlight .m, .code .m { color: #2e3436 } /* Literal.Number */
-.highlight .s, .code .s { color: #ad7fa8 } /* Literal.String */
-.highlight .na, .code .na { color: #c4a000 } /* Name.Attribute */
-.highlight .nb, .code .nb { color: #75507b } /* Name.Builtin */
-.highlight .nc, .code .nc { color: #204a87 } /* Name.Class */
-.highlight .no, .code .no { color: #ce5c00 } /* Name.Constant */
-.highlight .nd, .code .nd { color: #3465a4; font-weight: bold } /* Name.Decorator */
-.highlight .ni, .code .ni { color: #c4a000; text-decoration: underline } /* Name.Entity */
-.highlight .ne, .code .ne { color: #cc0000 } /* Name.Exception */
-.highlight .nf, .code .nf { color: #a40000 } /* Name.Function */
-.highlight .nl, .code .nl { color: #3465a4; font-weight: bold } /* Name.Label */
-.highlight .nn, .code .nn { color: #000000 } /* Name.Namespace */
-.highlight .nx, .code .nx { color: #000000 } /* Name.Other */
-.highlight .py, .code .py { color: #000000 } /* Name.Property */
-.highlight .nt, .code .nt { color: #a40000 } /* Name.Tag */
-.highlight .nv, .code .nv { color: #ce5c00 } /* Name.Variable */
-.highlight .ow, .code .ow { color: #8f5902 } /* Operator.Word */
-.highlight .w, .code .w { color: #d3d7cf; text-decoration: underline } /* Text.Whitespace */
-.highlight .mb, .code .mb { color: #2e3436 } /* Literal.Number.Bin */
-.highlight .mf, .code .mf { color: #2e3436 } /* Literal.Number.Float */
-.highlight .mh, .code .mh { color: #2e3436 } /* Literal.Number.Hex */
-.highlight .mi, .code .mi { color: #2e3436 } /* Literal.Number.Integer */
-.highlight .mo, .code .mo { color: #2e3436 } /* Literal.Number.Oct */
-.highlight .sa, .code .sa { color: #ad7fa8 } /* Literal.String.Affix */
-.highlight .sb, .code .sb { color: #ad7fa8 } /* Literal.String.Backtick */
-.highlight .sc, .code .sc { color: #ad7fa8; font-weight: bold } /* Literal.String.Char */
-.highlight .dl, .code .dl { color: #ad7fa8 } /* Literal.String.Delimiter */
-.highlight .sd, .code .sd { color: #ad7fa8 } /* Literal.String.Doc */
-.highlight .s2, .code .s2 { color: #ad7fa8 } /* Literal.String.Double */
-.highlight .se, .code .se { color: #ad7fa8; font-weight: bold } /* Literal.String.Escape */
-.highlight .sh, .code .sh { color: #ad7fa8; text-decoration: underline } /* Literal.String.Heredoc */
-.highlight .si, .code .si { color: #ce5c00 } /* Literal.String.Interpol */
-.highlight .sx, .code .sx { color: #ad7fa8 } /* Literal.String.Other */
-.highlight .sr, .code .sr { color: #ad7fa8 } /* Literal.String.Regex */
-.highlight .s1, .code .s1 { color: #ad7fa8 } /* Literal.String.Single */
-.highlight .ss, .code .ss { color: #8f5902 } /* Literal.String.Symbol */
-.highlight .bp, .code .bp { color: #5c35cc } /* Name.Builtin.Pseudo */
-.highlight .fm, .code .fm { color: #a40000 } /* Name.Function.Magic */
-.highlight .vc, .code .vc { color: #ce5c00 } /* Name.Variable.Class */
-.highlight .vg, .code .vg { color: #ce5c00; text-decoration: underline } /* Name.Variable.Global */
-.highlight .vi, .code .vi { color: #ce5c00 } /* Name.Variable.Instance */
-.highlight .vm, .code .vm { color: #ce5c00 } /* Name.Variable.Magic */
-.highlight .il, .code .il { color: #2e3436 } /* Literal.Number.Integer.Long */
-.hljs-doctag { color: green  }
-.hljs-comment { color: green  }

doc/quickstart.md

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

doc/reference.md

@@ -1,3 +0,0 @@
-# The Lean Reference Manual
-
-The latest version of the Lean reference manual is available [here](https://lean-lang.org/doc/reference/latest).

doc/semantic_highlighting.md

@@ -1,23 +0,0 @@
-Semantic Highlighting
----------------------
-
-The Lean language server provides semantic highlighting information to editors. In order to benefit from this in VSCode, you may need to activate the "Editor > Semantic Highlighting" option in the preferences (this is translates to `"editor.semanticHighlighting.enabled": true,`
-in `settings.json`). The default option here is to let your color theme decides whether it activates semantic highlighting (the default themes Dark+ and Light+ do activate it for instance).
-
-However this may be insufficient if your color theme does not distinguish enough syntax categories or distinguishes them very subtly. For instance the default Light+ theme uses color `#001080` for variables. This is awfully close to `#000000` that is used as the default text color. This makes it very easy to miss an accidental use of [auto bound implicit arguments](https://lean-lang.org/lean4/doc/autobound.html). For instance in
-```lean
-def my_id (n : nat) := n
-```
-maybe `nat` is a typo and `Nat` was intended. If your color theme is good enough then you should see that `n` and `nat` have the same color since they are both marked as variables by semantic highlighting. If you rather write `(n : Nat)` then `n` keeps its variable color but `Nat` gets the default text color.
-
-If you use such a bad theme, you can fix things by modifying the `Semantic Token Color Customizations` configuration. This cannot be done directly in the preferences dialog but you can click on "Edit in settings.json" to directly edit the settings file. Beware that you must save this file (in the same way you save any file opened in VSCode) before seeing any effect in other tabs or VSCode windows.
-
-In the main config object, you can add something like
-```
-"editor.semanticTokenColorCustomizations": {
-        "[Default Light+]": {"rules": {"function": "#ff0000", "property": "#00ff00", "variable": "#ff00ff"}}
-    },
-```
-The colors in this example are not meant to be nice but to be easy to spot in your file when testing. Of course you need to replace `Default Light+` with the name of your theme, and you can customize several themes if you use several themes. VSCode will display small colored boxes next to the HTML color specifications. Hovering on top of a color specification opens a convenient color picker dialog.
-
-In order to understand what `function`, `property` and `variable` mean in the above example, the easiest path is to open a Lean file and ask VSCode about its classification of various bits of your file. Open the command palette with Ctrl-shift-p (or ⌘-shift-p on a Mac) and search for "Inspect Editor Tokens and Scopes" (typing the word "tokens" should be enough to see it). You can then click on any word in your file and look if there is a "semantic token type" line in the displayed information.

doc/setup.md

@@ -1,65 +0,0 @@
-# Supported Platforms
-
-### Tier 1
-
-Platforms built & tested by our CI, available as binary releases via elan (see below)
-
-* x86-64 Linux with glibc 2.26+
-* x86-64 macOS 10.15+
-* aarch64 (Apple Silicon) macOS 10.15+
-* x86-64 Windows 11 (any version), Windows 10 (version 1903 or higher), Windows Server 2022
-
-### Tier 2
-
-Platforms cross-compiled but not tested by our CI, available as binary releases
-
-Releases may be silently broken due to the lack of automated testing.
-Issue reports and fixes are welcome.
-
-* aarch64 Linux with glibc 2.27+
-* x86 (32-bit) Linux
-* Emscripten Web Assembly
-
-<!--
-### Tier 3
-
-Platforms that are known to work from manual testing, but do not come with CI or official releases
--->
-
-# Setting Up Lean
-
-See also the [quickstart](./quickstart.md) instructions for a standard setup with VS Code as the editor.
-
-Release builds for all supported platforms are available at <https://github.com/leanprover/lean4/releases>.
-Instead of downloading these and setting up the paths manually, however, it is recommended to use the Lean version manager [`elan`](https://github.com/leanprover/elan) instead:
-```sh
-$ elan self update  # in case you haven't updated elan in a while
-# download & activate latest Lean 4 stable release (https://github.com/leanprover/lean4/releases)
-$ elan default leanprover/lean4:stable
-```
-
-## `lake`
-
-Lean 4 comes with a package manager named `lake`.
-Use `lake init foo` to initialize a Lean package `foo` in the current directory, and `lake build` to typecheck and build it as well as all its dependencies. Use `lake help` to learn about further commands.
-The general directory structure of a package `foo` is
-```sh
-lakefile.lean  # package configuration
-lean-toolchain # specifies the lean version to use
-Foo.lean       # main file, import via `import Foo`
-Foo/
-  A.lean       # further files, import via e.g. `import Foo.A`
-  A/...        # further nesting
-.lake/         # `lake` build output directory
-```
-
-After running `lake build` you will see a binary named `./.lake/build/bin/foo` and when you run it you should see the output:
-```
-Hello, world!
-```
-
-## Editing
-
-Lean implements the [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) that can be used for interactive development in [Emacs](https://github.com/leanprover/lean4-mode), [VS Code](https://github.com/leanprover-community/vscode-lean4), and possibly other editors.
-
-Changes must be saved to be visible in other files, which must then be invalidated using an editor command (see links above).

doc/simptypes.md

@@ -1,91 +0,0 @@
-## Simple Type Theory
-
-"Type theory" gets its name from the fact that every expression has an associated *type*.
-For example, in a given context, ``x + 0`` may denote a natural number and ``f`` may denote a function on the natural numbers.
-For those that don't like math, a Lean natural number is an arbitrary-precision unsigned integer.
-
-Here are some examples of how we can declare objects in Lean and check their types.
-
-```lean
-/- Declare some constants. -/
-
-constant m  : Nat   -- m is a natural number
-constant n  : Nat
-constant b1 : Bool  -- b1 is a Boolean
-constant b2 : Bool
-
-/- Check their types. -/
-
-#check m            -- output: Nat
-#check n
-#check n + 0        -- Nat
-#check m * (n + 0)  -- Nat
-#check b1           -- Bool
-#check b1 && b2     -- "&&" is the Boolean and
-#check b1 || b2     -- Boolean or
-#check true         -- Boolean "true"
-```
-
-Any text between ``/-`` and ``-/`` constitutes a comment block that is ignored by Lean.
-Similarly, two dashes `--` indicate that the rest of the line contains a comment that is also ignored.
-Comment blocks can be nested, making it possible to "comment out" chunks of code, just as in many programming languages.
-
-The ``constant`` command introduce new constant symbols into the working environment.
-The ``#check`` command asks Lean to report their types; in Lean, auxiliary commands that query the system for
-information typically begin with the hash symbol. You should try declaring some constants and type checking
-some expressions on your own. Declaring new objects in this way is a good way to experiment with the system.
-
-What makes simple type theory powerful is that one can build new types out of others.
-For example, if ``a`` and ``b`` are types, ``a -> b`` denotes the type of functions from ``a`` to ``b``,
-and ``a × b`` denotes the type of pairs consisting of an element of ``a``
-paired with an element of ``b``, also known as the *Cartesian product*.
-Note that `×` is a Unicode symbol. We believe that judicious use of Unicode improves legibility,
-and all modern editors have great support for it. In the Lean standard library, we often use
-Greek letters to denote types, and the Unicode symbol `→` as a more compact version of `->`.
-
-```lean
-constant m : Nat
-constant n : Nat
-
-constant f  : Nat → Nat         -- type the arrow as "\to" or "\r"
-constant f' : Nat -> Nat        -- alternative ASCII notation
-constant p  : Nat × Nat         -- type the product as "\times"
-constant q  : Prod Nat Nat      -- alternative notation
-constant g  : Nat → Nat → Nat
-constant g' : Nat → (Nat → Nat) -- has the same type as g!
-constant h  : Nat × Nat → Nat
-constant F  : (Nat → Nat) → Nat -- a "functional"
-
-#check f            -- Nat → Nat
-#check f n          -- Nat
-#check g m n        -- Nat
-#check g m          -- Nat → Nat
-#check (m, n)       -- Nat × Nat
-#check p.1          -- Nat
-#check p.2          -- Nat
-#check (m, n).1     -- Nat
-#check (p.1, n)     -- Nat × Nat
-#check F f          -- Nat
-```
-
-Once again, you should try some examples on your own.
-
-Let us dispense with some basic syntax. You can enter the unicode arrow ``→`` by typing ``\to`` or ``\r``.
-You can also use the ASCII alternative ``->``, so the expressions ``Nat -> Nat`` and ``Nat → Nat`` mean the same thing.
-Both expressions denote the type of functions that take a natural number as input and return a natural number as output.
-The unicode symbol ``×`` for the Cartesian product is entered as ``\times``.
-We will generally use lower-case Greek letters like ``α``, ``β``, and ``γ`` to range over types.
-You can enter these particular ones with ``\a``, ``\b``, and ``\g``.
-
-There are a few more things to notice here. First, the application of a function ``f`` to a value ``x`` is denoted ``f x``.
-Second, when writing type expressions, arrows associate to the *right*; for example, the type of ``g`` is ``Nat → (Nat → Nat)``.
-Thus we can view ``g`` as a function that takes natural numbers and returns another function that takes a natural number and
-returns a natural number.
-In type theory, this is generally more convenient than writing ``g`` as a function that takes a pair of natural numbers as input
-and returns a natural number as output. For example, it allows us to "partially apply" the function ``g``.
-The example above shows that ``g m`` has type ``Nat → Nat``, that is, the function that "waits" for a second argument, ``n``,
-and then returns ``g m n``. Taking a function ``h`` of type ``Nat × Nat → Nat`` and "redefining" it to look like ``g`` is a process
-known as *currying*, something we will come back to below.
-
-By now you may also have guessed that, in Lean, ``(m, n)`` denotes the ordered pair of ``m`` and ``n``,
-and if ``p`` is a pair, ``p.1`` and ``p.2`` denote the two projections.

doc/syntax_example.md

@@ -1,80 +0,0 @@
-# Balanced Parentheses as an Embedded Domain Specific Language
-
-Let's look at how to use macros to extend the Lean 4 parser and embed a language for building _balanced parentheses_.
-This language accepts strings given by the [BNF grammar](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form)
-
-```
-Dyck ::=
-  "(" Dyck ")"
-  | "{" Dyck "}"
-  | end
-```
-
-We begin by defining an inductive data type of the grammar we wish to parse:
-
-```lean,ignore
-inductive Dyck : Type where
-  | round : Dyck → Dyck  -- ( <inner> )
-  | curly : Dyck → Dyck  -- { <inner> }
-  | leaf : Dyck
-```
-
-We begin by declaring a _syntax category_ using the `declare_syntax_cat <category>` command.
-This names our grammar and allows us to specify parsing rules associated with our grammar.
-
-```lean,ignore
-declare_syntax_cat brack
-```
-
-Next, we specify the grammar using the `syntax <parse rule>` command:
-
-```lean,ignore
-syntax "end" : brack
-```
-
-The above means that the token "end" lives in syntax category `brack`.
-
-Similarly, we declare the rules `"(" Dyck ")"` and `"{" Dyck "}"` using the rules:
-
-```lean,ignore
-syntax "(" brack ")" : brack
-syntax "{" brack "}" : brack
-```
-
-Finally, we need a way to build _Lean 4 terms_ from this grammar -- that is, we must translate out of this
-grammar into a `Dyck` value, which is a Lean 4 term. For this, we create a new kind of "quotation" that
-consumes syntax in `brack` and produces a `term`.
-
-```lean,ignore
-syntax "`[Dyck| " brack "]" : term
-```
-
-To specify the transformation rules, we use `macro_rules` to declare how the syntax `` `[Dyck| <brack>] ``
-produces terms. This is written using a pattern-matching style syntax, where the left-hand side
-declares the syntax pattern to be matched, and the right-hand side declares the production. Syntax placeholders (antiquotations)
-are introduced via the `$<var-name>` syntax. The right-hand side is
-an arbitrary Lean term that we are producing.
-
-```lean,ignore
-macro_rules
-  | `(`[Dyck| end])    => `(Dyck.leaf)
-  | `(`[Dyck| ($b)]) => `(Dyck.round `[Dyck| $b])  -- recurse
-  | `(`[Dyck| {$b}]) => `(Dyck.curly `[Dyck| $b])  -- recurse
-```
-
-
-```lean,ignore
-#check `[Dyck| end]      -- Dyck.leaf
-#check `[Dyck| {(end)}]  -- Dyck.curl (Dyck.round Dyck.leaf)
-```
-
-In summary, we've seen:
-- How to declare a syntax category for the Dyck grammar.
-- How to specify parse trees of this grammar using `syntax`
-- How to translate out of this grammar into Lean 4 terms using `macro_rules`.
-
-The full program listing is given below:
-
-```lean
-{{#include syntax_example.lean}}
-```

doc/syntax_examples.md

@@ -1,4 +0,0 @@
-# Syntax Metaprogramming Examples
-
-- [Balanced Parentheses](./syntax_example.md)
-- [Arithmetic DSL](./metaprogramming-arith.md)

doc/syntax_highlight_in_latex.md

@@ -1,91 +0,0 @@
-You can copy highlighted code [straight from VS Code](https://code.visualstudio.com/updates/v1_10#_copy-with-syntax-highlighting) to any rich text editor supporting HTML input. For highlighting code in LaTeX, there are two options:
-* [listings](https://ctan.org/pkg/listings), which is a common package and simple to set up, but you may run into some restrictions of it and LaTeX around Unicode
-* [`minted`](https://ctan.org/pkg/minted), a LaTeX package wrapping the [Pygments](https://pygments.org/) syntax highlighting library. It needs a few more steps to set up, but provides unrestricted support for Unicode when combined with XeLaTeX or LuaLaTex.
-
-## Example with `listings`
-
-Save [`lstlean.tex`](https://raw.githubusercontent.com/leanprover/lean4/master/doc/latex/lstlean.tex) into the same directory, or anywhere in your `TEXINPUTS` path, as the following test file:
-```latex
-\documentclass{article}
-\usepackage[T1]{fontenc}
-\usepackage[utf8]{inputenc}
-\usepackage{listings}
-\usepackage{amssymb}
-
-\usepackage{color}
-\definecolor{keywordcolor}{rgb}{0.7, 0.1, 0.1}   % red
-\definecolor{tacticcolor}{rgb}{0.0, 0.1, 0.6}    % blue
-\definecolor{commentcolor}{rgb}{0.4, 0.4, 0.4}   % grey
-\definecolor{symbolcolor}{rgb}{0.0, 0.1, 0.6}    % blue
-\definecolor{sortcolor}{rgb}{0.1, 0.5, 0.1}      % green
-\definecolor{attributecolor}{rgb}{0.7, 0.1, 0.1} % red
-
-\def\lstlanguagefiles{lstlean.tex}
-% set default language
-\lstset{language=lean}
-
-\begin{document}
-\begin{lstlisting}
-theorem funext {f₁ f₂ : ∀ (x : α), β x} (h : ∀ x, f₁ x = f₂ x) : f₁ = f₂ := by
-  show extfunApp (Quotient.mk f₁) = extfunApp (Quotient.mk f₂)
-  apply congrArg
-  apply Quotient.sound
-  exact h
-\end{lstlisting}
-\end{document}
-```
-Compile the file via
-```bash
-$ pdflatex test.tex
-```
-
-* for older LaTeX versions, you might need to use `[utf8x]` instead of `[utf8]` with `inputenc`
-
-## Example with `minted`
-
-First [install Pygments](https://pygments.org/download/) (version 2.18 or newer).
-Then save the following sample LaTeX file `test.tex` into the same directory:
-
-```latex
-\documentclass{article}
-\usepackage{fontspec}
-% switch to a monospace font supporting more Unicode characters
-\setmonofont{FreeMono}
-\usepackage{minted}
-\newmintinline[lean]{lean4}{bgcolor=white}
-\newminted[leancode]{lean4}{fontsize=\footnotesize}
-\usemintedstyle{tango}  % a nice, colorful theme
-
-\begin{document}
-\begin{leancode}
-theorem funext {f₁ f₂ : ∀ (x : α), β x} (h : ∀ x, f₁ x = f₂ x) : f₁ = f₂ := by
-  show extfunApp (Quotient.mk' f₁) = extfunApp (Quotient.mk' f₂)
-  apply congrArg
-  apply Quotient.sound
-  exact h
-\end{leancode}
-\end{document}
-```
-
-You can then compile `test.tex` by executing the following command:
-
-```bash
-xelatex --shell-escape test.tex
-```
-
-Some remarks:
-
- - either `xelatex` or `lualatex` is required to handle Unicode characters in the code.
- - `--shell-escape` is needed to allow `xelatex` to execute `pygmentize` in a shell.
- - If the chosen monospace font is missing some Unicode symbols, you can direct them to be displayed using a fallback font or other replacement LaTeX code.
-   ``` latex
-   \usepackage{newunicodechar}
-   \newfontfamily{\freeserif}{DejaVu Sans}
-   \newunicodechar{✝}{\freeserif{✝}}
-   \newunicodechar{𝓞}{\ensuremath{\mathcal{O}}}
-   ```
- - If you are using an old version of Pygments, you can copy 
-   [`lean.py`](https://raw.githubusercontent.com/pygments/pygments/master/pygments/lexers/lean.py) into your working directory,
-   and use `lean4.py:Lean4Lexer -x` instead of `lean4` above.
-   If your version of `minted` is v2.7 or newer, but before v3.0,
-   you will additionally need to follow the workaround described in https://github.com/gpoore/minted/issues/360.

doc/tactics.md

@@ -1,393 +0,0 @@
-# Tactics
-
-Tactics are metaprograms, that is, programs that create programs.
-Lean is implemented in Lean, you can import its implementation using `import Lean`.
-The `Lean` package is part of the Lean distribution.
-You can use the functions in the `Lean` package to write your own metaprograms
-that automate repetitive tasks when writing programs and proofs.
-
-We provide the **tactic** domain specific language (DSL) for using the tactic framework.
-The tactic DSL provides commands for creating terms (and proofs). You
-don't need to import the `Lean` package for using the tactic DSL.
-Simple extensions can be implemented using macros. More complex extensions require
-the `Lean` package. Notation used to write Lean terms can be easily lifted to the tactic DSL.
-
-Tactics are instructions that tell Lean how to construct a term or proof.
-Tactics operate on holes also known as goals. Each hole represents a missing
-part of the term you are trying to build. Internally these holes are represented
-as metavariables. They have a type and a local context. The local context contains
-all local variables in scope.
-
-In the following example, we prove the same simple theorem using different tactics.
-The keyword `by` instructs Lean to use the tactic DSL to construct a term.
-Our initial goal is a hole with type `p ∨ q → q ∨ p`. The tactic `intro h`
-fills this hole using the term `fun h => ?m` where `?m` is a new hole we need to solve.
-This hole has type `q ∨ p`, and the local context contains `h : p ∨ q`.
-The tactic `cases` fills the hole using `Or.casesOn h (fun h1 => ?m1) (fun h2 => ?m2)`
-where `?m1` and `?m2` are new holes. The tactic `apply Or.inr` fills the hole `?m1`
-with the application `Or.inr ?m3`, and `exact h1` fills `?m3` with `h1`.
-The tactic `assumption` tries to fill a hole by searching the local context for a term with the same type.
-
-```lean
-theorem ex1 : p ∨ q → q ∨ p := by
-  intro h
-  cases h with
-  | inl h1 =>
-    apply Or.inr
-    exact h1
-  | inr h2 =>
-    apply Or.inl
-    assumption
-
-#print ex1
-/-
-theorem ex1 : {p q : Prop} → p ∨ q → q ∨ p :=
-fun {p q : Prop} (h : p ∨ q) =>
-  Or.casesOn h (fun (h1 : p) => Or.inr h1) fun (h2 : q) => Or.inl h2
--/
-
--- You can use `match-with` in tactics.
-theorem ex2 : p ∨ q → q ∨ p := by
-  intro h
-  match h with
-  | Or.inl _  => apply Or.inr; assumption
-  | Or.inr h2 => apply Or.inl; exact h2
-
--- As we have the `fun+match` syntax sugar for terms,
--- we have the `intro+match` syntax sugar
-theorem ex3 : p ∨ q → q ∨ p := by
-  intro
-  | Or.inl h1 =>
-    apply Or.inr
-    exact h1
-  | Or.inr h2 =>
-    apply Or.inl
-    assumption
-```
-
-The examples above are all structured, but Lean 4 still supports unstructured
-proofs. Unstructured proofs are useful when creating reusable scripts that may
-discharge different goals.
-Here is an unstructured version of the example above.
-
-```lean
-theorem ex1 : p ∨ q → q ∨ p := by
-  intro h
-  cases h
-  apply Or.inr
-  assumption
-  apply Or.inl
-  assumption
-  done -- fails with an error here if there are unsolvable goals
-
-theorem ex2 : p ∨ q → q ∨ p := by
-  intro h
-  cases h
-  focus -- instructs Lean to `focus` on the first goal,
-    apply Or.inr
-    assumption
-    -- it will fail if there are still unsolvable goals here
-  focus
-    apply Or.inl
-    assumption
-
-theorem ex3 : p ∨ q → q ∨ p := by
-  intro h
-  cases h
-  -- You can still use curly braces and semicolons instead of
-  -- whitespace sensitive notation as in the previous example
-  { apply Or.inr;
-    assumption
-    -- It will fail if there are unsolved goals
-  }
-  { apply Or.inl;
-    assumption
-  }
-
--- Many tactics tag subgoals. The tactic `cases` tag goals using constructor names.
--- The tactic `case tag => tactics` instructs Lean to solve the goal
--- with the matching tag.
-theorem ex4 : p ∨ q → q ∨ p := by
-  intro h
-  cases h
-  case inr =>
-    apply Or.inl
-    assumption
-  case inl =>
-    apply Or.inr
-    assumption
-
--- Same example for curly braces and semicolons aficionados
-theorem ex5 : p ∨ q → q ∨ p := by {
-  intro h;
-  cases h;
-  case inr => {
-    apply Or.inl;
-    assumption
-  }
-  case inl => {
-    apply Or.inr;
-    assumption
-  }
-}
-```
-
-## Rewrite
-
-TODO
-
-## Pattern matching
-
-As a convenience, pattern-matching has been integrated into tactics such as `intro` and `funext`.
-
-```lean
-theorem ex1 : s ∧ q ∧ r → p ∧ r → q ∧ p := by
-  intro ⟨_, ⟨hq, _⟩⟩ ⟨hp, _⟩
-  exact ⟨hq, hp⟩
-
-theorem ex2 :
-    (fun (x : Nat × Nat) (y : Nat × Nat) => x.1 + y.2)
-    =
-    (fun (x : Nat × Nat) (z : Nat × Nat) => z.2 + x.1) := by
-  funext (a, b) (c, d)
-  show a + d = d + a
-  rw [Nat.add_comm]
-```
-
-## Induction
-
-The `induction` tactic now supports user-defined induction principles with
-multiple targets (aka major premises).
-
-
-```lean
-/-
-theorem Nat.mod.inductionOn
-      {motive : Nat → Nat → Sort u}
-      (x y  : Nat)
-      (ind  : ∀ x y, 0 < y ∧ y ≤ x → motive (x - y) y → motive x y)
-      (base : ∀ x y, ¬(0 < y ∧ y ≤ x) → motive x y)
-      : motive x y :=
--/
-
-theorem ex (x : Nat) {y : Nat} (h : y > 0) : x % y < y := by
-  induction x, y using Nat.mod.inductionOn with
-  | ind x y h₁ ih =>
-    rw [Nat.mod_eq_sub_mod h₁.2]
-    exact ih h
-  | base x y h₁ =>
-     have : ¬ 0 < y ∨ ¬ y ≤ x := Iff.mp (Decidable.not_and_iff_or_not ..) h₁
-     match this with
-     | Or.inl h₁ => exact absurd h h₁
-     | Or.inr h₁ =>
-       have hgt : y > x := Nat.gt_of_not_le h₁
-       rw [← Nat.mod_eq_of_lt hgt] at hgt
-       assumption
-```
-
-## Cases
-
-TODO
-
-## Injection
-
-TODO
-
-## Split
-
-The `split` tactic can be used to split the cases of an if-then-else or
-match into new subgoals, which can then be discharged individually.
-
-```lean
-def addMoreIfOdd (n : Nat) := if n % 2 = 0 then n + 1 else n + 2
-
-/- Examine each branch of the conditional to show that the result
-   is always positive -/
-example (n : Nat) : 0 < addMoreIfOdd n := by
-  simp only [addMoreIfOdd]
-  split
-  next => exact Nat.zero_lt_succ _
-  next => exact Nat.zero_lt_succ _
-```
-
-```lean
-def binToChar (n : Nat) : Option Char :=
-  match n with
-  | 0 => some '0'
-  | 1 => some '1'
-  | _ => none
-
-example (n : Nat) : (binToChar n).isSome -> n = 0 ∨ n = 1 := by
-  simp only [binToChar]
-  split
-  next => exact fun _ => Or.inl rfl
-  next => exact fun _ => Or.inr rfl
-  next => intro h; cases h
-
-/- Hypotheses about previous cases can be accessed by assigning them a
-   name, like `ne_zero` below. Information about the matched term can also
-   be preserved using the `generalizing` tactic: -/
-example (n : Nat) : (n = 0) -> (binToChar n = some '0') := by
-  simp only [binToChar]
-  split
-  case h_1 => intro _; rfl
-  case h_2 => intro h; cases h
-  /- Here, we can introduce `n ≠ 0` and `n ≠ 1` this case assumes
-     neither of the previous cases matched. -/
-  case h_3 ne_zero _  => intro eq_zero; exact absurd eq_zero ne_zero
-```
-
-## Dependent pattern matching
-
-The `match-with` expression implements dependent pattern matching. You can use it to create concise proofs.
-
-```lean
-inductive Mem : α → List α → Prop where
-  | head (a : α) (as : List α)   : Mem a (a::as)
-  | tail (a b : α) (bs : List α) : Mem a bs → Mem a (b::bs)
-
-infix:50 (priority := high) "∈" => Mem
-
-theorem mem_split {a : α} {as : List α} (h : a ∈ as) : ∃ s t, as = s ++ a :: t :=
-  match a, as, h with
-  | _, _, Mem.head a bs     => ⟨[], ⟨bs, rfl⟩⟩
-  | _, _, Mem.tail a b bs h =>
-    match bs, mem_split h with
-    | _, ⟨s, ⟨t, rfl⟩⟩ => ⟨b::s, ⟨t, List.cons_append .. ▸ rfl⟩⟩
-```
-
-In the tactic DSL, the right-hand-side of each alternative in a `match-with` is a sequence of tactics instead of a term.
-Here is a similar proof using the tactic DSL.
-
-```lean
-# inductive Mem : α → List α → Prop where
-#  | head (a : α) (as : List α)   : Mem a (a::as)
-#  | tail (a b : α) (bs : List α) : Mem a bs → Mem a (b::bs)
-# infix:50 (priority := high) "∈" => Mem
-theorem mem_split {a : α} {as : List α} (h : a ∈ as) : ∃ s t, as = s ++ a :: t := by
-  match a, as, h with
-  | _, _, Mem.head a bs     => exists []; exists bs; rfl
-  | _, _, Mem.tail a b bs h =>
-    match bs, mem_split h with
-    | _, ⟨s, ⟨t, rfl⟩⟩ =>
-      exists b::s; exists t;
-      rw [List.cons_append]
-```
-
-We can use `match-with` nested in tactics.
-Here is a similar proof that uses the `induction` tactic instead of recursion.
-
-```lean
-# inductive Mem : α → List α → Prop where
-#  | head (a : α) (as : List α)   : Mem a (a::as)
-#  | tail (a b : α) (bs : List α) : Mem a bs → Mem a (b::bs)
-# infix:50 (priority := high) "∈" => Mem
-theorem mem_split {a : α} {as : List α} (h : a ∈ as) : ∃ s t, as = s ++ a :: t := by
-  induction as with
-  | nil          => cases h
-  | cons b bs ih => cases h with
-    | head a bs => exact ⟨[], ⟨bs, rfl⟩⟩
-    | tail a b bs h =>
-      match bs, ih h with
-      | _, ⟨s, ⟨t, rfl⟩⟩ =>
-        exists b::s; exists t
-        rw [List.cons_append]
-```
-
-You can create your own notation using existing tactics. In the following example,
-we define a simple `obtain` tactic using macros. We say it is simple because it takes only one
-discriminant. Later, we show how to create more complex automation using macros.
-
-```lean
-# inductive Mem : α → List α → Prop where
-#  | head (a : α) (as : List α)   : Mem a (a::as)
-#  | tail (a b : α) (bs : List α) : Mem a bs → Mem a (b::bs)
-# infix:50 (priority := high) "∈" => Mem
-macro "obtain " p:term " from " d:term : tactic =>
-  `(tactic| match $d:term with | $p:term => ?_)
-
-theorem mem_split {a : α} {as : List α} (h : a ∈ as) : ∃ s t, as = s ++ a :: t := by
-  induction as with
-  | cons b bs ih => cases h with
-    | tail a b bs h =>
-      obtain ⟨s, ⟨t, h⟩⟩ from ih h
-      exists b::s; exists t
-      rw [h, List.cons_append]
-    | head a bs => exact ⟨[], ⟨bs, rfl⟩⟩
-  | nil => cases h
-
-```
-
-## Extensible tactics
-
-In the following example, we define the notation `triv` for the tactic DSL using
-the command `syntax`. Then, we use the command `macro_rules` to specify what should
-be done when `triv` is used. You can provide different expansions, and the tactic DSL
-interpreter will try all of them until one succeeds.
-
-```lean
--- Define a new notation for the tactic DSL
-syntax "triv" : tactic
-
-macro_rules
-  | `(tactic| triv) => `(tactic| assumption)
-
-theorem ex1 (h : p) : p := by
-  triv
-
--- You cannot prove the following theorem using `triv`
--- theorem ex2 (x : α) : x = x := by
---  triv
-
--- Let's extend `triv`. The `by` DSL interpreter
--- tries all possible macro extensions for `triv` until one succeeds
-macro_rules
-  | `(tactic| triv) => `(tactic| rfl)
-
-theorem ex2 (x : α) : x = x := by
-  triv
-
-theorem ex3 (x : α) (h : p) : x = x ∧ p := by
-  apply And.intro <;> triv
-```
-
-# `let-rec`
-
-You can use `let rec` to write local recursive functions. We lifted it to the tactic DSL,
-and you can use it to create proofs by induction.
-
-```lean
-theorem length_replicateTR {α} (n : Nat) (a : α) : (List.replicateTR n a).length = n := by
-  let rec aux (n : Nat) (as : List α)
-      : (List.replicateTR.loop a n as).length = n + as.length := by
-    match n with
-    | 0   => rw [Nat.zero_add]; rfl
-    | n+1 =>
-      show List.length (List.replicateTR.loop a n (a::as)) = Nat.succ n + as.length
-      rw [aux n, List.length_cons, Nat.add_succ, Nat.succ_add]
-  exact aux n []
-```
-
-You can also introduce auxiliary recursive declarations using `where` clause after your definition.
-Lean converts them into a `let rec`.
-
-```lean
-theorem length_replicateTR {α} (n : Nat) (a : α) : (List.replicateTR n a).length = n :=
-  loop n []
-where
-  loop n as : (List.replicateTR.loop a n as).length = n + as.length := by
-    match n with
-    | 0   => rw [Nat.zero_add]; rfl
-    | n+1 =>
-      show List.length (List.replicateTR.loop a n (a::as)) = Nat.succ n + as.length
-      rw [loop n, List.length_cons, Nat.add_succ, Nat.succ_add]
-```
-
-# `begin-end` lovers
-
-If you love Lean 3 `begin ... end` tactic blocks and commas, you can define this notation
-in Lean 4 using macros in a few lines of code.
-
-```lean
-{{#include ../tests/lean/beginEndAsMacro.lean:doc}}
-```

doc/tour.md

@@ -1,200 +0,0 @@
-# Tour of Lean
-
-The best way to learn about Lean is to read and write Lean code.
-This article will act as a tour through some of the key features of the Lean
-language and give you some code snippets that you can execute on your machine.
-To learn about setting up a development environment, check out [Setting Up Lean](./setup.md).
-
-There are two primary concepts in Lean: functions and types.
-This tour will emphasize features of the language which fall into
-these two concepts.
-
-# Functions and Namespaces
-
-The most fundamental pieces of any Lean program are functions organized into namespaces.
-[Functions](./functions.md) perform work on inputs to produce outputs,
-and they are organized under [namespaces](./namespaces.md),
-which are the primary way you group things in Lean.
-They are defined using the `def` command,
-which give the function a name and define its arguments.
-
-```lean
-namespace BasicFunctions
-
--- The `#eval` command evaluates an expression on the fly and prints the result.
-#eval 2+2
-
--- You use 'def' to define a function. This one accepts a natural number
--- and returns a natural number.
--- Parentheses are optional for function arguments, except for when
--- you use an explicit type annotation.
--- Lean can often infer the type of the function's arguments.
-def sampleFunction1 x := x*x + 3
-
--- Apply the function, naming the function return result using 'def'.
--- The variable type is inferred from the function return type.
-def result1 := sampleFunction1 4573
-
--- This line uses an interpolated string to print the result. Expressions inside
--- braces `{}` are converted into strings using the polymorphic method `toString`
-#eval println! "The result of squaring the integer 4573 and adding 3 is {result1}"
-
--- When needed, annotate the type of a parameter name using '(argument : type)'.
-def sampleFunction2 (x : Nat) := 2*x*x - x + 3
-
-def result2 := sampleFunction2 (7 + 4)
-
-#eval println! "The result of applying the 2nd sample function to (7 + 4) is {result2}"
-
--- Conditionals use if/then/else
-def sampleFunction3 (x : Int) :=
-  if x > 100 then
-    2*x*x - x + 3
-  else
-    2*x*x + x - 37
-
-#eval println! "The result of applying sampleFunction3 to 2 is {sampleFunction3 2}"
-
-end BasicFunctions
-```
-
-```lean
--- Lean has first-class functions.
--- `twice` takes two arguments `f` and `a` where
--- `f` is a function from natural numbers to natural numbers, and
--- `a` is a natural number.
-def twice (f : Nat → Nat) (a : Nat) :=
-  f (f a)
-
--- `fun` is used to declare anonymous functions
-#eval twice (fun x => x + 2) 10
-
--- You can prove theorems about your functions.
--- The following theorem states that for any natural number `a`,
--- adding 2 twice produces a value equal to `a + 4`.
-theorem twiceAdd2 (a : Nat) : twice (fun x => x + 2) a = a + 4 :=
-  -- The proof is by reflexivity. Lean "symbolically" reduces both sides of the equality
-  -- until they are identical.
-  rfl
-
--- `(· + 2)` is syntax sugar for `(fun x => x + 2)`. The parentheses + `·` notation
--- is useful for defining simple anonymous functions.
-#eval twice (· + 2) 10
-
--- Enumerated types are a special case of inductive types in Lean,
--- which we will learn about later.
--- The following command creates a new type `Weekday`.
-inductive Weekday where
-  | sunday    : Weekday
-  | monday    : Weekday
-  | tuesday   : Weekday
-  | wednesday : Weekday
-  | thursday  : Weekday
-  | friday    : Weekday
-  | saturday  : Weekday
-
--- `Weekday` has 7 constructors/elements.
--- The constructors live in the `Weekday` namespace.
--- Think of `sunday`, `monday`, …, `saturday` as being distinct elements of `Weekday`,
--- with no other distinguishing properties.
--- The command `#check` prints the type of a term in Lean.
-#check Weekday.sunday
-#check Weekday.monday
-
--- The `open` command opens a namespace, making all declarations in it accessible without
--- qualification.
-open Weekday
-#check sunday
-#check tuesday
-
--- You can define functions by pattern matching.
--- The following function converts a `Weekday` into a natural number.
-def natOfWeekday (d : Weekday) : Nat :=
-  match d with
-  | sunday    => 1
-  | monday    => 2
-  | tuesday   => 3
-  | wednesday => 4
-  | thursday  => 5
-  | friday    => 6
-  | saturday  => 7
-
-#eval natOfWeekday tuesday
-
-def isMonday : Weekday → Bool :=
-  -- `fun` + `match`  is a common idiom.
-  -- The following expression is syntax sugar for
-  -- `fun d => match d with | monday => true | _ => false`.
-  fun
-    | monday => true
-    | _      => false
-
-#eval isMonday monday
-#eval isMonday sunday
-
--- Lean has support for type classes and polymorphic methods.
--- The `toString` method converts a value into a `String`.
-#eval toString 10
-#eval toString (10, 20)
-
--- The method `toString` converts values of any type that implements
--- the class `ToString`.
--- You can implement instances of `ToString` for your own types.
-instance : ToString Weekday where
-  toString (d : Weekday) : String :=
-    match d with
-    | sunday    => "Sunday"
-    | monday    => "Monday"
-    | tuesday   => "Tuesday"
-    | wednesday => "Wednesday"
-    | thursday  => "Thursday"
-    | friday    => "Friday"
-    | saturday  => "Saturday"
-
-#eval toString (sunday, 10)
-
-def Weekday.next (d : Weekday) : Weekday :=
-  match d with
-  | sunday    => monday
-  | monday    => tuesday
-  | tuesday   => wednesday
-  | wednesday => thursday
-  | thursday  => friday
-  | friday    => saturday
-  | saturday  => sunday
-
-#eval Weekday.next Weekday.wednesday
--- Since the `Weekday` namespace has already been opened, you can also write
-#eval next wednesday
-
--- Matching on a parameter like in the previous definition
--- is so common that Lean provides syntax sugar for it. The following
--- function uses it.
-def Weekday.previous : Weekday -> Weekday
-  | sunday    => saturday
-  | monday    => sunday
-  | tuesday   => monday
-  | wednesday => tuesday
-  | thursday  => wednesday
-  | friday    => thursday
-  | saturday  => friday
-
-#eval next (previous wednesday)
-
--- We can prove that for any `Weekday` `d`, `next (previous d) = d`
-theorem Weekday.nextOfPrevious (d : Weekday) : next (previous d) = d :=
-  match d with
-  | sunday    => rfl
-  | monday    => rfl
-  | tuesday   => rfl
-  | wednesday => rfl
-  | thursday  => rfl
-  | friday    => rfl
-  | saturday  => rfl
-
--- You can automate definitions such as `Weekday.nextOfPrevious`
--- using metaprogramming (or "tactics").
-theorem Weekday.nextOfPrevious' (d : Weekday) : next (previous d) = d := by
-  cases d       -- A proof by case distinction
-  all_goals rfl  -- Each case is solved using `rfl`
-```

doc/tpil.md

@@ -1,5 +0,0 @@
-Theorem Proving in Lean
-=======================
-
-We strongly encourage you to read the book [Theorem Proving in Lean](https://lean-lang.org/theorem_proving_in_lean4/title_page.html).
-Many Lean users consider it to be the Lean Bible.

doc/typeobjs.md

@@ -1,129 +0,0 @@
-## Types as objects
-
-One way in which Lean's dependent type theory extends simple type theory is that types themselves --- entities like ``Nat`` and ``Bool`` ---
-are first-class citizens, which is to say that they themselves are objects. For that to be the case, each of them also has to have a type.
-
-```lean
-#check Nat               -- Type
-#check Bool              -- Type
-#check Nat → Bool        -- Type
-#check Nat × Bool        -- Type
-#check Nat → Nat         -- ...
-#check Nat × Nat → Nat
-#check Nat → Nat → Nat
-#check Nat → (Nat → Nat)
-#check Nat → Nat → Bool
-#check (Nat → Nat) → Nat
-```
-
-We see that each one of the expressions above is an object of type ``Type``. We can also declare new constants and constructors for types:
-
-```lean
-constant α : Type
-constant β : Type
-constant F : Type → Type
-constant G : Type → Type → Type
-
-#check α        -- Type
-#check F α      -- Type
-#check F Nat    -- Type
-#check G α      -- Type → Type
-#check G α β    -- Type
-#check G α Nat  -- Type
-```
-
-Indeed, we have already seen an example of a function of type ``Type → Type → Type``, namely, the Cartesian product.
-
-```lean
-constant α : Type
-constant β : Type
-
-#check Prod α β       -- Type
-#check Prod Nat Nat   -- Type
-```
-
-Here is another example: given any type ``α``, the type ``List α`` denotes the type of lists of elements of type ``α``.
-
-```lean
-constant α : Type
-
-#check List α    -- Type
-#check List Nat  -- Type
-```
-
-Given that every expression in Lean has a type, it is natural to ask: what type does ``Type`` itself have?
-
-```lean
-#check Type      -- Type 1
-```
-
-We have actually come up against one of the most subtle aspects of Lean's typing system.
-Lean's underlying foundation has an infinite hierarchy of types:
-
-```lean
-#check Type     -- Type 1
-#check Type 1   -- Type 2
-#check Type 2   -- Type 3
-#check Type 3   -- Type 4
-#check Type 4   -- Type 5
-```
-
-Think of ``Type 0`` as a universe of "small" or "ordinary" types.
-``Type 1`` is then a larger universe of types, which contains ``Type 0`` as an element,
-and ``Type 2`` is an even larger universe of types, which contains ``Type 1`` as an element.
-The list is indefinite, so that there is a ``Type n`` for every natural number ``n``.
-``Type`` is an abbreviation for ``Type 0``:
-
-```lean
-#check Type
-#check Type 0
-```
-
-There is also another type universe, ``Prop``, which has special properties.
-
-```lean
-#check Prop -- Type
-```
-
-We will discuss ``Prop`` later.
-
-We want some operations, however, to be *polymorphic* over type universes. For example, ``List α`` should
-make sense for any type ``α``, no matter which type universe ``α`` lives in. This explains the type annotation of the function ``List``:
-
-```lean
-#check List    -- Type u_1 → Type u_1
-```
-
-Here ``u_1`` is a variable ranging over type levels. The output of the ``#check`` command means that whenever ``α`` has type ``Type n``, ``List α`` also has type ``Type n``. The function ``Prod`` is similarly polymorphic:
-
-```lean
-#check Prod    -- Type u_1 → Type u_2 → Type (max u_1 u_2)
-```
-
-To define polymorphic constants and variables, Lean allows us to declare universe variables explicitly using the `universe` command:
-
-```lean
-universe u
-constant α : Type u
-#check α
-```
-Equivalently, we can write ``Type _`` to avoid giving the arbitrary universe a name:
-
-```lean
-constant α : Type _
-#check α
-```
-
-Several Lean 3 users use the shorthand `Type*` for `Type _`. The `Type*` notation is not builtin in Lean 4, but you can easily define it using a `macro`.
-```lean
-macro "Type*" : term => `(Type _)
-
-def f (α : Type*) (a : α) := a
-
-def g (α : Type _) (a : α) := a
-
-#check f
-#check g
-```
-
-We explain later how the `macro` command works.

doc/types.md

@@ -1,56 +0,0 @@
-# Types
-
-Every programming language needs a type system and
-Lean has a rich extensible inductive type system.
-
-## Basic Types
-
-Lean has built in support for the following basic types:
-
-- [Bool](bool.md) : a `true` or `false` value.
-- [Int](integers.md) : multiple precision integers (with no overflows!).
-
-- [Nat](integers.md) : natural numbers, or non-negative integers (also with no overflows!).
-- [Float](float.md): floating point numbers.
-- [Char](char.md): a Unicode character.
-- [String](string.md): a UTF-8 encoded string of characters.
-- [Array](array.md): a dynamic (aka growable) array of typed objects.
-- [List](list.md): a linked list of typed objects.
-- TODO: what else?
-
-And Lean allows you to create your own custom types using:
-- [Enumerated Types](enum.md): a special case of inductive types.
-- [Type Classes](typeclasses.md): a way of creating custom polymorphism.
-- [Types as objects](typeobjs.md): a way of manipulating types themselves.
-- [Structures](struct.md): a collection of named and typed fields. A
-  structure is actually special case of inductive datatype.
-- [Inductive Types](inductive.md): TODO: add one liner...
-
-## Universes
-
-Every type in Lean is, by definition, an expression of type `Sort u`
-for some universe level `u`. A universe level is one of the
-following:
-
-* a natural number, `n`
-* a universe variable, `u` (declared with the command `universe` or `universes`)
-* an expression `u + n`, where `u` is a universe level and `n` is a natural number
-* an expression `max u v`, where `u` and `v` are universes
-* an expression `imax u v`, where `u` and `v` are universe levels
-
-The last one denotes the universe level `0` if `v` is `0`, and `max u v` otherwise.
-
-```lean
-universe u v
-
-#check Sort u                       -- Type u
-#check Sort 5                       -- Type 4 : Type 5
-#check Sort (u + 1)                 -- Type u : Type (u + 1)
-#check Sort (u + 3)                 -- Type (u + 2) : Type (u + 3)
-#check Sort (max u v)               -- Sort (max u v) : Type (max u v)
-#check Sort (max (u + 3) v)         -- Sort (max (u + 3) v) : Type (max (u + 3) v)
-#check Sort (imax (u + 3) v)        -- Sort (imax (u + 3) v) : Type (imax (u + 3) v)
-#check Prop                         -- Type
-#check Type                         -- Type 1
-#check Type 1                       -- Type 1 : Type 2
-```

doc/using_lean.md

@@ -1 +0,0 @@
-# Using Lean

doc/whatIsLean.md

@@ -1,42 +0,0 @@
-# What is Lean
-
-Lean is a functional programming language that makes it easy to
-write correct and maintainable code.
-You can also use Lean as an interactive theorem prover.
-
-Lean programming primarily involves defining types and functions.
-This allows your focus to remain on the problem domain and manipulating its data,
-rather than the details of programming.
-
-```lean
--- Defines a function that takes a name and produces a greeting.
-def getGreeting (name : String) := s!"Hello, {name}! Isn't Lean great?"
-
--- The `main` function is the entry point of your program.
--- Its type is `IO Unit` because it can perform `IO` operations (side effects).
-def main : IO Unit :=
-  -- Define a list of names
-  let names := ["Sebastian", "Leo", "Daniel"]
-
-  -- Map each name to a greeting
-  let greetings := names.map getGreeting
-
-  -- Print the list of greetings
-  for greeting in greetings do
-    IO.println greeting
-```
-
-Lean has numerous features, including:
-
-- Type inference
-- First-class functions
-- Powerful data types
-- Pattern matching
-- [Type classes](./typeclass.md)
-- [Monads](./monads/intro.md)
-- [Extensible syntax](./syntax.md)
-- Hygienic macros
-- [Dependent types](https://lean-lang.org/theorem_proving_in_lean4/dependent_type_theory.html)
-- [Metaprogramming](./macro_overview.md)
-- Multithreading
-- Verification: you can prove properties of your functions using Lean itself

flake.lock

@@ -1,112 +1,50 @@
 {
   "nodes": {
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1710146030,
-        "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1710889954,
-        "narHash": "sha256-Pr6F5Pmd7JnNEMHHmspZ0qVqIBVxyZ13ik1pJtm2QXk=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "7872526e9c5332274ea5932a0c3270d6e4724f3b",
-        "type": "github"
+        "lastModified": 1745636243,
+        "narHash": "sha256-kbNvlQZf8wwok3d2X1kM/TlXH/MZ+03ZNv+IPPBx+DM=",
+        "rev": "f771eb401a46846c1aebd20552521b233dd7e18b",
+        "type": "tarball",
+        "url": "https://releases.nixos.org/nixos/unstable/nixos-25.05pre789333.f771eb401a46/nixexprs.tar.xz"
       },
       "original": {
-        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs-cadical": {
-      "locked": {
-        "lastModified": 1722221733,
-        "narHash": "sha256-sga9SrrPb+pQJxG1ttJfMPheZvDOxApFfwXCFO0H9xw=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "12bf09802d77264e441f48e25459c10c93eada2e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "12bf09802d77264e441f48e25459c10c93eada2e",
-        "type": "github"
+        "type": "tarball",
+        "url": "https://channels.nixos.org/nixos-unstable/nixexprs.tar.xz"
       }
     },
     "nixpkgs-old": {
       "flake": false,
       "locked": {
-        "lastModified": 1581379743,
-        "narHash": "sha256-i1XCn9rKuLjvCdu2UeXKzGLF6IuQePQKFt4hEKRU5oc=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "34c7eb7545d155cc5b6f499b23a7cb1c96ab4d59",
-        "type": "github"
+        "lastModified": 1582018169,
+        "narHash": "sha256-qv1iK1IchpZKSeWL3NEs4U5Jl5QVyNHDdiMJvLOI4Yc=",
+        "type": "tarball",
+        "url": "https://releases.nixos.org/nixos/19.03/nixos-19.03.173691.34c7eb7545d/nixexprs.tar.xz"
       },
       "original": {
-        "owner": "NixOS",
-        "ref": "nixos-19.03",
-        "repo": "nixpkgs",
-        "type": "github"
+        "type": "tarball",
+        "url": "https://channels.nixos.org/nixos-19.03/nixexprs.tar.xz"
       }
     },
     "nixpkgs-older": {
       "flake": false,
       "locked": {
-        "lastModified": 1523316493,
-        "narHash": "sha256-5qJS+i5ECICPAKA6FhPLIWkhPKDnOZsZbh2PHYF1Kbs=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "0b307aa73804bbd7a7172899e59ae0b8c347a62d",
-        "type": "github"
+        "lastModified": 1550657948,
+        "narHash": "sha256-BE0XqzNfzvhhtTXv37LyySyq4moL7z1i1hMvwbFNL/I=",
+        "type": "tarball",
+        "url": "https://releases.nixos.org/nixos/18.03/nixos-18.03.133402.cb0e20d6db9/nixexprs.tar.xz"
       },
       "original": {
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "0b307aa73804bbd7a7172899e59ae0b8c347a62d",
-        "type": "github"
+        "type": "tarball",
+        "url": "https://channels.nixos.org/nixos-18.03/nixexprs.tar.xz"
       }
     },
     "root": {
       "inputs": {
-        "flake-utils": "flake-utils",
         "nixpkgs": "nixpkgs",
-        "nixpkgs-cadical": "nixpkgs-cadical",
         "nixpkgs-old": "nixpkgs-old",
         "nixpkgs-older": "nixpkgs-older"
       }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
     }
   },
   "root": "root",

flake.nix

@@ -1,29 +1,22 @@
 {
   description = "Lean development flake. Not intended for end users.";
 
-  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+  # We use channels so we're not affected by GitHub's rate limits
+  inputs.nixpkgs.url = "https://channels.nixos.org/nixos-unstable/nixexprs.tar.xz";
   # old nixpkgs used for portable release with older glibc (2.27)
-  inputs.nixpkgs-old.url = "github:NixOS/nixpkgs/nixos-19.03";
+  inputs.nixpkgs-old.url = "https://channels.nixos.org/nixos-19.03/nixexprs.tar.xz";
   inputs.nixpkgs-old.flake = false;
   # old nixpkgs used for portable release with older glibc (2.26)
-  inputs.nixpkgs-older.url = "github:NixOS/nixpkgs/0b307aa73804bbd7a7172899e59ae0b8c347a62d";
+  inputs.nixpkgs-older.url = "https://channels.nixos.org/nixos-18.03/nixexprs.tar.xz";
   inputs.nixpkgs-older.flake = false;
-  # for cadical 1.9.5; sync with CMakeLists.txt
-  inputs.nixpkgs-cadical.url = "github:NixOS/nixpkgs/12bf09802d77264e441f48e25459c10c93eada2e";
-  inputs.flake-utils.url = "github:numtide/flake-utils";
 
-  outputs = inputs: inputs.flake-utils.lib.eachDefaultSystem (system:
+  outputs = inputs: builtins.foldl' inputs.nixpkgs.lib.attrsets.recursiveUpdate {} (builtins.map (system:
     let
       pkgs = import inputs.nixpkgs { inherit system; };
       # An old nixpkgs for creating releases with an old glibc
       pkgsDist-old = import inputs.nixpkgs-older { inherit system; };
       # An old nixpkgs for creating releases with an old glibc
       pkgsDist-old-aarch = import inputs.nixpkgs-old { localSystem.config = "aarch64-unknown-linux-gnu"; };
-      pkgsCadical = import inputs.nixpkgs-cadical { inherit system; };
-      cadical = if pkgs.stdenv.isLinux then
-        # use statically-linked cadical on Linux to avoid glibc versioning troubles
-        pkgsCadical.pkgsStatic.cadical.overrideAttrs { doCheck = false; }
-      else pkgsCadical.cadical;
 
       lean-packages = pkgs.callPackage (./nix/packages.nix) { src = ./.; };
 
@@ -31,7 +24,7 @@
           stdenv = pkgs.overrideCC pkgs.stdenv lean-packages.llvmPackages.clang;
         } ({
           buildInputs = with pkgs; [
-            cmake gmp libuv ccache cadical pkg-config
+            cmake gmp libuv ccache pkg-config
             lean-packages.llvmPackages.llvm  # llvm-symbolizer for asan/lsan
             gdb
             tree  # for CI
@@ -63,18 +56,21 @@
           GLIBC_DEV = pkgsDist.glibc.dev;
           GCC_LIB = pkgsDist.gcc.cc.lib;
           ZLIB = pkgsDist.zlib;
+          # for CI coredumps
           GDB = pkgsDist.gdb;
         });
     in {
-      packages = {
+      packages.${system} = {
         # to be removed when Nix CI is not needed anymore
         inherit (lean-packages) cacheRoots test update-stage0-commit ciShell;
         deprecated = lean-packages;
       };
 
-      # The default development shell for working on lean itself
-      devShells.default = devShellWithDist pkgs;
-      devShells.oldGlibc = devShellWithDist pkgsDist-old;
-      devShells.oldGlibcAArch = devShellWithDist pkgsDist-old-aarch;
-    });
+      devShells.${system} = {
+        # The default development shell for working on lean itself
+        default = devShellWithDist pkgs;
+        oldGlibc = devShellWithDist pkgsDist-old;
+        oldGlibcAArch = devShellWithDist pkgsDist-old-aarch;
+      };
+    }) ["x86_64-linux" "aarch64-linux"]);
 }

nix/bootstrap.nix

@@ -17,7 +17,7 @@ lib.warn "The Nix-based build is deprecated" rec {
     '';
   } // args // {
     src = args.realSrc or (sourceByRegex args.src [ "[a-z].*" "CMakeLists\.txt" ]);
-    cmakeFlags = (args.cmakeFlags or [ "-DSTAGE=1" "-DPREV_STAGE=./faux-prev-stage" "-DUSE_GITHASH=OFF" "-DCADICAL=${cadical}/bin/cadical" ]) ++ (args.extraCMakeFlags or extraCMakeFlags) ++ lib.optional (args.debug or debug) [ "-DCMAKE_BUILD_TYPE=Debug" ];
+    cmakeFlags = ["-DSMALL_ALLOCATOR=ON" "-DUSE_MIMALLOC=OFF"] ++ (args.cmakeFlags or [ "-DSTAGE=1" "-DPREV_STAGE=./faux-prev-stage" "-DUSE_GITHASH=OFF" "-DCADICAL=${cadical}/bin/cadical" ]) ++ (args.extraCMakeFlags or extraCMakeFlags) ++ lib.optional (args.debug or debug) [ "-DCMAKE_BUILD_TYPE=Debug" ];
     preConfigure = args.preConfigure or "" + ''
       # ignore absence of submodule
       sed -i 's!lake/Lake.lean!!' CMakeLists.txt

nix/buildLeanPackage.nix

@@ -159,7 +159,7 @@ with builtins; let
       dir=$(dirname $relpath)
       mkdir -p $dir $out/$dir $ilean/$dir $c/$dir
       if [ -d $src ]; then cp -r $src/. .; else cp $src $leanPath; fi
-      lean -o $out/$oleanPath -i $ilean/$ileanPath -c $c/$cPath $leanPath $leanFlags $leanPluginFlags $leanLoadDynlibFlags
+      lean -o $out/$oleanPath -i $out/$ileanPath -c $c/$cPath $leanPath $leanFlags $leanPluginFlags $leanLoadDynlibFlags
     '';
   }) // {
     inherit deps;
@@ -194,7 +194,7 @@ with builtins; let
   modCandidates = mapAttrs (mod: header:
     let
       deps = if header.errors == []
-             then map (m: m.module) header.imports
+             then map (m: m.module) header.result.imports
              else abort "errors while parsing imports of ${mod}:\n${lib.concatStringsSep "\n" header.errors}";
     in mkMod mod (map (dep: if modDepsMap ? ${dep} then modCandidates.${dep} else externalModMap.${dep}) deps)) modDepsMap;
   expandGlob = g:
@@ -206,7 +206,7 @@ with builtins; let
   # subset of `modCandidates` that is transitively reachable from `roots`
   mods' = listToAttrs (map (e: { name = e.key; value = modCandidates.${e.key}; }) (genericClosure {
     startSet = map (m: { key = m; }) (concatMap expandGlob roots);
-    operator = e: if modDepsMap ? ${e.key} then map (m: { key = m.module; }) (filter (m: modCandidates ? ${m.module}) modDepsMap.${e.key}.imports) else [];
+    operator = e: if modDepsMap ? ${e.key} then map (m: { key = m.module; }) (filter (m: modCandidates ? ${m.module}) modDepsMap.${e.key}.result.imports) else [];
   }));
   allLinkFlags = lib.foldr (shared: acc: acc ++ [ "-L${shared}" "-l${shared.linkName or shared.name}" ]) linkFlags allNativeSharedLibs;
 

releases/v4.0.0-m4.md

@@ -1,292 +0,0 @@
-v4.0.0-m4 (23 March 2022)
----------
-
-* `simp` now takes user-defined simp-attributes. You can define a new `simp` attribute by creating a file (e.g., `MySimp.lean`) containing
-  ```lean
-  import Lean
-  open Lean.Meta
-
-  initialize my_ext : SimpExtension ← registerSimpAttr `my_simp "my own simp attribute"
-  ```
-  If you don't need to access `my_ext`, you can also use the macro
-  ```lean
-  import Lean
-
-  register_simp_attr my_simp "my own simp attribute"
-  ```
-  Recall that the new `simp` attribute is not active in the Lean file where it was defined.
-  Here is a small example using the new feature.
-  ```lean
-  import MySimp
-
-  def f (x : Nat) := x + 2
-  def g (x : Nat) := x + 1
-
-  @[my_simp] theorem f_eq : f x = x + 2 := rfl
-  @[my_simp] theorem g_eq : g x = x + 1 := rfl
-
-  example : f x + g x = 2*x + 3 := by
-    simp_arith [my_simp]
-  ```
-
-* Extend `match` syntax: multiple left-hand-sides in a single alternative. Example:
-  ```lean
-  def fib : Nat → Nat
-  | 0 | 1 => 1
-  | n+2 => fib n + fib (n+1)
-  ```
-  This feature was discussed at [issue 371](https://github.com/leanprover/lean4/issues/371). It was implemented as a macro expansion. Thus, the following is accepted.
-  ```lean
-  inductive StrOrNum where
-    | S (s : String)
-    | I (i : Int)
-
-  def StrOrNum.asString (x : StrOrNum) :=
-    match x with
-    | I a | S a => toString a
-  ```
-
-
-* Improve `#eval` command. Now, when it fails to synthesize a `Lean.MetaEval` instance for the result type, it reduces the type and tries again. The following example now works without additional annotations
-  ```lean
-  def Foo := List Nat
-
-  def test (x : Nat) : Foo :=
-    [x, x+1, x+2]
-
-  #eval test 4
-  ```
-
-* `rw` tactic can now apply auto-generated equation theorems for a given definition. Example:
-  ```lean
-  example (a : Nat) (h : n = 1) : [a].length = n := by
-    rw [List.length]
-    trace_state -- .. |- [].length + 1 = n
-    rw [List.length]
-    trace_state -- .. |- 0 + 1 = n
-    rw [h]
-  ```
-
-* [Fuzzy matching for auto completion](https://github.com/leanprover/lean4/pull/1023)
-
-* Extend dot-notation `x.field` for arrow types. If type of `x` is an arrow, we look up for `Function.field`.
-For example, given `f : Nat → Nat` and `g : Nat → Nat`, `f.comp g` is now notation for `Function.comp f g`.
-
-* The new `.<identifier>` notation is now also accepted where a function type is expected.
-  ```lean
-  example (xs : List Nat) : List Nat := .map .succ xs
-  example (xs : List α) : Std.RBTree α ord := xs.foldl .insert ∅
-  ```
-
-* [Add code folding support to the language server](https://github.com/leanprover/lean4/pull/1014).
-
-* Support notation `let <pattern> := <expr> | <else-case>` in `do` blocks.
-
-* Remove support for "auto" `pure`. In the [Zulip thread](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/for.2C.20unexpected.20need.20for.20type.20ascription/near/269083574), the consensus seemed to be that "auto" `pure` is more confusing than it's worth.
-
-* Remove restriction in `congr` theorems that all function arguments on the left-hand-side must be free variables. For example, the following theorem is now a valid `congr` theorem.
-  ```lean
-  @[congr]
-  theorem dep_congr [DecidableEq ι] {p : ι → Set α} [∀ i, Inhabited (p i)] :
-                    ∀ {i j} (h : i = j) (x : p i) (y : α) (hx : x = y), Pi.single (f := (p ·)) i x = Pi.single (f := (p ·)) j ⟨y, hx ▸ h ▸ x.2⟩ :=
-  ```
-
-* [Partially applied congruence theorems.](https://github.com/leanprover/lean4/issues/988)
-
-* Improve elaboration postponement heuristic when expected type is a metavariable. Lean now reduces the expected type before performing the test.
-
-* [Remove deprecated leanpkg](https://github.com/leanprover/lean4/pull/985) in favor of [Lake](https://github.com/leanprover/lake) now bundled with Lean.
-
-* Various improvements to go-to-definition & find-all-references accuracy.
-
-* Auto generated congruence lemmas with support for casts on proofs and `Decidable` instances (see [wishlist](https://github.com/leanprover/lean4/issues/988)).
-
-* Rename option `autoBoundImplicitLocal` => `autoImplicit`.
-
-* [Relax auto-implicit restrictions](https://github.com/leanprover/lean4/pull/1011). The command `set_option relaxedAutoImplicit false` disables the relaxations.
-
-* `contradiction` tactic now closes the goal if there is a `False.elim` application in the target.
-
-* Renamed tatic `byCases` => `by_cases` (motivation: enforcing naming convention).
-
-* Local instances occurring in patterns are now considered by the type class resolution procedure. Example:
-  ```lean
-  def concat : List ((α : Type) × ToString α × α) → String
-    | [] => ""
-    | ⟨_, _, a⟩ :: as => toString a ++ concat as
-  ```
-
-* Notation for providing the motive for `match` expressions has changed.
-  before:
-  ```lean
-  match x, rfl : (y : Nat) → x = y → Nat with
-  | 0,   h => ...
-  | x+1, h => ...
-  ```
-  now:
-  ```lean
-  match (motive := (y : Nat) → x = y → Nat) x, rfl with
-  | 0,   h => ...
-  | x+1, h => ...
-  ```
-  With this change, the notation for giving names to equality proofs in `match`-expressions is not whitespace sensitive anymore. That is,
-  we can now write
-  ```lean
-  match h : sort.swap a b with
-  | (r₁, r₂) => ... -- `h : sort.swap a b = (r₁, r₂)`
-  ```
-
-* `(generalizing := true)` is the default behavior for `match` expressions even if the expected type is not a proposition. In the following example, we used to have to include `(generalizing := true)` manually.
-  ```lean
-  inductive Fam : Type → Type 1 where
-    | any : Fam α
-    | nat : Nat → Fam Nat
-
-  example (a : α) (x : Fam α) : α :=
-    match x with
-    | Fam.any   => a
-    | Fam.nat n => n
-  ```
-
-* We now use `PSum` (instead of `Sum`) when compiling mutually recursive definitions using well-founded recursion.
-
-* Better support for parametric well-founded relations. See [issue #1017](https://github.com/leanprover/lean4/issues/1017). This change affects the low-level `termination_by'` hint because the fixed prefix of the function parameters in not "packed" anymore when constructing the well-founded relation type. For example, in the following definition, `as` is part of the fixed prefix, and is not packed anymore. In previous versions, the `termination_by'` term would be written as `measure fun ⟨as, i, _⟩ => as.size - i`
-  ```lean
-  def sum (as : Array Nat) (i : Nat) (s : Nat) : Nat :=
-    if h : i < as.size then
-      sum as (i+1) (s + as.get ⟨i, h⟩)
-    else
-      s
-  termination_by' measure fun ⟨i, _⟩ => as.size - i
-  ```
-
-* Add `while <cond> do <do-block>`, `repeat <do-block>`, and `repeat <do-block> until <cond>` macros for `do`-block. These macros are based on `partial` definitions, and consequently are useful only for writing programs we don't want to prove anything about.
-
-* Add `arith` option to `Simp.Config`, the macro `simp_arith` expands to `simp (config := { arith := true })`. Only `Nat` and linear arithmetic is currently supported. Example:
-  ```lean
-  example : 0 < 1 + x ∧ x + y + 2 ≥ y + 1 := by
-    simp_arith
-  ```
-
-* Add `fail <string>?` tactic that always fail.
-
-* Add support for acyclicity at dependent elimination. See [issue #1022](https://github.com/leanprover/lean4/issues/1022).
-
-* Add `trace <string>` tactic for debugging purposes.
-
-* Add nontrivial `SizeOf` instance for types `Unit → α`, and add support for them in the auto-generated `SizeOf` instances for user-defined inductive types. For example, given the inductive datatype
-  ```lean
-  inductive LazyList (α : Type u) where
-    | nil                               : LazyList α
-    | cons (hd : α) (tl : LazyList α)   : LazyList α
-    | delayed (t : Thunk (LazyList α))  : LazyList α
-  ```
-  we now have `sizeOf (LazyList.delayed t) = 1 + sizeOf t` instead of `sizeOf (LazyList.delayed t) = 2`.
-
-* Add support for guessing (very) simple well-founded relations when proving termination. For example, the following function does not require a `termination_by` annotation anymore.
-  ```lean
-  def Array.insertAtAux (i : Nat) (as : Array α) (j : Nat) : Array α :=
-    if h : i < j then
-      let as := as.swap! (j-1) j;
-      insertAtAux i as (j-1)
-    else
-      as
-  ```
-
-* Add support for `for h : x in xs do ...` notation where `h : x ∈ xs`. This is mainly useful for showing termination.
-
-* Auto implicit behavior changed for inductive families. An auto implicit argument occurring in inductive family index is also treated as an index (IF it is not fixed, see next item). For example
-  ```lean
-  inductive HasType : Index n → Vector Ty n → Ty → Type where
-  ```
-  is now interpreted as
-  ```lean
-  inductive HasType : {n : Nat} → Index n → Vector Ty n → Ty → Type where
-  ```
-
-* To make the previous feature more convenient to use, we promote a fixed prefix of inductive family indices to parameters. For example, the following declaration is now accepted by Lean
-  ```lean
-  inductive Lst : Type u → Type u
-    | nil  : Lst α
-    | cons : α → Lst α → Lst α
-  ```
-  and `α` in `Lst α` is a parameter. The actual number of parameters can be inspected using the command `#print Lst`. This feature also makes sure we still accept the declaration
-  ```lean
-  inductive Sublist : List α → List α → Prop
-    | slnil : Sublist [] []
-    | cons l₁ l₂ a : Sublist l₁ l₂ → Sublist l₁ (a :: l₂)
-    | cons2 l₁ l₂ a : Sublist l₁ l₂ → Sublist (a :: l₁) (a :: l₂)
-  ```
-
-* Added auto implicit "chaining". Unassigned metavariables occurring in the auto implicit types now become new auto implicit locals. Consider the following example:
-  ```lean
-  inductive HasType : Fin n → Vector Ty n → Ty → Type where
-    | stop : HasType 0 (ty :: ctx) ty
-    | pop  : HasType k ctx ty → HasType k.succ (u :: ctx) ty
-  ```
-  `ctx` is an auto implicit local in the two constructors, and it has type `ctx : Vector Ty ?m`. Without auto implicit "chaining", the metavariable `?m` will remain unassigned. The new feature creates yet another implicit local `n : Nat` and assigns `n` to `?m`. So, the declaration above is shorthand for
-  ```lean
-  inductive HasType : {n : Nat} → Fin n → Vector Ty n → Ty → Type where
-    | stop : {ty : Ty} → {n : Nat} → {ctx : Vector Ty n} → HasType 0 (ty :: ctx) ty
-    | pop  : {n : Nat} → {k : Fin n} → {ctx : Vector Ty n} → {ty : Ty} → HasType k ctx ty → HasType k.succ (u :: ctx) ty
-  ```
-
-* Eliminate auxiliary type annotations (e.g, `autoParam` and `optParam`) from recursor minor premises and projection declarations. Consider the following example
-  ```lean
-  structure A :=
-    x : Nat
-    h : x = 1 := by trivial
-
-  example (a : A) : a.x = 1 := by
-    have aux := a.h
-    -- `aux` has now type `a.x = 1` instead of `autoParam (a.x = 1) auto✝`
-    exact aux
-
-  example (a : A) : a.x = 1 := by
-    cases a with
-    | mk x h =>
-      -- `h` has now type `x = 1` instead of `autoParam (x = 1) auto✝`
-      assumption
-  ```
-
-* We now accept overloaded notation in patterns, but we require the set of pattern variables in each alternative to be the same. Example:
-  ```lean
-  inductive Vector (α : Type u) : Nat → Type u
-    | nil : Vector α 0
-    | cons : α → Vector α n → Vector α (n+1)
-
-  infix:67 " :: " => Vector.cons -- Overloading the `::` notation
-
-  def head1 (x : List α) (h : x ≠ []) : α :=
-    match x with
-    | a :: as => a -- `::` is `List.cons` here
-
-  def head2 (x : Vector α (n+1)) : α :=
-    match x with
-    | a :: as => a -- `::` is `Vector.cons` here
-  ```
-
-* New notation `.<identifier>` based on Swift. The namespace is inferred from the expected type. See [issue #944](https://github.com/leanprover/lean4/issues/944). Examples:
-  ```lean
-  def f (x : Nat) : Except String Nat :=
-    if x > 0 then
-      .ok x
-    else
-      .error "x is zero"
-
-  namespace Lean.Elab
-  open Lsp
-
-  def identOf : Info → Option (RefIdent × Bool)
-    | .ofTermInfo ti => match ti.expr with
-      | .const n .. => some (.const n, ti.isBinder)
-      | .fvar id .. => some (.fvar id, ti.isBinder)
-      | _ => none
-    | .ofFieldInfo fi => some (.const fi.projName, false)
-    | _ => none
-
-  def isImplicit (bi : BinderInfo) : Bool :=
-    bi matches .implicit
-
-  end Lean.Elab
-  ```

releases/v4.0.0-m5.md

@@ -1,715 +0,0 @@
-v4.0.0-m5 (07 August 2022)
----------
-
-* Update Lake to v4.0.0. See the [v4.0.0 release notes](https://github.com/leanprover/lake/releases/tag/v4.0.0) for detailed changes.
-
-* Mutual declarations in different namespaces are now supported. Example:
-  ```lean
-  mutual
-    def Foo.boo (x : Nat) :=
-      match x with
-      | 0 => 1
-      | x + 1 => 2*Boo.bla x
-
-    def Boo.bla (x : Nat) :=
-      match x with
-      | 0 => 2
-      | x+1 => 3*Foo.boo x
-  end
-  ```
-  A `namespace` is automatically created for the common prefix. Example:
-  ```lean
-  mutual
-    def Tst.Foo.boo (x : Nat) := ...
-    def Tst.Boo.bla (x : Nat) := ...
-  end
-  ```
-  expands to
-  ```lean
-  namespace Tst
-  mutual
-    def Foo.boo (x : Nat) := ...
-    def Boo.bla (x : Nat) := ...
-  end
-  end Tst
-  ```
-
-* Allow users to install their own `deriving` handlers for existing type classes.
-  See example at [Simple.lean](https://github.com/leanprover/lean4/blob/master/tests/pkg/deriving/UserDeriving/Simple.lean).
-
-* Add tactic `congr (num)?`. See doc string for additional details.
-
-* [Missing doc linter](https://github.com/leanprover/lean4/pull/1390)
-
-* `match`-syntax notation now checks for unused alternatives. See issue [#1371](https://github.com/leanprover/lean4/issues/1371).
-
-* Auto-completion for structure instance fields. Example:
-  ```lean
-  example : Nat × Nat := {
-    f -- HERE
-  }
-  ```
-  `fst` now appears in the list of auto-completion suggestions.
-
-* Auto-completion for dotted identifier notation. Example:
-  ```lean
-  example : Nat :=
-    .su -- HERE
-  ```
-  `succ` now appears in the list of auto-completion suggestions.
-
-* `nat_lit` is not needed anymore when declaring `OfNat` instances. See issues [#1389](https://github.com/leanprover/lean4/issues/1389) and [#875](https://github.com/leanprover/lean4/issues/875). Example:
-  ```lean
-  inductive Bit where
-    | zero
-    | one
-
-  instance inst0 : OfNat Bit 0 where
-    ofNat := Bit.zero
-
-  instance : OfNat Bit 1 where
-    ofNat := Bit.one
-
-  example : Bit := 0
-  example : Bit := 1
-  ```
-
-* Add `[elabAsElim]` attribute (it is called `elab_as_eliminator` in Lean 3). Motivation: simplify the Mathlib port to Lean 4.
-
-* `Trans` type class now accepts relations in `Type u`. See this [Zulip issue](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Calc.20mode/near/291214574).
-
-* Accept unescaped keywords as inductive constructor names. Escaping can often be avoided at use sites via dot notation.
-  ```lean
-  inductive MyExpr
-    | let : ...
-
-  def f : MyExpr → MyExpr
-    | .let ... => .let ...
-  ```
-
-* Throw an error message at parametric local instances such as `[Nat -> Decidable p]`. The type class resolution procedure
-  cannot use this kind of local instance because the parameter does not have a forward dependency.
-  This check can be disabled using `set_option checkBinderAnnotations false`.
-
-* Add option `pp.showLetValues`. When set to `false`, the info view hides the value of `let`-variables in a goal.
-  By default, it is `true` when visualizing tactic goals, and `false` otherwise.
-  See [issue #1345](https://github.com/leanprover/lean4/issues/1345) for additional details.
-
-* Add option `warningAsError`. When set to true, warning messages are treated as errors.
-
-* Support dotted notation and named arguments in patterns. Example:
-  ```lean
-  def getForallBinderType (e : Expr) : Expr :=
-    match e with
-    | .forallE (binderType := type) .. => type
-    | _ => panic! "forall expected"
-  ```
-
-* "jump-to-definition" now works for function names embedded in the following attributes
-  `@[implementedBy funName]`, `@[tactic parserName]`, `@[termElab parserName]`, `@[commandElab parserName]`,
-  `@[builtinTactic parserName]`, `@[builtinTermElab parserName]`, and `@[builtinCommandElab parserName]`.
-   See [issue #1350](https://github.com/leanprover/lean4/issues/1350).
-
-* Improve `MVarId` methods discoverability. See [issue #1346](https://github.com/leanprover/lean4/issues/1346).
-  We still have to add similar methods for `FVarId`, `LVarId`, `Expr`, and other objects.
-  Many existing methods have been marked as deprecated.
-
-* Add attribute `[deprecated]` for marking deprecated declarations. Examples:
-  ```lean
-  def g (x : Nat) := x + 1
-
-  -- Whenever `f` is used, a warning message is generated suggesting to use `g` instead.
-  @[deprecated g]
-  def f (x : Nat) := x + 1
-
-  #check f 0 -- warning: `f` has been deprecated, use `g` instead
-
-  -- Whenever `h` is used, a warning message is generated.
-  @[deprecated]
-  def h (x : Nat) := x + 1
-
-  #check h 0 -- warning: `h` has been deprecated
-  ```
-
-* Add type `LevelMVarId` (and abbreviation `LMVarId`) for universe level metavariable ids.
-  Motivation: prevent meta-programmers from mixing up universe and expression metavariable ids.
-
-* Improve `calc` term and tactic. See [issue #1342](https://github.com/leanprover/lean4/issues/1342).
-
-* [Relaxed antiquotation parsing](https://github.com/leanprover/lean4/pull/1272) further reduces the need for explicit `$x:p` antiquotation kind annotations.
-
-* Add support for computed fields in inductives. Example:
-  ```lean
-  inductive Exp
-    | var (i : Nat)
-    | app (a b : Exp)
-  with
-    @[computedField] hash : Exp → Nat
-      | .var i => i
-      | .app a b => a.hash * b.hash + 1
-  ```
-  The result of the `Exp.hash` function is then stored as an extra "computed" field in the `.var` and `.app` constructors;
-  `Exp.hash` accesses this field and thus runs in constant time (even on dag-like values).
-
-* Update `a[i]` notation. It is now based on the typeclass
-  ```lean
-  class GetElem (cont : Type u) (idx : Type v) (elem : outParam (Type w)) (dom : outParam (cont → idx → Prop)) where
-    getElem (xs : cont) (i : idx) (h : dom xs i) : Elem
-  ```
-  The notation `a[i]` is now defined as follows
-  ```lean
-  macro:max x:term noWs "[" i:term "]" : term => `(getElem $x $i (by get_elem_tactic))
-  ```
-  The proof that `i` is a valid index is synthesized using the tactic `get_elem_tactic`.
-  For example, the type `Array α` has the following instances
-  ```lean
-  instance : GetElem (Array α) Nat α fun xs i => LT.lt i xs.size where ...
-  instance : GetElem (Array α) USize α fun xs i => LT.lt i.toNat xs.size where ...
-  ```
-  You can use the notation `a[i]'h` to provide the proof manually.
-  Two other notations were introduced: `a[i]!` and `a[i]?`, For `a[i]!`, a panic error message is produced at
-  runtime if `i` is not a valid index. `a[i]?` has type `Option α`, and `a[i]?` evaluates to `none` if the
-  index `i` is not valid.
-  The three new notations are defined as follows:
-  ```lean
-  @[inline] def getElem' [GetElem cont idx elem dom] (xs : cont) (i : idx) (h : dom xs i) : elem :=
-  getElem xs i h
-
-  @[inline] def getElem! [GetElem cont idx elem dom] [Inhabited elem] (xs : cont) (i : idx) [Decidable (dom xs i)] : elem :=
-    if h : _ then getElem xs i h else panic! "index out of bounds"
-
-  @[inline] def getElem? [GetElem cont idx elem dom] (xs : cont) (i : idx) [Decidable (dom xs i)] : Option elem :=
-    if h : _ then some (getElem xs i h) else none
-
-  macro:max x:term noWs "[" i:term "]" noWs "?" : term => `(getElem? $x $i)
-  macro:max x:term noWs "[" i:term "]" noWs "!" : term => `(getElem! $x $i)
-  macro x:term noWs "[" i:term "]'" h:term:max : term => `(getElem' $x $i $h)
-  ```
-  See discussion on [Zulip](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/String.2EgetOp/near/287855425).
-  Examples:
-  ```lean
-  example (a : Array Int) (i : Nat) : Int :=
-    a[i] -- Error: failed to prove index is valid ...
-
-  example (a : Array Int) (i : Nat) (h : i < a.size) : Int :=
-    a[i] -- Ok
-
-  example (a : Array Int) (i : Nat) : Int :=
-    a[i]! -- Ok
-
-  example (a : Array Int) (i : Nat) : Option Int :=
-    a[i]? -- Ok
-
-  example (a : Array Int) (h : a.size = 2) : Int :=
-    a[0]'(by rw [h]; decide) -- Ok
-
-  example (a : Array Int) (h : a.size = 2) : Int :=
-    have : 0 < a.size := by rw [h]; decide
-    have : 1 < a.size := by rw [h]; decide
-    a[0] + a[1] -- Ok
-
-  example (a : Array Int) (i : USize) (h : i.toNat < a.size) : Int :=
-    a[i] -- Ok
-  ```
-  The `get_elem_tactic` is defined as
-  ```lean
-  macro "get_elem_tactic" : tactic =>
-    `(first
-      | get_elem_tactic_trivial
-      | fail "failed to prove index is valid, ..."
-     )
-  ```
-  The `get_elem_tactic_trivial` auxiliary tactic can be extended using `macro_rules`. By default, it tries `trivial`, `simp_arith`, and a special case for `Fin`. In the future, it will also try `linarith`.
-  You can extend `get_elem_tactic_trivial` using `my_tactic` as follows
-  ```lean
-  macro_rules
-  | `(tactic| get_elem_tactic_trivial) => `(tactic| my_tactic)
-  ```
-  Note that `Idx`'s type in `GetElem` does not depend on `Cont`. So, you cannot write the instance `instance : GetElem (Array α) (Fin ??) α fun xs i => ...`, but the Lean library comes equipped with the following auxiliary instance:
-  ```lean
-  instance [GetElem cont Nat elem dom] : GetElem cont (Fin n) elem fun xs i => dom xs i where
-    getElem xs i h := getElem xs i.1 h
-  ```
-  and helper tactic
-  ```lean
-  macro_rules
-  | `(tactic| get_elem_tactic_trivial) => `(tactic| apply Fin.val_lt_of_le; get_elem_tactic_trivial; done)
-  ```
-  Example:
-  ```lean
-  example (a : Array Nat) (i : Fin a.size) :=
-    a[i] -- Ok
-
-  example (a : Array Nat) (h : n ≤ a.size) (i : Fin n) :=
-    a[i] -- Ok
-  ```
-
-* Better support for qualified names in recursive declarations. The following is now supported:
-  ```lean
-  namespace Nat
-    def fact : Nat → Nat
-    | 0 => 1
-    | n+1 => (n+1) * Nat.fact n
-  end Nat
-  ```
-
-* Add support for `CommandElabM` monad at `#eval`. Example:
-  ```lean
-  import Lean
-
-  open Lean Elab Command
-
-  #eval do
-    let id := mkIdent `foo
-    elabCommand (← `(def $id := 10))
-
-  #eval foo -- 10
-  ```
-
-* Try to elaborate `do` notation even if the expected type is not available. We still delay elaboration when the expected type
-  is not available. This change is particularly useful when writing examples such as
-  ```lean
-  #eval do
-    IO.println "hello"
-    IO.println "world"
-  ```
-  That is, we don't have to use the idiom `#eval show IO _ from do ...` anymore.
-  Note that auto monadic lifting is less effective when the expected type is not available.
-  Monadic polymorphic functions (e.g., `ST.Ref.get`) also require the expected type.
-
-* On Linux, panics now print a backtrace by default, which can be disabled by setting the environment variable `LEAN_BACKTRACE` to `0`.
-  Other platforms are TBD.
-
-* The `group(·)` `syntax` combinator is now introduced automatically where necessary, such as when using multiple parsers inside `(...)+`.
-
-* Add ["Typed Macros"](https://github.com/leanprover/lean4/pull/1251): syntax trees produced and accepted by syntax antiquotations now remember their syntax kinds, preventing accidental production of ill-formed syntax trees and reducing the need for explicit `:kind` antiquotation annotations. See PR for details.
-
-* Aliases of protected definitions are protected too. Example:
-  ```lean
-  protected def Nat.double (x : Nat) := 2*x
-
-  namespace Ex
-  export Nat (double) -- Add alias Ex.double for Nat.double
-  end Ex
-
-  open Ex
-  #check Ex.double -- Ok
-  #check double -- Error, `Ex.double` is alias for `Nat.double` which is protected
-  ```
-
-* Use `IO.getRandomBytes` to initialize random seed for `IO.rand`. See discussion at [this PR](https://github.com/leanprover/lean4-samples/pull/2).
-
-* Improve dot notation and aliases interaction. See discussion on [Zulip](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Namespace-based.20overloading.20does.20not.20find.20exports/near/282946185) for additional details.
-  Example:
-  ```lean
-  def Set (α : Type) := α → Prop
-  def Set.union (s₁ s₂ : Set α) : Set α := fun a => s₁ a ∨ s₂ a
-  def FinSet (n : Nat) := Fin n → Prop
-
-  namespace FinSet
-    export Set (union) -- FinSet.union is now an alias for `Set.union`
-  end FinSet
-
-  example (x y : FinSet 10) : FinSet 10 :=
-    x.union y -- Works
-  ```
-
-* `ext` and `enter` conv tactics can now go inside let-declarations. Example:
-  ```lean
-  example (g : Nat → Nat) (y : Nat) (h : let x := y + 1; g (0+x) = x) : g (y + 1) = y + 1 := by
-    conv at h => enter [x, 1, 1]; rw [Nat.zero_add]
-    /-
-      g : Nat → Nat
-      y : Nat
-      h : let x := y + 1;
-          g x = x
-      ⊢ g (y + 1) = y + 1
-    -/
-    exact h
-  ```
-
-* Add `zeta` conv tactic to expand let-declarations. Example:
-  ```lean
-  example (h : let x := y + 1; 0 + x = y) : False := by
-    conv at h => zeta; rw [Nat.zero_add]
-    /-
-      y : Nat
-      h : y + 1 = y
-      ⊢ False
-    -/
-    simp_arith at h
-  ```
-
-* Improve namespace resolution. See issue [#1224](https://github.com/leanprover/lean4/issues/1224). Example:
-  ```lean
-  import Lean
-  open Lean Parser Elab
-  open Tactic -- now opens both `Lean.Parser.Tactic` and `Lean.Elab.Tactic`
-  ```
-
-* Rename `constant` command to `opaque`. See discussion at [Zulip](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/What.20is.20.60opaque.60.3F/near/284926171).
-
-* Extend `induction` and `cases` syntax: multiple left-hand-sides in a single alternative. This extension is very similar to the one implemented for `match` expressions. Examples:
-  ```lean
-  inductive Foo where
-    | mk1 (x : Nat) | mk2 (x : Nat) | mk3
-
-  def f (v : Foo) :=
-    match v with
-    | .mk1 x => x + 1
-    | .mk2 x => 2*x + 1
-    | .mk3   => 1
-
-  theorem f_gt_zero : f v > 0 := by
-    cases v with
-    | mk1 x | mk2 x => simp_arith!  -- New feature used here!
-    | mk3 => decide
-  ```
-
-* [`let/if` indentation in `do` blocks in now supported.](https://github.com/leanprover/lean4/issues/1120)
-
-* Add unnamed antiquotation `$_` for use in syntax quotation patterns.
-
-* [Add unused variables linter](https://github.com/leanprover/lean4/pull/1159). Feedback welcome!
-
-* Lean now generates an error if the body of a declaration body contains a universe parameter that does not occur in the declaration type, nor is an explicit parameter.
-  Examples:
-  ```lean
-  /-
-  The following declaration now produces an error because `PUnit` is universe polymorphic,
-  but the universe parameter does not occur in the function type `Nat → Nat`
-  -/
-  def f (n : Nat) : Nat :=
-    let aux (_ : PUnit) : Nat := n + 1
-    aux ⟨⟩
-
-  /-
-  The following declaration is accepted because the universe parameter was explicitly provided in the
-  function signature.
-  -/
-  def g.{u} (n : Nat) : Nat :=
-    let aux (_ : PUnit.{u}) : Nat := n + 1
-    aux ⟨⟩
-  ```
-
-* Add `subst_vars` tactic.
-
-* [Fix `autoParam` in structure fields lost in multiple inheritance.](https://github.com/leanprover/lean4/issues/1158).
-
-* Add `[eliminator]` attribute. It allows users to specify default recursor/eliminators for the `induction` and `cases` tactics.
-  It is an alternative for the `using` notation. Example:
-  ```lean
-  @[eliminator] protected def recDiag {motive : Nat → Nat → Sort u}
-      (zero_zero : motive 0 0)
-      (succ_zero : (x : Nat) → motive x 0 → motive (x + 1) 0)
-      (zero_succ : (y : Nat) → motive 0 y → motive 0 (y + 1))
-      (succ_succ : (x y : Nat) → motive x y → motive (x + 1) (y + 1))
-      (x y : Nat) :  motive x y :=
-    let rec go : (x y : Nat) → motive x y
-      | 0,     0 => zero_zero
-      | x+1, 0   => succ_zero x (go x 0)
-      | 0,   y+1 => zero_succ y (go 0 y)
-      | x+1, y+1 => succ_succ x y (go x y)
-    go x y
-  termination_by go x y => (x, y)
-
-  def f (x y : Nat) :=
-    match x, y with
-    | 0,   0   => 1
-    | x+1, 0   => f x 0
-    | 0,   y+1 => f 0 y
-    | x+1, y+1 => f x y
-  termination_by f x y => (x, y)
-
-  example (x y : Nat) : f x y > 0 := by
-    induction x, y <;> simp [f, *]
-  ```
-
-* Add support for `casesOn` applications to structural and well-founded recursion modules.
-  This feature is useful when writing definitions using tactics. Example:
-  ```lean
-  inductive Foo where
-    | a | b | c
-    | pair: Foo × Foo → Foo
-
-  def Foo.deq (a b : Foo) : Decidable (a = b) := by
-    cases a <;> cases b
-    any_goals apply isFalse Foo.noConfusion
-    any_goals apply isTrue rfl
-    case pair a b =>
-      let (a₁, a₂) := a
-      let (b₁, b₂) := b
-      exact match deq a₁ b₁, deq a₂ b₂ with
-      | isTrue h₁, isTrue h₂ => isTrue (by rw [h₁,h₂])
-      | isFalse h₁, _ => isFalse (fun h => by cases h; cases (h₁ rfl))
-      | _, isFalse h₂ => isFalse (fun h => by cases h; cases (h₂ rfl))
-  ```
-
-* `Option` is again a monad. The auxiliary type `OptionM` has been removed. See [Zulip thread](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Do.20we.20still.20need.20OptionM.3F/near/279761084).
-
-* Improve `split` tactic. It used to fail on `match` expressions of the form `match h : e with ...` where `e` is not a free variable.
-  The failure used to occur during generalization.
-
-
-* New encoding for `match`-expressions that use the `h :` notation for discriminants. The information is not lost during delaboration,
-  and it is the foundation for a better `split` tactic. at delaboration time. Example:
-  ```lean
-  #print Nat.decEq
-  /-
-  protected def Nat.decEq : (n m : Nat) → Decidable (n = m) :=
-  fun n m =>
-    match h : Nat.beq n m with
-    | true => isTrue (_ : n = m)
-    | false => isFalse (_ : ¬n = m)
-  -/
-  ```
-
-* `exists` tactic is now takes a comma separated list of terms.
-
-* Add `dsimp` and `dsimp!` tactics. They guarantee the result term is definitionally equal, and only apply
-  `rfl`-theorems.
-
-* Fix binder information for `match` patterns that use definitions tagged with `[matchPattern]` (e.g., `Nat.add`).
-  We now have proper binder information for the variable `y` in the following example.
-  ```lean
-  def f (x : Nat) : Nat :=
-    match x with
-    | 0 => 1
-    | y + 1 => y
-  ```
-
-* (Fix) the default value for structure fields may now depend on the structure parameters. Example:
-  ```lean
-  structure Something (i: Nat) where
-  n1: Nat := 1
-  n2: Nat := 1 + i
-
-  def s : Something 10 := {}
-  example : s.n2 = 11 := rfl
-  ```
-
-* Apply `rfl` theorems at the `dsimp` auxiliary method used by `simp`. `dsimp` can be used anywhere in an expression
-  because it preserves definitional equality.
-
-* Refine auto bound implicit feature. It does not consider anymore unbound variables that have the same
-  name of a declaration being defined. Example:
-  ```lean
-  def f : f → Bool := -- Error at second `f`
-    fun _ => true
-
-  inductive Foo : List Foo → Type -- Error at second `Foo`
-    | x : Foo []
-  ```
-  Before this refinement, the declarations above would be accepted and the
-  second `f` and `Foo` would be treated as auto implicit variables. That is,
-  `f : {f : Sort u} → f → Bool`, and
-  `Foo : {Foo : Type u} → List Foo → Type`.
-
-
-* Fix syntax highlighting for recursive declarations. Example
-  ```lean
-  inductive List (α : Type u) where
-    | nil : List α  -- `List` is not highlighted as a variable anymore
-    | cons (head : α) (tail : List α) : List α
-
-  def List.map (f : α → β) : List α → List β
-    | []    => []
-    | a::as => f a :: map f as -- `map` is not highlighted as a variable anymore
-  ```
-* Add `autoUnfold` option to `Lean.Meta.Simp.Config`, and the following macros
-  - `simp!` for `simp (config := { autoUnfold := true })`
-  - `simp_arith!` for `simp (config := { autoUnfold := true, arith := true })`
-  - `simp_all!` for `simp_all (config := { autoUnfold := true })`
-  - `simp_all_arith!` for `simp_all (config := { autoUnfold := true, arith := true })`
-
-  When the `autoUnfold` is set to true, `simp` tries to unfold the following kinds of definition
-  - Recursive definitions defined by structural recursion.
-  - Non-recursive definitions where the body is a `match`-expression. This
-    kind of definition is only unfolded if the `match` can be reduced.
-  Example:
-  ```lean
-  def append (as bs : List α) : List α :=
-    match as with
-    | [] => bs
-    | a :: as => a :: append as bs
-
-  theorem append_nil (as : List α) : append as [] = as := by
-    induction as <;> simp_all!
-
-  theorem append_assoc (as bs cs : List α) : append (append as bs) cs = append as (append bs cs) := by
-    induction as <;> simp_all!
-  ```
-
-* Add `save` tactic for creating checkpoints more conveniently. Example:
-  ```lean
-  example : <some-proposition> := by
-    tac_1
-    tac_2
-    save
-    tac_3
-    ...
-  ```
-  is equivalent to
-  ```lean
-  example : <some-proposition> := by
-    checkpoint
-      tac_1
-      tac_2
-    tac_3
-    ...
-  ```
-
-* Remove support for `{}` annotation from inductive datatype constructors. This annotation was barely used, and we can control the binder information for parameter bindings using the new inductive family indices to parameter promotion. Example: the following declaration using `{}`
-  ```lean
-  inductive LE' (n : Nat) : Nat → Prop where
-    | refl {} : LE' n n -- Want `n` to be explicit
-    | succ  : LE' n m → LE' n (m+1)
-  ```
-  can now be written as
-  ```lean
-  inductive LE' : Nat → Nat → Prop where
-    | refl (n : Nat) : LE' n n
-    | succ : LE' n m → LE' n (m+1)
-  ```
-  In both cases, the inductive family has one parameter and one index.
-  Recall that the actual number of parameters can be retrieved using the command `#print`.
-
-* Remove support for `{}` annotation in the `structure` command.
-
-* Several improvements to LSP server. Examples: "jump to definition" in mutually recursive sections, fixed incorrect hover information in "match"-expression patterns, "jump to definition" for pattern variables, fixed auto-completion in function headers, etc.
-
-* In `macro ... xs:p* ...` and similar macro bindings of combinators, `xs` now has the correct type `Array Syntax`
-
-* Identifiers in syntax patterns now ignore macro scopes during matching.
-
-* Improve binder names for constructor auto implicit parameters. Example, given the inductive datatype
-  ```lean
-  inductive Member : α → List α → Type u
-    | head : Member a (a::as)
-    | tail : Member a bs → Member a (b::bs)
-  ```
-  before:
-  ```lean
-  #check @Member.head
-  -- @Member.head : {x : Type u_1} → {a : x} → {as : List x} → Member a (a :: as)
-  ```
-  now:
-  ```lean
-  #check @Member.head
-  -- @Member.head : {α : Type u_1} → {a : α} → {as : List α} → Member a (a :: as)
-  ```
-
-* Improve error message when constructor parameter universe level is too big.
-
-* Add support for `for h : i in [start:stop] do .. ` where `h : i ∈ [start:stop]`. This feature is useful for proving
-  termination of functions such as:
-  ```lean
-  inductive Expr where
-    | app (f : String) (args : Array Expr)
-
-  def Expr.size (e : Expr) : Nat := Id.run do
-    match e with
-    | app f args =>
-      let mut sz := 1
-      for h : i in [: args.size] do
-        -- h.upper : i < args.size
-        sz := sz + size (args.get ⟨i, h.upper⟩)
-      return sz
-  ```
-
-* Add tactic `case'`. It is similar to `case`, but does not admit the goal on failure.
-  For example, the new tactic is useful when writing tactic scripts where we need to use `case'`
-  at `first | ... | ...`, and we want to take the next alternative when `case'` fails.
-
-* Add tactic macro
-  ```lean
-  macro "stop" s:tacticSeq : tactic => `(repeat sorry)
-  ```
-  See discussion on [Zulip](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Partial.20evaluation.20of.20a.20file).
-
-* When displaying goals, we do not display inaccessible proposition names
-if they do not have forward dependencies. We still display their types.
-For example, the goal
-  ```lean
-  case node.inl.node
-  β : Type u_1
-  b : BinTree β
-  k : Nat
-  v : β
-  left : Tree β
-  key : Nat
-  value : β
-  right : Tree β
-  ihl : BST left → Tree.find? (Tree.insert left k v) k = some v
-  ihr : BST right → Tree.find? (Tree.insert right k v) k = some v
-  h✝ : k < key
-  a✝³ : BST left
-  a✝² : ForallTree (fun k v => k < key) left
-  a✝¹ : BST right
-  a✝ : ForallTree (fun k v => key < k) right
-  ⊢ BST left
-  ```
-  is now displayed as
-  ```lean
-  case node.inl.node
-  β : Type u_1
-  b : BinTree β
-  k : Nat
-  v : β
-  left : Tree β
-  key : Nat
-  value : β
-  right : Tree β
-  ihl : BST left → Tree.find? (Tree.insert left k v) k = some v
-  ihr : BST right → Tree.find? (Tree.insert right k v) k = some v
-   : k < key
-   : BST left
-   : ForallTree (fun k v => k < key) left
-   : BST right
-   : ForallTree (fun k v => key < k) right
-  ⊢ BST left
-  ```
-
-* The hypothesis name is now optional in the `by_cases` tactic.
-
-* [Fix inconsistency between `syntax` and kind names](https://github.com/leanprover/lean4/issues/1090).
-  The node kinds `numLit`, `charLit`, `nameLit`, `strLit`, and `scientificLit` are now called
-  `num`, `char`, `name`, `str`, and `scientific` respectively. Example: we now write
-  ```lean
-  macro_rules | `($n:num) => `("hello")
-  ```
-  instead of
-  ```lean
-  macro_rules | `($n:numLit) => `("hello")
-  ```
-
-* (Experimental) New `checkpoint <tactic-seq>` tactic for big interactive proofs.
-
-* Rename tactic `nativeDecide` => `native_decide`.
-
-* Antiquotations are now accepted in any syntax. The `incQuotDepth` `syntax` parser is therefore obsolete and has been removed.
-
-* Renamed tactic `nativeDecide` => `native_decide`.
-
-* "Cleanup" local context before elaborating a `match` alternative right-hand-side. Examples:
-  ```lean
-  example (x : Nat) : Nat :=
-    match g x with
-    | (a, b) => _ -- Local context does not contain the auxiliary `_discr := g x` anymore
-
-  example (x : Nat × Nat) (h : x.1 > 0) : f x > 0 := by
-    match x with
-    | (a, b) => _ -- Local context does not contain the `h✝ : x.fst > 0` anymore
-  ```
-
-* Improve `let`-pattern (and `have`-pattern) macro expansion. In the following example,
-  ```lean
-  example (x : Nat × Nat) : f x > 0 := by
-    let (a, b) := x
-    done
-  ```
-  The resulting goal is now `... |- f (a, b) > 0` instead of `... |- f x > 0`.
-
-* Add cross-compiled [aarch64 Linux](https://github.com/leanprover/lean4/pull/1066) and [aarch64 macOS](https://github.com/leanprover/lean4/pull/1076) releases.
-
-* [Add tutorial-like examples to our documentation](https://github.com/leanprover/lean4/tree/master/doc/examples), rendered using LeanInk+Alectryon.

releases/v4.0.0.md

@@ -1,120 +0,0 @@
-v4.0.0
----------
-
-* [`Lean.Meta.getConst?` has been renamed](https://github.com/leanprover/lean4/pull/2454).
-  We have renamed `getConst?` to `getUnfoldableConst?` (and `getConstNoEx?` to `getUnfoldableConstNoEx?`).
-  These were not intended to be part of the public API, but downstream projects had been using them
-  (sometimes expecting different behaviour) incorrectly instead of `Lean.getConstInfo`.
-
-* [`dsimp` / `simp` / `simp_all` now fail by default if they make no progress](https://github.com/leanprover/lean4/pull/2336).
-
-  This can be overridden with the `(config := { failIfUnchanged := false })` option.
-  This change was made to ease manual use of `simp` (with complicated goals it can be hard to tell if it was effective)
-  and to allow easier flow control in tactics internally using `simp`.
-  See the [summary discussion](https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/simp.20fails.20if.20no.20progress/near/380153295)
-  on zulip for more details.
-
-* [`simp_all` now preserves order of hypotheses](https://github.com/leanprover/lean4/pull/2334).
-
-  In order to support the `failIfUnchanged` configuration option for `dsimp` / `simp` / `simp_all`
-  the way `simp_all` replaces hypotheses has changed.
-  In particular it is now more likely to preserve the order of hypotheses.
-  See [`simp_all` reorders hypotheses unnecessarily](https://github.com/leanprover/lean4/pull/2334).
-  (Previously all non-dependent propositional hypotheses were reverted and reintroduced.
-  Now only such hypotheses which were changed, or which come after a changed hypothesis,
-  are reverted and reintroduced.
-  This has the effect of preserving the ordering amongst the non-dependent propositional hypotheses,
-  but now any dependent or non-propositional hypotheses retain their position amongst the unchanged
-  non-dependent propositional hypotheses.)
-  This may affect proofs that use `rename_i`, `case ... =>`, or `next ... =>`.
-
-* [New `have this` implementation](https://github.com/leanprover/lean4/pull/2247).
-
-  `this` is now a regular identifier again that is implicitly introduced by anonymous `have :=` for the remainder of the tactic block. It used to be a keyword that was visible in all scopes and led to unexpected behavior when explicitly used as a binder name.
-
-* [Show typeclass and tactic names in profile output](https://github.com/leanprover/lean4/pull/2170).
-
-* [Make `calc` require the sequence of relation/proof-s to have the same indentation](https://github.com/leanprover/lean4/pull/1844),
-  and [add `calc` alternative syntax allowing underscores `_` in the first relation](https://github.com/leanprover/lean4/pull/1844).
-
-  The flexible indentation in `calc` was often used to align the relation symbols:
-  ```lean
-  example (x y : Nat) : (x + y) * (x + y) = x * x + y * x + x * y + y * y :=
-    calc
-        (x + y) * (x + y) = (x + y) * x + (x + y) * y       := by rw [Nat.mul_add]
-                        -- improper indentation
-                        _ = x * x + y * x + (x + y) * y     := by rw [Nat.add_mul]
-                        _ = x * x + y * x + (x * y + y * y) := by rw [Nat.add_mul]
-                        _ = x * x + y * x + x * y + y * y   := by rw [←Nat.add_assoc]
-  ```
-
-  This is no longer legal.  The new syntax puts the first term right after the `calc` and each step has the same indentation:
-  ```lean
-  example (x y : Nat) : (x + y) * (x + y) = x * x + y * x + x * y + y * y :=
-    calc (x + y) * (x + y)
-      _ = (x + y) * x + (x + y) * y       := by rw [Nat.mul_add]
-      _ = x * x + y * x + (x + y) * y     := by rw [Nat.add_mul]
-      _ = x * x + y * x + (x * y + y * y) := by rw [Nat.add_mul]
-      _ = x * x + y * x + x * y + y * y   := by rw [←Nat.add_assoc]
-  ```
-
-
-* Update Lake to latest prerelease.
-
-* [Make go-to-definition on a typeclass projection application go to the instance(s)](https://github.com/leanprover/lean4/pull/1767).
-
-* [Include timings in trace messages when `profiler` is true](https://github.com/leanprover/lean4/pull/1995).
-
-* [Pretty-print signatures in hover and `#check <ident>`](https://github.com/leanprover/lean4/pull/1943).
-
-* [Introduce parser memoization to avoid exponential behavior](https://github.com/leanprover/lean4/pull/1799).
-
-* [feat: allow `doSeq` in `let x <- e | seq`](https://github.com/leanprover/lean4/pull/1809).
-
-* [Add hover/go-to-def/refs for options](https://github.com/leanprover/lean4/pull/1783).
-
-* [Add empty type ascription syntax `(e :)`](https://github.com/leanprover/lean4/pull/1797).
-
-* [Make tokens in `<|>` relevant to syntax match](https://github.com/leanprover/lean4/pull/1744).
-
-* [Add `linter.deprecated` option to silence deprecation warnings](https://github.com/leanprover/lean4/pull/1768).
-
-* [Improve fuzzy-matching heuristics](https://github.com/leanprover/lean4/pull/1710).
-
-* [Implementation-detail hypotheses](https://github.com/leanprover/lean4/pull/1692).
-
-* [Hover information for `cases`/`induction` case names](https://github.com/leanprover/lean4/pull/1660).
-
-* [Prefer longer parse even if unsuccessful](https://github.com/leanprover/lean4/pull/1658).
-
-* [Show declaration module in hover](https://github.com/leanprover/lean4/pull/1638).
-
-* [New `conv` mode structuring tactics](https://github.com/leanprover/lean4/pull/1636).
-
-* `simp` can track information and can print an equivalent `simp only`. [PR #1626](https://github.com/leanprover/lean4/pull/1626).
-
-* Enforce uniform indentation in tactic blocks / do blocks. See issue [#1606](https://github.com/leanprover/lean4/issues/1606).
-
-* Moved `AssocList`, `HashMap`, `HashSet`, `RBMap`, `RBSet`, `PersistentArray`, `PersistentHashMap`, `PersistentHashSet` to the Lean package. The [standard library](https://github.com/leanprover/std4) contains versions that will evolve independently to simplify bootstrapping process.
-
-* Standard library moved to the [std4 GitHub repository](https://github.com/leanprover/std4).
-
-* `InteractiveGoals` now has information that a client infoview can use to show what parts of the goal have changed after applying a tactic. [PR #1610](https://github.com/leanprover/lean4/pull/1610).
-
-* Add `[inheritDoc]` attribute. [PR #1480](https://github.com/leanprover/lean4/pull/1480).
-
-* Expose that `panic = default`. [PR #1614](https://github.com/leanprover/lean4/pull/1614).
-
-* New [code generator](https://github.com/leanprover/lean4/tree/master/src/Lean/Compiler/LCNF) project has started.
-
-* Remove description argument from `register_simp_attr`. [PR #1566](https://github.com/leanprover/lean4/pull/1566).
-
-* [Additional concurrency primitives](https://github.com/leanprover/lean4/pull/1555).
-
-* [Collapsible traces with messages](https://github.com/leanprover/lean4/pull/1448).
-
-* [Hygienic resolution of namespaces](https://github.com/leanprover/lean4/pull/1442).
-
-* [New `Float` functions](https://github.com/leanprover/lean4/pull/1460).
-
-* Many new doc strings have been added to declarations at `Init`.

releases/v4.1.0.md

@@ -1,21 +0,0 @@
-v4.1.0
----------
-
-* The error positioning on missing tokens has been [improved](https://github.com/leanprover/lean4/pull/2393). In particular, this should make it easier to spot errors in incomplete tactic proofs.
-
-* After elaborating a configuration file, Lake will now cache the configuration to a `lakefile.olean`. Subsequent runs of Lake will import this OLean instead of elaborating the configuration file. This provides a significant performance improvement (benchmarks indicate that using the OLean cuts Lake's startup time in half), but there are some important details to keep in mind:
-  + Lake will regenerate this OLean after each modification to the `lakefile.lean` or `lean-toolchain`. You can also force a reconfigure by passing the new `--reconfigure` / `-R` option to `lake`.
-  + Lake configuration options (i.e., `-K`) will be fixed at the moment of elaboration. Setting these options when `lake` is using the cached configuration will have no effect. To change options, run `lake` with `-R` / `--reconfigure`.
-  + **The `lakefile.olean` is a local configuration and should not be committed to Git. Therefore, existing Lake packages need to add it to their `.gitignore`.**
-
-* The signature of `Lake.buildO` has changed, `args` has been split into `weakArgs` and `traceArgs`. `traceArgs` are included in the input trace and `weakArgs` are not. See Lake's [FFI example](src/lake/examples/ffi/lib/lakefile.lean) for a demonstration of how to adapt to this change.
-
-* The signatures of `Lean.importModules`, `Lean.Elab.headerToImports`, and `Lean.Elab.parseImports`
-  have [changed](https://github.com/leanprover/lean4/pull/2480) from taking `List Import` to `Array Import`.
-
-* There is now [an `occs` field](https://github.com/leanprover/lean4/pull/2470)
-  in the configuration object for the `rewrite` tactic,
-  allowing control of which occurrences of a pattern should be rewritten.
-  This was previously a separate argument for `Lean.MVarId.rewrite`,
-  and this has been removed in favour of an additional field of `Rewrite.Config`.
-  It was not previously accessible from user tactics.

releases/v4.10.0.md

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

releases/v4.11.0.md

@@ -1,337 +0,0 @@
-v4.11.0
-----------
-
-### Language features, tactics, and metaprograms
-
-* The variable inclusion mechanism has been changed. Like before, when a definition mentions a variable, Lean will add it as an argument of the definition, but now in theorem bodies, variables are not included based on usage in order to ensure that changes to the proof cannot change the statement of the overall theorem. Instead, variables are only available to the proof if they have been mentioned in the theorem header or in an **`include` command** or are instance implicit and depend only on such variables. The **`omit` command** can be used to omit included variables.
-
-  See breaking changes below.
-
-  PRs: [#4883](https://github.com/leanprover/lean4/pull/4883), [#4814](https://github.com/leanprover/lean4/pull/4814), [#5000](https://github.com/leanprover/lean4/pull/5000), [#5036](https://github.com/leanprover/lean4/pull/5036), [#5138](https://github.com/leanprover/lean4/pull/5138), [0edf1b](https://github.com/leanprover/lean4/commit/0edf1bac392f7e2fe0266b28b51c498306363a84).
-
-* **Recursive definitions**
-  * Structural recursion can now be explicitly requested using
-    ```
-    termination_by structural x
-    ```
-    in analogy to the existing `termination_by x` syntax that causes well-founded recursion to be used.
-    [#4542](https://github.com/leanprover/lean4/pull/4542)
-  * [#4672](https://github.com/leanprover/lean4/pull/4672) fixes a bug that could lead to ill-typed terms.
-  * The `termination_by?` syntax no longer forces the use of well-founded recursion, and when structural
-    recursion is inferred, it will print the result using the `termination_by structural` syntax.
-  * **Mutual structural recursion** is now supported. This feature supports both mutual recursion over a non-mutual
-    data type, as well as recursion over mutual or nested data types:
-
-    ```lean
-    mutual
-    def Even : Nat → Prop
-      | 0 => True
-      | n+1 => Odd n
-
-    def Odd : Nat → Prop
-      | 0 => False
-      | n+1 => Even n
-    end
-
-    mutual
-    inductive A
-    | other : B → A
-    | empty
-    inductive B
-    | other : A → B
-    | empty
-    end
-
-    mutual
-    def A.size : A → Nat
-    | .other b => b.size + 1
-    | .empty => 0
-
-    def B.size : B → Nat
-    | .other a => a.size + 1
-    | .empty => 0
-    end
-
-    inductive Tree where | node : List Tree → Tree
-
-    mutual
-    def Tree.size : Tree → Nat
-    | node ts => Tree.list_size ts
-
-    def Tree.list_size : List Tree → Nat
-    | [] => 0
-    | t::ts => Tree.size t + Tree.list_size ts
-    end
-    ```
-
-    Functional induction principles are generated for these functions as well (`A.size.induct`, `A.size.mutual_induct`).
-
-    Nested structural recursion is still not supported.
-
-    PRs: [#4639](https://github.com/leanprover/lean4/pull/4639), [#4715](https://github.com/leanprover/lean4/pull/4715), [#4642](https://github.com/leanprover/lean4/pull/4642), [#4656](https://github.com/leanprover/lean4/pull/4656), [#4684](https://github.com/leanprover/lean4/pull/4684), [#4715](https://github.com/leanprover/lean4/pull/4715), [#4728](https://github.com/leanprover/lean4/pull/4728), [#4575](https://github.com/leanprover/lean4/pull/4575), [#4731](https://github.com/leanprover/lean4/pull/4731), [#4658](https://github.com/leanprover/lean4/pull/4658), [#4734](https://github.com/leanprover/lean4/pull/4734), [#4738](https://github.com/leanprover/lean4/pull/4738), [#4718](https://github.com/leanprover/lean4/pull/4718), [#4733](https://github.com/leanprover/lean4/pull/4733), [#4787](https://github.com/leanprover/lean4/pull/4787), [#4788](https://github.com/leanprover/lean4/pull/4788), [#4789](https://github.com/leanprover/lean4/pull/4789), [#4807](https://github.com/leanprover/lean4/pull/4807), [#4772](https://github.com/leanprover/lean4/pull/4772)
-  * [#4809](https://github.com/leanprover/lean4/pull/4809) makes unnecessary `termination_by` clauses cause warnings, not errors.
-  * [#4831](https://github.com/leanprover/lean4/pull/4831) improves handling of nested structural recursion through non-recursive types.
-  * [#4839](https://github.com/leanprover/lean4/pull/4839) improves support for structural recursive over inductive predicates when there are reflexive arguments.
-* `simp` tactic
-  * [#4784](https://github.com/leanprover/lean4/pull/4784) sets configuration `Simp.Config.implicitDefEqProofs` to `true` by default.
-
-* `omega` tactic
-  * [#4612](https://github.com/leanprover/lean4/pull/4612) normalizes the order that constraints appear in error messages.
-  * [#4695](https://github.com/leanprover/lean4/pull/4695) prevents pushing casts into multiplications unless it produces a non-trivial linear combination.
-  * [#4989](https://github.com/leanprover/lean4/pull/4989) fixes a regression.
-
-* `decide` tactic
-  * [#4711](https://github.com/leanprover/lean4/pull/4711) switches from using default transparency to *at least* default transparency when reducing the `Decidable` instance.
-  * [#4674](https://github.com/leanprover/lean4/pull/4674) adds detailed feedback on `decide` tactic failure. It tells you which `Decidable` instances it unfolded, if it get stuck on `Eq.rec` it gives a hint about avoiding tactics when defining `Decidable` instances, and if it gets stuck on `Classical.choice` it gives hints about classical instances being in scope. During this process, it processes `Decidable.rec`s and matches to pin blame on a non-reducing instance.
-
-* `@[ext]` attribute
-  * [#4543](https://github.com/leanprover/lean4/pull/4543) and [#4762](https://github.com/leanprover/lean4/pull/4762) make `@[ext]` realize `ext_iff` theorems from user `ext` theorems. Fixes the attribute so that `@[local ext]` and `@[scoped ext]` are usable. The `@[ext (iff := false)]` option can be used to turn off `ext_iff` realization.
-  * [#4694](https://github.com/leanprover/lean4/pull/4694) makes "go to definition" work for the generated lemmas. Also adjusts the core library to make use of `ext_iff` generation.
-  * [#4710](https://github.com/leanprover/lean4/pull/4710) makes `ext_iff` theorem preserve inst implicit binder types, rather than making all binder types implicit.
-
-* `#eval` command
-  * [#4810](https://github.com/leanprover/lean4/pull/4810) introduces a safer `#eval` command that prevents evaluation of terms that contain `sorry`. The motivation is that failing tactics, in conjunction with operations such as array accesses, can lead to the Lean process crashing. Users can use the new `#eval!` command to use the previous unsafe behavior. ([#4829](https://github.com/leanprover/lean4/pull/4829) adjusts a test.)
-
-* [#4447](https://github.com/leanprover/lean4/pull/4447) adds `#discr_tree_key` and `#discr_tree_simp_key` commands, for helping debug discrimination tree failures. The `#discr_tree_key t` command prints the discrimination tree keys for a term `t` (or, if it is a single identifier, the type of that constant). It uses the default configuration for generating keys. The `#discr_tree_simp_key` command is similar to `#discr_tree_key`, but treats the underlying type as one of a simp lemma, that is it transforms it into an equality and produces the key of the left-hand side.
-
-  For example,
-  ```
-  #discr_tree_key (∀ {a n : Nat}, bar a (OfNat.ofNat n))
-  -- bar _ (@OfNat.ofNat Nat _ _)
-
-  #discr_tree_simp_key Nat.add_assoc
-  -- @HAdd.hAdd Nat Nat Nat _ (@HAdd.hAdd Nat Nat Nat _ _ _) _
-  ```
-
-* [#4741](https://github.com/leanprover/lean4/pull/4741) changes option parsing to allow user-defined options from the command line. Initial options are now re-parsed and validated after importing. Command line option assignments prefixed with `weak.` are silently discarded if the option name without the prefix does not exist.
-
-* **Deriving handlers**
-  * [7253ef](https://github.com/leanprover/lean4/commit/7253ef8751f76bcbe0e6f46dcfa8069699a2bac7) and [a04f3c](https://github.com/leanprover/lean4/commit/a04f3cab5a9fe2870825af6544ca13c5bb766706) improve the construction of the `BEq` deriving handler.
-  * [86af04](https://github.com/leanprover/lean4/commit/86af04cc08c0dbbe0e735ea13d16edea3465f850) makes `BEq` deriving handler work when there are dependently typed fields.
-  * [#4826](https://github.com/leanprover/lean4/pull/4826) refactors the `DecidableEq` deriving handle to use `termination_by structural`.
-
-* **Metaprogramming**
-  * [#4593](https://github.com/leanprover/lean4/pull/4593) adds `unresolveNameGlobalAvoidingLocals`.
-  * [#4618](https://github.com/leanprover/lean4/pull/4618) deletes deprecated functions from 2022.
-  * [#4642](https://github.com/leanprover/lean4/pull/4642) adds `Meta.lambdaBoundedTelescope`.
-  * [#4731](https://github.com/leanprover/lean4/pull/4731) adds `Meta.withErasedFVars`, to enter a context with some fvars erased from the local context.
-  * [#4777](https://github.com/leanprover/lean4/pull/4777) adds assignment validation at `closeMainGoal`, preventing users from circumventing the occurs check for tactics such as `exact`.
-  * [#4807](https://github.com/leanprover/lean4/pull/4807) introduces `Lean.Meta.PProdN` module for packing and projecting nested `PProd`s.
-  * [#5170](https://github.com/leanprover/lean4/pull/5170) fixes `Syntax.unsetTrailing`. A consequence of this is that "go to definition" now works on the last module name in an `import` block (issue [#4958](https://github.com/leanprover/lean4/issues/4958)).
-
-
-### Language server, widgets, and IDE extensions
-
-* [#4727](https://github.com/leanprover/lean4/pull/4727) makes it so that responses to info view requests come as soon as the relevant tactic has finished execution.
-* [#4580](https://github.com/leanprover/lean4/pull/4580) makes it so that whitespace changes do not invalidate imports, and so starting to type the first declaration after imports should no longer cause them to reload.
-* [#4780](https://github.com/leanprover/lean4/pull/4780) fixes an issue where hovering over unimported builtin names could result in a panic.
-
-### Pretty printing
-
-* [#4558](https://github.com/leanprover/lean4/pull/4558) fixes the `pp.instantiateMVars` setting and changes the default value to `true`.
-* [#4631](https://github.com/leanprover/lean4/pull/4631) makes sure syntax nodes always run their formatters. Fixes an issue where if `ppSpace` appears in a `macro` or `elab` command then it does not format with a space.
-* [#4665](https://github.com/leanprover/lean4/pull/4665) fixes a bug where pretty printed signatures (for example in `#check`) were overly hoverable due to `pp.tagAppFns` being set.
-* [#4724](https://github.com/leanprover/lean4/pull/4724) makes `match` pretty printer be sensitive to `pp.explicit`, which makes hovering over a `match` in the Infoview show the underlying term.
-* [#4764](https://github.com/leanprover/lean4/pull/4764) documents why anonymous constructor notation isn't pretty printed with flattening.
-* [#4786](https://github.com/leanprover/lean4/pull/4786) adjusts the parenthesizer so that only the parentheses are hoverable, implemented by having the parentheses "steal" the term info from the parenthesized expression.
-* [#4854](https://github.com/leanprover/lean4/pull/4854) allows arbitrarily long sequences of optional arguments to be omitted from the end of applications, versus the previous conservative behavior of omitting up to one optional argument.
-
-### Library
-
-* `Nat`
-  * [#4597](https://github.com/leanprover/lean4/pull/4597) adds bitwise lemmas `Nat.and_le_(left|right)`.
-  * [#4874](https://github.com/leanprover/lean4/pull/4874) adds simprocs for simplifying bit expressions.
-* `Int`
-  * [#4903](https://github.com/leanprover/lean4/pull/4903) fixes performance of `HPow Int Nat Int` synthesis by rewriting it as a `NatPow Int` instance.
-* `UInt*` and `Fin`
-  * [#4605](https://github.com/leanprover/lean4/pull/4605) adds lemmas.
-  * [#4629](https://github.com/leanprover/lean4/pull/4629) adds `*.and_toNat`.
-* `Option`
-  * [#4599](https://github.com/leanprover/lean4/pull/4599) adds `get` lemmas.
-  * [#4600](https://github.com/leanprover/lean4/pull/4600) adds `Option.or`, a version of `Option.orElse` that is strict in the second argument.
-* `GetElem`
-  * [#4603](https://github.com/leanprover/lean4/pull/4603) adds `getElem_congr` to help with rewriting indices.
-* `List` and `Array`
-  * Upstreamed from Batteries: [#4586](https://github.com/leanprover/lean4/pull/4586) upstreams `List.attach` and `Array.attach`, [#4697](https://github.com/leanprover/lean4/pull/4697) upstreams `List.Subset` and `List.Sublist` and API, [#4706](https://github.com/leanprover/lean4/pull/4706) upstreams basic material on `List.Pairwise` and `List.Nodup`, [#4720](https://github.com/leanprover/lean4/pull/4720) upstreams more `List.erase` API, [#4836](https://github.com/leanprover/lean4/pull/4836) and [#4837](https://github.com/leanprover/lean4/pull/4837) upstream `List.IsPrefix`/`List.IsSuffix`/`List.IsInfix` and add `Decidable` instances, [#4855](https://github.com/leanprover/lean4/pull/4855) upstreams `List.tail`, `List.findIdx`, `List.indexOf`, `List.countP`, `List.count`, and `List.range'`, [#4856](https://github.com/leanprover/lean4/pull/4856) upstreams more List lemmas, [#4866](https://github.com/leanprover/lean4/pull/4866) upstreams `List.pairwise_iff_getElem`, [#4865](https://github.com/leanprover/lean4/pull/4865) upstreams `List.eraseIdx` lemmas.
-  * [#4687](https://github.com/leanprover/lean4/pull/4687) adjusts `List.replicate` simp lemmas and simprocs.
-  * [#4704](https://github.com/leanprover/lean4/pull/4704) adds characterizations of `List.Sublist`.
-  * [#4707](https://github.com/leanprover/lean4/pull/4707) adds simp normal form tests for `List.Pairwise` and `List.Nodup`.
-  * [#4708](https://github.com/leanprover/lean4/pull/4708) and [#4815](https://github.com/leanprover/lean4/pull/4815) reorganize lemmas on list getters.
-  * [#4765](https://github.com/leanprover/lean4/pull/4765) adds simprocs for literal array accesses such as `#[1,2,3,4,5][2]`.
-  * [#4790](https://github.com/leanprover/lean4/pull/4790) removes typeclass assumptions for `List.Nodup.eraseP`.
-  * [#4801](https://github.com/leanprover/lean4/pull/4801) adds efficient `usize` functions for array types.
-  * [#4820](https://github.com/leanprover/lean4/pull/4820) changes `List.filterMapM` to run left-to-right.
-  * [#4835](https://github.com/leanprover/lean4/pull/4835) fills in and cleans up gaps in List API.
-  * [#4843](https://github.com/leanprover/lean4/pull/4843), [#4868](https://github.com/leanprover/lean4/pull/4868), and [#4877](https://github.com/leanprover/lean4/pull/4877) correct `List.Subset` lemmas.
-  * [#4863](https://github.com/leanprover/lean4/pull/4863) splits `Init.Data.List.Lemmas` into function-specific files.
-  * [#4875](https://github.com/leanprover/lean4/pull/4875) fixes statement of `List.take_takeWhile`.
-  * Lemmas: [#4602](https://github.com/leanprover/lean4/pull/4602), [#4627](https://github.com/leanprover/lean4/pull/4627), [#4678](https://github.com/leanprover/lean4/pull/4678) for `List.head` and `list.getLast`, [#4723](https://github.com/leanprover/lean4/pull/4723) for `List.erase`, [#4742](https://github.com/leanprover/lean4/pull/4742)
-* `ByteArray`
-  * [#4582](https://github.com/leanprover/lean4/pull/4582) eliminates `partial` from `ByteArray.toList` and `ByteArray.findIdx?`.
-* `BitVec`
-  * [#4568](https://github.com/leanprover/lean4/pull/4568) adds recurrence theorems for bitblasting multiplication.
-  * [#4571](https://github.com/leanprover/lean4/pull/4571) adds `shiftLeftRec` lemmas.
-  * [#4872](https://github.com/leanprover/lean4/pull/4872) adds `ushiftRightRec` and lemmas.
-  * [#4873](https://github.com/leanprover/lean4/pull/4873) adds `getLsb_replicate`.
-* `Std.HashMap` added:
-  * [#4583](https://github.com/leanprover/lean4/pull/4583) **adds `Std.HashMap`** as a verified replacement for `Lean.HashMap`. See the PR for naming differences, but [#4725](https://github.com/leanprover/lean4/pull/4725) renames `HashMap.remove` to `HashMap.erase`.
-  * [#4682](https://github.com/leanprover/lean4/pull/4682) adds `Inhabited` instances.
-  * [#4732](https://github.com/leanprover/lean4/pull/4732) improves `BEq` argument order in hash map lemmas.
-  * [#4759](https://github.com/leanprover/lean4/pull/4759) makes lemmas resolve instances via unification.
-  * [#4771](https://github.com/leanprover/lean4/pull/4771) documents that hash maps should be used linearly to avoid expensive copies.
-  * [#4791](https://github.com/leanprover/lean4/pull/4791) removes `bif` from hash map lemmas, which is inconvenient to work with in practice.
-  * [#4803](https://github.com/leanprover/lean4/pull/4803) adds more lemmas.
-* `SMap`
-  * [#4690](https://github.com/leanprover/lean4/pull/4690) upstreams `SMap.foldM`.
-* `BEq`
-  * [#4607](https://github.com/leanprover/lean4/pull/4607) adds `PartialEquivBEq`, `ReflBEq`, `EquivBEq`, and `LawfulHashable` classes.
-* `IO`
-  * [#4660](https://github.com/leanprover/lean4/pull/4660) adds `IO.Process.Child.tryWait`.
-* [#4747](https://github.com/leanprover/lean4/pull/4747), [#4730](https://github.com/leanprover/lean4/pull/4730), and [#4756](https://github.com/leanprover/lean4/pull/4756) add `×'` syntax for `PProd`. Adds a delaborator for `PProd` and `MProd` values to pretty print as flattened angle bracket tuples.
-* **Other fixes or improvements**
-  * [#4604](https://github.com/leanprover/lean4/pull/4604) adds lemmas for cond.
-  * [#4619](https://github.com/leanprover/lean4/pull/4619) changes some definitions into theorems.
-  * [#4616](https://github.com/leanprover/lean4/pull/4616) fixes some names with duplicated namespaces.
-  * [#4620](https://github.com/leanprover/lean4/pull/4620) fixes simp lemmas flagged by the simpNF linter.
-  * [#4666](https://github.com/leanprover/lean4/pull/4666) makes the `Antisymm` class be a `Prop`.
-  * [#4621](https://github.com/leanprover/lean4/pull/4621) cleans up unused arguments flagged by linter.
-  * [#4680](https://github.com/leanprover/lean4/pull/4680) adds imports for orphaned `Init` modules.
-  * [#4679](https://github.com/leanprover/lean4/pull/4679) adds imports for orphaned `Std.Data` modules.
-  * [#4688](https://github.com/leanprover/lean4/pull/4688) adds forward and backward directions of `not_exists`.
-  * [#4689](https://github.com/leanprover/lean4/pull/4689) upstreams `eq_iff_true_of_subsingleton`.
-  * [#4709](https://github.com/leanprover/lean4/pull/4709) fixes precedence handling for `Repr` instances for negative numbers for `Int` and `Float`.
-  * [#4760](https://github.com/leanprover/lean4/pull/4760) renames `TC` ("transitive closure") to `Relation.TransGen`.
-  * [#4842](https://github.com/leanprover/lean4/pull/4842) fixes `List` deprecations.
-  * [#4852](https://github.com/leanprover/lean4/pull/4852) upstreams some Mathlib attributes applied to lemmas.
-  * [93ac63](https://github.com/leanprover/lean4/commit/93ac635a89daa5a8e8ef33ec96b0bcbb5d7ec1ea) improves proof.
-  * [#4862](https://github.com/leanprover/lean4/pull/4862) and [#4878](https://github.com/leanprover/lean4/pull/4878) generalize the universe for `PSigma.exists` and rename it to `Exists.of_psigma_prop`.
-  * Typos: [#4737](https://github.com/leanprover/lean4/pull/4737), [7d2155](https://github.com/leanprover/lean4/commit/7d2155943c67c743409420b4546d47fadf73af1c)
-  * Docs: [#4782](https://github.com/leanprover/lean4/pull/4782), [#4869](https://github.com/leanprover/lean4/pull/4869), [#4648](https://github.com/leanprover/lean4/pull/4648)
-
-### Lean internals
-* **Elaboration**
-  * [#4596](https://github.com/leanprover/lean4/pull/4596) enforces `isDefEqStuckEx` at `unstuckMVar` procedure, causing isDefEq to throw a stuck defeq exception if the metavariable was created in a previous level. This results in some better error messages, and it helps `rw` succeed in synthesizing instances (see issue [#2736](https://github.com/leanprover/lean4/issues/2736)).
-  * [#4713](https://github.com/leanprover/lean4/pull/4713) fixes deprecation warnings when there are overloaded symbols.
-  * `elab_as_elim` algorithm:
-    * [#4722](https://github.com/leanprover/lean4/pull/4722) adds check that inferred motive is type-correct.
-    * [#4800](https://github.com/leanprover/lean4/pull/4800) elaborates arguments for parameters appearing in the types of targets.
-    * [#4817](https://github.com/leanprover/lean4/pull/4817) makes the algorithm correctly handle eliminators with explicit motive arguments.
-  * [#4792](https://github.com/leanprover/lean4/pull/4792) adds term elaborator for `Lean.Parser.Term.namedPattern` (e.g. `n@(n' + 1)`) to report errors when used in non-pattern-matching contexts.
-  * [#4818](https://github.com/leanprover/lean4/pull/4818) makes anonymous dot notation work when the expected type is a pi-type-valued type synonym.
-* **Typeclass inference**
-  * [#4646](https://github.com/leanprover/lean4/pull/4646) improves `synthAppInstances`, the function responsible for synthesizing instances for the `rw` and `apply` tactics. Adds a synthesis loop to handle functions whose instances need to be synthesized in a complex order.
-* **Inductive types**
-  * [#4684](https://github.com/leanprover/lean4/pull/4684) (backported as [98ee78](https://github.com/leanprover/lean4/commit/98ee789990f91ff5935627787b537911ef8773c4)) refactors `InductiveVal` to have a `numNested : Nat` field instead of `isNested : Bool`. This modifies the kernel.
-* **Definitions**
-  * [#4776](https://github.com/leanprover/lean4/pull/4776) improves performance of `Replacement.apply`.
-  * [#4712](https://github.com/leanprover/lean4/pull/4712) fixes `.eq_def` theorem generation with messy universes.
-  * [#4841](https://github.com/leanprover/lean4/pull/4841) improves success of finding `T.below x` hypothesis when transforming `match` statements for `IndPredBelow`.
-* **Diagnostics and profiling**
-  * [#4611](https://github.com/leanprover/lean4/pull/4611) makes kernel diagnostics appear when `diagnostics` is enabled even if it is the only section.
-  * [#4753](https://github.com/leanprover/lean4/pull/4753) adds missing `profileitM` functions.
-  * [#4754](https://github.com/leanprover/lean4/pull/4754) adds `Lean.Expr.numObjs` to compute the number of allocated sub-expressions in a given expression, primarily for diagnosing performance issues.
-  * [#4769](https://github.com/leanprover/lean4/pull/4769) adds missing `withTraceNode`s to improve `trace.profiler` output.
-  * [#4781](https://github.com/leanprover/lean4/pull/4781) and [#4882](https://github.com/leanprover/lean4/pull/4882) make the "use `set_option diagnostics true`" message be conditional on current setting of `diagnostics`.
-* **Performance**
-  * [#4767](https://github.com/leanprover/lean4/pull/4767), [#4775](https://github.com/leanprover/lean4/pull/4775), and [#4887](https://github.com/leanprover/lean4/pull/4887) add `ShareCommon.shareCommon'` for sharing common terms. In an example with 16 million subterms, it is 20 times faster than the old `shareCommon` procedure.
-  * [#4779](https://github.com/leanprover/lean4/pull/4779) ensures `Expr.replaceExpr` preserves DAG structure in `Expr`s.
-  * [#4783](https://github.com/leanprover/lean4/pull/4783) documents performance issue in `Expr.replaceExpr`.
-  * [#4794](https://github.com/leanprover/lean4/pull/4794), [#4797](https://github.com/leanprover/lean4/pull/4797), [#4798](https://github.com/leanprover/lean4/pull/4798) make `for_each` use precise cache.
-  * [#4795](https://github.com/leanprover/lean4/pull/4795) makes `Expr.find?` and `Expr.findExt?` use the kernel implementations.
-  * [#4799](https://github.com/leanprover/lean4/pull/4799) makes `Expr.replace` use the kernel implementation.
-  * [#4871](https://github.com/leanprover/lean4/pull/4871) makes `Expr.foldConsts` use a precise cache.
-  * [#4890](https://github.com/leanprover/lean4/pull/4890) makes `expr_eq_fn` use a precise cache.
-* **Utilities**
-  * [#4453](https://github.com/leanprover/lean4/pull/4453) upstreams `ToExpr FilePath` and `compile_time_search_path%`.
-* **Module system**
-  * [#4652](https://github.com/leanprover/lean4/pull/4652) fixes handling of `const2ModIdx` in `finalizeImport`, making it prefer the original module for a declaration when a declaration is re-declared.
-* **Kernel**
-  * [#4637](https://github.com/leanprover/lean4/pull/4637) adds a check to prevent large `Nat` exponentiations from evaluating. Elaborator reduction is controlled by the option `exponentiation.threshold`.
-  * [#4683](https://github.com/leanprover/lean4/pull/4683) updates comments in `kernel/declaration.h`, making sure they reflect the current Lean 4 types.
-  * [#4796](https://github.com/leanprover/lean4/pull/4796) improves performance by using `replace` with a precise cache.
-  * [#4700](https://github.com/leanprover/lean4/pull/4700) improves performance by fixing the implementation of move constructors and move assignment operators. Expression copying was taking 10% of total runtime in some workloads. See issue [#4698](https://github.com/leanprover/lean4/issues/4698).
-  * [#4702](https://github.com/leanprover/lean4/pull/4702) improves performance in `replace_rec_fn::apply` by avoiding expression copies. These copies represented about 13% of time spent in `save_result` in some workloads. See the same issue.
-* **Other fixes or improvements**
-  * [#4590](https://github.com/leanprover/lean4/pull/4590) fixes a typo in some constants and `trace.profiler.useHeartbeats`.
-  * [#4617](https://github.com/leanprover/lean4/pull/4617) add 'since' dates to `deprecated` attributes.
-  * [#4625](https://github.com/leanprover/lean4/pull/4625) improves the robustness of the constructor-as-variable test.
-  * [#4740](https://github.com/leanprover/lean4/pull/4740) extends test with nice example reported on Zulip.
-  * [#4766](https://github.com/leanprover/lean4/pull/4766) moves `Syntax.hasIdent` to be available earlier and shakes dependencies.
-  * [#4881](https://github.com/leanprover/lean4/pull/4881) splits out `Lean.Language.Lean.Types`.
-  * [#4893](https://github.com/leanprover/lean4/pull/4893) adds `LEAN_EXPORT` for `sharecommon` functions.
-  * Typos: [#4635](https://github.com/leanprover/lean4/pull/4635), [#4719](https://github.com/leanprover/lean4/pull/4719), [af40e6](https://github.com/leanprover/lean4/commit/af40e618111581c82fc44de922368a02208b499f)
-  * Docs: [#4748](https://github.com/leanprover/lean4/pull/4748) (`Command.Scope`)
-
-### Compiler, runtime, and FFI
-* [#4661](https://github.com/leanprover/lean4/pull/4661) moves `Std` from `libleanshared` to much smaller `libInit_shared`. This fixes the Windows build.
-* [#4668](https://github.com/leanprover/lean4/pull/4668) fixes initialization, explicitly initializing `Std` in `lean_initialize`.
-* [#4746](https://github.com/leanprover/lean4/pull/4746) adjusts `shouldExport` to exclude more symbols to get below Windows symbol limit. Some exceptions are added by [#4884](https://github.com/leanprover/lean4/pull/4884) and [#4956](https://github.com/leanprover/lean4/pull/4956) to support Verso.
-* [#4778](https://github.com/leanprover/lean4/pull/4778) adds `lean_is_exclusive_obj` (`Lean.isExclusiveUnsafe`) and `lean_set_external_data`.
-* [#4515](https://github.com/leanprover/lean4/pull/4515) fixes calling programs with spaces on Windows.
-
-### Lake
-
-* [#4735](https://github.com/leanprover/lean4/pull/4735) improves a number of elements related to Git checkouts, cloud releases,
-and related error handling.
-
-  * On error, Lake now prints all top-level logs. Top-level logs are those produced by Lake outside of the job monitor (e.g., when cloning dependencies).
-  * When fetching a remote for a dependency, Lake now forcibly fetches tags. This prevents potential errors caused by a repository recreating tags already fetched.
-  * Git error handling is now more informative.
-  * The builtin package facets `release`, `optRelease`, `extraDep` are now captions in the same manner as other facets.
-  * `afterReleaseSync` and `afterReleaseAsync` now fetch `optRelease` rather than `release`.
-  * Added support for optional jobs, whose failure does not cause the whole build to failure. Now `optRelease` is such a job.
-
-* [#4608](https://github.com/leanprover/lean4/pull/4608) adds draft CI workflow when creating new projects.
-* [#4847](https://github.com/leanprover/lean4/pull/4847) adds CLI options to control log levels. The `--log-level=<lv>` controls the minimum log level Lake should output. For instance, `--log-level=error` will only print errors (not warnings or info). Also, adds an analogous `--fail-level` option to control the minimum log level for build failures. The existing `--iofail` and `--wfail` options are respectively equivalent to `--fail-level=info` and `--fail-level=warning`.
-
-* Docs: [#4853](https://github.com/leanprover/lean4/pull/4853)
-
-
-### DevOps/CI
-
-* **Workflows**
-  * [#4531](https://github.com/leanprover/lean4/pull/4531) makes release trigger an update of `release.lean-lang.org`.
-  * [#4598](https://github.com/leanprover/lean4/pull/4598) adjusts `pr-release` to the new `lakefile.lean` syntax.
-  * [#4632](https://github.com/leanprover/lean4/pull/4632) makes `pr-release` use the correct tag name.
-  * [#4638](https://github.com/leanprover/lean4/pull/4638) adds ability to manually trigger nightly release.
-  * [#4640](https://github.com/leanprover/lean4/pull/4640) adds more debugging output for `restart-on-label` CI.
-  * [#4663](https://github.com/leanprover/lean4/pull/4663) bumps up waiting for 10s to 30s for `restart-on-label`.
-  * [#4664](https://github.com/leanprover/lean4/pull/4664) bumps versions for `actions/checkout` and `actions/upload-artifacts`.
-  * [582d6e](https://github.com/leanprover/lean4/commit/582d6e7f7168e0dc0819099edaace27d913b893e) bumps version for `actions/download-artifact`.
-  * [6d9718](https://github.com/leanprover/lean4/commit/6d971827e253a4dc08cda3cf6524d7f37819eb47) adds back dropped `check-stage3`.
-  * [0768ad](https://github.com/leanprover/lean4/commit/0768ad4eb9020af0777587a25a692d181e857c14) adds Jira sync (for FRO).
-  * [#4830](https://github.com/leanprover/lean4/pull/4830) adds support to report CI errors on FRO Zulip.
-  * [#4838](https://github.com/leanprover/lean4/pull/4838) adds trigger for `nightly_bump_toolchain` on mathlib4 upon nightly release.
-  * [abf420](https://github.com/leanprover/lean4/commit/abf4206e9c0fcadf17b6f7933434fd1580175015) fixes msys2.
-  * [#4895](https://github.com/leanprover/lean4/pull/4895) deprecates Nix-based builds and removes interactive components. Users who prefer the flake build should maintain it externally.
-* [#4693](https://github.com/leanprover/lean4/pull/4693), [#4458](https://github.com/leanprover/lean4/pull/4458), and [#4876](https://github.com/leanprover/lean4/pull/4876) update the **release checklist**.
-* [#4669](https://github.com/leanprover/lean4/pull/4669) fixes the "max dynamic symbols" metric per static library.
-* [#4691](https://github.com/leanprover/lean4/pull/4691) improves compatibility of `tests/list_simp` for retesting simp normal forms with Mathlib.
-* [#4806](https://github.com/leanprover/lean4/pull/4806) updates the quickstart guide.
-* [c02aa9](https://github.com/leanprover/lean4/commit/c02aa98c6a08c3a9b05f68039c071085a4ef70d7) documents the **triage team** in the contribution guide.
-
-
-### Breaking changes
-
-* For `@[ext]`-generated `ext` and `ext_iff` lemmas, the `x` and `y` term arguments are now implicit. Furthermore these two lemmas are now protected ([#4543](https://github.com/leanprover/lean4/pull/4543)).
-
-* Now `trace.profiler.useHearbeats` is `trace.profiler.useHeartbeats` ([#4590](https://github.com/leanprover/lean4/pull/4590)).
-
-* A bugfix in the structural recursion code may in some cases break existing code, when a parameter of the type of the recursive argument is bound behind indices of that type. This can usually be fixed by reordering the parameters of the function ([#4672](https://github.com/leanprover/lean4/pull/4672)).
-
-* Now `List.filterMapM` sequences monadic actions left-to-right ([#4820](https://github.com/leanprover/lean4/pull/4820)).
-
-* The effect of the `variable` command on proofs of `theorem`s has been changed. Whether such section variables are accessible in the proof now depends only on the theorem signature and other top-level commands, not on the proof itself. This change ensures that
-  * the statement of a theorem is independent of its proof. In other words, changes in the proof cannot change the theorem statement.
-  * tactics such as `induction` cannot accidentally include a section variable.
-  * the proof can be elaborated in parallel to subsequent declarations in a future version of Lean.
-
-  The effect of `variable`s on the theorem header as well as on other kinds of declarations is unchanged.
-
-  Specifically, section variables are included if they
-  * are directly referenced by the theorem header,
-  * are included via the new `include` command in the current section and not subsequently mentioned in an `omit` statement,
-  * are directly referenced by any variable included by these rules, OR
-  * are instance-implicit variables that reference only variables included by these rules.
-
-  For porting, a new option `deprecated.oldSectionVars` is included to locally switch back to the old behavior.

releases/v4.12.0.md

@@ -1,312 +0,0 @@
-v4.12.0
-----------
-
-### Language features, tactics, and metaprograms
-
-* `bv_decide` tactic. This release introduces a new tactic for proving goals involving `BitVec` and `Bool`. It reduces the goal to a SAT instance that is refuted by an external solver, and the resulting LRAT proof is checked in Lean. This is used to synthesize a proof of the goal by reflection. As this process uses verified algorithms, proofs generated by this tactic use `Lean.ofReduceBool`, so this tactic includes the Lean compiler as part of the trusted code base. The external solver CaDiCaL is included with Lean and does not need to be installed separately to make use of `bv_decide`.
-
-  For example, we can use `bv_decide` to verify that a bit twiddling formula leaves at most one bit set:
-  ```lean
-  def popcount (x : BitVec 64) : BitVec 64 :=
-    let rec go (x pop : BitVec 64) : Nat → BitVec 64
-      | 0 => pop
-      | n + 1 => go (x >>> 2) (pop + (x &&& 1)) n
-    go x 0 64
-
-  example (x : BitVec 64) : popcount ((x &&& (x - 1)) ^^^ x) ≤ 1 := by
-    simp only [popcount, popcount.go]
-    bv_decide
-  ```
-  When the external solver fails to refute the SAT instance generated by `bv_decide`, it can report a counterexample:
-  ```lean
-  /--
-  error: The prover found a counterexample, consider the following assignment:
-  x = 0xffffffffffffffff#64
-  -/
-  #guard_msgs in
-  example (x : BitVec 64) : x < x + 1 := by
-    bv_decide
-  ```
-
-  See `Lean.Elab.Tactic.BVDecide` for a more detailed overview, and look in `tests/lean/run/bv_*` for examples.
-
-  [#5013](https://github.com/leanprover/lean4/pull/5013), [#5074](https://github.com/leanprover/lean4/pull/5074), [#5100](https://github.com/leanprover/lean4/pull/5100), [#5113](https://github.com/leanprover/lean4/pull/5113), [#5137](https://github.com/leanprover/lean4/pull/5137), [#5203](https://github.com/leanprover/lean4/pull/5203), [#5212](https://github.com/leanprover/lean4/pull/5212), [#5220](https://github.com/leanprover/lean4/pull/5220).
-
-* `simp` tactic
-  * [#4988](https://github.com/leanprover/lean4/pull/4988) fixes a panic in the `reducePow` simproc.
-  * [#5071](https://github.com/leanprover/lean4/pull/5071) exposes the `index` option to the `dsimp` tactic, introduced to `simp` in [#4202](https://github.com/leanprover/lean4/pull/4202).
-  * [#5159](https://github.com/leanprover/lean4/pull/5159) fixes a panic at `Fin.isValue` simproc.
-  * [#5167](https://github.com/leanprover/lean4/pull/5167) and [#5175](https://github.com/leanprover/lean4/pull/5175) rename the `simpCtorEq` simproc to `reduceCtorEq` and makes it optional. (See breaking changes.)
-  * [#5187](https://github.com/leanprover/lean4/pull/5187) ensures `reduceCtorEq` is enabled in the `norm_cast` tactic.
-  * [#5073](https://github.com/leanprover/lean4/pull/5073) modifies the simp debug trace messages to tag with "dpre" and "dpost" instead of "pre" and "post" when in definitional rewrite mode. [#5054](https://github.com/leanprover/lean4/pull/5054) explains the `reduce` steps for `trace.Debug.Meta.Tactic.simp` trace messages.
-* `ext` tactic
-  * [#4996](https://github.com/leanprover/lean4/pull/4996) reduces default maximum iteration depth from 1000000 to 100.
-* `induction` tactic
-  * [#5117](https://github.com/leanprover/lean4/pull/5117) fixes a bug where `let` bindings in minor premises wouldn't be counted correctly.
-
-* `omega` tactic
-  * [#5157](https://github.com/leanprover/lean4/pull/5157) fixes a panic.
-
-* `conv` tactic
-  * [#5149](https://github.com/leanprover/lean4/pull/5149) improves `arg n` to handle subsingleton instance arguments.
-
-* [#5044](https://github.com/leanprover/lean4/pull/5044) upstreams the `#time` command.
-* [#5079](https://github.com/leanprover/lean4/pull/5079) makes `#check` and `#reduce` typecheck the elaborated terms.
-
-* **Incrementality**
-  * [#4974](https://github.com/leanprover/lean4/pull/4974) fixes regression where we would not interrupt elaboration of previous document versions.
-  * [#5004](https://github.com/leanprover/lean4/pull/5004) fixes a performance regression.
-  * [#5001](https://github.com/leanprover/lean4/pull/5001) disables incremental body elaboration in presence of `where` clauses in declarations.
-  * [#5018](https://github.com/leanprover/lean4/pull/5018) enables infotrees on the command line for ilean generation.
-  * [#5040](https://github.com/leanprover/lean4/pull/5040) and [#5056](https://github.com/leanprover/lean4/pull/5056) improve performance of info trees.
-  * [#5090](https://github.com/leanprover/lean4/pull/5090) disables incrementality in the `case .. | ..` tactic.
-  * [#5312](https://github.com/leanprover/lean4/pull/5312) fixes a bug where changing whitespace after the module header could break subsequent commands.
-
-* **Definitions**
-  * [#5016](https://github.com/leanprover/lean4/pull/5016) and [#5066](https://github.com/leanprover/lean4/pull/5066) add `clean_wf` tactic to clean up tactic state in `decreasing_by`. This can be disabled with `set_option debug.rawDecreasingByGoal false`.
-  * [#5055](https://github.com/leanprover/lean4/pull/5055) unifies equational theorems between structural and well-founded recursion.
-  * [#5041](https://github.com/leanprover/lean4/pull/5041) allows mutually recursive functions to use different parameter names among the “fixed parameter prefix”
-  * [#4154](https://github.com/leanprover/lean4/pull/4154) and [#5109](https://github.com/leanprover/lean4/pull/5109) add fine-grained equational lemmas for non-recursive functions. See breaking changes.
-  * [#5129](https://github.com/leanprover/lean4/pull/5129) unifies equation lemmas for recursive and non-recursive definitions. The `backward.eqns.deepRecursiveSplit` option can be set to `false` to get the old behavior. See breaking changes.
-  * [#5141](https://github.com/leanprover/lean4/pull/5141) adds `f.eq_unfold` lemmas. Now Lean produces the following zoo of rewrite rules:
-    ```
-    Option.map.eq_1      : Option.map f none = none
-    Option.map.eq_2      : Option.map f (some x) = some (f x)
-    Option.map.eq_def    : Option.map f p = match o with | none => none | (some x) => some (f x)
-    Option.map.eq_unfold : Option.map = fun f p => match o with | none => none | (some x) => some (f x)
-    ```
-    The `f.eq_unfold` variant is especially useful to rewrite with `rw` under binders.
-  * [#5136](https://github.com/leanprover/lean4/pull/5136) fixes bugs in recursion over predicates.
-
-* **Variable inclusion**
-  * [#5206](https://github.com/leanprover/lean4/pull/5206) documents that `include` currently only applies to theorems.
-
-* **Elaboration**
-  * [#4926](https://github.com/leanprover/lean4/pull/4926) fixes a bug where autoparam errors were associated to an incorrect source position.
-  * [#4833](https://github.com/leanprover/lean4/pull/4833) fixes an issue where cdot anonymous functions (e.g. `(· + ·)`) would not handle ambiguous notation correctly. Numbers the parameters, making this example expand as `fun x1 x2 => x1 + x2` rather than `fun x x_1 => x + x_1`.
-  * [#5037](https://github.com/leanprover/lean4/pull/5037) improves strength of the tactic that proves array indexing is in bounds.
-  * [#5119](https://github.com/leanprover/lean4/pull/5119) fixes a bug in the tactic that proves indexing is in bounds where it could loop in the presence of mvars.
-  * [#5072](https://github.com/leanprover/lean4/pull/5072) makes the structure type clickable in "not a field of structure" errors for structure instance notation.
-  * [#4717](https://github.com/leanprover/lean4/pull/4717) fixes a bug where mutual `inductive` commands could create terms that the kernel rejects.
-  * [#5142](https://github.com/leanprover/lean4/pull/5142) fixes a bug where `variable` could fail when mixing binder updates and declarations.
-
-* **Other fixes or improvements**
-  * [#5118](https://github.com/leanprover/lean4/pull/5118) changes the definition of the `syntheticHole` parser so that hovering over `_` in `?_` gives the docstring for synthetic holes.
-  * [#5173](https://github.com/leanprover/lean4/pull/5173) uses the emoji variant selector for ✅️,❌️,💥️ in messages, improving fonts selection.
-  * [#5183](https://github.com/leanprover/lean4/pull/5183) fixes a bug in `rename_i` where implementation detail hypotheses could be renamed.
-
-### Language server, widgets, and IDE extensions
-
-* [#4821](https://github.com/leanprover/lean4/pull/4821) resolves two language server bugs that especially affect Windows users. (1) Editing the header could result in the watchdog not correctly restarting the file worker, which would lead to the file seemingly being processed forever. (2) On an especially slow Windows machine, we found that starting the language server would sometimes not succeed at all. This PR also resolves an issue where we would not correctly emit messages that we received while the file worker is being restarted to the corresponding file worker after the restart.
-* [#5006](https://github.com/leanprover/lean4/pull/5006) updates the user widget manual.
-* [#5193](https://github.com/leanprover/lean4/pull/5193) updates the quickstart guide with the new display name for the Lean 4 extension ("Lean 4").
-* [#5185](https://github.com/leanprover/lean4/pull/5185) fixes a bug where over time "import out of date" messages would accumulate.
-* [#4900](https://github.com/leanprover/lean4/pull/4900) improves ilean loading performance by about a factor of two. Optimizes the JSON parser and the conversion from JSON to Lean data structures; see PR description for details.
-* **Other fixes or improvements**
-  * [#5031](https://github.com/leanprover/lean4/pull/5031) localizes an instance in `Lsp.Diagnostics`.
-
-### Pretty printing
-
-* [#4976](https://github.com/leanprover/lean4/pull/4976) introduces `@[app_delab]`, a macro for creating delaborators for particular constants. The `@[app_delab ident]` syntax resolves `ident` to its constant name `name` and then expands to `@[delab app.name]`.
-* [#4982](https://github.com/leanprover/lean4/pull/4982) fixes a bug where the pretty printer assumed structure projections were type correct (such terms can appear in type mismatch errors). Improves hoverability of `#print` output for structures.
-* [#5218](https://github.com/leanprover/lean4/pull/5218) and [#5239](https://github.com/leanprover/lean4/pull/5239) add `pp.exprSizes` debugging option. When true, each pretty printed expression is prefixed with `[size a/b/c]`, where `a` is the size without sharing, `b` is the actual size, and `c` is the size with the maximum possible sharing.
-
-### Library
-
-* [#5020](https://github.com/leanprover/lean4/pull/5020) swaps the parameters to `Membership.mem`. A purpose of this change is to make set-like `CoeSort` coercions to refer to the eta-expanded function `fun x => Membership.mem s x`, which can reduce in many computations. Another is that having the `s` argument first leads to better discrimination tree keys. (See breaking changes.)
-* `Array`
-  * [#4970](https://github.com/leanprover/lean4/pull/4970) adds `@[ext]` attribute to `Array.ext`.
-  * [#4957](https://github.com/leanprover/lean4/pull/4957) deprecates `Array.get_modify`.
-* `List`
-  * [#4995](https://github.com/leanprover/lean4/pull/4995) upstreams `List.findIdx` lemmas.
-  * [#5029](https://github.com/leanprover/lean4/pull/5029), [#5048](https://github.com/leanprover/lean4/pull/5048) and [#5132](https://github.com/leanprover/lean4/pull/5132) add `List.Sublist` lemmas, some upstreamed. [#5077](https://github.com/leanprover/lean4/pull/5077) fixes implicitness in refl/rfl lemma binders.  add `List.Sublist` theorems.
-  * [#5047](https://github.com/leanprover/lean4/pull/5047) upstreams `List.Pairwise` lemmas.
-  * [#5053](https://github.com/leanprover/lean4/pull/5053), [#5124](https://github.com/leanprover/lean4/pull/5124), and [#5161](https://github.com/leanprover/lean4/pull/5161) add `List.find?/findSome?/findIdx?` theorems.
-  * [#5039](https://github.com/leanprover/lean4/pull/5039) adds `List.foldlRecOn` and `List.foldrRecOn` recursion principles to prove things about `List.foldl` and `List.foldr`.
-  * [#5069](https://github.com/leanprover/lean4/pull/5069) upstreams `List.Perm`.
-  * [#5092](https://github.com/leanprover/lean4/pull/5092) and [#5107](https://github.com/leanprover/lean4/pull/5107) add `List.mergeSort` and a fast `@[csimp]` implementation.
-  * [#5103](https://github.com/leanprover/lean4/pull/5103) makes the simp lemmas for `List.subset` more aggressive.
-  * [#5106](https://github.com/leanprover/lean4/pull/5106) changes the statement of `List.getLast?_cons`.
-  * [#5123](https://github.com/leanprover/lean4/pull/5123) and [#5158](https://github.com/leanprover/lean4/pull/5158) add `List.range` and `List.iota` lemmas.
-  * [#5130](https://github.com/leanprover/lean4/pull/5130) adds `List.join` lemmas.
-  * [#5131](https://github.com/leanprover/lean4/pull/5131) adds `List.append` lemmas.
-  * [#5152](https://github.com/leanprover/lean4/pull/5152) adds `List.erase(|P|Idx)` lemmas.
-  * [#5127](https://github.com/leanprover/lean4/pull/5127) makes miscellaneous lemma updates.
-  * [#5153](https://github.com/leanprover/lean4/pull/5153) and [#5160](https://github.com/leanprover/lean4/pull/5160) add lemmas about `List.attach` and `List.pmap`.
-  * [#5164](https://github.com/leanprover/lean4/pull/5164), [#5177](https://github.com/leanprover/lean4/pull/5177), and [#5215](https://github.com/leanprover/lean4/pull/5215) add `List.find?` and `List.range'/range/iota` lemmas.
-  * [#5196](https://github.com/leanprover/lean4/pull/5196) adds `List.Pairwise_erase` and related lemmas.
-  * [#5151](https://github.com/leanprover/lean4/pull/5151) and [#5163](https://github.com/leanprover/lean4/pull/5163) improve confluence of `List` simp lemmas. [#5105](https://github.com/leanprover/lean4/pull/5105) and [#5102](https://github.com/leanprover/lean4/pull/5102) adjust `List` simp lemmas.
-  * [#5178](https://github.com/leanprover/lean4/pull/5178) removes `List.getLast_eq_iff_getLast_eq_some` as a simp lemma.
-  * [#5210](https://github.com/leanprover/lean4/pull/5210) reverses the meaning of `List.getElem_drop` and `List.getElem_drop'`.
-  * [#5214](https://github.com/leanprover/lean4/pull/5214) moves `@[csimp]` lemmas earlier where possible.
-* `Nat` and `Int`
-  * [#5104](https://github.com/leanprover/lean4/pull/5104) adds `Nat.add_left_eq_self` and relatives.
-  * [#5146](https://github.com/leanprover/lean4/pull/5146) adds missing `Nat.and_xor_distrib_(left|right)`.
-  * [#5148](https://github.com/leanprover/lean4/pull/5148) and [#5190](https://github.com/leanprover/lean4/pull/5190) improve `Nat` and `Int` simp lemma confluence.
-  * [#5165](https://github.com/leanprover/lean4/pull/5165) adjusts `Int` simp lemmas.
-  * [#5166](https://github.com/leanprover/lean4/pull/5166) adds `Int` lemmas relating `neg` and `emod`/`mod`.
-  * [#5208](https://github.com/leanprover/lean4/pull/5208) reverses the direction of the `Int.toNat_sub` simp lemma.
-  * [#5209](https://github.com/leanprover/lean4/pull/5209) adds `Nat.bitwise` lemmas.
-  * [#5230](https://github.com/leanprover/lean4/pull/5230) corrects the docstrings for integer division and modulus.
-* `Option`
-  * [#5128](https://github.com/leanprover/lean4/pull/5128) and [#5154](https://github.com/leanprover/lean4/pull/5154) add `Option` lemmas.
-* `BitVec`
-  * [#4889](https://github.com/leanprover/lean4/pull/4889) adds `sshiftRight` bitblasting.
-  * [#4981](https://github.com/leanprover/lean4/pull/4981) adds `Std.Associative` and `Std.Commutative` instances for `BitVec.[and|or|xor]`.
-  * [#4913](https://github.com/leanprover/lean4/pull/4913) enables `missingDocs` error for `BitVec` modules.
-  * [#4930](https://github.com/leanprover/lean4/pull/4930) makes parameter names for `BitVec` more consistent.
-  * [#5098](https://github.com/leanprover/lean4/pull/5098) adds `BitVec.intMin`. Introduces `boolToPropSimps` simp set for converting from boolean to propositional expressions.
-  * [#5200](https://github.com/leanprover/lean4/pull/5200) and [#5217](https://github.com/leanprover/lean4/pull/5217) rename `BitVec.getLsb` to `BitVec.getLsbD`, etc., to bring naming in line with `List`/`Array`/etc.
-  * **Theorems:** [#4977](https://github.com/leanprover/lean4/pull/4977), [#4951](https://github.com/leanprover/lean4/pull/4951), [#4667](https://github.com/leanprover/lean4/pull/4667), [#5007](https://github.com/leanprover/lean4/pull/5007), [#4997](https://github.com/leanprover/lean4/pull/4997), [#5083](https://github.com/leanprover/lean4/pull/5083), [#5081](https://github.com/leanprover/lean4/pull/5081), [#4392](https://github.com/leanprover/lean4/pull/4392)
-* `UInt`
-  * [#4514](https://github.com/leanprover/lean4/pull/4514) fixes naming convention for `UInt` lemmas.
-* `Std.HashMap` and `Std.HashSet`
-  * [#4943](https://github.com/leanprover/lean4/pull/4943) deprecates variants of hash map query methods. (See breaking changes.)
-  * [#4917](https://github.com/leanprover/lean4/pull/4917) switches the library and Lean to `Std.HashMap` and `Std.HashSet` almost everywhere.
-  * [#4954](https://github.com/leanprover/lean4/pull/4954) deprecates `Lean.HashMap` and `Lean.HashSet`.
-  * [#5023](https://github.com/leanprover/lean4/pull/5023) cleans up lemma parameters.
-
-* `Std.Sat` (for `bv_decide`)
-  * [#4933](https://github.com/leanprover/lean4/pull/4933) adds definitions of SAT and CNF.
-  * [#4953](https://github.com/leanprover/lean4/pull/4953) defines "and-inverter graphs" (AIGs) as described in section 3 of [Davis-Swords 2013](https://arxiv.org/pdf/1304.7861.pdf).
-
-* **Parsec**
-  * [#4774](https://github.com/leanprover/lean4/pull/4774) generalizes the `Parsec` library, allowing parsing of iterable data beyond `String` such as `ByteArray`. (See breaking changes.)
-  * [#5115](https://github.com/leanprover/lean4/pull/5115) moves `Lean.Data.Parsec` to `Std.Internal.Parsec` for bootstrappng reasons.
-
-* `Thunk`
-  * [#4969](https://github.com/leanprover/lean4/pull/4969) upstreams `Thunk.ext`.
-
-* **IO**
-  * [#4973](https://github.com/leanprover/lean4/pull/4973) modifies `IO.FS.lines` to handle `\r\n` on all operating systems instead of just on Windows.
-  * [#5125](https://github.com/leanprover/lean4/pull/5125) adds `createTempFile` and `withTempFile` for creating temporary files that can only be read and written by the current user.
-
-* **Other fixes or improvements**
-  * [#4945](https://github.com/leanprover/lean4/pull/4945) adds `Array`, `Bool` and `Prod` utilities from LeanSAT.
-  * [#4960](https://github.com/leanprover/lean4/pull/4960) adds `Relation.TransGen.trans`.
-  * [#5012](https://github.com/leanprover/lean4/pull/5012) states `WellFoundedRelation Nat` using `<`, not `Nat.lt`.
-  * [#5011](https://github.com/leanprover/lean4/pull/5011) uses `≠` instead of `Not (Eq ...)` in `Fin.ne_of_val_ne`.
-  * [#5197](https://github.com/leanprover/lean4/pull/5197) upstreams `Fin.le_antisymm`.
-  * [#5042](https://github.com/leanprover/lean4/pull/5042) reduces usage of `refine'`.
-  * [#5101](https://github.com/leanprover/lean4/pull/5101) adds about `if-then-else` and `Option`.
-  * [#5112](https://github.com/leanprover/lean4/pull/5112) adds basic instances for `ULift` and `PLift`.
-  * [#5133](https://github.com/leanprover/lean4/pull/5133) and [#5168](https://github.com/leanprover/lean4/pull/5168) make fixes from running the simpNF linter over Lean.
-  * [#5156](https://github.com/leanprover/lean4/pull/5156) removes a bad simp lemma in `omega` theory.
-  * [#5155](https://github.com/leanprover/lean4/pull/5155) improves confluence of `Bool` simp lemmas.
-  * [#5162](https://github.com/leanprover/lean4/pull/5162) improves confluence of `Function.comp` simp lemmas.
-  * [#5191](https://github.com/leanprover/lean4/pull/5191) improves confluence of `if-then-else` simp lemmas.
-  * [#5147](https://github.com/leanprover/lean4/pull/5147) adds `@[elab_as_elim]` to `Quot.rec`, `Nat.strongInductionOn` and `Nat.casesStrongInductionOn`, and also renames the latter two to `Nat.strongRecOn` and `Nat.casesStrongRecOn` (deprecated in [#5179](https://github.com/leanprover/lean4/pull/5179)).
-  * [#5180](https://github.com/leanprover/lean4/pull/5180) disables some simp lemmas with bad discrimination tree keys.
-  * [#5189](https://github.com/leanprover/lean4/pull/5189) cleans up internal simp lemmas that had leaked.
-  * [#5198](https://github.com/leanprover/lean4/pull/5198) cleans up `allowUnsafeReducibility`.
-  * [#5229](https://github.com/leanprover/lean4/pull/5229) removes unused lemmas from some `simp` tactics.
-  * [#5199](https://github.com/leanprover/lean4/pull/5199) removes >6 month deprecations.
-
-### Lean internals
-
-* **Performance**
-  * Some core algorithms have been rewritten in C++ for performance.
-    * [#4910](https://github.com/leanprover/lean4/pull/4910) and [#4912](https://github.com/leanprover/lean4/pull/4912) reimplement `instantiateLevelMVars`.
-    * [#4915](https://github.com/leanprover/lean4/pull/4915), [#4922](https://github.com/leanprover/lean4/pull/4922), and [#4931](https://github.com/leanprover/lean4/pull/4931) reimplement `instantiateExprMVars`, 30% faster on a benchmark.
-  * [#4934](https://github.com/leanprover/lean4/pull/4934) has optimizations for the kernel's `Expr` equality test.
-  * [#4990](https://github.com/leanprover/lean4/pull/4990) fixes bug in hashing for the kernel's `Expr` equality test.
-  * [#4935](https://github.com/leanprover/lean4/pull/4935) and [#4936](https://github.com/leanprover/lean4/pull/4936) skip some `PreDefinition` transformations if they are not needed.
-  * [#5225](https://github.com/leanprover/lean4/pull/5225) adds caching for visited exprs at `CheckAssignmentQuick` in `ExprDefEq`.
-  * [#5226](https://github.com/leanprover/lean4/pull/5226) maximizes term sharing at `instantiateMVarDeclMVars`, used by `runTactic`.
-* **Diagnostics and profiling**
-  * [#4923](https://github.com/leanprover/lean4/pull/4923) adds profiling for `instantiateMVars` in `Lean.Elab.MutualDef`, which can be a bottleneck there.
-  * [#4924](https://github.com/leanprover/lean4/pull/4924) adds diagnostics for large theorems, controlled by the `diagnostics.threshold.proofSize` option.
-  * [#4897](https://github.com/leanprover/lean4/pull/4897) improves display of diagnostic results.
-* **Other fixes or improvements**
-  * [#4921](https://github.com/leanprover/lean4/pull/4921) cleans up `Expr.betaRev`.
-  * [#4940](https://github.com/leanprover/lean4/pull/4940) fixes tests by not writing directly to stdout, which is unreliable now that elaboration and reporting are executed in separate threads.
-  * [#4955](https://github.com/leanprover/lean4/pull/4955) documents that `stderrAsMessages` is now the default on the command line as well.
-  * [#4647](https://github.com/leanprover/lean4/pull/4647) adjusts documentation for building on macOS.
-  * [#4987](https://github.com/leanprover/lean4/pull/4987) makes regular mvar assignments take precedence over delayed ones in `instantiateMVars`. Normally delayed assignment metavariables are never directly assigned, but on errors Lean assigns `sorry` to unassigned metavariables.
-  * [#4967](https://github.com/leanprover/lean4/pull/4967) adds linter name to errors when a linter crashes.
-  * [#5043](https://github.com/leanprover/lean4/pull/5043) cleans up command line snapshots logic.
-  * [#5067](https://github.com/leanprover/lean4/pull/5067) minimizes some imports.
-  * [#5068](https://github.com/leanprover/lean4/pull/5068) generalizes the monad for `addMatcherInfo`.
-  * [f71a1f](https://github.com/leanprover/lean4/commit/f71a1fb4ae958fccb3ad4d48786a8f47ced05c15) adds missing test for [#5126](https://github.com/leanprover/lean4/issues/5126).
-  * [#5201](https://github.com/leanprover/lean4/pull/5201) restores a test.
-  * [#3698](https://github.com/leanprover/lean4/pull/3698) fixes a bug where label attributes did not pass on the attribute kind.
-  * Typos: [#5080](https://github.com/leanprover/lean4/pull/5080), [#5150](https://github.com/leanprover/lean4/pull/5150), [#5202](https://github.com/leanprover/lean4/pull/5202)
-
-### Compiler, runtime, and FFI
-
-* [#3106](https://github.com/leanprover/lean4/pull/3106) moves frontend to new snapshot architecture. Note that `Frontend.processCommand` and `FrontendM` are no longer used by Lean core, but they will be preserved.
-* [#4919](https://github.com/leanprover/lean4/pull/4919) adds missing include in runtime for `AUTO_THREAD_FINALIZATION` feature on Windows.
-* [#4941](https://github.com/leanprover/lean4/pull/4941) adds more `LEAN_EXPORT`s for Windows.
-* [#4911](https://github.com/leanprover/lean4/pull/4911) improves formatting of CLI help text for the frontend.
-* [#4950](https://github.com/leanprover/lean4/pull/4950) improves file reading and writing.
-  * `readBinFile` and `readFile` now only require two system calls (`stat` + `read`) instead of one `read` per 1024 byte chunk.
-  * `Handle.getLine` and `Handle.putStr` no longer get tripped up by NUL characters.
-* [#4971](https://github.com/leanprover/lean4/pull/4971) handles the SIGBUS signal when detecting stack overflows.
-* [#5062](https://github.com/leanprover/lean4/pull/5062) avoids overwriting existing signal handlers, like in [rust-lang/rust#69685](https://github.com/rust-lang/rust/pull/69685).
-* [#4860](https://github.com/leanprover/lean4/pull/4860) improves workarounds for building on Windows. Splits `libleanshared` on Windows to avoid symbol limit, removes the `LEAN_EXPORT` denylist workaround, adds missing `LEAN_EXPORT`s.
-* [#4952](https://github.com/leanprover/lean4/pull/4952) output panics into Lean's redirected stderr, ensuring panics ARE visible as regular messages in the language server and properly ordered in relation to other messages on the command line.
-* [#4963](https://github.com/leanprover/lean4/pull/4963) links LibUV.
-
-### Lake
-
-* [#5030](https://github.com/leanprover/lean4/pull/5030) removes dead code.
-* [#4770](https://github.com/leanprover/lean4/pull/4770) adds additional fields to the package configuration which will be used by Reservoir. See the PR description for details.
-
-
-### DevOps/CI
-* [#4914](https://github.com/leanprover/lean4/pull/4914) and [#4937](https://github.com/leanprover/lean4/pull/4937) improve the release checklist.
-* [#4925](https://github.com/leanprover/lean4/pull/4925) ignores stale leanpkg tests.
-* [#5003](https://github.com/leanprover/lean4/pull/5003) upgrades `actions/cache` in CI.
-* [#5010](https://github.com/leanprover/lean4/pull/5010) sets `save-always` in cache actions in CI.
-* [#5008](https://github.com/leanprover/lean4/pull/5008) adds more libuv search patterns for the speedcenter.
-* [#5009](https://github.com/leanprover/lean4/pull/5009) reduce number of runs in the speedcenter for "fast" benchmarks from 10 to 3.
-* [#5014](https://github.com/leanprover/lean4/pull/5014) adjusts lakefile editing to use new `git` syntax in `pr-release` workflow.
-* [#5025](https://github.com/leanprover/lean4/pull/5025) has `pr-release` workflow pass `--retry` to `curl`.
-* [#5022](https://github.com/leanprover/lean4/pull/5022) builds MacOS Aarch64 release for PRs by default.
-* [#5045](https://github.com/leanprover/lean4/pull/5045) adds libuv to the required packages heading in macos docs.
-* [#5034](https://github.com/leanprover/lean4/pull/5034) fixes the install name of `libleanshared_1` on macOS.
-* [#5051](https://github.com/leanprover/lean4/pull/5051) fixes Windows stage 0.
-* [#5052](https://github.com/leanprover/lean4/pull/5052) fixes 32bit stage 0 builds in CI.
-* [#5057](https://github.com/leanprover/lean4/pull/5057) avoids rebuilding `leanmanifest` in each build.
-* [#5099](https://github.com/leanprover/lean4/pull/5099) makes `restart-on-label` workflow also filter by commit SHA.
-* [#4325](https://github.com/leanprover/lean4/pull/4325) adds CaDiCaL.
-
-### Breaking changes
-
-* [LibUV](https://libuv.org/) is now required to build Lean. This change only affects developers who compile Lean themselves instead of obtaining toolchains via `elan`. We have updated the official build instructions with information on how to obtain LibUV on our supported platforms. ([#4963](https://github.com/leanprover/lean4/pull/4963))
-
-* Recursive definitions with a `decreasing_by` clause that begins with `simp_wf` may break. Try removing `simp_wf` or replacing it with `simp`. ([#5016](https://github.com/leanprover/lean4/pull/5016))
-
-* The behavior of `rw [f]` where `f` is a non-recursive function defined by pattern matching changed.
-
-  For example, preciously, `rw [Option.map]` would rewrite `Option.map f o` to `match o with … `. Now this rewrite fails because it will use the equational lemmas, and these require constructors – just like for `List.map`.
-
-  Remedies:
-  * Split on `o` before rewriting.
-  * Use `rw [Option.map.eq_def]`, which rewrites any (saturated) application of `Option.map`.
-  * Use `set_option backward.eqns.nonrecursive false` when *defining* the function in question.
-  ([#4154](https://github.com/leanprover/lean4/pull/4154))
-
-* The unified handling of equation lemmas for recursive and non-recursive functions can break existing code, as there now can be extra equational lemmas:
-
-  * Explicit uses of `f.eq_2` might have to be adjusted if the numbering changed.
-
-  * Uses of `rw [f]` or `simp [f]` may no longer apply if they previously matched (and introduced a `match` statement), when the equational lemmas got more fine-grained.
-
-    In this case either case analysis on the parameters before rewriting helps, or setting the option `backward.eqns.deepRecursiveSplit false` while *defining* the function.
-
-  ([#5129](https://github.com/leanprover/lean4/pull/5129), [#5207](https://github.com/leanprover/lean4/pull/5207))
-
-* The `reduceCtorEq` simproc is now optional, and it might need to be included in lists of simp lemmas, like `simp only [reduceCtorEq]`. This simproc is responsible for reducing equalities of constructors. ([#5167](https://github.com/leanprover/lean4/pull/5167))
-
-* `Nat.strongInductionOn` is now `Nat.strongRecOn` and `Nat.caseStrongInductionOn` to `Nat.caseStrongRecOn`. ([#5147](https://github.com/leanprover/lean4/pull/5147))
-
-* The parameters to `Membership.mem` have been swapped, which affects all `Membership` instances. ([#5020](https://github.com/leanprover/lean4/pull/5020))
-
-* The meanings of `List.getElem_drop` and `List.getElem_drop'` have been reversed and the first is now a simp lemma. ([#5210](https://github.com/leanprover/lean4/pull/5210))
-
-* The `Parsec` library has moved from `Lean.Data.Parsec` to `Std.Internal.Parsec`. The `Parsec` type is now more general with a parameter for an iterable. Users parsing strings can migrate to `Parser` in the `Std.Internal.Parsec.String` namespace, which also includes string-focused parsing combinators. ([#4774](https://github.com/leanprover/lean4/pull/4774))
-
-* The `Lean` module has switched from `Lean.HashMap` and `Lean.HashSet` to `Std.HashMap` and `Std.HashSet` ([#4943](https://github.com/leanprover/lean4/pull/4943)). `Lean.HashMap` and `Lean.HashSet` are now deprecated ([#4954](https://github.com/leanprover/lean4/pull/4954)) and will be removed in a future release. Users of `Lean` APIs that interact with hash maps, for example `Lean.Environment.const2ModIdx`, might encounter minor breakage due to the following changes from `Lean.HashMap` to `Std.HashMap`:
-  * query functions use the term `get` instead of `find`, ([#4943](https://github.com/leanprover/lean4/pull/4943))
-  * the notation `map[key]` no longer returns an optional value but instead expects a proof that the key is present in the map. The previous behavior is available via the `map[key]?` notation.

releases/v4.13.0.md

@@ -1,312 +0,0 @@
-v4.13.0
-----------
-
-**Full Changelog**: https://github.com/leanprover/lean4/compare/v4.12.0...v4.13.0
-
-### Language features, tactics, and metaprograms
-
-* `structure` command
-  * [#5511](https://github.com/leanprover/lean4/pull/5511) allows structure parents to be type synonyms.
-  * [#5531](https://github.com/leanprover/lean4/pull/5531) allows default values for structure fields to be noncomputable.
-
-* `rfl` and `apply_rfl` tactics
-  * [#3714](https://github.com/leanprover/lean4/pull/3714), [#3718](https://github.com/leanprover/lean4/pull/3718) improve the `rfl` tactic and give better error messages.
-  * [#3772](https://github.com/leanprover/lean4/pull/3772) makes `rfl` no longer use kernel defeq for ground terms.
-  * [#5329](https://github.com/leanprover/lean4/pull/5329) tags `Iff.refl` with `@[refl]` (@Parcly-Taxel)
-  * [#5359](https://github.com/leanprover/lean4/pull/5359) ensures that the `rfl` tactic tries `Iff.rfl` (@Parcly-Taxel)
-
-* `unfold` tactic
-  * [#4834](https://github.com/leanprover/lean4/pull/4834) let `unfold` do zeta-delta reduction of local definitions, incorporating functionality of the Mathlib `unfold_let` tactic.
-
-* `omega` tactic
-  * [#5382](https://github.com/leanprover/lean4/pull/5382) fixes spurious error in [#5315](https://github.com/leanprover/lean4/issues/5315)
-  * [#5523](https://github.com/leanprover/lean4/pull/5523) supports `Int.toNat`
-
-* `simp` tactic
-  * [#5479](https://github.com/leanprover/lean4/pull/5479) lets `simp` apply rules with higher-order patterns.
-
-* `induction` tactic
-  * [#5494](https://github.com/leanprover/lean4/pull/5494) fixes `induction`’s "pre-tactic" block to always be indented, avoiding unintended uses of it.
-
-* `ac_nf` tactic
-  * [#5524](https://github.com/leanprover/lean4/pull/5524) adds `ac_nf`, a counterpart to `ac_rfl`, for normalizing expressions with respect to associativity and commutativity. Tests it with `BitVec` expressions.
-
-* `bv_decide`
-  * [#5211](https://github.com/leanprover/lean4/pull/5211) makes `extractLsb'` the primitive `bv_decide` understands, rather than `extractLsb` (@alexkeizer)
-  * [#5365](https://github.com/leanprover/lean4/pull/5365) adds `bv_decide` diagnoses.
-  * [#5375](https://github.com/leanprover/lean4/pull/5375) adds `bv_decide` normalization rules for `ofBool (a.getLsbD i)` and `ofBool a[i]` (@alexkeizer)
-  * [#5423](https://github.com/leanprover/lean4/pull/5423) enhances the rewriting rules of `bv_decide`
-  * [#5433](https://github.com/leanprover/lean4/pull/5433) presents the `bv_decide` counterexample at the API
-  * [#5484](https://github.com/leanprover/lean4/pull/5484) handles `BitVec.ofNat` with `Nat` fvars in `bv_decide`
-  * [#5506](https://github.com/leanprover/lean4/pull/5506), [#5507](https://github.com/leanprover/lean4/pull/5507) add `bv_normalize` rules.
-  * [#5568](https://github.com/leanprover/lean4/pull/5568) generalize the `bv_normalize` pipeline to support more general preprocessing passes
-  * [#5573](https://github.com/leanprover/lean4/pull/5573) gets `bv_normalize` up-to-date with the current `BitVec` rewrites
-  * Cleanups: [#5408](https://github.com/leanprover/lean4/pull/5408), [#5493](https://github.com/leanprover/lean4/pull/5493), [#5578](https://github.com/leanprover/lean4/pull/5578)
-
-
-* Elaboration improvements
-  * [#5266](https://github.com/leanprover/lean4/pull/5266) preserve order of overapplied arguments in `elab_as_elim` procedure.
-  * [#5510](https://github.com/leanprover/lean4/pull/5510) generalizes `elab_as_elim` to allow arbitrary motive applications.
-  * [#5283](https://github.com/leanprover/lean4/pull/5283), [#5512](https://github.com/leanprover/lean4/pull/5512) refine how named arguments suppress explicit arguments. Breaking change: some previously omitted explicit arguments may need explicit `_` arguments now.
-  * [#5376](https://github.com/leanprover/lean4/pull/5376) modifies projection instance binder info for instances, making parameters that are instance implicit in the type be implicit.
-  * [#5402](https://github.com/leanprover/lean4/pull/5402) localizes universe metavariable errors to `let` bindings and `fun` binders if possible. Makes "cannot synthesize metavariable" errors take precedence over unsolved universe level errors.
-  * [#5419](https://github.com/leanprover/lean4/pull/5419) must not reduce `ite` in the discriminant of `match`-expression when reducibility setting is `.reducible`
-  * [#5474](https://github.com/leanprover/lean4/pull/5474) have autoparams report parameter/field on failure
-  * [#5530](https://github.com/leanprover/lean4/pull/5530) makes automatic instance names about types with hygienic names be hygienic.
-
-* Deriving handlers
-  * [#5432](https://github.com/leanprover/lean4/pull/5432) makes `Repr` deriving instance handle explicit type parameters
-
-* Functional induction
-  * [#5364](https://github.com/leanprover/lean4/pull/5364) adds more equalities in context, more careful cleanup.
-
-* Linters
-  * [#5335](https://github.com/leanprover/lean4/pull/5335) fixes the unused variables linter complaining about match/tactic combinations
-  * [#5337](https://github.com/leanprover/lean4/pull/5337) fixes the unused variables linter complaining about some wildcard patterns
-
-* Other fixes
-  * [#4768](https://github.com/leanprover/lean4/pull/4768) fixes a parse error when `..` appears with a `.` on the next line
-
-* Metaprogramming
-  * [#3090](https://github.com/leanprover/lean4/pull/3090) handles level parameters in `Meta.evalExpr` (@eric-wieser)
-  * [#5401](https://github.com/leanprover/lean4/pull/5401) instance for `Inhabited (TacticM α)` (@alexkeizer)
-  * [#5412](https://github.com/leanprover/lean4/pull/5412) expose Kernel.check for debugging purposes
-  * [#5556](https://github.com/leanprover/lean4/pull/5556) improves the "invalid projection" type inference error in `inferType`.
-  * [#5587](https://github.com/leanprover/lean4/pull/5587) allows `MVarId.assertHypotheses` to set `BinderInfo` and `LocalDeclKind`.
-  * [#5588](https://github.com/leanprover/lean4/pull/5588) adds `MVarId.tryClearMany'`, a variant of `MVarId.tryClearMany`.
-
-
-
-### Language server, widgets, and IDE extensions
-
-* [#5205](https://github.com/leanprover/lean4/pull/5205) decreases the latency of auto-completion in tactic blocks.
-* [#5237](https://github.com/leanprover/lean4/pull/5237) fixes symbol occurrence highlighting in VS Code not highlighting occurrences when moving the text cursor into the identifier from the right.
-* [#5257](https://github.com/leanprover/lean4/pull/5257) fixes several instances of incorrect auto-completions being reported.
-* [#5299](https://github.com/leanprover/lean4/pull/5299) allows auto-completion to report completions for global identifiers when the elaborator fails to provide context-specific auto-completions.
-* [#5312](https://github.com/leanprover/lean4/pull/5312) fixes the server breaking when changing whitespace after the module header.
-* [#5322](https://github.com/leanprover/lean4/pull/5322) fixes several instances of auto-completion reporting non-existent namespaces.
-* [#5428](https://github.com/leanprover/lean4/pull/5428) makes sure to always report some recent file range as progress when waiting for elaboration.
-
-
-### Pretty printing
-
-* [#4979](https://github.com/leanprover/lean4/pull/4979) make pretty printer escape identifiers that are tokens.
-* [#5389](https://github.com/leanprover/lean4/pull/5389) makes formatter use the current token table.
-* [#5513](https://github.com/leanprover/lean4/pull/5513) use breakable instead of unbreakable whitespace when formatting tokens.
-
-
-### Library
-
-* [#5222](https://github.com/leanprover/lean4/pull/5222) reduces allocations in `Json.compress`.
-* [#5231](https://github.com/leanprover/lean4/pull/5231) upstreams `Zero` and `NeZero`
-* [#5292](https://github.com/leanprover/lean4/pull/5292) refactors `Lean.Elab.Deriving.FromToJson` (@arthur-adjedj)
-* [#5415](https://github.com/leanprover/lean4/pull/5415) implements `Repr Empty` (@TomasPuverle)
-* [#5421](https://github.com/leanprover/lean4/pull/5421) implements `To/FromJSON Empty` (@TomasPuverle)
-
-* Logic
-  * [#5263](https://github.com/leanprover/lean4/pull/5263) allows simplifying `dite_not`/`decide_not` with only `Decidable (¬p)`.
-  * [#5268](https://github.com/leanprover/lean4/pull/5268) fixes binders on `ite_eq_left_iff`
-  * [#5284](https://github.com/leanprover/lean4/pull/5284) turns off `Inhabited (Sum α β)` instances
-  * [#5355](https://github.com/leanprover/lean4/pull/5355) adds simp lemmas for `LawfulBEq`
-  * [#5374](https://github.com/leanprover/lean4/pull/5374) add `Nonempty` instances for products, allowing more `partial` functions to elaborate successfully
-  * [#5447](https://github.com/leanprover/lean4/pull/5447) updates Pi instance names
-  * [#5454](https://github.com/leanprover/lean4/pull/5454) makes some instance arguments implicit
-  * [#5456](https://github.com/leanprover/lean4/pull/5456) adds `heq_comm`
-  * [#5529](https://github.com/leanprover/lean4/pull/5529) moves `@[simp]` from `exists_prop'` to `exists_prop`
-
-* `Bool`
-  * [#5228](https://github.com/leanprover/lean4/pull/5228) fills gaps in Bool lemmas
-  * [#5332](https://github.com/leanprover/lean4/pull/5332) adds notation `^^` for Bool.xor
-  * [#5351](https://github.com/leanprover/lean4/pull/5351) removes `_root_.and` (and or/not/xor) and instead exports/uses `Bool.and` (etc.).
-
-* `BitVec`
-  * [#5240](https://github.com/leanprover/lean4/pull/5240) removes BitVec simps with complicated RHS
-  * [#5247](https://github.com/leanprover/lean4/pull/5247) `BitVec.getElem_zeroExtend`
-  * [#5248](https://github.com/leanprover/lean4/pull/5248) simp lemmas for BitVec, improving confluence
-  * [#5249](https://github.com/leanprover/lean4/pull/5249) removes `@[simp]` from some BitVec lemmas
-  * [#5252](https://github.com/leanprover/lean4/pull/5252) changes `BitVec.intMin/Max` from abbrev to def
-  * [#5278](https://github.com/leanprover/lean4/pull/5278) adds `BitVec.getElem_truncate` (@tobiasgrosser)
-  * [#5281](https://github.com/leanprover/lean4/pull/5281) adds udiv/umod bitblasting for `bv_decide` (@bollu)
-  * [#5297](https://github.com/leanprover/lean4/pull/5297) `BitVec` unsigned order theoretic results
-  * [#5313](https://github.com/leanprover/lean4/pull/5313) adds more basic BitVec ordering theory for UInt
-  * [#5314](https://github.com/leanprover/lean4/pull/5314) adds `toNat_sub_of_le` (@bollu)
-  * [#5357](https://github.com/leanprover/lean4/pull/5357) adds `BitVec.truncate` lemmas
-  * [#5358](https://github.com/leanprover/lean4/pull/5358) introduces `BitVec.setWidth` to unify zeroExtend and truncate (@tobiasgrosser)
-  * [#5361](https://github.com/leanprover/lean4/pull/5361) some BitVec GetElem lemmas
-  * [#5385](https://github.com/leanprover/lean4/pull/5385) adds `BitVec.ofBool_[and|or|xor]_ofBool` theorems (@tobiasgrosser)
-  * [#5404](https://github.com/leanprover/lean4/pull/5404) more of `BitVec.getElem_*` (@tobiasgrosser)
-  * [#5410](https://github.com/leanprover/lean4/pull/5410) BitVec analogues of `Nat.{mul_two, two_mul, mul_succ, succ_mul}` (@bollu)
-  * [#5411](https://github.com/leanprover/lean4/pull/5411) `BitVec.toNat_{add,sub,mul_of_lt}` for BitVector non-overflow reasoning (@bollu)
-  * [#5413](https://github.com/leanprover/lean4/pull/5413) adds `_self`, `_zero`, and `_allOnes` for `BitVec.[and|or|xor]` (@tobiasgrosser)
-  * [#5416](https://github.com/leanprover/lean4/pull/5416) adds LawCommIdentity + IdempotentOp for `BitVec.[and|or|xor]` (@tobiasgrosser)
-  * [#5418](https://github.com/leanprover/lean4/pull/5418) decidable quantifers for BitVec
-  * [#5450](https://github.com/leanprover/lean4/pull/5450) adds `BitVec.toInt_[intMin|neg|neg_of_ne_intMin]` (@tobiasgrosser)
-  * [#5459](https://github.com/leanprover/lean4/pull/5459) missing BitVec lemmas
-  * [#5469](https://github.com/leanprover/lean4/pull/5469) adds `BitVec.[not_not, allOnes_shiftLeft_or_shiftLeft, allOnes_shiftLeft_and_shiftLeft]` (@luisacicolini)
-  * [#5478](https://github.com/leanprover/lean4/pull/5478) adds `BitVec.(shiftLeft_add_distrib, shiftLeft_ushiftRight)` (@luisacicolini)
-  * [#5487](https://github.com/leanprover/lean4/pull/5487) adds `sdiv_eq`, `smod_eq` to allow `sdiv`/`smod` bitblasting (@bollu)
-  * [#5491](https://github.com/leanprover/lean4/pull/5491) adds `BitVec.toNat_[abs|sdiv|smod]` (@tobiasgrosser)
-  * [#5492](https://github.com/leanprover/lean4/pull/5492) `BitVec.(not_sshiftRight, not_sshiftRight_not, getMsb_not, msb_not)` (@luisacicolini)
-  * [#5499](https://github.com/leanprover/lean4/pull/5499) `BitVec.Lemmas` - drop non-terminal simps (@tobiasgrosser)
-  * [#5505](https://github.com/leanprover/lean4/pull/5505) unsimps `BitVec.divRec_succ'`
-  * [#5508](https://github.com/leanprover/lean4/pull/5508) adds `BitVec.getElem_[add|add_add_bool|mul|rotateLeft|rotateRight…` (@tobiasgrosser)
-  * [#5554](https://github.com/leanprover/lean4/pull/5554) adds `Bitvec.[add, sub, mul]_eq_xor` and `width_one_cases` (@luisacicolini)
-
-* `List`
-  * [#5242](https://github.com/leanprover/lean4/pull/5242) improve naming for `List.mergeSort` lemmas
-  * [#5302](https://github.com/leanprover/lean4/pull/5302) provide `mergeSort` comparator autoParam
-  * [#5373](https://github.com/leanprover/lean4/pull/5373) fix name of `List.length_mergeSort`
-  * [#5377](https://github.com/leanprover/lean4/pull/5377) upstream `map_mergeSort`
-  * [#5378](https://github.com/leanprover/lean4/pull/5378) modify signature of lemmas about `mergeSort`
-  * [#5245](https://github.com/leanprover/lean4/pull/5245) avoid importing `List.Basic` without List.Impl
-  * [#5260](https://github.com/leanprover/lean4/pull/5260) review of List API
-  * [#5264](https://github.com/leanprover/lean4/pull/5264) review of List API
-  * [#5269](https://github.com/leanprover/lean4/pull/5269) remove HashMap's duplicated Pairwise and Sublist
-  * [#5271](https://github.com/leanprover/lean4/pull/5271) remove @[simp] from `List.head_mem` and similar
-  * [#5273](https://github.com/leanprover/lean4/pull/5273) lemmas about `List.attach`
-  * [#5275](https://github.com/leanprover/lean4/pull/5275) reverse direction of `List.tail_map`
-  * [#5277](https://github.com/leanprover/lean4/pull/5277) more `List.attach` lemmas
-  * [#5285](https://github.com/leanprover/lean4/pull/5285) `List.count` lemmas
-  * [#5287](https://github.com/leanprover/lean4/pull/5287) use boolean predicates in `List.filter`
-  * [#5289](https://github.com/leanprover/lean4/pull/5289) `List.mem_ite_nil_left` and analogues
-  * [#5293](https://github.com/leanprover/lean4/pull/5293) cleanup of `List.findIdx` / `List.take` lemmas
-  * [#5294](https://github.com/leanprover/lean4/pull/5294) switch primes on `List.getElem_take`
-  * [#5300](https://github.com/leanprover/lean4/pull/5300) more `List.findIdx` theorems
-  * [#5310](https://github.com/leanprover/lean4/pull/5310) fix `List.all/any` lemmas
-  * [#5311](https://github.com/leanprover/lean4/pull/5311) fix `List.countP` lemmas
-  * [#5316](https://github.com/leanprover/lean4/pull/5316) `List.tail` lemma
-  * [#5331](https://github.com/leanprover/lean4/pull/5331) fix implicitness of `List.getElem_mem`
-  * [#5350](https://github.com/leanprover/lean4/pull/5350) `List.replicate` lemmas
-  * [#5352](https://github.com/leanprover/lean4/pull/5352) `List.attachWith` lemmas
-  * [#5353](https://github.com/leanprover/lean4/pull/5353) `List.head_mem_head?`
-  * [#5360](https://github.com/leanprover/lean4/pull/5360) lemmas about `List.tail`
-  * [#5391](https://github.com/leanprover/lean4/pull/5391) review of `List.erase` / `List.find` lemmas
-  * [#5392](https://github.com/leanprover/lean4/pull/5392) `List.fold` / `attach` lemmas
-  * [#5393](https://github.com/leanprover/lean4/pull/5393) `List.fold` relators
-  * [#5394](https://github.com/leanprover/lean4/pull/5394) lemmas about `List.maximum?`
-  * [#5403](https://github.com/leanprover/lean4/pull/5403) theorems about `List.toArray`
-  * [#5405](https://github.com/leanprover/lean4/pull/5405) reverse direction of `List.set_map`
-  * [#5448](https://github.com/leanprover/lean4/pull/5448) add lemmas about `List.IsPrefix` (@Command-Master)
-  * [#5460](https://github.com/leanprover/lean4/pull/5460) missing `List.set_replicate_self`
-  * [#5518](https://github.com/leanprover/lean4/pull/5518) rename `List.maximum?` to `max?`
-  * [#5519](https://github.com/leanprover/lean4/pull/5519) upstream `List.fold` lemmas
-  * [#5520](https://github.com/leanprover/lean4/pull/5520) restore `@[simp]` on `List.getElem_mem` etc.
-  * [#5521](https://github.com/leanprover/lean4/pull/5521) List simp fixes
-  * [#5550](https://github.com/leanprover/lean4/pull/5550) `List.unattach` and simp lemmas
-  * [#5594](https://github.com/leanprover/lean4/pull/5594) induction-friendly `List.min?_cons`
-
-* `Array`
-  * [#5246](https://github.com/leanprover/lean4/pull/5246) cleanup imports of Array.Lemmas
-  * [#5255](https://github.com/leanprover/lean4/pull/5255) split Init.Data.Array.Lemmas for better bootstrapping
-  * [#5288](https://github.com/leanprover/lean4/pull/5288) rename `Array.data` to `Array.toList`
-  * [#5303](https://github.com/leanprover/lean4/pull/5303) cleanup of `List.getElem_append` variants
-  * [#5304](https://github.com/leanprover/lean4/pull/5304) `Array.not_mem_empty`
-  * [#5400](https://github.com/leanprover/lean4/pull/5400) reorganization in Array/Basic
-  * [#5420](https://github.com/leanprover/lean4/pull/5420) make `Array` functions either semireducible or use structural recursion
-  * [#5422](https://github.com/leanprover/lean4/pull/5422) refactor `DecidableEq (Array α)`
-  * [#5452](https://github.com/leanprover/lean4/pull/5452) refactor of Array
-  * [#5458](https://github.com/leanprover/lean4/pull/5458) cleanup of Array docstrings after refactor
-  * [#5461](https://github.com/leanprover/lean4/pull/5461) restore `@[simp]` on `Array.swapAt!_def`
-  * [#5465](https://github.com/leanprover/lean4/pull/5465) improve Array GetElem lemmas
-  * [#5466](https://github.com/leanprover/lean4/pull/5466) `Array.foldX` lemmas
-  * [#5472](https://github.com/leanprover/lean4/pull/5472) @[simp] lemmas about `List.toArray`
-  * [#5485](https://github.com/leanprover/lean4/pull/5485) reverse simp direction for `toArray_concat`
-  * [#5514](https://github.com/leanprover/lean4/pull/5514) `Array.eraseReps`
-  * [#5515](https://github.com/leanprover/lean4/pull/5515) upstream `Array.qsortOrd`
-  * [#5516](https://github.com/leanprover/lean4/pull/5516) upstream `Subarray.empty`
-  * [#5526](https://github.com/leanprover/lean4/pull/5526) fix name of `Array.length_toList`
-  * [#5527](https://github.com/leanprover/lean4/pull/5527) reduce use of deprecated lemmas in Array
-  * [#5534](https://github.com/leanprover/lean4/pull/5534) cleanup of Array GetElem lemmas
-  * [#5536](https://github.com/leanprover/lean4/pull/5536) fix `Array.modify` lemmas
-  * [#5551](https://github.com/leanprover/lean4/pull/5551) upstream `Array.flatten` lemmas
-  * [#5552](https://github.com/leanprover/lean4/pull/5552) switch obvious cases of array "bang"`[]!` indexing to rely on hypothesis (@TomasPuverle)
-  * [#5577](https://github.com/leanprover/lean4/pull/5577) add missing simp to `Array.size_feraseIdx`
-  * [#5586](https://github.com/leanprover/lean4/pull/5586) `Array/Option.unattach`
-
-* `Option`
-  * [#5272](https://github.com/leanprover/lean4/pull/5272) remove @[simp] from `Option.pmap/pbind` and add simp lemmas
-  * [#5307](https://github.com/leanprover/lean4/pull/5307) restoring Option simp confluence
-  * [#5354](https://github.com/leanprover/lean4/pull/5354) remove @[simp] from `Option.bind_map`
-  * [#5532](https://github.com/leanprover/lean4/pull/5532) `Option.attach`
-  * [#5539](https://github.com/leanprover/lean4/pull/5539) fix explicitness of `Option.mem_toList`
-
-* `Nat`
-  * [#5241](https://github.com/leanprover/lean4/pull/5241) add @[simp] to `Nat.add_eq_zero_iff`
-  * [#5261](https://github.com/leanprover/lean4/pull/5261) Nat bitwise lemmas
-  * [#5262](https://github.com/leanprover/lean4/pull/5262) `Nat.testBit_add_one` should not be a global simp lemma
-  * [#5267](https://github.com/leanprover/lean4/pull/5267) protect some Nat bitwise theorems
-  * [#5305](https://github.com/leanprover/lean4/pull/5305) rename Nat bitwise lemmas
-  * [#5306](https://github.com/leanprover/lean4/pull/5306) add `Nat.self_sub_mod` lemma
-  * [#5503](https://github.com/leanprover/lean4/pull/5503) restore @[simp] to upstreamed `Nat.lt_off_iff`
-
-* `Int`
-  * [#5301](https://github.com/leanprover/lean4/pull/5301) rename `Int.div/mod` to `Int.tdiv/tmod`
-  * [#5320](https://github.com/leanprover/lean4/pull/5320) add `ediv_nonneg_of_nonpos_of_nonpos` to DivModLemmas (@sakehl)
-
-* `Fin`
-  * [#5250](https://github.com/leanprover/lean4/pull/5250) missing lemma about `Fin.ofNat'`
-  * [#5356](https://github.com/leanprover/lean4/pull/5356) `Fin.ofNat'` uses `NeZero`
-  * [#5379](https://github.com/leanprover/lean4/pull/5379) remove some @[simp]s from Fin lemmas
-  * [#5380](https://github.com/leanprover/lean4/pull/5380) missing Fin @[simp] lemmas
-
-* `HashMap`
-  * [#5244](https://github.com/leanprover/lean4/pull/5244) (`DHashMap`|`HashMap`|`HashSet`).(`getKey?`|`getKey`|`getKey!`|`getKeyD`)
-  * [#5362](https://github.com/leanprover/lean4/pull/5362) remove the last use of `Lean.(HashSet|HashMap)`
-  * [#5369](https://github.com/leanprover/lean4/pull/5369) `HashSet.ofArray`
-  * [#5370](https://github.com/leanprover/lean4/pull/5370) `HashSet.partition`
-  * [#5581](https://github.com/leanprover/lean4/pull/5581) `Singleton`/`Insert`/`Union` instances for `HashMap`/`Set`
-  * [#5582](https://github.com/leanprover/lean4/pull/5582) `HashSet.all`/`any`
-  * [#5590](https://github.com/leanprover/lean4/pull/5590) adding `Insert`/`Singleton`/`Union` instances for `HashMap`/`Set.Raw`
-  * [#5591](https://github.com/leanprover/lean4/pull/5591) `HashSet.Raw.all/any`
-
-* `Monads`
-  * [#5463](https://github.com/leanprover/lean4/pull/5463) upstream some monad lemmas
-  * [#5464](https://github.com/leanprover/lean4/pull/5464) adjust simp attributes on monad lemmas
-  * [#5522](https://github.com/leanprover/lean4/pull/5522) more monadic simp lemmas
-
-* Simp lemma cleanup
-  * [#5251](https://github.com/leanprover/lean4/pull/5251) remove redundant simp annotations
-  * [#5253](https://github.com/leanprover/lean4/pull/5253) remove Int simp lemmas that can't fire
-  * [#5254](https://github.com/leanprover/lean4/pull/5254) variables appearing on both sides of an iff should be implicit
-  * [#5381](https://github.com/leanprover/lean4/pull/5381) cleaning up redundant simp lemmas
-
-
-### Compiler, runtime, and FFI
-
-* [#4685](https://github.com/leanprover/lean4/pull/4685) fixes a typo in the C `run_new_frontend` signature
-* [#4729](https://github.com/leanprover/lean4/pull/4729) has IR checker suggest using `noncomputable`
-* [#5143](https://github.com/leanprover/lean4/pull/5143) adds a shared library for Lake
-* [#5437](https://github.com/leanprover/lean4/pull/5437) removes (syntactically) duplicate imports (@euprunin)
-* [#5462](https://github.com/leanprover/lean4/pull/5462) updates `src/lake/lakefile.toml` to the adjusted Lake build process
-* [#5541](https://github.com/leanprover/lean4/pull/5541) removes new shared libs before build to better support Windows
-* [#5558](https://github.com/leanprover/lean4/pull/5558) make `lean.h` compile with MSVC (@kant2002)
-* [#5564](https://github.com/leanprover/lean4/pull/5564) removes non-conforming size-0 arrays (@eric-wieser)
-
-
-### Lake
-  * Reservoir build cache. Lake will now attempt to fetch a pre-built copy of the package from Reservoir before building it. This is only enabled for packages in the leanprover or leanprover-community organizations on versions indexed by Reservoir. Users can force Lake to build packages from the source by passing --no-cache on the CLI or by setting the  LAKE_NO_CACHE environment variable to true. [#5486](https://github.com/leanprover/lean4/pull/5486), [#5572](https://github.com/leanprover/lean4/pull/5572), [#5583](https://github.com/leanprover/lean4/pull/5583), [#5600](https://github.com/leanprover/lean4/pull/5600), [#5641](https://github.com/leanprover/lean4/pull/5641), [#5642](https://github.com/leanprover/lean4/pull/5642).
-  * [#5504](https://github.com/leanprover/lean4/pull/5504) lake new and lake init now produce TOML configurations by default.
-  * [#5878](https://github.com/leanprover/lean4/pull/5878) fixes a serious issue where Lake would delete path dependencies when attempting to cleanup a dependency required with an incorrect name.
-
-  * **Breaking changes**
-    * [#5641](https://github.com/leanprover/lean4/pull/5641) A Lake build of target within a package will no longer build a package's dependencies package-level extra target dependencies. At the technical level, a package's extraDep facet no longer transitively builds its dependencies’ extraDep facets (which include their extraDepTargets).
-
-### Documentation fixes
-
-* [#3918](https://github.com/leanprover/lean4/pull/3918) `@[builtin_doc]` attribute (@digama0)
-* [#4305](https://github.com/leanprover/lean4/pull/4305) explains the borrow syntax (@eric-wieser)
-* [#5349](https://github.com/leanprover/lean4/pull/5349) adds documentation for `groupBy.loop` (@vihdzp)
-* [#5473](https://github.com/leanprover/lean4/pull/5473) fixes typo in `BitVec.mul` docstring (@llllvvuu)
-* [#5476](https://github.com/leanprover/lean4/pull/5476) fixes typos in `Lean.MetavarContext`
-* [#5481](https://github.com/leanprover/lean4/pull/5481) removes mention of `Lean.withSeconds` (@alexkeizer)
-* [#5497](https://github.com/leanprover/lean4/pull/5497) updates documentation and tests for `toUIntX` functions (@TomasPuverle)
-* [#5087](https://github.com/leanprover/lean4/pull/5087) mentions that `inferType` does not ensure type correctness
-* Many fixes to spelling across the doc-strings, (@euprunin): [#5425](https://github.com/leanprover/lean4/pull/5425) [#5426](https://github.com/leanprover/lean4/pull/5426) [#5427](https://github.com/leanprover/lean4/pull/5427) [#5430](https://github.com/leanprover/lean4/pull/5430)  [#5431](https://github.com/leanprover/lean4/pull/5431) [#5434](https://github.com/leanprover/lean4/pull/5434) [#5435](https://github.com/leanprover/lean4/pull/5435) [#5436](https://github.com/leanprover/lean4/pull/5436) [#5438](https://github.com/leanprover/lean4/pull/5438) [#5439](https://github.com/leanprover/lean4/pull/5439) [#5440](https://github.com/leanprover/lean4/pull/5440) [#5599](https://github.com/leanprover/lean4/pull/5599)
-
-### Changes to CI
-
-* [#5343](https://github.com/leanprover/lean4/pull/5343) allows addition of `release-ci` label via comment (@thorimur)
-* [#5344](https://github.com/leanprover/lean4/pull/5344) sets check level correctly during workflow (@thorimur)
-* [#5444](https://github.com/leanprover/lean4/pull/5444) Mathlib's `lean-pr-testing-NNNN` branches should use Batteries' `lean-pr-testing-NNNN` branches
-* [#5489](https://github.com/leanprover/lean4/pull/5489) commit `lake-manifest.json` when updating `lean-pr-testing` branches
-* [#5490](https://github.com/leanprover/lean4/pull/5490) use separate secrets for commenting and branching in `pr-release.yml`

releases/v4.14.0.md

@@ -1,282 +0,0 @@
-v4.14.0
-----------
-
-**Full Changelog**: https://github.com/leanprover/lean4/compare/v4.13.0...v4.14.0
-
-### Language features, tactics, and metaprograms
-
-* `structure` and `inductive` commands
-  * [#5517](https://github.com/leanprover/lean4/pull/5517) improves universe level inference for the resulting type of an `inductive` or `structure.` Recall that a `Prop`-valued inductive type is a syntactic subsingleton if it has at most one constructor and all the arguments to the constructor are in `Prop`. Such types have large elimination, so they could be defined in `Type` or `Prop` without any trouble. The way inference has changed is that if a type is a syntactic subsingleton with exactly one constructor, and the constructor has at least one parameter/field, then the `inductive`/`structure` command will prefer creating a `Prop` instead of a `Type`. The upshot is that the `: Prop` in `structure S : Prop` is often no longer needed. (With @arthur-adjedj).
-  * [#5842](https://github.com/leanprover/lean4/pull/5842) and [#5783](https://github.com/leanprover/lean4/pull/5783) implement a feature where the `structure` command can now define recursive inductive types:
-    ```lean
-    structure Tree where
-      n : Nat
-      children : Fin n → Tree
-
-    def Tree.size : Tree → Nat
-      | {n, children} => Id.run do
-        let mut s := 0
-        for h : i in [0 : n] do
-          s := s + (children ⟨i, h.2⟩).size
-        pure s
-    ```
-  * [#5814](https://github.com/leanprover/lean4/pull/5814) fixes a bug where Mathlib's `Type*` elaborator could lead to incorrect universe parameters with the `inductive` command.
-  * [#3152](https://github.com/leanprover/lean4/pull/3152) and [#5844](https://github.com/leanprover/lean4/pull/5844) fix bugs in default value processing for structure instance notation (with @arthur-adjedj).
-  * [#5399](https://github.com/leanprover/lean4/pull/5399) promotes instance synthesis order calculation failure from a soft error to a hard error.
-  * [#5542](https://github.com/leanprover/lean4/pull/5542) deprecates `:=` variants of `inductive` and `structure` (see breaking changes).
-
-* **Application elaboration improvements**
-  * [#5671](https://github.com/leanprover/lean4/pull/5671) makes `@[elab_as_elim]` require at least one discriminant, since otherwise there is no advantage to this alternative elaborator.
-  * [#5528](https://github.com/leanprover/lean4/pull/5528) enables field notation in explicit mode. The syntax `@x.f` elaborates as `@S.f` with `x` supplied to the appropriate parameter.
-  * [#5692](https://github.com/leanprover/lean4/pull/5692) modifies the dot notation resolution algorithm so that it can apply `CoeFun` instances. For example, Mathlib has `Multiset.card : Multiset α →+ Nat`, and now with `m : Multiset α`, the notation `m.card` resolves to `⇑Multiset.card m`.
-  * [#5658](https://github.com/leanprover/lean4/pull/5658) fixes a bug where 'don't know how to synthesize implicit argument' errors might have the incorrect local context when the eta arguments feature is activated.
-  * [#5933](https://github.com/leanprover/lean4/pull/5933) fixes a bug where `..` ellipses in patterns made use of optparams and autoparams.
-  * [#5770](https://github.com/leanprover/lean4/pull/5770) makes dot notation for structures resolve using *all* ancestors. Adds a *resolution order* for generalized field notation. This is the order of namespaces visited during resolution when trying to resolve names. The algorithm to compute a resolution order is the commonly used C3 linearization (used for example by Python), which when successful ensures that immediate parents' namespaces are considered before more distant ancestors' namespaces. By default we use a relaxed version of the algorithm that tolerates inconsistencies, but using `set_option structure.strictResolutionOrder true` makes inconsistent parent orderings into warnings.
-
-* **Recursion and induction principles**
-  * [#5619](https://github.com/leanprover/lean4/pull/5619) fixes functional induction principle generation to avoid over-eta-expanding in the preprocessing step.
-  * [#5766](https://github.com/leanprover/lean4/pull/5766) fixes structural nested recursion so that it is not confused when a nested type appears first.
-  * [#5803](https://github.com/leanprover/lean4/pull/5803) fixes a bug in functional induction principle generation when there are `let` bindings.
-  * [#5904](https://github.com/leanprover/lean4/pull/5904) improves functional induction principle generation to unfold aux definitions more carefully.
-  * [#5850](https://github.com/leanprover/lean4/pull/5850) refactors code for `Predefinition.Structural`.
-
-* **Error messages**
-  * [#5276](https://github.com/leanprover/lean4/pull/5276) fixes a bug in "type mismatch" errors that would structurally assign metavariables during the algorithm to expose differences.
-  * [#5919](https://github.com/leanprover/lean4/pull/5919) makes "type mismatch" errors add type ascriptions to expose differences for numeric literals.
-  * [#5922](https://github.com/leanprover/lean4/pull/5922) makes "type mismatch" errors expose differences in the bodies of functions and pi types.
-  * [#5888](https://github.com/leanprover/lean4/pull/5888) improves the error message for invalid induction alternative names in `match` expressions (@josojo).
-  * [#5719](https://github.com/leanprover/lean4/pull/5719) improves `calc` error messages.
-
-* [#5627](https://github.com/leanprover/lean4/pull/5627) and [#5663](https://github.com/leanprover/lean4/pull/5663) improve the **`#eval` command** and introduce some new features.
-  * Now results can be pretty printed if there is a `ToExpr` instance, which means **hoverable output**. If `ToExpr` fails, it then tries looking for a `Repr` or `ToString` instance like before. Setting `set_option eval.pp false` disables making use of `ToExpr` instances.
-  * There is now **auto-derivation** of `Repr` instances, enabled with the `pp.derive.repr` option (default to **true**). For example:
-    ```lean
-    inductive Baz
-    | a | b
-
-    #eval Baz.a
-    -- Baz.a
-    ```
-    It simply does `deriving instance Repr for Baz` when there's no way to represent `Baz`.
-  * The option `eval.type` controls whether or not to include the type in the output. For now the default is false.
-  * Now expressions such as `#eval do return 2`, where monad is unknown, work. It tries unifying the monad with `CommandElabM`, `TermElabM`, or `IO`.
-  * The classes `Lean.Eval` and `Lean.MetaEval` have been removed. These each used to be responsible for adapting monads and printing results. Now the `MonadEval` class is responsible for adapting monads for evaluation (it is similar to `MonadLift`, but instances are allowed to use default data when initializing state), and representing results is handled through a separate process.
-  * Error messages about failed instance synthesis are now more precise. Once it detects that a `MonadEval` class applies, then the error message will be specific about missing `ToExpr`/`Repr`/`ToString` instances.
-  * Fixes bugs where evaluating `MetaM` and `CoreM` wouldn't collect log messages.
-  * Fixes a bug where `let rec` could not be used in `#eval`.
-
-* `partial` definitions
-  * [#5780](https://github.com/leanprover/lean4/pull/5780) improves the error message when `partial` fails to prove a type is inhabited. Add delta deriving.
-  * [#5821](https://github.com/leanprover/lean4/pull/5821) gives `partial` inhabitation the ability to create local `Inhabited` instances from parameters.
-
-* **New tactic configuration syntax.** The configuration syntax for all core tactics has been given an upgrade. Rather than `simp (config := { contextual := true, maxSteps := 22})`, one can now write `simp +contextual (maxSteps := 22)`. Tactic authors can migrate by switching from `(config)?` to `optConfig` in tactic syntaxes and potentially deleting `mkOptionalNode` in elaborators. [#5883](https://github.com/leanprover/lean4/pull/5883), [#5898](https://github.com/leanprover/lean4/pull/5898),  [#5928](https://github.com/leanprover/lean4/pull/5928), and [#5932](https://github.com/leanprover/lean4/pull/5932). (Tactic authors, see breaking changes.)
-
-* `simp` tactic
-  * [#5632](https://github.com/leanprover/lean4/pull/5632) fixes the simpproc for `Fin` literals to reduce more consistently.
-  * [#5648](https://github.com/leanprover/lean4/pull/5648) fixes a bug in `simpa ... using t` where metavariables in `t` were not properly accounted for, and also improves the type mismatch error.
-  * [#5838](https://github.com/leanprover/lean4/pull/5838) fixes the docstring of `simp!` to actually talk about `simp!`.
-  * [#5870](https://github.com/leanprover/lean4/pull/5870) adds support for `attribute [simp ←]` (note the reverse direction). This adds the reverse of a theorem as a global simp theorem.
-
-* `decide` tactic
-  * [#5665](https://github.com/leanprover/lean4/pull/5665) adds `decide!` tactic for using kernel reduction (warning: this is renamed to `decide +kernel` in a future release).
-
-* `bv_decide` tactic
-  * [#5714](https://github.com/leanprover/lean4/pull/5714) adds inequality regression tests (@alexkeizer).
-  * [#5608](https://github.com/leanprover/lean4/pull/5608) adds `bv_toNat` tag for `toNat_ofInt` (@bollu).
-  * [#5618](https://github.com/leanprover/lean4/pull/5618) adds support for `at` in `ac_nf` and uses it in `bv_normalize` (@tobiasgrosser).
-  * [#5628](https://github.com/leanprover/lean4/pull/5628) adds udiv support.
-  * [#5635](https://github.com/leanprover/lean4/pull/5635) adds auxiliary bitblasters for negation and subtraction.
-  * [#5637](https://github.com/leanprover/lean4/pull/5637) adds more `getLsbD` bitblaster theory.
-  * [#5652](https://github.com/leanprover/lean4/pull/5652) adds umod support.
-  * [#5653](https://github.com/leanprover/lean4/pull/5653) adds performance benchmark for modulo.
-  * [#5655](https://github.com/leanprover/lean4/pull/5655) reduces error on `bv_check` to warning.
-  * [#5670](https://github.com/leanprover/lean4/pull/5670) adds `~~~(-x)` support.
-  * [#5673](https://github.com/leanprover/lean4/pull/5673) disables `ac_nf` by default.
-  * [#5675](https://github.com/leanprover/lean4/pull/5675) fixes context tracking in `bv_decide` counter example.
-  * [#5676](https://github.com/leanprover/lean4/pull/5676) adds an error when the LRAT proof is invalid.
-  * [#5781](https://github.com/leanprover/lean4/pull/5781) introduces uninterpreted symbols everywhere.
-  * [#5823](https://github.com/leanprover/lean4/pull/5823) adds `BitVec.sdiv` support.
-  * [#5852](https://github.com/leanprover/lean4/pull/5852) adds `BitVec.ofBool` support.
-  * [#5855](https://github.com/leanprover/lean4/pull/5855) adds `if` support.
-  * [#5869](https://github.com/leanprover/lean4/pull/5869) adds support for all the SMTLIB BitVec divison/remainder operations.
-  * [#5886](https://github.com/leanprover/lean4/pull/5886) adds embedded constraint substitution.
-  * [#5918](https://github.com/leanprover/lean4/pull/5918) fixes loose mvars bug in `bv_normalize`.
-  * Documentation:
-    * [#5636](https://github.com/leanprover/lean4/pull/5636) adds remarks about multiplication.
-
-* `conv` mode
-  * [#5861](https://github.com/leanprover/lean4/pull/5861) improves the `congr` conv tactic to handle "over-applied" functions.
-  * [#5894](https://github.com/leanprover/lean4/pull/5894) improves the `arg` conv tactic so that it can access more arguments and so that it can handle "over-applied" functions (it generates a specialized congruence lemma for the specific argument in question). Makes `arg 1` and `arg 2` apply to pi types in more situations. Adds negative indexing, for example `arg -2` is equivalent to the `lhs` tactic. Makes the `enter [...]` tactic show intermediate states like `rw`.
-
-* **Other tactics**
-  * [#4846](https://github.com/leanprover/lean4/pull/4846) fixes a bug where `generalize ... at *` would apply to implementation details (@ymherklotz).
-  * [#5730](https://github.com/leanprover/lean4/pull/5730) upstreams the `classical` tactic combinator.
-  * [#5815](https://github.com/leanprover/lean4/pull/5815) improves the error message when trying to unfold a local hypothesis that is not a local definition.
-  * [#5862](https://github.com/leanprover/lean4/pull/5862) and [#5863](https://github.com/leanprover/lean4/pull/5863) change how `apply` and `simp` elaborate, making them not disable error recovery. This improves hovers and completions when the term has elaboration errors.
-
-* `deriving` clauses
-  * [#5899](https://github.com/leanprover/lean4/pull/5899) adds declaration ranges for delta-derived instances.
-  * [#5265](https://github.com/leanprover/lean4/pull/5265) removes unused syntax in `deriving` clauses for providing arguments to deriving handlers (see breaking changes).
-
-* [#5065](https://github.com/leanprover/lean4/pull/5065) upstreams and updates `#where`, a command that reports the current scope information.
-
-* **Linters**
-  * [#5338](https://github.com/leanprover/lean4/pull/5338) makes the unused variables linter ignore variables defined in tactics by default now, avoiding performance bottlenecks.
-  * [#5644](https://github.com/leanprover/lean4/pull/5644) ensures that linters in general do not run on `#guard_msgs` itself.
-
-* **Metaprogramming interface**
-  * [#5720](https://github.com/leanprover/lean4/pull/5720) adds `pushGoal`/`pushGoals` and `popGoal` for manipulating the goal state. These are an alternative to `replaceMainGoal` and `getMainGoal`, and with them you don't need to worry about making sure nothing clears assigned metavariables from the goal list between assigning the main goal and using `replaceMainGoal`. Modifies `closeMainGoalUsing`, which is like a `TacticM` version of `liftMetaTactic`. Now the callback is run in a context where the main goal is removed from the goal list, and the callback is free to modify the goal list. Furthermore, the `checkUnassigned` argument has been replaced with `checkNewUnassigned`, which checks whether the value assigned to the goal has any *new* metavariables, relative to the start of execution of the callback. Modifies `withCollectingNewGoalsFrom` to take the `parentTag` argument explicitly rather than indirectly via `getMainTag`. Modifies `elabTermWithHoles` to optionally take `parentTag?`.
-  * [#5563](https://github.com/leanprover/lean4/pull/5563) fixes `getFunInfo` and `inferType` to use `withAtLeastTransparency` rather than `withTransparency`.
-  * [#5679](https://github.com/leanprover/lean4/pull/5679) fixes `RecursorVal.getInduct` to return the name of major argument’s type. This makes "structure eta" work for nested inductives.
-  * [#5681](https://github.com/leanprover/lean4/pull/5681) removes unused `mkRecursorInfoForKernelRec`.
-  * [#5686](https://github.com/leanprover/lean4/pull/5686) makes discrimination trees index the domains of foralls, for better performance of the simplify and type class search.
-  * [#5760](https://github.com/leanprover/lean4/pull/5760) adds `Lean.Expr.name?` recognizer for `Name` expressions.
-  * [#5800](https://github.com/leanprover/lean4/pull/5800) modifies `liftCommandElabM` to preserve more state, fixing an issue where using it would drop messages.
-  * [#5857](https://github.com/leanprover/lean4/pull/5857) makes it possible to use dot notation in `m!` strings, for example `m!"{.ofConstName n}"`.
-  * [#5841](https://github.com/leanprover/lean4/pull/5841) and [#5853](https://github.com/leanprover/lean4/pull/5853) record the complete list of `structure` parents in the `StructureInfo` environment extension.
-
-* **Other fixes or improvements**
-  * [#5566](https://github.com/leanprover/lean4/pull/5566) fixes a bug introduced in [#4781](https://github.com/leanprover/lean4/pull/4781) where heartbeat exceptions were no longer being handled properly. Now such exceptions are tagged with `runtime.maxHeartbeats` (@eric-wieser).
-  * [#5708](https://github.com/leanprover/lean4/pull/5708) modifies the proof objects produced by the proof-by-reflection tactics `ac_nf0` and `simp_arith` so that the kernel is less prone to reducing expensive atoms.
-  * [#5768](https://github.com/leanprover/lean4/pull/5768) adds a `#version` command that prints Lean's version information.
-  * [#5822](https://github.com/leanprover/lean4/pull/5822) fixes elaborator algorithms to match kernel algorithms for primitive projections (`Expr.proj`).
-  * [#5811](https://github.com/leanprover/lean4/pull/5811) improves the docstring for the `rwa` tactic.
-
-
-### Language server, widgets, and IDE extensions
-
-* [#5224](https://github.com/leanprover/lean4/pull/5224) fixes `WorkspaceClientCapabilities` to make `applyEdit` optional, in accordance with the LSP specification (@pzread).
-* [#5340](https://github.com/leanprover/lean4/pull/5340) fixes a server deadlock when shutting down the language server and a desync between client and language server after a file worker crash.
-* [#5560](https://github.com/leanprover/lean4/pull/5560) makes `initialize` and `builtin_initialize` participate in the call hierarchy and other requests.
-* [#5650](https://github.com/leanprover/lean4/pull/5650) makes references in attributes participate in the call hierarchy and other requests.
-* [#5666](https://github.com/leanprover/lean4/pull/5666) add auto-completion in tactic blocks without having to type the first character of the tactic, and adds tactic completion docs to tactic auto-completion items.
-* [#5677](https://github.com/leanprover/lean4/pull/5677) fixes several cases where goal states were not displayed in certain text cursor positions.
-* [#5707](https://github.com/leanprover/lean4/pull/5707) indicates deprecations in auto-completion items.
-* [#5736](https://github.com/leanprover/lean4/pull/5736), [#5752](https://github.com/leanprover/lean4/pull/5752), [#5763](https://github.com/leanprover/lean4/pull/5763), [#5802](https://github.com/leanprover/lean4/pull/5802), and [#5805](https://github.com/leanprover/lean4/pull/5805) fix various performance issues in the language server.
-* [#5801](https://github.com/leanprover/lean4/pull/5801) distinguishes theorem auto-completions from non-theorem auto-completions.
-
-### Pretty printing
-
-* [#5640](https://github.com/leanprover/lean4/pull/5640) fixes a bug where goal states in messages might print newlines as spaces.
-* [#5643](https://github.com/leanprover/lean4/pull/5643) adds option `pp.mvars.delayed` (default false), which when false causes delayed assignment metavariables to pretty print with what they are assigned to. Now `fun x : Nat => ?a` pretty prints as `fun x : Nat => ?a` rather than `fun x ↦ ?m.7 x`.
-* [#5711](https://github.com/leanprover/lean4/pull/5711) adds options `pp.mvars.anonymous` and `pp.mvars.levels`, which when false respectively cause expression metavariables and level metavariables to pretty print as `?_`.
-* [#5710](https://github.com/leanprover/lean4/pull/5710) adjusts the `⋯` elaboration warning to mention `pp.maxSteps`.
-
-* [#5759](https://github.com/leanprover/lean4/pull/5759) fixes the app unexpander for `sorryAx`.
-* [#5827](https://github.com/leanprover/lean4/pull/5827) improves accuracy of binder names in the signature pretty printer (like in output of `#check`). Also fixes the issue where consecutive hygienic names pretty print without a space separating them, so we now have `(x✝ y✝ : Nat)` rather than `(x✝y✝ : Nat)`.
-* [#5830](https://github.com/leanprover/lean4/pull/5830) makes sure all the core delaborators respond to `pp.explicit` when appropriate.
-* [#5639](https://github.com/leanprover/lean4/pull/5639) makes sure name literals use escaping when pretty printing.
-* [#5854](https://github.com/leanprover/lean4/pull/5854) adds delaborators for `<|>`, `<*>`, `>>`, `<*`, and `*>`.
-
-### Library
-
-* `Array`
-  * [#5687](https://github.com/leanprover/lean4/pull/5687) deprecates `Array.data`.
-  * [#5705](https://github.com/leanprover/lean4/pull/5705) uses a better default value for `Array.swapAt!`.
-  * [#5748](https://github.com/leanprover/lean4/pull/5748) moves `Array.mapIdx` lemmas to a new file.
-  * [#5749](https://github.com/leanprover/lean4/pull/5749) simplifies signature of `Array.mapIdx`.
-  * [#5758](https://github.com/leanprover/lean4/pull/5758) upstreams `Array.reduceOption`.
-  * [#5786](https://github.com/leanprover/lean4/pull/5786) adds simp lemmas for `Array.isEqv` and `BEq`.
-  * [#5796](https://github.com/leanprover/lean4/pull/5796) renames `Array.shrink` to `Array.take`, and relates it to `List.take`.
-  * [#5798](https://github.com/leanprover/lean4/pull/5798) upstreams `List.modify`, adds lemmas, relates to `Array.modify`.
-  * [#5799](https://github.com/leanprover/lean4/pull/5799) relates `Array.forIn` and `List.forIn`.
-  * [#5833](https://github.com/leanprover/lean4/pull/5833) adds `Array.forIn'`, and relates to `List`.
-  * [#5848](https://github.com/leanprover/lean4/pull/5848) fixes deprecations in `Init.Data.Array.Basic` to not recommend the deprecated constant.
-  * [#5895](https://github.com/leanprover/lean4/pull/5895) adds `LawfulBEq (Array α) ↔ LawfulBEq α`.
-  * [#5896](https://github.com/leanprover/lean4/pull/5896) moves `@[simp]` from `back_eq_back?` to `back_push`.
-  * [#5897](https://github.com/leanprover/lean4/pull/5897) renames `Array.back` to `back!`.
-
-* `List`
-  * [#5605](https://github.com/leanprover/lean4/pull/5605) removes `List.redLength`.
-  * [#5696](https://github.com/leanprover/lean4/pull/5696) upstreams `List.mapIdx` and adds lemmas.
-  * [#5697](https://github.com/leanprover/lean4/pull/5697) upstreams `List.foldxM_map`.
-  * [#5701](https://github.com/leanprover/lean4/pull/5701) renames `List.join` to `List.flatten`.
-  * [#5703](https://github.com/leanprover/lean4/pull/5703) upstreams `List.sum`.
-  * [#5706](https://github.com/leanprover/lean4/pull/5706) marks `prefix_append_right_inj` as a simp lemma.
-  * [#5716](https://github.com/leanprover/lean4/pull/5716) fixes `List.drop_drop` addition order.
-  * [#5731](https://github.com/leanprover/lean4/pull/5731) renames `List.bind` and `Array.concatMap` to `flatMap`.
-  * [#5732](https://github.com/leanprover/lean4/pull/5732) renames `List.pure` to `List.singleton`.
-  * [#5742](https://github.com/leanprover/lean4/pull/5742) upstreams `ne_of_mem_of_not_mem`.
-  * [#5743](https://github.com/leanprover/lean4/pull/5743) upstreams `ne_of_apply_ne`.
-  * [#5816](https://github.com/leanprover/lean4/pull/5816) adds more `List.modify` lemmas.
-  * [#5879](https://github.com/leanprover/lean4/pull/5879) renames `List.groupBy` to `splitBy`.
-  * [#5913](https://github.com/leanprover/lean4/pull/5913) relates `for` loops over `List` with `foldlM`.
-
-* `Nat`
-  * [#5694](https://github.com/leanprover/lean4/pull/5694) removes `instBEqNat`, which is redundant with `instBEqOfDecidableEq` but not defeq.
-  * [#5746](https://github.com/leanprover/lean4/pull/5746) deprecates `Nat.sum`.
-  * [#5785](https://github.com/leanprover/lean4/pull/5785) adds `Nat.forall_lt_succ` and variants.
-
-* Fixed width integers
-  * [#5323](https://github.com/leanprover/lean4/pull/5323) redefine unsigned fixed width integers in terms of `BitVec`.
-  * [#5735](https://github.com/leanprover/lean4/pull/5735) adds `UIntX.[val_ofNat, toBitVec_ofNat]`.
-  * [#5790](https://github.com/leanprover/lean4/pull/5790) defines `Int8`.
-  * [#5901](https://github.com/leanprover/lean4/pull/5901) removes native code for `UInt8.modn`.
-
-* `BitVec`
-  * [#5604](https://github.com/leanprover/lean4/pull/5604) completes `BitVec.[getMsbD|getLsbD|msb]` for shifts (@luisacicolini).
-  * [#5609](https://github.com/leanprover/lean4/pull/5609) adds lemmas for division when denominator is zero (@bollu).
-  * [#5620](https://github.com/leanprover/lean4/pull/5620) documents Bitblasting (@bollu)
-  * [#5623](https://github.com/leanprover/lean4/pull/5623) moves `BitVec.udiv/umod/sdiv/smod` after `add/sub/mul/lt` (@tobiasgrosser).
-  * [#5645](https://github.com/leanprover/lean4/pull/5645) defines `udiv` normal form to be `/`, resp. `umod` and `%` (@bollu).
-  * [#5646](https://github.com/leanprover/lean4/pull/5646) adds lemmas about arithmetic inequalities (@bollu).
-  * [#5680](https://github.com/leanprover/lean4/pull/5680) expands relationship with `toFin` (@tobiasgrosser).
-  * [#5691](https://github.com/leanprover/lean4/pull/5691) adds `BitVec.(getMSbD, msb)_(add, sub)` and `BitVec.getLsbD_sub` (@luisacicolini).
-  * [#5712](https://github.com/leanprover/lean4/pull/5712) adds `BitVec.[udiv|umod]_[zero|one|self]` (@tobiasgrosser).
-  * [#5718](https://github.com/leanprover/lean4/pull/5718) adds `BitVec.sdiv_[zero|one|self]` (@tobiasgrosser).
-  * [#5721](https://github.com/leanprover/lean4/pull/5721) adds `BitVec.(msb, getMsbD, getLsbD)_(neg, abs)` (@luisacicolini).
-  * [#5772](https://github.com/leanprover/lean4/pull/5772) adds `BitVec.toInt_sub`, simplifies `BitVec.toInt_neg` (@tobiasgrosser).
-  * [#5778](https://github.com/leanprover/lean4/pull/5778) prove that `intMin` the smallest signed bitvector (@alexkeizer).
-  * [#5851](https://github.com/leanprover/lean4/pull/5851) adds `(msb, getMsbD)_twoPow` (@luisacicolini).
-  * [#5858](https://github.com/leanprover/lean4/pull/5858) adds `BitVec.[zero_ushiftRight|zero_sshiftRight|zero_mul]` and cleans up BVDecide (@tobiasgrosser).
-  * [#5865](https://github.com/leanprover/lean4/pull/5865) adds `BitVec.(msb, getMsbD)_concat` (@luisacicolini).
-  * [#5881](https://github.com/leanprover/lean4/pull/5881) adds `Hashable (BitVec n)`
-
-* `String`/`Char`
-  * [#5728](https://github.com/leanprover/lean4/pull/5728) upstreams `String.dropPrefix?`.
-  * [#5745](https://github.com/leanprover/lean4/pull/5745) changes `String.dropPrefix?` signature.
-  * [#5747](https://github.com/leanprover/lean4/pull/5747) adds `Hashable Char` instance
-
-* `HashMap`
-  * [#5880](https://github.com/leanprover/lean4/pull/5880) adds interim implementation of `HashMap.modify`/`alter`
-
-* **Other**
-  * [#5704](https://github.com/leanprover/lean4/pull/5704) removes `@[simp]` from `Option.isSome_eq_isSome`.
-  * [#5739](https://github.com/leanprover/lean4/pull/5739) upstreams material on `Prod`.
-  * [#5740](https://github.com/leanprover/lean4/pull/5740) moves `Antisymm` to `Std.Antisymm`.
-  * [#5741](https://github.com/leanprover/lean4/pull/5741) upstreams basic material on `Sum`.
-  * [#5756](https://github.com/leanprover/lean4/pull/5756) adds `Nat.log2_two_pow` (@spinylobster).
-  * [#5892](https://github.com/leanprover/lean4/pull/5892) removes duplicated `ForIn` instances.
-  * [#5900](https://github.com/leanprover/lean4/pull/5900) removes `@[simp]` from `Sum.forall` and `Sum.exists`.
-  * [#5812](https://github.com/leanprover/lean4/pull/5812) removes redundant `Decidable` assumptions (@FR-vdash-bot).
-
-### Compiler, runtime, and FFI
-
-* [#5685](https://github.com/leanprover/lean4/pull/5685) fixes help message flags, removes the `-f` flag and adds the `-g` flag (@James-Oswald).
-* [#5930](https://github.com/leanprover/lean4/pull/5930) adds `--short-version` (`-V`) option to display short version (@juhp).
-* [#5144](https://github.com/leanprover/lean4/pull/5144) switches all 64-bit platforms over to consistently using GMP for bignum arithmetic.
-* [#5753](https://github.com/leanprover/lean4/pull/5753) raises the minimum supported Windows version to Windows 10 1903 (released May 2019).
-
-### Lake
-
-* [#5715](https://github.com/leanprover/lean4/pull/5715) changes `lake new math` to use `autoImplicit false` (@eric-wieser).
-* [#5688](https://github.com/leanprover/lean4/pull/5688) makes `Lake` not create core aliases in the `Lake` namespace.
-* [#5924](https://github.com/leanprover/lean4/pull/5924) adds a `text` option for `buildFile*` utilities.
-* [#5789](https://github.com/leanprover/lean4/pull/5789) makes `lake init` not `git init` when inside git work tree (@haoxins).
-* [#5684](https://github.com/leanprover/lean4/pull/5684) has Lake update a package's `lean-toolchain` file on `lake update` if it finds the package's direct dependencies use a newer compatible toolchain. To skip this step, use the `--keep-toolchain` CLI option. (See breaking changes.)
-* [#6218](https://github.com/leanprover/lean4/pull/6218) makes Lake no longer automatically fetch GitHub cloud releases if the package build directory is already present (mirroring the behavior of the Reservoir cache). This prevents the cache from clobbering existing prebuilt artifacts. Users can still manually fetch the cache and clobber the build directory by running `lake build <pkg>:release`.
-* [#6231](https://github.com/leanprover/lean4/pull/6231) improves the errors Lake produces when it fails to fetch a dependency from Reservoir. If the package is not indexed, it will produce a suggestion about how to require it from GitHub.
-
-### Documentation
-
-* [#5617](https://github.com/leanprover/lean4/pull/5617) fixes MSYS2 build instructions.
-* [#5725](https://github.com/leanprover/lean4/pull/5725) points out that `OfScientific` is called with raw literals (@eric-wieser).
-* [#5794](https://github.com/leanprover/lean4/pull/5794) adds a stub for application ellipsis notation (@eric-wieser).
-
-### Breaking changes
-
-* The syntax for providing arguments to deriving handlers has been removed, which was not used by any major Lean projects in the ecosystem. As a result, the  `applyDerivingHandlers` now takes one fewer argument, `registerDerivingHandlerWithArgs` is now simply `registerDerivingHandler`, `DerivingHandler` no longer includes the unused parameter, and `DerivingHandlerNoArgs` has been deprecated. To migrate code, delete the unused `none` argument and use `registerDerivingHandler` and `DerivingHandler`. ([#5265](https://github.com/leanprover/lean4/pull/5265))
-* The minimum supported Windows version has been raised to Windows 10 1903, released May 2019. ([#5753](https://github.com/leanprover/lean4/pull/5753))
-* The `--lean` CLI option for `lake` was removed. Use the `LEAN` environment variable instead. ([#5684](https://github.com/leanprover/lean4/pull/5684))
-* The `inductive ... :=`, `structure ... :=`, and `class ... :=` syntaxes have been deprecated in favor of the `... where` variants. The old syntax produces a warning, controlled by the `linter.deprecated` option. ([#5542](https://github.com/leanprover/lean4/pull/5542))
-* The generated tactic configuration elaborators now land in `TacticM` to make use of the current recovery state. Commands that wish to elaborate configurations should now use `declare_command_config_elab` instead of `declare_config_elab` to get an elaborator landing in `CommandElabM`. Syntaxes should migrate to `optConfig` instead of `(config)?`, but the elaborators are reverse compatible. ([#5883](https://github.com/leanprover/lean4/pull/5883))

releases/v4.15.0.md

@@ -1,645 +0,0 @@
-v4.15.0
-----------
-
-## Language
-
-- [#4595](https://github.com/leanprover/lean4/pull/4595) implements `Simp.Config.implicitDefEqsProofs`. When `true`
-(default: `true`), `simp` will **not** create a proof term for a
-rewriting rule associated with an `rfl`-theorem. Rewriting rules are
-provided by users by annotating theorems with the attribute `@[simp]`.
-If the proof of the theorem is just `rfl` (reflexivity), and
-`implicitDefEqProofs := true`, `simp` will **not** create a proof term
-which is an application of the annotated theorem.
-
-- [#5429](https://github.com/leanprover/lean4/pull/5429) avoid negative environment lookup
-
-- [#5501](https://github.com/leanprover/lean4/pull/5501) ensure `instantiateMVarsProfiling` adds a trace node
-
-- [#5856](https://github.com/leanprover/lean4/pull/5856) adds a feature to the the mutual def elaborator where the
-`instance` command yields theorems instead of definitions when the class
-is a `Prop`.
-
-- [#5907](https://github.com/leanprover/lean4/pull/5907) unset trailing for `simpa?` "try this" suggestion
-
-- [#5920](https://github.com/leanprover/lean4/pull/5920) changes the rule for which projections become instances. Before,
-all parents along with all indirect ancestors that were represented as
-subobject fields would have their projections become instances. Now only
-projections for direct parents become instances.
-
-- [#5934](https://github.com/leanprover/lean4/pull/5934) make `all_goals` admit goals on failure
-
-- [#5942](https://github.com/leanprover/lean4/pull/5942) introduce synthetic atoms in bv_decide
-
-- [#5945](https://github.com/leanprover/lean4/pull/5945) adds a new definition `Message.kind` which returns the top-level
-tag of a message. This is serialized as the new field `kind` in
-`SerialMessaege` so that i can be used by external consumers (e.g.,
-Lake) to identify messages via `lean --json`.
-
-- [#5968](https://github.com/leanprover/lean4/pull/5968) `arg` conv tactic misreported number of arguments on error
-
-- [#5979](https://github.com/leanprover/lean4/pull/5979) BitVec.twoPow in bv_decide
-
-- [#5991](https://github.com/leanprover/lean4/pull/5991) simplifies the implementation of `omega`.
-
-- [#5992](https://github.com/leanprover/lean4/pull/5992) fix style in bv_decide normalizer
-
-- [#5999](https://github.com/leanprover/lean4/pull/5999) adds configuration options for
-`decide`/`decide!`/`native_decide` and refactors the tactics to be
-frontends to the same backend. Adds a `+revert` option that cleans up
-the local context and reverts all local variables the goal depends on,
-along with indirect propositional hypotheses. Makes `native_decide` fail
-at elaboration time on failure without sacrificing performance (the
-decision procedure is still evaluated just once). Now `native_decide`
-supports universe polymorphism.
-
-- [#6010](https://github.com/leanprover/lean4/pull/6010) changes `bv_decide`'s configuration from lots of `set_option` to
-an elaborated config like `simp` or `omega`. The notable exception is
-`sat.solver` which is still a `set_option` such that users can configure
-a custom SAT solver globally for an entire project or file. Additionally
-it introduces the ability to set `maxSteps` for the simp preprocessing
-run through the new config.
-
-- [#6012](https://github.com/leanprover/lean4/pull/6012) improves the validation of new syntactic tokens. Previously, the
-validation code had inconsistencies: some atoms would be accepted only
-if they had a leading space as a pretty printer hint. Additionally,
-atoms with internal whitespace are no longer allowed.
-
-- [#6016](https://github.com/leanprover/lean4/pull/6016) removes the `decide!` tactic in favor of `decide +kernel`
-(breaking change).
-
-- [#6019](https://github.com/leanprover/lean4/pull/6019) removes @[specilize] from `MkBinding.mkBinding`, which is a
-function that cannot be specialized (as none of its arguments are
-functions). As a result, the specializable function `Nat.foldRevM.loop`
-doesn't get specialized, which leads to worse performing code.
-
-- [#6022](https://github.com/leanprover/lean4/pull/6022) makes the `change` tactic and conv tactic use the same
-elaboration strategy. It works uniformly for both the target and local
-hypotheses. Now `change` can assign metavariables, for example:
-```lean
-example (x y z : Nat) : x + y = z := by
-  change ?a = _
-  let w := ?a
-  -- now `w : Nat := x + y`
-```
-
-- [#6024](https://github.com/leanprover/lean4/pull/6024) fixes a bug where the monad lift coercion elaborator would
-partially unify expressions even if they were not monads. This could be
-taken advantage of to propagate information that could help elaboration
-make progress, for example the first `change` worked because the monad
-lift coercion elaborator was unifying `@Eq _ _` with `@Eq (Nat × Nat)
-p`:
-```lean
-example (p : Nat × Nat) : p = p := by
-  change _ = ⟨_, _⟩ -- used to work (yielding `p = (p.fst, p.snd)`), now it doesn't
-  change ⟨_, _⟩ = _ -- never worked
-```
-As such, this is a breaking change; you may need to adjust expressions
-to include additional implicit arguments.
-
-- [#6029](https://github.com/leanprover/lean4/pull/6029) adds a normalization rule to `bv_normalize` (which is used by
-`bv_decide`) that converts `x / 2^k` into `x >>> k` under suitable
-conditions. This allows us to simplify the expensive division circuits
-that are used for bitblasting into much cheaper shifting circuits.
-Concretely, it allows for the following canonicalization:
-
-- [#6030](https://github.com/leanprover/lean4/pull/6030) fixes `simp only [· ∈ ·]` after #5020.
-
-- [#6035](https://github.com/leanprover/lean4/pull/6035) introduces the and flattening pre processing pass from Bitwuzla
-to `bv_decide`. It splits hypotheses of the form `(a && b) = true` into
-`a = true` and `b = true` which has synergy potential with the already
-existing embedded constraint substitution pass.
-
-- [#6037](https://github.com/leanprover/lean4/pull/6037) fixes `bv_decide`'s embedded constraint substitution to generate
-correct counter examples in the corner case where duplicate theorems are
-in the local context.
-
-- [#6045](https://github.com/leanprover/lean4/pull/6045) add `LEAN_ALWAYS_INLINE` to some functions
-
-- [#6048](https://github.com/leanprover/lean4/pull/6048) fixes `simp?` suggesting output with invalid indentation
-
-- [#6051](https://github.com/leanprover/lean4/pull/6051) mark `Meta.Context.config` as private
-
-- [#6053](https://github.com/leanprover/lean4/pull/6053) fixes the caching infrastructure for `whnf` and `isDefEq`,
-ensuring the cache accounts for all relevant configuration flags. It
-also cleans up the `WHNF.lean` module and improves the configuration of
-`whnf`.
-
-- [#6061](https://github.com/leanprover/lean4/pull/6061) adds a simp_arith benchmark.
-
-- [#6062](https://github.com/leanprover/lean4/pull/6062) optimize Nat.Linear.Expr.toPoly
-
-- [#6064](https://github.com/leanprover/lean4/pull/6064) optimize Nat.Linear.Poly.norm
-
-- [#6068](https://github.com/leanprover/lean4/pull/6068) improves the asymptotic performance of `simp_arith` when there are many variables to consider.
-
-- [#6077](https://github.com/leanprover/lean4/pull/6077) adds options to `bv_decide`'s configuration structure such that
-all non mandatory preprocessing passes can be disabled.
-
-- [#6082](https://github.com/leanprover/lean4/pull/6082) changes how the canonicalizer handles `forall` and `lambda`,
-replacing bvars with temporary fvars. Fixes a bug reported by @hrmacbeth
-on
-[zulip](https://leanprover.zulipchat.com/#narrow/channel/270676-lean4/topic/Quantifiers.20in.20CanonM/near/482483448).
-
-- [#6093](https://github.com/leanprover/lean4/pull/6093) use mkFreshUserName in ArgsPacker
-
-- [#6096](https://github.com/leanprover/lean4/pull/6096) improves the `#print` command for structures to show all fields
-and which parents the fields were inherited from, hiding internal
-details such as which parents are represented as subobjects. This
-information is still present in the constructor if needed. The pretty
-printer for private constants is also improved, and it now handles
-private names from the current module like any other name; private names
-from other modules are made hygienic.
-
-- [#6098](https://github.com/leanprover/lean4/pull/6098) modifies `Lean.MVarId.replaceTargetDefEq` and
-`Lean.MVarId.replaceLocalDeclDefEq` to use `Expr.equal` instead of
-`Expr.eqv` when determining whether the expression has changed. This is
-justified on the grounds that binder names and binder infos are
-user-visible and affect elaboration.
-
-- [#6105](https://github.com/leanprover/lean4/pull/6105) fixes a stack overflow caused by a cyclic assignment in the
-metavariable context. The cycle is unintentionally introduced by the
-structure instance elaborator.
-
-- [#6108](https://github.com/leanprover/lean4/pull/6108) turn off pp.mvars in apply? results
-
-- [#6109](https://github.com/leanprover/lean4/pull/6109) fixes an issue in the `injection` tactic. This tactic may
-execute multiple sub-tactics. If any of them fail, we must backtrack the
-partial assignment. This issue was causing the error: "`mvarId` is
-already assigned" in issue #6066. The issue is not yet resolved, as the
-equation generator for the match expressions is failing in the example
-provided in this issue.
-
-- [#6112](https://github.com/leanprover/lean4/pull/6112) makes stricter requirements for the `@[deprecated]` attribute,
-requiring either a replacement identifier as `@[deprecated bar]` or
-suggestion text `@[deprecated "Past its use by date"]`, and also
-requires a `since := "..."` field.
-
-- [#6114](https://github.com/leanprover/lean4/pull/6114) liberalizes atom rules by allowing `''` to be a prefix of an
-atom, after #6012 only added an exception for `''` alone, and also adds
-some unit tests for atom validation.
-
-- [#6116](https://github.com/leanprover/lean4/pull/6116) fixes a bug where structural recursion did not work when indices
-of the recursive argument appeared as function parameters in a different
-order than in the argument's type's definition.
-
-- [#6125](https://github.com/leanprover/lean4/pull/6125) adds support for `structure` in `mutual` blocks, allowing
-inductive types defined by `inductive` and `structure` to be mutually
-recursive. The limitations are (1) that the parents in the `extends`
-clause must be defined before the `mutual` block and (2) mutually
-recursive classes are not allowed (a limitation shared by `class
-inductive`). There are also improvements to universe level inference for
-inductive types and structures. Breaking change: structure parents now
-elaborate with the structure in scope (fix: use qualified names or
-rename the structure to avoid shadowing), and structure parents no
-longer elaborate with autoimplicits enabled.
-
-- [#6128](https://github.com/leanprover/lean4/pull/6128) does the same fix as #6104, but such that it doesn't break the
-test/the file in `Plausible`. This is done by not creating unused let
-binders in metavariable types that are made by `elimMVar`. (This is also
-a positive thing for users looking at metavariable types, for example in
-error messages)
-
-- [#6129](https://github.com/leanprover/lean4/pull/6129) fixes a bug at `isDefEq` when `zetaDelta := false`. See new test
-for a small example that exposes the issue.
-
-- [#6131](https://github.com/leanprover/lean4/pull/6131) fixes a bug at the definitional equality test (`isDefEq`). At
-unification constraints of the form `c.{u} =?= c.{v}`, it was not trying
-to unfold `c`. This bug did not affect the kernel.
-
-- [#6141](https://github.com/leanprover/lean4/pull/6141) make use of recursive structures in snapshot types
-
-- [#6145](https://github.com/leanprover/lean4/pull/6145) fixes the `revert` tactic so that it creates a `syntheticOpaque`
-metavariable as the new goal, instead of a `natural` metavariable
-
-- [#6146](https://github.com/leanprover/lean4/pull/6146) fixes a non-termination bug that occurred when generating the
-match-expression splitter theorem. The bug was triggered when the proof
-automation for the splitter theorem repeatedly applied `injection` to
-the same local declaration, as it could not be removed due to forward
-dependencies. See issue #6065 for an example that reproduces this issue.
-
-- [#6165](https://github.com/leanprover/lean4/pull/6165) modifies structure instance notation and `where` notation to use
-the same notation for fields. Structure instance notation now admits
-binders, type ascriptions, and equations, and `where` notation admits
-full structure lvals. Examples of these for structure instance notation:
-```lean
-structure PosFun where
-  f : Nat → Nat
-  pos : ∀ n, 0 < f n
-```
-
-- [#6168](https://github.com/leanprover/lean4/pull/6168) extends the "motive is not type correct" error message for the
-rewrite tactic to explain what it means. It also pretty prints the
-type-incorrect motive and reports the type error.
-
-- [#6170](https://github.com/leanprover/lean4/pull/6170) adds core metaprogramming functions for forking off background
-tasks from elaboration such that their results are visible to reporting
-and the language server
-
-- [#6175](https://github.com/leanprover/lean4/pull/6175) fixes a bug with the `structure`/`class` command where if there
-are parents that are not represented as subobjects but which used other
-parents as instances, then there would be a kernel error. Closes #2611.
-
-- [#6180](https://github.com/leanprover/lean4/pull/6180) fixes a non-termination bug that occurred when generating the
-match-expression equation theorems. The bug was triggered when the proof
-automation for the equation theorem repeatedly applied `injection(` to
-the same local declaration, as it could not be removed due to forward
-dependencies. See issue #6067 for an example that reproduces this issue.
-
-- [#6189](https://github.com/leanprover/lean4/pull/6189) changes how generalized field notation ("dot notation") resolves
-the function. The new resolution rule is that if `x : S`, then `x.f`
-resolves the name `S.f` relative to the root namespace (hence it now
-affected by `export` and `open`). Breaking change: aliases now resolve
-differently. Before, if `x : S`, and if `S.f` is an alias for `S'.f`,
-then `x.f` would use `S'.f` and look for an argument of type `S'`. Now,
-it looks for an argument of type `S`, which is more generally useful
-behavior. Code making use of the old behavior should consider defining
-`S` or `S'` in terms of the other, since dot notation can unfold
-definitions during resolution.
-
-- [#6206](https://github.com/leanprover/lean4/pull/6206) makes it possible to write `rw (occs := [1,2]) ...` instead of
-`rw (occs := .pos [1,2]) ...` by adding a coercion from `List.Nat` to
-`Lean.Meta.Occurrences`.
-
-- [#6220](https://github.com/leanprover/lean4/pull/6220) adds proper support for `let_fun` in `simp`.
-
-- [#6236](https://github.com/leanprover/lean4/pull/6236) fixes an issue where edits to a command containing a nested
-docstring fail to reparse the entire command.
-
-## Library
-
-- [#4904](https://github.com/leanprover/lean4/pull/4904) introduces date and time functionality to the Lean 4 Std.
-
-- [#5616](https://github.com/leanprover/lean4/pull/5616) is a follow-up to https://github.com/leanprover/lean4/pull/5609,
-where we add lemmas characterizing `smtUDiv` and `smtSDiv`'s behavior
-when the denominator is zero.
-
-- [#5866](https://github.com/leanprover/lean4/pull/5866) verifies the `keys` function on `Std.HashMap`.
-
-- [#5885](https://github.com/leanprover/lean4/pull/5885) add Int16/Int32/Int64
-
-- [#5926](https://github.com/leanprover/lean4/pull/5926) add `Option.or_some'`
-
-- [#5927](https://github.com/leanprover/lean4/pull/5927) `List.pmap_eq_self`
-
-- [#5937](https://github.com/leanprover/lean4/pull/5937) upstream lemmas about Fin.foldX
-
-- [#5938](https://github.com/leanprover/lean4/pull/5938) upstream List.ofFn and relate to Array.ofFn
-
-- [#5941](https://github.com/leanprover/lean4/pull/5941) List.mapFinIdx, lemmas, relate to Array version
-
-- [#5949](https://github.com/leanprover/lean4/pull/5949) consolidate `decide_True` and `decide_true_eq_true`
-
-- [#5950](https://github.com/leanprover/lean4/pull/5950) relate Array.takeWhile with List.takeWhile
-
-- [#5951](https://github.com/leanprover/lean4/pull/5951) remove @[simp] from BitVec.ofFin_sub and sub_ofFin
-
-- [#5952](https://github.com/leanprover/lean4/pull/5952) relate Array.eraseIdx with List.eraseIdx
-
-- [#5961](https://github.com/leanprover/lean4/pull/5961) define ISize and basic operations on it
-
-- [#5969](https://github.com/leanprover/lean4/pull/5969) upstream List.insertIdx from Batteries, lemmas from Mathlib, and revise lemmas
-
-- [#5970](https://github.com/leanprover/lean4/pull/5970) deprecate Array.split in favour of identical Array.partition
-
-- [#5971](https://github.com/leanprover/lean4/pull/5971) relate Array.isPrefixOf with List.isPrefixOf
-
-- [#5972](https://github.com/leanprover/lean4/pull/5972) relate Array.zipWith/zip/unzip with List versions
-
-- [#5974](https://github.com/leanprover/lean4/pull/5974) add another List.find?_eq_some lemma
-
-- [#5981](https://github.com/leanprover/lean4/pull/5981) names the default SizeOf instance `instSizeOfDefault`
-
-- [#5982](https://github.com/leanprover/lean4/pull/5982) minor lemmas about List.ofFn
-
-- [#5984](https://github.com/leanprover/lean4/pull/5984) adds lemmas for `List` for the interactions between {`foldl`,
-`foldr`, `foldlM`, `foldlrM`} and {`filter`, `filterMap`}.
-
-- [#5985](https://github.com/leanprover/lean4/pull/5985) relates the operations `findSomeM?`, `findM?`, `findSome?`, and
-`find?` on `Array` with the corresponding operations on `List`, and also
-provides simp lemmas for the `Array` operations `findSomeRevM?`,
-`findRevM?`, `findSomeRev?`, `findRev?` (in terms of `reverse` and the
-usual forward find operations).
-
-- [#5987](https://github.com/leanprover/lean4/pull/5987) BitVec.getMsbD in bv_decide
-
-- [#5988](https://github.com/leanprover/lean4/pull/5988) changes the signature of `Array.set` to take a `Nat`, and a
-tactic-provided bound, rather than a `Fin`.
-
-- [#5995](https://github.com/leanprover/lean4/pull/5995) BitVec.sshiftRight' in bv_decide
-
-- [#6007](https://github.com/leanprover/lean4/pull/6007) List.modifyTailIdx naming fix
-
-- [#6008](https://github.com/leanprover/lean4/pull/6008) missing @[ext] attribute on monad transformer ext lemmas
-
-- [#6023](https://github.com/leanprover/lean4/pull/6023) variants of List.forIn_eq_foldlM
-
-- [#6025](https://github.com/leanprover/lean4/pull/6025) deprecate duplicated Fin.size_pos
-
-- [#6032](https://github.com/leanprover/lean4/pull/6032) changes the signature of `Array.get` to take a Nat and a proof,
-rather than a `Fin`, for consistency with the rest of the (planned)
-Array API. Note that because of bootstrapping issues we can't provide
-`get_elem_tactic` as an autoparameter for the proof. As users will
-mostly use the `xs[i]` notation provided by `GetElem`, this hopefully
-isn't a problem.
-
-- [#6041](https://github.com/leanprover/lean4/pull/6041) modifies the order of arguments for higher-order `Array`
-functions, preferring to put the `Array` last (besides positional
-arguments with defaults). This is more consistent with the `List` API,
-and is more flexible, as dot notation allows two different partially
-applied versions.
-
-- [#6049](https://github.com/leanprover/lean4/pull/6049) adds a primitive for accessing the current thread ID
-
-- [#6052](https://github.com/leanprover/lean4/pull/6052) adds `Array.pmap`, as well as a `@[csimp]` lemma in terms of the
-no-copy `Array.attachWith`.
-
-- [#6055](https://github.com/leanprover/lean4/pull/6055) adds lemmas about for loops over `Array`, following the existing
-lemmas for `List`.
-
-- [#6056](https://github.com/leanprover/lean4/pull/6056) upstream some NameMap functions
-
-- [#6060](https://github.com/leanprover/lean4/pull/6060) implements conversion functions from `Bool` to all `UIntX` and
-`IntX` types.
-
-- [#6070](https://github.com/leanprover/lean4/pull/6070) adds the Lean.RArray data structure.
-
-- [#6074](https://github.com/leanprover/lean4/pull/6074) allow `Sort u` in `Squash`
-
-- [#6094](https://github.com/leanprover/lean4/pull/6094) adds raw transmutation of floating-point numbers to and from
-`UInt64`. Floats and UInts share the same endianness across all
-supported platforms. The IEEE 754 standard precisely specifies the bit
-layout of floats. Note that `Float.toBits` is distinct from
-`Float.toUInt64`, which attempts to preserve the numeric value rather
-than the bitwise value.
-
-- [#6095](https://github.com/leanprover/lean4/pull/6095) generalize `List.get_mem`
-
-- [#6097](https://github.com/leanprover/lean4/pull/6097) naming convention and `NaN` normalization
-
-- [#6102](https://github.com/leanprover/lean4/pull/6102) moves `IO.rand` and `IO.setRandSeed` to be in the `BaseIO`
-monad.
-
-- [#6106](https://github.com/leanprover/lean4/pull/6106) fix naming of left/right injectivity lemmas
-
-- [#6111](https://github.com/leanprover/lean4/pull/6111) fills in the API for `Array.findSome?` and `Array.find?`,
-transferring proofs from the corresponding List statements.
-
-- [#6120](https://github.com/leanprover/lean4/pull/6120) adds theorems `BitVec.(getMsbD, msb)_(rotateLeft, rotateRight)`.
-
-- [#6126](https://github.com/leanprover/lean4/pull/6126) adds lemmas for extracting a given bit of a `BitVec` obtained
-via `sub`/`neg`/`sshiftRight'`/`abs`.
-
-- [#6130](https://github.com/leanprover/lean4/pull/6130) adds `Lean.loadPlugin` which exposes functionality similar to
-the `lean` executable's `--plugin` option to Lean code.
-
-- [#6132](https://github.com/leanprover/lean4/pull/6132) duplicates the verification API for
-`List.attach`/`attachWith`/`pmap` over to `Array`.
-
-- [#6133](https://github.com/leanprover/lean4/pull/6133) replaces `Array.feraseIdx` and `Array.insertAt` with
-`Array.eraseIdx` and `Array.insertIdx`, both of which take a `Nat`
-argument and a tactic-provided proof that it is in bounds. We also have
-`eraseIdxIfInBounds` and `insertIdxIfInBounds` which are noops if the
-index is out of bounds. We also provide a `Fin` valued version of
-`Array.findIdx?`. Together, these quite ergonomically improve the array
-indexing safety at a number of places in the compiler/elaborator.
-
-- [#6136](https://github.com/leanprover/lean4/pull/6136) fixes the run-time evaluation of `(default : Float)`.
-
-- [#6139](https://github.com/leanprover/lean4/pull/6139) modifies the signature of the functions `Nat.fold`,
-`Nat.foldRev`, `Nat.any`, `Nat.all`, so that the function is passed the
-upper bound. This allows us to change runtime array bounds checks to
-compile time checks in many places.
-
-- [#6148](https://github.com/leanprover/lean4/pull/6148) adds a primitive for creating temporary directories, akin to the
-existing functionality for creating temporary files.
-
-- [#6149](https://github.com/leanprover/lean4/pull/6149) completes the elementwise accessors for `ofNatLt`, `allOnes`,
-and `not` by adding their implementations of `getMsbD`.
-
-- [#6151](https://github.com/leanprover/lean4/pull/6151) completes the `toInt` interface for `BitVec` bitwise operations.
-
-- [#6154](https://github.com/leanprover/lean4/pull/6154) implements `BitVec.toInt_abs`.
-
-- [#6155](https://github.com/leanprover/lean4/pull/6155) adds `toNat` theorems for `BitVec.signExtend.`
-
-- [#6157](https://github.com/leanprover/lean4/pull/6157) adds toInt theorems for BitVec.signExtend.
-
-- [#6160](https://github.com/leanprover/lean4/pull/6160) adds theorem `mod_eq_sub`, makes theorem
-`sub_mul_eq_mod_of_lt_of_le` not private anymore and moves its location
-within the `rotate*` section to use it in other proofs.
-
-- [#6184](https://github.com/leanprover/lean4/pull/6184) uses `Array.findFinIdx?` in preference to `Array.findIdx?` where
-it allows converting a runtime bounds check to a compile time bounds
-check.
-
-- [#6188](https://github.com/leanprover/lean4/pull/6188) completes the `toNat` theorems for the bitwise operations
-(`and`, `or`, `xor`, `shiftLeft`, `shiftRight`) of the UInt types and
-adds `toBitVec` theorems as well. It also renames `and_toNat` to
-`toNat_and` to fit with the current naming convention.
-
-- [#6190](https://github.com/leanprover/lean4/pull/6190) adds the builtin simproc `USize.reduceToNat` which reduces the
-`USize.toNat` operation on literals less than `UInt32.size` (i.e.,
-`4294967296`).
-
-- [#6191](https://github.com/leanprover/lean4/pull/6191) adds `Array.zipWithAll`, and the basic lemmas relating it to
-`List.zipWithAll`.
-
-- [#6192](https://github.com/leanprover/lean4/pull/6192) adds deprecations for `Lean.HashMap` functions which did not
-receive deprecation attributes initially.
-
-- [#6193](https://github.com/leanprover/lean4/pull/6193) completes the TODO in `Init.Data.Array.BinSearch`, removing the
-`partial` keyword and converting runtime bounds checks to compile time
-bounds checks.
-
-- [#6194](https://github.com/leanprover/lean4/pull/6194) changes the signature of `Array.swap`, so it takes `Nat`
-arguments with tactic provided bounds checking. It also renames
-`Array.swap!` to `Array.swapIfInBounds`.
-
-- [#6195](https://github.com/leanprover/lean4/pull/6195) renames `Array.setD` to `Array.setIfInBounds`.
-
-- [#6197](https://github.com/leanprover/lean4/pull/6197) upstreams the definition of `Vector` from Batteries, along with
-the basic functions.
-
-- [#6200](https://github.com/leanprover/lean4/pull/6200) upstreams `Nat.lt_pow_self` and `Nat.lt_two_pow` from Mathlib
-and uses them to prove the simp theorem `Nat.mod_two_pow`.
-
-- [#6202](https://github.com/leanprover/lean4/pull/6202) makes `USize.toUInt64` a regular non-opaque definition.
-
-- [#6203](https://github.com/leanprover/lean4/pull/6203) adds the theorems `le_usize_size` and `usize_size_le`, which
-make proving inequalities about `USize.size` easier.
-
-- [#6205](https://github.com/leanprover/lean4/pull/6205) upstreams some UInt theorems from Batteries and adds more
-`toNat`-related theorems. It also adds the missing `UInt8` and `UInt16`
-to/from `USize` conversions so that the the interface is uniform across
-the UInt types.
-
-- [#6207](https://github.com/leanprover/lean4/pull/6207) ensures the `Fin.foldl` and `Fin.foldr` are semireducible.
-Without this the defeq `example (f : Fin 3 → ℕ) : List.ofFn f = [f 0, f
-1, f 2] := rfl` was failing.
-
-- [#6208](https://github.com/leanprover/lean4/pull/6208) fix Vector.indexOf?
-
-- [#6217](https://github.com/leanprover/lean4/pull/6217) adds `simp` lemmas about `List`'s `==` operation.
-
-- [#6221](https://github.com/leanprover/lean4/pull/6221) fixes:
-- Problems in other linux distributions that the default `tzdata`
-directory is not the same as previously defined by ensuring it with a
-fallback behavior when directory is missing.
-- Trim unnecessary characters from local time identifier.
-
-- [#6222](https://github.com/leanprover/lean4/pull/6222) changes the definition of `HashSet.insertMany` and
-`HashSet.Raw.insertMany` so that it is equivalent to repeatedly calling
-`HashSet.insert`/`HashSet.Raw.insert`. It also clarifies the docstrings
-of all the `insert` and `insertMany` functions.
-
-- [#6230](https://github.com/leanprover/lean4/pull/6230) copies some lemmas about `List.foldX` to `Array`.
-
-- [#6233](https://github.com/leanprover/lean4/pull/6233) upstreams lemmas about `Vector` from Batteries.
-
-- [#6234](https://github.com/leanprover/lean4/pull/6234) upstreams the definition and basic lemmas about `List.finRange`
-from Batteries.
-
-- [#6235](https://github.com/leanprover/lean4/pull/6235) relates that operations `Nat.fold`/`foldRev`/`any`/`all` to the
-corresponding List operations over `List.finRange`.
-
-- [#6241](https://github.com/leanprover/lean4/pull/6241) refactors `Array.qsort` to remove runtime array bounds checks,
-and avoids the use of `partial`. We use the `Vector` API, along with
-auto_params, to avoid having to write any proofs. The new code
-benchmarks indistinguishably from the old.
-
-- [#6242](https://github.com/leanprover/lean4/pull/6242) deprecates `Fin.ofNat` in favour of `Fin.ofNat'` (which takes an
-`[NeZero]` instance, rather than returning an element of `Fin (n+1)`).
-
-- [#6247](https://github.com/leanprover/lean4/pull/6247) adds the theorems `numBits_pos`, `le_numBits`, `numBits_le` ,
-which make proving inequalities about `System.Platform.numBits` easier.
-
-## Compiler
-
-- [#5840](https://github.com/leanprover/lean4/pull/5840) changes `lean_sharecommon_{eq,hash}` to only consider the
-salient bytes of an object, and not any bytes of any
-unspecified/uninitialized unused capacity.
-
-- [#6087](https://github.com/leanprover/lean4/pull/6087) fixes a bug in the constant folding for the `Nat.ble` and
-`Nat.blt` function in the old code generator, leading to a
-miscompilation.
-
-- [#6143](https://github.com/leanprover/lean4/pull/6143) should make lean better-behaved around sanitizers, per
-https://github.com/google/sanitizers/issues/1688.
-As far as I can tell,
-https://github.com/google/sanitizers/wiki/AddressSanitizerUseAfterReturn#algorithm
-replaces local variables with heap allocations, and so taking the
-address of a local is not effective at producing a monotonic measure of
-stack usage.
-
-- [#6209](https://github.com/leanprover/lean4/pull/6209) documents under which conditions `Runtime.markPersistent` is
-unsafe and adjusts the elaborator accordingly
-
-- [#6257](https://github.com/leanprover/lean4/pull/6257) harden `markPersistent` uses
-
-## Pretty Printing
-
-- [#2934](https://github.com/leanprover/lean4/pull/2934) adds the option `pp.parens` (default: false) that causes the
-pretty printer to eagerly insert parentheses, which can be useful for
-teaching and for understanding the structure of expressions. For
-example, it causes `p → q → r` to pretty print as `p → (q → r)`.
-
-- [#6014](https://github.com/leanprover/lean4/pull/6014) prevents `Nat.succ ?_` from pretty printing as `?_.succ`, which
-should make `apply?` be more usable.
-
-- [#6085](https://github.com/leanprover/lean4/pull/6085) improves the term info for coercions marked with
-`CoeFnType.coeFun` (such as `DFunLike.coe` in Mathlib), making "go to
-definition" on the function name work. Hovering over such a coerced
-function will show the coercee rather than the coercion expression. The
-coercion expression can still be seen by hovering over the whitespace in
-the function application.
-
-- [#6096](https://github.com/leanprover/lean4/pull/6096) improves the `#print` command for structures to show all fields
-and which parents the fields were inherited from, hiding internal
-details such as which parents are represented as subobjects. This
-information is still present in the constructor if needed. The pretty
-printer for private constants is also improved, and it now handles
-private names from the current module like any other name; private names
-from other modules are made hygienic.
-
-- [#6119](https://github.com/leanprover/lean4/pull/6119) adds a new delab option `pp.coercions.types` which, when
-enabled, will display all coercions with an explicit type ascription.
-
-- [#6161](https://github.com/leanprover/lean4/pull/6161) ensures whitespace is printed before `+opt` and `-opt`
-configuration options when pretty printing, improving the experience of
-tactics such as `simp?`.
-
-- [#6181](https://github.com/leanprover/lean4/pull/6181) fixes a bug where the signature pretty printer would ignore the
-current setting of `pp.raw`. This fixes an issue where `#check ident`
-would not heed `pp.raw`. Closes #6090.
-
-- [#6213](https://github.com/leanprover/lean4/pull/6213) exposes the difference in "synthesized type class instance is
-not definitionally equal" errors.
-
-## Documentation
-
-- [#6009](https://github.com/leanprover/lean4/pull/6009) fixes a typo in the docstring for prec and makes the text
-slightly more precise.
-
-- [#6040](https://github.com/leanprover/lean4/pull/6040) join → flatten in docstring
-
-- [#6110](https://github.com/leanprover/lean4/pull/6110) does some mild refactoring of the `Lean.Elab.StructInst` module
-while adding documentation.
-
-- [#6144](https://github.com/leanprover/lean4/pull/6144) converts 3 doc-string to module docs since it seems that this is
-what they were intended to be!
-
-- [#6150](https://github.com/leanprover/lean4/pull/6150) refine kernel code comments
-
-- [#6158](https://github.com/leanprover/lean4/pull/6158) adjust file reference in Data.Sum
-
-- [#6239](https://github.com/leanprover/lean4/pull/6239) explains the order in which `Expr.abstract` introduces de Bruijn
-indices.
-
-## Server
-
-- [#5835](https://github.com/leanprover/lean4/pull/5835) adds auto-completion for the fields of structure instance notation. Specifically, querying the completions via `Ctrl+Space` in the whitespace of a structure instance notation will now bring up the full list of fields. Whitespace structure completion can be enabled for custom syntax by wrapping the parser for the list of fields in a `structInstFields` parser.
-
-- [#5837](https://github.com/leanprover/lean4/pull/5837) fixes an old auto-completion bug where `x.` would issue
-nonsensical completions when `x.` could not be elaborated as a dot
-completion.
-
-- [#5996](https://github.com/leanprover/lean4/pull/5996) avoid max heartbeat error in completion
-
-- [#6031](https://github.com/leanprover/lean4/pull/6031) fixes a regression with go-to-definition and document highlight
-misbehaving on tactic blocks.
-
-- [#6246](https://github.com/leanprover/lean4/pull/6246) fixes a performance issue where the Lean language server would
-walk the full project file tree every time a file was saved, blocking
-the processing of all other requests and notifications and significantly
-increasing overall language server latency after saving.
-
-## Lake
-
-- [#5684](https://github.com/leanprover/lean4/pull/5684) update toolchain on `lake update`
-
-- [#6026](https://github.com/leanprover/lean4/pull/6026) adds a newline at end of each Lean file generated by `lake new`
-templates.
-
-- [#6218](https://github.com/leanprover/lean4/pull/6218) makes Lake no longer automatically fetch GitHub cloud releases
-if the package build directory is already present (mirroring the
-behavior of the Reservoir cache). This prevents the cache from
-clobbering existing prebuilt artifacts. Users can still manually fetch
-the cache and clobber the build directory by running `lake build
-<pkg>:release`.
-
-- [#6225](https://github.com/leanprover/lean4/pull/6225) makes `lake build` also eagerly print package materialization
-log lines. Previously, only a `lake update` performed eager logging.
-
-- [#6231](https://github.com/leanprover/lean4/pull/6231) improves the errors Lake produces when it fails to fetch a
-dependency from Reservoir. If the package is not indexed, it will
-produce a suggestion about how to require it from GitHub.
-
-## Other
-
-- [#6137](https://github.com/leanprover/lean4/pull/6137) adds support for displaying multiple threads in the trace
-profiler output.
-
-- [#6138](https://github.com/leanprover/lean4/pull/6138) fixes `trace.profiler.pp` not using the term pretty printer.
-
-- [#6259](https://github.com/leanprover/lean4/pull/6259) ensures that nesting trace nodes are annotated with timing
-information iff `trace.profiler` is active.

releases/v4.16.0.md

@@ -1,565 +0,0 @@
-v4.16.0
-----------
-## Highlights
-
-### Unique `sorry`s
-
-[#5757](https://github.com/leanprover/lean4/pull/5757) makes it harder to create "fake" theorems about definitions that
-are stubbed-out with `sorry` by ensuring that each `sorry` is not
-definitionally equal to any other. For example, this now fails:
-```lean
-example : (sorry : Nat) = sorry := rfl -- fails
-```
-However, this still succeeds, since the `sorry` is a single
-indeterminate `Nat`:
-```lean
-def f (n : Nat) : Nat := sorry
-example : f 0 = f 1 := rfl -- succeeds
-```
-One can be more careful by putting parameters to the right of the colon:
-```lean
-def f : (n : Nat) → Nat := sorry
-example : f 0 = f 1 := rfl -- fails
-```
-Most sources of synthetic sorries (recall: a sorry that originates from
-the elaborator) are now unique, except for elaboration errors, since
-making these unique tends to cause a confusing cascade of errors. In
-general, however, such sorries are labeled. This enables "go to
-definition" on `sorry` in the Infoview, which brings you to its origin.
-The option `set_option pp.sorrySource true` causes the pretty printer to
-show source position information on sorries.
-
-### Separators in numeric literals
-
-[#6204](https://github.com/leanprover/lean4/pull/6204) lets `_` be used in numeric literals as a separator. For
-example, `1_000_000`, `0xff_ff` or `0b_10_11_01_00`. New lexical syntax:
-```text
-numeral10 : [0-9]+ ("_"+ [0-9]+)*
-numeral2  : "0" [bB] ("_"* [0-1]+)+
-numeral8  : "0" [oO] ("_"* [0-7]+)+
-numeral16 : "0" [xX] ("_"* hex_char+)+
-float     : numeral10 "." numeral10? [eE[+-]numeral10]
-```
-
-### Additional new featues
-
-* [#6300](https://github.com/leanprover/lean4/pull/6300) adds the `debug.proofAsSorry` option. When enabled, the proofs
-of theorems are ignored and replaced with `sorry`.
-
-* [#6362](https://github.com/leanprover/lean4/pull/6362) adds the `--error=kind` option (shorthand: `-Ekind`) to the
-`lean` CLI. When set, messages of `kind` (e.g.,
-`linter.unusedVariables`) will be reported as errors. This setting does
-nothing in interactive contexts (e.g., the server).
-
-* [#6366](https://github.com/leanprover/lean4/pull/6366) adds support for `Float32` and fixes a bug in the runtime.
-
-### Library updates
-
-The Lean 4 library saw many changes that improve arithmetic reasoning, enhance data structure APIs,
-and refine library organization. Key changes include better support for bitwise operations, shifts,
-and conversions, expanded lemmas for `Array`, `Vector`, and `List`, and improved ordering definitions.
-Some modules have been reorganized for clarity, and internal refinements ensure greater consistency and correctness.
-
-### Breaking changes
-
-[#6330](https://github.com/leanprover/lean4/pull/6330) removes unnecessary parameters from the functional induction
-principles. This is a breaking change; broken code can typically be adjusted
-simply by passing fewer parameters.
-
-_This highlights section was contributed by Violetta Sim._
-
-For this release, 201 changes landed. In addition to the 74 feature additions and 44 fixes listed below there were 7 refactoring changes, 5 documentation improvements and 62 chores.
-
-## Language
-
-* [#3696](https://github.com/leanprover/lean4/pull/3696) makes all message constructors handle pretty printer errors.
-
-* [#4460](https://github.com/leanprover/lean4/pull/4460) runs all linters for a single command (together) on a separate
-thread from further elaboration, making a first step towards
-parallelizing the elaborator.
-
-* [#5757](https://github.com/leanprover/lean4/pull/5757), see the highlights section above for details.
-
-* [#6123](https://github.com/leanprover/lean4/pull/6123) ensures that the configuration in `Simp.Config` is used when
-reducing terms and checking definitional equality in `simp`.
-
-* [#6204](https://github.com/leanprover/lean4/pull/6204), see the highlights section above for details.
-
-* [#6270](https://github.com/leanprover/lean4/pull/6270) fixes a bug that could cause the `injectivity` tactic to fail in
-reducible mode, which could cause unfolding lemma generation to fail
-(used by tactics such as `unfold`). In particular,
-`Lean.Meta.isConstructorApp'?` was not aware that `n + 1` is equivalent
-to `Nat.succ n`.
-
-* [#6273](https://github.com/leanprover/lean4/pull/6273) modifies the "foo has been deprecated: use betterFoo instead"
-warning so that foo and betterFoo are hoverable.
-
-* [#6278](https://github.com/leanprover/lean4/pull/6278) enables simp configuration options to be passed to `norm_cast`.
-
-* [#6286](https://github.com/leanprover/lean4/pull/6286) ensure `bv_decide` uses definitional equality in its reflection
-procedure as much as possible. Previously it would build up explicit
-congruence proofs for the kernel to check. This reduces the size of
-proof terms passed to kernel speeds up checking of large reflection
-proofs.
-
-* [#6288](https://github.com/leanprover/lean4/pull/6288) uses Lean.RArray in bv_decide's reflection proofs. Giving
-speedups on problems with lots of variables.
-
-* [#6295](https://github.com/leanprover/lean4/pull/6295) sets up simprocs for all the remaining operations defined in
-`Init.Data.Fin.Basic`
-
-* [#6300](https://github.com/leanprover/lean4/pull/6300), see the highlights section above for details.
-
-* [#6330](https://github.com/leanprover/lean4/pull/6330), see the highlights section above for details.
-
-* [#6362](https://github.com/leanprover/lean4/pull/6362), see the highlights section above for details.
-
-* [#6366](https://github.com/leanprover/lean4/pull/6366), see the highlights section above for details.
-
-* [#6375](https://github.com/leanprover/lean4/pull/6375) fixes a bug in the simplifier. It was producing terms with loose
-bound variables when eliminating unused `let_fun` expressions.
-
-* [#6378](https://github.com/leanprover/lean4/pull/6378) adds an explanation to the error message when `cases` and
-`induction` are applied to a term whose type is not an inductive type.
-For `Prop`, these tactics now suggest the `by_cases` tactic. Example:
-```
-tactic 'cases' failed, major premise type is not an inductive type
-  Prop
-```
-
-* [#6381](https://github.com/leanprover/lean4/pull/6381) fixes a bug in `withTrackingZetaDelta` and
-`withTrackingZetaDeltaSet`. The `MetaM` caches need to be reset. See new
-test.
-
-* [#6385](https://github.com/leanprover/lean4/pull/6385) fixes a bug in `simp_all?` that caused some local declarations
-to be omitted from the `Try this:` suggestions.
-
-* [#6386](https://github.com/leanprover/lean4/pull/6386) ensures that `revertAll` clears auxiliary declarations when
-invoked directly by users.
-
-* [#6387](https://github.com/leanprover/lean4/pull/6387) fixes a type error in the proof generated by the `contradiction`
-tactic.
-
-* [#6397](https://github.com/leanprover/lean4/pull/6397) ensures that `simp` and `dsimp` do not unfold definitions that
-are not intended to be unfolded by the user. See issue #5755 for an
-example affected by this issue.
-
-* [#6398](https://github.com/leanprover/lean4/pull/6398) ensures `Meta.check` check projections.
-
-* [#6412](https://github.com/leanprover/lean4/pull/6412) adds reserved names for congruence theorems used in the
-simplifier and `grind` tactics. The idea is prevent the same congruence
-theorems to be generated over and over again.
-
-* [#6413](https://github.com/leanprover/lean4/pull/6413) introduces the following features to the WIP `grind` tactic:
-- `Expr` internalization.
-- Congruence theorem cache.
-- Procedure for adding new facts
-- New tracing options
-- New preprocessing steps: fold projections and eliminate dangling
-`Expr.mdata`
-
-* [#6414](https://github.com/leanprover/lean4/pull/6414) fixes a bug in `Lean.Meta.Closure` that would introduce
-under-applied delayed assignment metavariables, which would keep them
-from ever getting instantiated. This bug affected `match` elaboration
-when the expected type contained postponed elaboration problems, for
-example tactic blocks.
-
-* [#6419](https://github.com/leanprover/lean4/pull/6419) fixes multiple bugs in the WIP `grind` tactic. It also adds
-support for printing the `grind` internal state.
-
-* [#6428](https://github.com/leanprover/lean4/pull/6428) adds a new preprocessing step to the `grind` tactic:
-universe-level normalization. The goal is to avoid missing equalities in
-the congruence closure module.
-
-* [#6430](https://github.com/leanprover/lean4/pull/6430) adds the predicate `Expr.fvarsSet a b`, which returns `true` if
-and only if the free variables in `a` are a subset of the free variables
-in `b`.
-
-* [#6433](https://github.com/leanprover/lean4/pull/6433) adds a custom type and instance canonicalizer for the (WIP)
-`grind` tactic. The `grind` tactic uses congruence closure but
-disregards types, type formers, instances, and proofs. Proofs are
-ignored due to proof irrelevance. Types, type formers, and instances are
-considered supporting elements and are not factored into congruence
-detection. Instead, `grind` only checks whether elements are
-structurally equal, which, in the context of the `grind` tactic, is
-equivalent to pointer equality. See new tests for examples where the
-canonicalizer is important.
-
-* [#6435](https://github.com/leanprover/lean4/pull/6435) implements the congruence table for the (WIP) `grind` tactic. It
-also fixes several bugs, and adds a new preprocessing step.
-
-* [#6437](https://github.com/leanprover/lean4/pull/6437) adds support for detecting congruent terms in the (WIP) `grind`
-tactic. It also introduces the `grind.debug` option, which, when set to
-`true`, checks many invariants after each equivalence class is merged.
-This option is intended solely for debugging purposes.
-
-* [#6438](https://github.com/leanprover/lean4/pull/6438) ensures `norm_cast` doesn't fail to act in the presence of
-`no_index` annotations
-
-* [#6441](https://github.com/leanprover/lean4/pull/6441) adds basic truth value propagation rules to the (WIP) `grind`
-tactic.
-
-* [#6442](https://github.com/leanprover/lean4/pull/6442) fixes the `checkParents` sanity check in `grind`.
-
-* [#6443](https://github.com/leanprover/lean4/pull/6443) adds support for propagating the truth value of equalities in
-the (WIP) `grind` tactic.
-
-* [#6447](https://github.com/leanprover/lean4/pull/6447) refactors `grind` and adds support for invoking the simplifier
-using the `GrindM` monad.
-
-* [#6448](https://github.com/leanprover/lean4/pull/6448) declares the command `builtin_grind_propagator` for registering
-equation propagator for `grind`. It also declares the auxiliary the
-attribute.
-
-* [#6449](https://github.com/leanprover/lean4/pull/6449) completes the implementation of the command
-`builtin_grind_propagator`.
-
-* [#6452](https://github.com/leanprover/lean4/pull/6452) adds support for generating (small) proofs for any two
-expressions that belong to the same equivalence class in the `grind`
-tactic state.
-
-* [#6453](https://github.com/leanprover/lean4/pull/6453) improves bv_decide's performance in the presence of large
-literals.
-
-* [#6455](https://github.com/leanprover/lean4/pull/6455) fixes a bug in the equality proof generator in the (WIP) `grind`
-tactic.
-
-* [#6456](https://github.com/leanprover/lean4/pull/6456) fixes another bug in the equality proof generator in the (WIP)
-`grind` tactic.
-
-* [#6457](https://github.com/leanprover/lean4/pull/6457) adds support for generating congruence proofs for congruences
-detected by the `grind` tactic.
-
-* [#6458](https://github.com/leanprover/lean4/pull/6458) adds support for compact congruence proofs in the (WIP) `grind`
-tactic. The `mkCongrProof` function now verifies whether the congruence
-proof can be constructed using only `congr`, `congrFun`, and `congrArg`,
-avoiding the need to generate the more complex `hcongr` auxiliary
-theorems.
-
-* [#6459](https://github.com/leanprover/lean4/pull/6459) adds the (WIP) `grind` tactic. It currently generates a warning
-message to make it clear that the tactic is not ready for production.
-
-* [#6461](https://github.com/leanprover/lean4/pull/6461) adds a new propagation rule for negation to the (WIP) `grind`
-tactic.
-
-* [#6463](https://github.com/leanprover/lean4/pull/6463) adds support for constructors to the (WIP) `grind` tactic. When
-merging equivalence classes, `grind` checks for equalities between
-constructors. If they are distinct, it closes the goal; if they are the
-same, it applies injectivity.
-
-* [#6464](https://github.com/leanprover/lean4/pull/6464) completes support for literal values in the (WIP) `grind`
-tactic. `grind` now closes the goal whenever it merges two equivalence
-classes with distinct literal values.
-
-* [#6465](https://github.com/leanprover/lean4/pull/6465) adds support for projection functions to the (WIP) `grind`
-tactic.
-
-* [#6466](https://github.com/leanprover/lean4/pull/6466) completes the implementation of `addCongrTable` in the (WIP)
-`grind` tactic. It also adds a new test to demonstrate why the extra
-check is needed. It also updates the field `cgRoot` (congruence root).
-
-* [#6468](https://github.com/leanprover/lean4/pull/6468) fixes issue #6467
-
-* [#6469](https://github.com/leanprover/lean4/pull/6469) adds support code for implementing e-match in the (WIP) `grind`
-tactic.
-
-* [#6470](https://github.com/leanprover/lean4/pull/6470) introduces a command for specifying patterns used in the
-heuristic instantiation of global theorems in the `grind` tactic. Note
-that this PR only adds the parser.
-
-* [#6472](https://github.com/leanprover/lean4/pull/6472) implements the command `grind_pattern`. The new command allows
-users to associate patterns with theorems. These patterns are used for
-performing heuristic instantiation with e-matching. In the future, we
-will add the attributes `@[grind_eq]`, `@[grind_fwd]`, and
-`@[grind_bwd]` to compute the patterns automatically for theorems.
-
-* [#6473](https://github.com/leanprover/lean4/pull/6473) adds a deriving handler for the `ToExpr` class. It can handle
-mutual and nested inductive types, however it falls back to creating
-`partial` instances in such cases. This is upstreamed from the Mathlib
-deriving handler written by @kmill, but has fixes to handle autoimplicit
-universe level variables.
-
-* [#6474](https://github.com/leanprover/lean4/pull/6474) adds pattern validation to the `grind_pattern` command. The new
-`checkCoverage` function will also be used to implement the attributes
-`@[grind_eq]`, `@[grind_fwd]`, and `@[grind_bwd]`.
-
-* [#6475](https://github.com/leanprover/lean4/pull/6475) adds support for activating relevant theorems for the (WIP)
-`grind` tactic. We say a theorem is relevant to a `grind` goal if the
-symbols occurring in its patterns also occur in the goal.
-
-* [#6478](https://github.com/leanprover/lean4/pull/6478) internalize nested ground patterns when activating ematch
-theorems in the (WIP) `grind` tactic.
-
-* [#6481](https://github.com/leanprover/lean4/pull/6481) implements E-matching for the (WIP) `grind` tactic. We still
-need to finalize and internalize the new instances.
-
-* [#6484](https://github.com/leanprover/lean4/pull/6484) addresses a few error messages where diffs weren't being
-exposed.
-
-* [#6485](https://github.com/leanprover/lean4/pull/6485) implements `Grind.EMatch.instantiateTheorem` in the (WIP)
-`grind` tactic.
-
-* [#6487](https://github.com/leanprover/lean4/pull/6487) adds source position information for `structure` parent
-projections, supporting "go to definition". Closes #3063.
-
-* [#6488](https://github.com/leanprover/lean4/pull/6488) fixes and refactors the E-matching module for the (WIP) `grind`
-tactic.
-
-* [#6490](https://github.com/leanprover/lean4/pull/6490) adds basic configuration options for the `grind` tactic.
-
-* [#6492](https://github.com/leanprover/lean4/pull/6492) fixes a bug in the theorem instantiation procedure in the (WIP)
-`grind` tactic. 
-
-* [#6497](https://github.com/leanprover/lean4/pull/6497) fixes another theorem instantiation bug in the `grind` tactic.
-It also moves new instances to be processed to `Goal`.
-
-* [#6498](https://github.com/leanprover/lean4/pull/6498) adds support in the `grind` tactic for propagating dependent
-forall terms `forall (h : p), q[h]` where `p` is a proposition.
-
-* [#6499](https://github.com/leanprover/lean4/pull/6499) fixes the proof canonicalizer for `grind`.
-
-* [#6500](https://github.com/leanprover/lean4/pull/6500) fixes a bug in the `markNestedProofs` used in `grind`. See new
-test.
-
-* [#6502](https://github.com/leanprover/lean4/pull/6502) fixes a bug in the proof assembly procedure utilized by the
-`grind` tactic.
-
-* [#6503](https://github.com/leanprover/lean4/pull/6503) adds a simple strategy to the (WIP) `grind` tactic. It just
-keeps internalizing new theorem instances found by E-matching. 
-
-* [#6506](https://github.com/leanprover/lean4/pull/6506) adds the `monotonicity` tactic, intended to be used inside the
-`partial_fixpoint` feature.
-
-* [#6508](https://github.com/leanprover/lean4/pull/6508) fixes a bug in the sanity checkers for the `grind` tactic. See
-the new test for an example of a case where it was panicking.
-
-* [#6509](https://github.com/leanprover/lean4/pull/6509) fixes a bug in the congruence closure data structure used in the
-`grind` tactic. The new test includes an example that previously caused
-a panic. A similar panic was also occurring in the test
-`grind_nested_proofs.lean`.
-
-* [#6510](https://github.com/leanprover/lean4/pull/6510) adds a custom congruence rule for equality in `grind`. The new
-rule takes into account that `Eq` is a symmetric relation. In the
-future, we will add support for arbitrary symmetric relations. The
-current rule is important for propagating disequalities effectively in
-`grind`.
-
-* [#6512](https://github.com/leanprover/lean4/pull/6512) introduces support for user-defined fallback code in the `grind`
-tactic. The fallback code can be utilized to inspect the state of
-failing `grind` subgoals and/or invoke user-defined automation. Users
-can now write `grind on_failure <code>`, where `<code>` should have the
-type `GoalM Unit`. See the modified tests in this PR for examples.
-
-* [#6513](https://github.com/leanprover/lean4/pull/6513) adds support for (dependent) if-then-else terms (i.e., `ite` and
-`dite` applications) in the `grind` tactic.
-
-* [#6514](https://github.com/leanprover/lean4/pull/6514) enhances the assertion of new facts in `grind` by avoiding the
-creation of unnecessary metavariables.
-
-## Library
-
-* [#6182](https://github.com/leanprover/lean4/pull/6182) adds `BitVec.[toInt|toFin]_concat` and moves a couple of
-theorems into the concat section, as `BitVec.msb_concat` is needed for
-the `toInt_concat` proof.
-
-* [#6188](https://github.com/leanprover/lean4/pull/6188) completes the `toNat` theorems for the bitwise operations
-(`and`, `or`, `xor`, `shiftLeft`, `shiftRight`) of the UInt types and
-adds `toBitVec` theorems as well. It also renames `and_toNat` to
-`toNat_and` to fit with the current naming convention.
-
-* [#6238](https://github.com/leanprover/lean4/pull/6238) adds theorems characterizing the value of the unsigned shift
-right of a bitvector in terms of its 2s complement interpretation as an
-integer.
-Unsigned shift right by at least one bit makes the value of the
-bitvector less than or equal to `2^(w-1)`,
-makes the interpretation of the bitvector `Int` and `Nat` agree.
-In the case when `n = 0`, then the shift right value equals the integer
-interpretation.
-
-* [#6244](https://github.com/leanprover/lean4/pull/6244) changes the implementation of `HashMap.toList`, so the ordering
-agrees with `HashMap.toArray`.
-
-* [#6272](https://github.com/leanprover/lean4/pull/6272) introduces the basic theory of permutations of `Array`s and
-proves `Array.swap_perm`.
-
-* [#6282](https://github.com/leanprover/lean4/pull/6282) moves `IO.Channel` and `IO.Mutex` from `Init` to `Std.Sync` and
-renames them to `Std.Channel` and `Std.Mutex`.
-
-* [#6294](https://github.com/leanprover/lean4/pull/6294) upstreams `List.length_flatMap`, `countP_flatMap` and
-`count_flatMap` from Mathlib. These were not possible to state before we
-upstreamed `List.sum`.
-
-* [#6315](https://github.com/leanprover/lean4/pull/6315) adds `protected` to `Fin.cast` and `BitVec.cast`, to avoid
-confusion with `_root_.cast`. These should mostly be used via
-dot-notation in any case.
-
-* [#6316](https://github.com/leanprover/lean4/pull/6316) adds lemmas simplifying `for` loops over `Option` into
-`Option.pelim`, giving parity with lemmas simplifying `for` loops of
-`List` into `List.fold`.
-
-* [#6317](https://github.com/leanprover/lean4/pull/6317) completes the basic API for BitVec.ofBool.
-
-* [#6318](https://github.com/leanprover/lean4/pull/6318) generalizes the universe level for `Array.find?`, by giving it a
-separate implementation from `Array.findM?`.
-
-* [#6324](https://github.com/leanprover/lean4/pull/6324) adds `GetElem` lemmas for the basic `Vector` operations.
-
-* [#6333](https://github.com/leanprover/lean4/pull/6333) generalizes the panic functions to a type of `Sort u` rather
-than `Type u`. This better supports universe polymorphic types and
-avoids confusing errors.
-
-* [#6334](https://github.com/leanprover/lean4/pull/6334) adds `Nat` theorems for distributing `>>>` over bitwise
-operations, paralleling those of `BitVec`.
-
-* [#6338](https://github.com/leanprover/lean4/pull/6338) adds `BitVec.[toFin|getMsbD]_setWidth` and
-`[getMsb|msb]_signExtend` as well as `ofInt_toInt`.
-
-* [#6341](https://github.com/leanprover/lean4/pull/6341) generalizes `DecidableRel` to allow a heterogeneous relation.
-
-* [#6353](https://github.com/leanprover/lean4/pull/6353) reproduces the API around `List.any/all` for `Array.any/all`.
-
-* [#6364](https://github.com/leanprover/lean4/pull/6364) makes fixes suggested by the Batteries environment linters,
-particularly `simpNF`, and `unusedHavesSuffices`.
-
-* [#6365](https://github.com/leanprover/lean4/pull/6365) expands the `Array.set` and `Array.setIfInBounds` lemmas to
-match existing lemmas for `List.set`.
-
-* [#6367](https://github.com/leanprover/lean4/pull/6367) brings Vector lemmas about membership and indexing to parity
-with List and Array.
-
-* [#6369](https://github.com/leanprover/lean4/pull/6369) adds lemmas about `Vector.set`, `anyM`, `any`, `allM`, and
-`all`.
-
-* [#6376](https://github.com/leanprover/lean4/pull/6376) adds theorems about `==` on `Vector`, reproducing those already
-on `List` and `Array`.
-
-* [#6379](https://github.com/leanprover/lean4/pull/6379) replaces the inductive predicate `List.lt` with an upstreamed version of `List.Lex` from Mathlib.
-(Previously `Lex.lt` was defined in terms of `<`; now it is generalized to take an arbitrary relation.)
-This subtly changes the notion of ordering on `List α`.
-
-  `List.lt` was a weaker relation: in particular if `l₁ < l₂`, then `a :: l₁ < b :: l₂` may hold according to `List.lt` even if `a` and `b` are merely incomparable (either neither `a < b` nor `b < a`), whereas according to `List.Lex` this would require `a = b`.
-
-  When `<` is total, in the sense that `¬ · < ·` is antisymmetric, then the two relations coincide.
-
-  Mathlib was already overriding the order instances for `List α`, so this change should not be noticed by anyone already using Mathlib.
-
-  We simultaneously add the boolean valued `List.lex` function, parameterised by a `BEq` typeclass and an arbitrary `lt` function. This will support the flexibility previously provided for `List.lt`, via a `==` function which is weaker than strict equality.
-
-* [#6390](https://github.com/leanprover/lean4/pull/6390) redefines `Range.forIn'` and `Range.forM`, in preparation for
-writing lemmas about them.
-
-* [#6391](https://github.com/leanprover/lean4/pull/6391) requires that the step size in `Std.Range` is positive, to avoid
-ill-specified behaviour.
-
-* [#6396](https://github.com/leanprover/lean4/pull/6396) adds lemmas reducing for loops over `Std.Range` to for loops
-over `List.range'`.
-
-* [#6399](https://github.com/leanprover/lean4/pull/6399) adds basic lemmas about lexicographic order on Array and Vector,
-achieving parity with List.
-
-* [#6423](https://github.com/leanprover/lean4/pull/6423) adds missing lemmas about lexicographic order on
-List/Array/Vector.
-
-* [#6477](https://github.com/leanprover/lean4/pull/6477) adds the necessary domain theory that backs the
-`partial_fixpoint` feature.
-
-## Compiler
-
-* [#6311](https://github.com/leanprover/lean4/pull/6311) adds support for `HEq` to the new code generator.
-
-* [#6348](https://github.com/leanprover/lean4/pull/6348) adds support for `Float32` to the Lean runtime.
-
-* [#6350](https://github.com/leanprover/lean4/pull/6350) adds missing features and fixes bugs in the `Float32` support
-
-* [#6383](https://github.com/leanprover/lean4/pull/6383) ensures the new code generator produces code for `opaque`
-definitions that are not tagged as `@[extern]`.
-Remark: This is the behavior of the old code generator.
-
-* [#6405](https://github.com/leanprover/lean4/pull/6405) adds support for erasure of `Decidable.decide` to the new code
-generator. It also adds a new `Probe.runOnDeclsNamed` function, which is
-helpful for writing targeted single-file tests of compiler internals.
-
-* [#6415](https://github.com/leanprover/lean4/pull/6415) fixes a bug in the `sharecommon` module, which was returning
-incorrect results for objects that had already been processed by
-`sharecommon`. See the new test for an example that triggered the bug.
-
-* [#6429](https://github.com/leanprover/lean4/pull/6429) adds support for extern LCNF decls, which is required for parity
-with the existing code generator.
-
-* [#6535](https://github.com/leanprover/lean4/pull/6535) avoids a linker warning on Windows.
-
-* [#6547](https://github.com/leanprover/lean4/pull/6547) should prevent Lake from accidentally picking up other linkers
-installed on the machine.
-
-* [#6574](https://github.com/leanprover/lean4/pull/6574) actually prevents Lake from accidentally picking up other
-toolchains installed on the machine.
-
-## Pretty Printing
-
-* [#5689](https://github.com/leanprover/lean4/pull/5689) adjusts the way the pretty printer unresolves names. It used to
-make use of all `export`s when pretty printing, but now it only uses
-`export`s that put names into parent namespaces (heuristic: these are
-"API exports" that are intended by the library author), rather than
-"horizontal exports" that put the names into an unrelated namespace,
-which the dot notation feature in #6189 now incentivizes.
-
-* [#5757](https://github.com/leanprover/lean4/pull/5757), aside from introducing labeled sorries, fixes the bug that the metadata attached to the pretty-printed representation of arguments with a borrow annotation (for example, the second argument of `String.append`), is inconsistent with the metadata attached to the regular arguments.
-
-## Documentation
-
-* [#6450](https://github.com/leanprover/lean4/pull/6450) adds a docstring to the `@[app_delab]` attribute.
-
-## Server
-
-* [#6279](https://github.com/leanprover/lean4/pull/6279) fixes a bug in structure instance field completion that caused
-it to not function correctly for bracketed structure instances written
-in Mathlib style.
-
-* [#6408](https://github.com/leanprover/lean4/pull/6408) fixes a regression where goals that don't exist were being
-displayed. The regression was triggered by #5835 and originally caused
-by #4926.
-
-## Lake
-
-* [#6176](https://github.com/leanprover/lean4/pull/6176) changes Lake's build process to no longer use `leanc` for
-compiling C files or linking shared libraries and executables. Instead,
-it directly invokes the bundled compiler (or the native compiler if
-none) using the necessary flags.
-
-* [#6289](https://github.com/leanprover/lean4/pull/6289) adapts Lake modules to use `prelude` and includes them in the
-`check-prelude` CI.
-
-* [#6291](https://github.com/leanprover/lean4/pull/6291) ensures the the log error position is properly preserved when
-prepending stray log entries to the job log. It also adds comparison
-support for `Log.Pos`.
-
-* [#6388](https://github.com/leanprover/lean4/pull/6388) merges `BuildJob` and `Job`, deprecating the former. `Job` now
-contains a trace as part of its state which can be interacted with
-monadically. also simplifies the implementation of `OpaqueJob`.
-
-* [#6411](https://github.com/leanprover/lean4/pull/6411) adds the ability to override package entries in a Lake manifest
-via a separate JSON file. This file can be specified on the command line
-with `--packages` or applied persistently by placing it at
-`.lake/package-overrides.json`.
-
-* [#6422](https://github.com/leanprover/lean4/pull/6422) fixes a bug in #6388 where the `Package.afterBuildCahe*`
-functions would produce different traces depending on whether the cache
-was fetched.
-
-* [#6627](https://github.com/leanprover/lean4/pull/6627) aims to fix the trace issues reported by Mathlib that are
-breaking `lake exe cache` in downstream projects.
-
-* [#6631](https://github.com/leanprover/lean4/pull/6631) sets `MACOSX_DEPLOYMENT_TARGET` for shared libraries (it was
-previously only set for executables).
-
-## Other
-
-* [#6285](https://github.com/leanprover/lean4/pull/6285) upstreams the `ToLevel` typeclass from mathlib and uses it to
-fix the existing `ToExpr` instances so that they are truly universe
-polymorphic (previously it generated malformed expressions when the
-universe level was nonzero). We improve on the mathlib definition of
-`ToLevel` to ensure the class always lives in `Type`, irrespective of
-the universe parameter.
-
-* [#6363](https://github.com/leanprover/lean4/pull/6363) fixes errors at load time in the comparison mode of the Firefox
-profiler.

releases/v4.2.0.md

@@ -1,16 +0,0 @@
-v4.2.0
----------
-
-* [isDefEq cache for terms not containing metavariables.](https://github.com/leanprover/lean4/pull/2644).
-* Make [`Environment.mk`](https://github.com/leanprover/lean4/pull/2604) and [`Environment.add`](https://github.com/leanprover/lean4/pull/2642) private, and add [`replay`](https://github.com/leanprover/lean4/pull/2617) as a safer alternative.
-* `IO.Process.output` no longer inherits the standard input of the caller.
-* [Do not inhibit caching](https://github.com/leanprover/lean4/pull/2612) of default-level `match` reduction.
-* [List the valid case tags](https://github.com/leanprover/lean4/pull/2629) when the user writes an invalid one.
-* The derive handler for `DecidableEq` [now handles](https://github.com/leanprover/lean4/pull/2591) mutual inductive types.
-* [Show path of failed import in Lake](https://github.com/leanprover/lean4/pull/2616).
-* [Fix linker warnings on macOS](https://github.com/leanprover/lean4/pull/2598).
-* **Lake:** Add `postUpdate?` package configuration option. Used by a package to specify some code which should be run after a successful `lake update` of the package or one of its downstream dependencies. ([lake#185](https://github.com/leanprover/lake/issues/185))
-* Improvements to Lake startup time ([#2572](https://github.com/leanprover/lean4/pull/2572), [#2573](https://github.com/leanprover/lean4/pull/2573))
-* `refine e` now replaces the main goal with metavariables which were created during elaboration of `e` and no longer captures pre-existing metavariables that occur in `e` ([#2502](https://github.com/leanprover/lean4/pull/2502)).
-  * This is accomplished via changes to `withCollectingNewGoalsFrom`, which also affects `elabTermWithHoles`, `refine'`, `calc` (tactic), and `specialize`. Likewise, all of these now only include newly-created metavariables in their output.
-  * Previously, both newly-created and pre-existing metavariables occurring in `e` were returned inconsistently in different edge cases, causing duplicated goals in the infoview (issue [#2495](https://github.com/leanprover/lean4/issues/2495)), erroneously closed goals (issue [#2434](https://github.com/leanprover/lean4/issues/2434)), and unintuitive behavior due to `refine e` capturing previously-created goals appearing unexpectedly in `e` (no issue; see PR).

releases/v4.3.0.md

@@ -1,37 +0,0 @@
-v4.3.0
----------
-
-* `simp [f]` does not unfold partial applications of `f` anymore. See issue [#2042](https://github.com/leanprover/lean4/issues/2042).
-  To fix proofs affected by this change, use `unfold f` or `simp (config := { unfoldPartialApp := true }) [f]`.
-* By default, `simp` will no longer try to use Decidable instances to rewrite terms. In particular, not all decidable goals will be closed by `simp`, and the `decide` tactic may be useful in such cases. The `decide` simp configuration option can be used to locally restore the old `simp` behavior, as in `simp (config := {decide := true})`; this includes using Decidable instances to verify side goals such as numeric inequalities.
-
-* Many bug fixes:
-  * [Add left/right actions to term tree coercion elaborator and make `^`` a right action](https://github.com/leanprover/lean4/pull/2778)
-  * [Fix for #2775, don't catch max recursion depth errors](https://github.com/leanprover/lean4/pull/2790)
-  * [Reduction of `Decidable` instances very slow when using `cases` tactic](https://github.com/leanprover/lean4/issues/2552)
-  * [`simp` not rewriting in binder](https://github.com/leanprover/lean4/issues/1926)
-  * [`simp` unfolding `let` even with `zeta := false` option](https://github.com/leanprover/lean4/issues/2669)
-  * [`simp` (with beta/zeta disabled) and discrimination trees](https://github.com/leanprover/lean4/issues/2281)
-  * [unknown free variable introduced by `rw ... at h`](https://github.com/leanprover/lean4/issues/2711)
-  * [`dsimp` doesn't use `rfl` theorems which consist of an unapplied constant](https://github.com/leanprover/lean4/issues/2685)
-  * [`dsimp` does not close reflexive equality goals if they are wrapped in metadata](https://github.com/leanprover/lean4/issues/2514)
-  * [`rw [h]` uses `h` from the environment in preference to `h` from the local context](https://github.com/leanprover/lean4/issues/2729)
-  * [missing `withAssignableSyntheticOpaque` for `assumption` tactic](https://github.com/leanprover/lean4/issues/2361)
-  * [ignoring default value for field warning](https://github.com/leanprover/lean4/issues/2178)
-* [Cancel outstanding tasks on document edit in the language server](https://github.com/leanprover/lean4/pull/2648).
-* [Remove unnecessary `%` operations in `Fin.mod` and `Fin.div`](https://github.com/leanprover/lean4/pull/2688)
-* [Avoid `DecidableEq` in `Array.mem`](https://github.com/leanprover/lean4/pull/2774)
-* [Ensure `USize.size` unifies with `?m + 1`](https://github.com/leanprover/lean4/issues/1926)
-* [Improve compatibility with emacs eglot client](https://github.com/leanprover/lean4/pull/2721)
-
-**Lake:**
-
-* [Sensible defaults for `lake new MyProject math`](https://github.com/leanprover/lean4/pull/2770)
-* Changed `postUpdate?` configuration option to a `post_update` declaration. See the `post_update` syntax docstring for more information on the new syntax.
-* [A manifest is automatically created on workspace load if one does not exists.](https://github.com/leanprover/lean4/pull/2680).
-* The `:=` syntax for configuration declarations (i.e., `package`, `lean_lib`, and `lean_exe`) has been deprecated. For example, `package foo := {...}` is deprecated.
-* [support for overriding package URLs via `LAKE_PKG_URL_MAP`](https://github.com/leanprover/lean4/pull/2709)
-* Moved the default build directory (e.g., `build`), default packages directory (e.g., `lake-packages`), and the compiled configuration (e.g., `lakefile.olean`) into a new dedicated directory for Lake outputs, `.lake`. The cloud release build archives are also stored here, fixing [#2713](https://github.com/leanprover/lean4/issues/2713).
-* Update manifest format to version 7 (see [lean4#2801](https://github.com/leanprover/lean4/pull/2801) for details on the changes).
-* Deprecate the `manifestFile` field of a package configuration.
-* There is now a more rigorous check on `lakefile.olean` compatibility (see [#2842](https://github.com/leanprover/lean4/pull/2842) for more details).

releases/v4.4.0.md

@@ -1,45 +0,0 @@
-v4.4.0
----------
-
-* Lake and the language server now support per-package server options using the `moreServerOptions` config field, as well as options that apply to both the language server and `lean` using the `leanOptions` config field. Setting either of these fields instead of `moreServerArgs` ensures that viewing files from a dependency uses the options for that dependency. Additionally, `moreServerArgs` is being deprecated in favor of the `moreGlobalServerArgs` field. See PR [#2858](https://github.com/leanprover/lean4/pull/2858).
-
-  A Lakefile with the following deprecated package declaration:
-  ```lean
-  def moreServerArgs := #[
-    "-Dpp.unicode.fun=true"
-  ]
-  def moreLeanArgs := moreServerArgs
-
-  package SomePackage where
-    moreServerArgs := moreServerArgs
-    moreLeanArgs := moreLeanArgs
-  ```
-
-  ... can be updated to the following package declaration to use per-package options:
-  ```lean
-  package SomePackage where
-    leanOptions := #[⟨`pp.unicode.fun, true⟩]
-  ```
-* [Rename request handler](https://github.com/leanprover/lean4/pull/2462).
-* [Import auto-completion](https://github.com/leanprover/lean4/pull/2904).
-* [`pp.beta`` to apply beta reduction when pretty printing](https://github.com/leanprover/lean4/pull/2864).
-* [Embed and check githash in .olean](https://github.com/leanprover/lean4/pull/2766).
-* [Guess lexicographic order for well-founded recursion](https://github.com/leanprover/lean4/pull/2874).
-* [Allow trailing comma in tuples, lists, and tactics](https://github.com/leanprover/lean4/pull/2643).
-
-Bug fixes for [#2628](https://github.com/leanprover/lean4/issues/2628), [#2883](https://github.com/leanprover/lean4/issues/2883),
-[#2810](https://github.com/leanprover/lean4/issues/2810), [#2925](https://github.com/leanprover/lean4/issues/2925), and [#2914](https://github.com/leanprover/lean4/issues/2914).
-
-**Lake:**
-
-* `lake init .` and a bare `lake init` and will now use the current directory as the package name. [#2890](https://github.com/leanprover/lean4/pull/2890)
-* `lake new` and `lake init` will now produce errors on invalid package names such as `..`, `foo/bar`, `Init`, `Lean`, `Lake`, and `Main`. See issue [#2637](https://github.com/leanprover/lean4/issues/2637) and PR [#2890](https://github.com/leanprover/lean4/pull/2890).
-* `lean_lib` no longer converts its name to upper camel case (e.g., `lean_lib bar` will include modules named `bar.*` rather than `Bar.*`). See issue [#2567](https://github.com/leanprover/lean4/issues/2567) and PR [#2889](https://github.com/leanprover/lean4/pull/2889).
-* Lean and Lake now properly support non-identifier library names (e.g., `lake new 123-hello` and `import «123Hello»` now work correctly). See issue [#2865](https://github.com/leanprover/lean4/issues/2865) and PR [#2889](https://github.com/leanprover/lean4/pull/2888).
-* Lake now filters the environment extensions loaded from a compiled configuration (`lakefile.olean`) to include only those relevant to Lake's workspace loading process. This resolves segmentation faults caused by environment extension type mismatches (e.g., when defining custom elaborators via `elab` in configurations). See issue [#2632](https://github.com/leanprover/lean4/issues/2632) and PR [#2896](https://github.com/leanprover/lean4/pull/2896).
-* Cloud releases will now properly be re-unpacked if the build directory is removed. See PR [#2928](https://github.com/leanprover/lean4/pull/2928).
-* Lake's `math` template has been simplified. See PR [#2930](https://github.com/leanprover/lean4/pull/2930).
-* `lake exe <target>` now parses `target` like a build target (as the help text states it should) rather than as a basic name. For example, `lake exe @mathlib/runLinter` should now work. See PR [#2932](https://github.com/leanprover/lean4/pull/2932).
-* `lake new foo.bar [std]` now generates executables named `foo-bar` and `lake new foo.bar exe` properly creates `foo/bar.lean`. See PR [#2932](https://github.com/leanprover/lean4/pull/2932).
-* Later packages and libraries in the dependency tree are now preferred over earlier ones. That is, the later ones "shadow" the earlier ones. Such an ordering is more consistent with how declarations generally work in programming languages. This will break any package that relied on the previous ordering. See issue [#2548](https://github.com/leanprover/lean4/issues/2548) and PR [#2937](https://github.com/leanprover/lean4/pull/2937).
-* Executable roots are no longer mistakenly treated as importable. They will no longer be picked up by `findModule?`. See PR [#2937](https://github.com/leanprover/lean4/pull/2937).

releases/v4.5.0.md

@@ -1,77 +0,0 @@
-v4.5.0
----------
-
-* Modify the lexical syntax of string literals to have string gaps, which are escape sequences of the form `"\" newline whitespace*`.
-  These have the interpretation of an empty string and allow a string to flow across multiple lines without introducing additional whitespace.
-  The following is equivalent to `"this is a string"`.
-  ```lean
-  "this is \
-     a string"
-  ```
-  [PR #2821](https://github.com/leanprover/lean4/pull/2821) and [RFC #2838](https://github.com/leanprover/lean4/issues/2838).
-
-* Add raw string literal syntax. For example, `r"\n"` is equivalent to `"\\n"`, with no escape processing.
-  To include double quote characters in a raw string one can add sufficiently many `#` characters before and after
-  the bounding `"`s, as in `r#"the "the" is in quotes"#` for `"the \"the\" is in quotes"`.
-  [PR #2929](https://github.com/leanprover/lean4/pull/2929) and [issue #1422](https://github.com/leanprover/lean4/issues/1422).
-
-* The low-level `termination_by'` clause is no longer supported.
-
-  Migration guide: Use `termination_by` instead, e.g.:
-  ```diff
-  -termination_by' measure (fun ⟨i, _⟩ => as.size - i)
-  +termination_by i _ => as.size - i
-  ```
-
-  If the well-founded relation you want to use is not the one that the
-  `WellFoundedRelation` type class would infer for your termination argument,
-  you can use `WellFounded.wrap` from the std library to explicitly give one:
-  ```diff
-  -termination_by' ⟨r, hwf⟩
-  +termination_by x => hwf.wrap x
-  ```
-
-* Support snippet edits in LSP `TextEdit`s. See `Lean.Lsp.SnippetString` for more details.
-
-* Deprecations and changes in the widget API.
-  - `Widget.UserWidgetDefinition` is deprecated in favour of `Widget.Module`. The annotation `@[widget]` is deprecated in favour of `@[widget_module]`. To migrate a definition of type `UserWidgetDefinition`, remove the `name` field and replace the type with `Widget.Module`. Removing the `name` results in a title bar no longer being drawn above your panel widget. To add it back, draw it as part of the component using `<details open=true><summary class='mv2 pointer'>{name}</summary>{rest_of_widget}</details>`. See an example migration [here](https://github.com/leanprover/std4/pull/475/files#diff-857376079661a0c28a53b7ff84701afabbdf529836a6944d106c5294f0e68109R43-R83).
-  - The new command `show_panel_widgets` allows displaying always-on and locally-on panel widgets.
-  - `RpcEncodable` widget props can now be stored in the infotree.
-  - See [RFC 2963](https://github.com/leanprover/lean4/issues/2963) for more details and motivation.
-
-* If no usable lexicographic order can be found automatically for a termination proof, explain why.
-  See [feat: GuessLex: if no measure is found, explain why](https://github.com/leanprover/lean4/pull/2960).
-
-* Option to print [inferred termination argument](https://github.com/leanprover/lean4/pull/3012).
-  With `set_option showInferredTerminationBy true` you will get messages like
-  ```
-  Inferred termination argument:
-  termination_by
-  ackermann n m => (sizeOf n, sizeOf m)
-  ```
-  for automatically generated `termination_by` clauses.
-
-* More detailed error messages for [invalid mutual blocks](https://github.com/leanprover/lean4/pull/2949).
-
-* [Multiple](https://github.com/leanprover/lean4/pull/2923) [improvements](https://github.com/leanprover/lean4/pull/2969) to the output of `simp?` and `simp_all?`.
-
-* Tactics with `withLocation *` [no longer fail](https://github.com/leanprover/lean4/pull/2917) if they close the main goal.
-
-* Implementation of a `test_extern` command for writing tests for `@[extern]` and `@[implemented_by]` functions.
-  Usage is
-  ```
-  import Lean.Util.TestExtern
-
-  test_extern Nat.add 17 37
-  ```
-  The head symbol must be the constant with the `@[extern]` or `@[implemented_by]` attribute. The return type must have a `DecidableEq` instance.
-
-Bug fixes for
-[#2853](https://github.com/leanprover/lean4/issues/2853), [#2953](https://github.com/leanprover/lean4/issues/2953), [#2966](https://github.com/leanprover/lean4/issues/2966),
-[#2971](https://github.com/leanprover/lean4/issues/2971), [#2990](https://github.com/leanprover/lean4/issues/2990), [#3094](https://github.com/leanprover/lean4/issues/3094).
-
-Bug fix for [eager evaluation of default value](https://github.com/leanprover/lean4/pull/3043) in `Option.getD`.
-Avoid [panic in `leanPosToLspPos`](https://github.com/leanprover/lean4/pull/3071) when file source is unavailable.
-Improve [short-circuiting behavior](https://github.com/leanprover/lean4/pull/2972) for `List.all` and `List.any`.
-
-Several Lake bug fixes: [#3036](https://github.com/leanprover/lean4/issues/3036), [#3064](https://github.com/leanprover/lean4/issues/3064), [#3069](https://github.com/leanprover/lean4/issues/3069).

releases/v4.6.0.md

@@ -1,230 +0,0 @@
-v4.6.0
----------
-
-* Add custom simplification procedures (aka `simproc`s) to `simp`. Simprocs can be triggered by the simplifier on a specified term-pattern. Here is an small example:
-  ```lean
-  import Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat
-
-  def foo (x : Nat) : Nat :=
-    x + 10
-
-  /--
-  The `simproc` `reduceFoo` is invoked on terms that match the pattern `foo _`.
-  -/
-  simproc reduceFoo (foo _) :=
-    /- A term of type `Expr → SimpM Step -/
-    fun e => do
-      /-
-      The `Step` type has three constructors: `.done`, `.visit`, `.continue`.
-      * The constructor `.done` instructs `simp` that the result does
-        not need to be simplified further.
-      * The constructor `.visit` instructs `simp` to visit the resulting expression.
-      * The constructor `.continue` instructs `simp` to try other simplification procedures.
-
-      All three constructors take a `Result`. The `.continue` constructor may also take `none`.
-      `Result` has two fields `expr` (the new expression), and `proof?` (an optional proof).
-       If the new expression is definitionally equal to the input one, then `proof?` can be omitted or set to `none`.
-      -/
-      /- `simp` uses matching modulo reducibility. So, we ensure the term is a `foo`-application. -/
-      unless e.isAppOfArity ``foo 1 do
-        return .continue
-      /- `Nat.fromExpr?` tries to convert an expression into a `Nat` value -/
-      let some n ← Nat.fromExpr? e.appArg!
-        | return .continue
-      return .done { expr := Lean.mkNatLit (n+10) }
-  ```
-  We disable simprocs support by using the command `set_option simprocs false`. This command is particularly useful when porting files to v4.6.0.
-  Simprocs can be scoped, manually added to `simp` commands, and suppressed using `-`. They are also supported by `simp?`. `simp only` does not execute any `simproc`. Here are some examples for the `simproc` defined above.
-  ```lean
-  example : x + foo 2 = 12 + x := by
-    set_option simprocs false in
-      /- This `simp` command does not make progress since `simproc`s are disabled. -/
-      fail_if_success simp
-    simp_arith
-
-  example : x + foo 2 = 12 + x := by
-    /- `simp only` must not use the default simproc set. -/
-    fail_if_success simp only
-    simp_arith
-
-  example : x + foo 2 = 12 + x := by
-    /-
-    `simp only` does not use the default simproc set,
-    but we can provide simprocs as arguments. -/
-    simp only [reduceFoo]
-    simp_arith
-
-  example : x + foo 2 = 12 + x := by
-    /- We can use `-` to disable `simproc`s. -/
-    fail_if_success simp [-reduceFoo]
-    simp_arith
-  ```
-  The command `register_simp_attr <id>` now creates a `simp` **and** a `simproc` set with the name `<id>`. The following command instructs Lean to insert the `reduceFoo` simplification procedure into the set `my_simp`. If no set is specified, Lean uses the default `simp` set.
-  ```lean
-  simproc [my_simp] reduceFoo (foo _) := ...
-  ```
-
-* The syntax of the `termination_by` and `decreasing_by` termination hints is overhauled:
-
-  * They are now placed directly after the function they apply to, instead of
-    after the whole `mutual` block.
-  * Therefore, the function name no longer has to be mentioned in the hint.
-  * If the function has a `where` clause, the `termination_by` and
-    `decreasing_by` for that function come before the `where`. The
-    functions in the `where` clause can have their own termination hints, each
-    following the corresponding definition.
-  * The `termination_by` clause can only bind “extra parameters”, that are not
-    already bound by the function header, but are bound in a lambda (`:= fun x
-    y z =>`) or in patterns (`| x, n + 1 => …`). These extra parameters used to
-    be understood as a suffix of the function parameters; now it is a prefix.
-
-  Migration guide: In simple cases just remove the function name, and any
-  variables already bound at the header.
-  ```diff
-   def foo : Nat → Nat → Nat := …
-  -termination_by foo a b => a - b
-  +termination_by a b => a - b
-  ```
-  or
-  ```diff
-   def foo : Nat → Nat → Nat := …
-  -termination_by _ a b => a - b
-  +termination_by a b => a - b
-  ```
-
-  If the parameters are bound in the function header (before the `:`), remove them as well:
-  ```diff
-   def foo (a b : Nat) : Nat := …
-  -termination_by foo a b => a - b
-  +termination_by a - b
-  ```
-
-  Else, if there are multiple extra parameters, make sure to refer to the right
-  ones; the bound variables are interpreted from left to right, no longer from
-  right to left:
-  ```diff
-   def foo : Nat → Nat → Nat → Nat
-     | a, b, c => …
-  -termination_by foo b c => b
-  +termination_by a b => b
-  ```
-
-  In the case of a `mutual` block, place the termination arguments (without the
-  function name) next to the function definition:
-  ```diff
-  -mutual
-  -def foo : Nat → Nat → Nat := …
-  -def bar : Nat → Nat := …
-  -end
-  -termination_by
-  -  foo a b => a - b
-  -  bar a => a
-  +mutual
-  +def foo : Nat → Nat → Nat := …
-  +termination_by a b => a - b
-  +def bar : Nat → Nat := …
-  +termination_by a => a
-  +end
-  ```
-
-  Similarly, if you have (mutual) recursion through `where` or `let rec`, the
-  termination hints are now placed directly after the function they apply to:
-  ```diff
-  -def foo (a b : Nat) : Nat := …
-  -  where bar (x : Nat) : Nat := …
-  -termination_by
-  -  foo a b => a - b
-  -  bar x => x
-  +def foo (a b : Nat) : Nat := …
-  +termination_by a - b
-  +  where
-  +    bar (x : Nat) : Nat := …
-  +    termination_by x
-
-  -def foo (a b : Nat) : Nat :=
-  -  let rec bar (x : Nat) :  Nat := …
-  -  …
-  -termination_by
-  -  foo a b => a - b
-  -  bar x => x
-  +def foo (a b : Nat) : Nat :=
-  +  let rec bar (x : Nat) : Nat := …
-  +    termination_by x
-  +  …
-  +termination_by a - b
-  ```
-
-  In cases where a single `decreasing_by` clause applied to multiple mutually
-  recursive functions before, the tactic now has to be duplicated.
-
-* The semantics of `decreasing_by` changed; the tactic is applied to all
-  termination proof goals together, not individually.
-
-  This helps when writing termination proofs interactively, as one can focus
-  each subgoal individually, for example using `·`. Previously, the given
-  tactic script had to work for _all_ goals, and one had to resort to tactic
-  combinators like `first`:
-
-  ```diff
-   def foo (n : Nat) := … foo e1 … foo e2 …
-  -decreasing_by
-  -simp_wf
-  -first | apply something_about_e1; …
-  -      | apply something_about_e2; …
-  +decreasing_by
-  +all_goals simp_wf
-  +· apply something_about_e1; …
-  +· apply something_about_e2; …
-  ```
-
-  To obtain the old behaviour of applying a tactic to each goal individually,
-  use `all_goals`:
-  ```diff
-   def foo (n : Nat) := …
-  -decreasing_by some_tactic
-  +decreasing_by all_goals some_tactic
-  ```
-
-  In the case of mutual recursion each `decreasing_by` now applies to just its
-  function. If some functions in a recursive group do not have their own
-  `decreasing_by`, the default `decreasing_tactic` is used. If the same tactic
-  ought to be applied to multiple functions, the `decreasing_by` clause has to
-  be repeated at each of these functions.
-
-* Modify `InfoTree.context` to facilitate augmenting it with partial contexts while elaborating a command. This breaks backwards compatibility with all downstream projects that traverse the `InfoTree` manually instead of going through the functions in `InfoUtils.lean`, as well as those manually creating and saving `InfoTree`s. See [PR #3159](https://github.com/leanprover/lean4/pull/3159) for how to migrate your code.
-
-* Add language server support for [call hierarchy requests](https://www.youtube.com/watch?v=r5LA7ivUb2c) ([PR #3082](https://github.com/leanprover/lean4/pull/3082)). The change to the .ilean format in this PR means that projects must be fully rebuilt once in order to generate .ilean files with the new format before features like "find references" work correctly again.
-
-* Structure instances with multiple sources (for example `{a, b, c with x := 0}`) now have their fields filled from these sources
-  in strict left-to-right order. Furthermore, the structure instance elaborator now aggressively use sources to fill in subobject
-  fields, which prevents unnecessary eta expansion of the sources,
-  and hence greatly reduces the reliance on costly structure eta reduction. This has a large impact on mathlib,
-  reducing total CPU instructions by 3% and enabling impactful refactors like leanprover-community/mathlib4#8386
-  which reduces the build time by almost 20%.
-  See [PR #2478](https://github.com/leanprover/lean4/pull/2478) and [RFC #2451](https://github.com/leanprover/lean4/issues/2451).
-
-* Add pretty printer settings to omit deeply nested terms (`pp.deepTerms false` and `pp.deepTerms.threshold`) ([PR #3201](https://github.com/leanprover/lean4/pull/3201))
-
-* Add pretty printer options `pp.numeralTypes` and `pp.natLit`.
-  When `pp.numeralTypes` is true, then natural number literals, integer literals, and rational number literals
-  are pretty printed with type ascriptions, such as `(2 : Rat)`, `(-2 : Rat)`, and `(-2 / 3 : Rat)`.
-  When `pp.natLit` is true, then raw natural number literals are pretty printed as `nat_lit 2`.
-  [PR #2933](https://github.com/leanprover/lean4/pull/2933) and [RFC #3021](https://github.com/leanprover/lean4/issues/3021).
-
-Lake updates:
-* improved platform information & control [#3226](https://github.com/leanprover/lean4/pull/3226)
-* `lake update` from unsupported manifest versions [#3149](https://github.com/leanprover/lean4/pull/3149)
-
-Other improvements:
-* make `intro` be aware of `let_fun` [#3115](https://github.com/leanprover/lean4/pull/3115)
-* produce simpler proof terms in `rw` [#3121](https://github.com/leanprover/lean4/pull/3121)
-* fuse nested `mkCongrArg` calls in proofs generated by `simp` [#3203](https://github.com/leanprover/lean4/pull/3203)
-* `induction using` followed by a general term [#3188](https://github.com/leanprover/lean4/pull/3188)
-* allow generalization in `let` [#3060](https://github.com/leanprover/lean4/pull/3060), fixing [#3065](https://github.com/leanprover/lean4/issues/3065)
-* reducing out-of-bounds `swap!` should return `a`, not `default`` [#3197](https://github.com/leanprover/lean4/pull/3197), fixing [#3196](https://github.com/leanprover/lean4/issues/3196)
-* derive `BEq` on structure with `Prop`-fields [#3191](https://github.com/leanprover/lean4/pull/3191), fixing [#3140](https://github.com/leanprover/lean4/issues/3140)
-* refine through more `casesOnApp`/`matcherApp` [#3176](https://github.com/leanprover/lean4/pull/3176), fixing [#3175](https://github.com/leanprover/lean4/pull/3175)
-* do not strip dotted components from lean module names [#2994](https://github.com/leanprover/lean4/pull/2994), fixing [#2999](https://github.com/leanprover/lean4/issues/2999)
-* fix `deriving` only deriving the first declaration for some handlers [#3058](https://github.com/leanprover/lean4/pull/3058), fixing [#3057](https://github.com/leanprover/lean4/issues/3057)
-* do not instantiate metavariables in kabstract/rw for disallowed occurrences [#2539](https://github.com/leanprover/lean4/pull/2539), fixing [#2538](https://github.com/leanprover/lean4/issues/2538)
-* hover info for `cases h : ...` [#3084](https://github.com/leanprover/lean4/pull/3084)

releases/v4.6.1.md

@@ -1,4 +0,0 @@
-v4.6.1
----------
-* Backport of [#3552](https://github.com/leanprover/lean4/pull/3552) fixing a performance regression
-  in server startup.

releases/v4.7.0.md

@@ -1,186 +0,0 @@
-v4.7.0
----------
-
-* `simp` and `rw` now use instance arguments found by unification,
-  rather than always resynthesizing. For backwards compatibility, the original behaviour is
-  available via `set_option tactic.skipAssignedInstances false`.
-  [#3507](https://github.com/leanprover/lean4/pull/3507) and
-  [#3509](https://github.com/leanprover/lean4/pull/3509).
-
-* When the `pp.proofs` is false, now omitted proofs use `⋯` rather than `_`,
-  which gives a more helpful error message when copied from the Infoview.
-  The `pp.proofs.threshold` option lets small proofs always be pretty printed.
-  [#3241](https://github.com/leanprover/lean4/pull/3241).
-
-* `pp.proofs.withType` is now set to false by default to reduce noise in the info view.
-
-* The pretty printer for applications now handles the case of over-application itself when applying app unexpanders.
-  In particular, the ``| `($_ $a $b $xs*) => `(($a + $b) $xs*)`` case of an `app_unexpander` is no longer necessary.
-  [#3495](https://github.com/leanprover/lean4/pull/3495).
-
-* New `simp` (and `dsimp`) configuration option: `zetaDelta`. It is `false` by default.
-  The `zeta` option is still `true` by default, but their meaning has changed.
-  - When `zeta := true`, `simp` and `dsimp` reduce terms of the form
-    `let x := val; e[x]` into `e[val]`.
-  - When `zetaDelta := true`, `simp` and `dsimp` will expand let-variables in
-    the context. For example, suppose the context contains `x := val`. Then,
-    any occurrence of `x` is replaced with `val`.
-
-  See [issue #2682](https://github.com/leanprover/lean4/pull/2682) for additional details. Here are some examples:
-  ```
-  example (h : z = 9) : let x := 5; let y := 4; x + y = z := by
-    intro x
-    simp
-    /-
-    New goal:
-    h : z = 9; x := 5 |- x + 4 = z
-    -/
-    rw [h]
-
-  example (h : z = 9) : let x := 5; let y := 4; x + y = z := by
-    intro x
-    -- Using both `zeta` and `zetaDelta`.
-    simp (config := { zetaDelta := true })
-    /-
-    New goal:
-    h : z = 9; x := 5 |- 9 = z
-    -/
-    rw [h]
-
-  example (h : z = 9) : let x := 5; let y := 4; x + y = z := by
-    intro x
-    simp [x] -- asks `simp` to unfold `x`
-    /-
-    New goal:
-    h : z = 9; x := 5 |- 9 = z
-    -/
-    rw [h]
-
-  example (h : z = 9) : let x := 5; let y := 4; x + y = z := by
-    intro x
-    simp (config := { zetaDelta := true, zeta := false })
-    /-
-    New goal:
-    h : z = 9; x := 5 |- let y := 4; 5 + y = z
-    -/
-    rw [h]
-  ```
-
-* When adding new local theorems to `simp`, the system assumes that the function application arguments
-  have been annotated with `no_index`. This modification, which addresses [issue #2670](https://github.com/leanprover/lean4/issues/2670),
-  restores the Lean 3 behavior that users expect. With this modification, the following examples are now operational:
-  ```
-  example {α β : Type} {f : α × β → β → β} (h : ∀ p : α × β, f p p.2 = p.2)
-    (a : α) (b : β) : f (a, b) b = b := by
-    simp [h]
-
-  example {α β : Type} {f : α × β → β → β}
-    (a : α) (b : β) (h : f (a,b) (a,b).2 = (a,b).2) : f (a, b) b = b := by
-    simp [h]
-  ```
-  In both cases, `h` is applicable because `simp` does not index f-arguments anymore when adding `h` to the `simp`-set.
-  It's important to note, however, that global theorems continue to be indexed in the usual manner.
-
-* Improved the error messages produced by the `decide` tactic. [#3422](https://github.com/leanprover/lean4/pull/3422)
-
-* Improved auto-completion performance. [#3460](https://github.com/leanprover/lean4/pull/3460)
-
-* Improved initial language server startup performance. [#3552](https://github.com/leanprover/lean4/pull/3552)
-
-* Changed call hierarchy to sort entries and strip private header from names displayed in the call hierarchy. [#3482](https://github.com/leanprover/lean4/pull/3482)
-
-* There is now a low-level error recovery combinator in the parsing framework, primarily intended for DSLs. [#3413](https://github.com/leanprover/lean4/pull/3413)
-
-* You can now write `termination_by?` after a declaration to see the automatically inferred
-  termination argument, and turn it into a `termination_by …` clause using the “Try this” widget or a code action. [#3514](https://github.com/leanprover/lean4/pull/3514)
-
-* A large fraction of `Std` has been moved into the Lean repository.
-  This was motivated by:
-  1. Making universally useful tactics such as `ext`, `by_cases`, `change at`,
-    `norm_cast`, `rcases`, `simpa`, `simp?`, `omega`, and `exact?`
-    available to all users of Lean, without imports.
-  2. Minimizing the syntactic changes between plain Lean and Lean with `import Std`.
-  3. Simplifying the development process for the basic data types
-     `Nat`, `Int`, `Fin` (and variants such as `UInt64`), `List`, `Array`,
-     and `BitVec` as we begin making the APIs and simp normal forms for these types
-     more complete and consistent.
-  4. Laying the groundwork for the Std roadmap, as a library focused on
-     essential datatypes not provided by the core language (e.g. `RBMap`)
-     and utilities such as basic IO.
-  While we have achieved most of our initial aims in `v4.7.0-rc1`,
-  some upstreaming will continue over the coming months.
-
-* The `/` and `%` notations in `Int` now use `Int.ediv` and `Int.emod`
-  (i.e. the rounding conventions have changed).
-  Previously `Std` overrode these notations, so this is no change for users of `Std`.
-  There is now kernel support for these functions.
-  [#3376](https://github.com/leanprover/lean4/pull/3376).
-
-* `omega`, our integer linear arithmetic tactic, is now available in the core language.
-  * It is supplemented by a preprocessing tactic `bv_omega` which can solve goals about `BitVec`
-    which naturally translate into linear arithmetic problems.
-    [#3435](https://github.com/leanprover/lean4/pull/3435).
-  * `omega` now has support for `Fin` [#3427](https://github.com/leanprover/lean4/pull/3427),
-    the `<<<` operator [#3433](https://github.com/leanprover/lean4/pull/3433).
-  * During the port `omega` was modified to no longer identify atoms up to definitional equality
-    (so in particular it can no longer prove `id x ≤ x`). [#3525](https://github.com/leanprover/lean4/pull/3525).
-    This may cause some regressions.
-    We plan to provide a general purpose preprocessing tactic later, or an `omega!` mode.
-  * `omega` is now invoked in Lean's automation for termination proofs
-    [#3503](https://github.com/leanprover/lean4/pull/3503) as well as in
-    array indexing proofs [#3515](https://github.com/leanprover/lean4/pull/3515).
-    This automation will be substantially revised in the medium term,
-    and while `omega` does help automate some proofs, we plan to make this much more robust.
-
-* The library search tactics `exact?` and `apply?` that were originally in
-  Mathlib are now available in Lean itself.  These use the implementation using
-  lazy discrimination trees from `Std`, and thus do not require a disk cache but
-  have a slightly longer startup time.  The order used for selection lemmas has
-  changed as well to favor goals purely based on how many terms in the head
-  pattern match the current goal.
-
-* The `solve_by_elim` tactic has been ported from `Std` to Lean so that library
-  search can use it.
-
-* New `#check_tactic` and `#check_simp` commands have been added.  These are
-  useful for checking tactics (particularly `simp`) behave as expected in test
-  suites.
-
-* Previously, app unexpanders would only be applied to entire applications. However, some notations produce
-  functions, and these functions can be given additional arguments. The solution so far has been to write app unexpanders so that they can take an arbitrary number of additional arguments. However this leads to misleading hover information in the Infoview. For example, while `HAdd.hAdd f g 1` pretty prints as `(f + g) 1`, hovering over `f + g` shows `f`. There is no way to fix the situation from within an app unexpander; the expression position for `HAdd.hAdd f g` is absent, and app unexpanders cannot register TermInfo.
-
-  This commit changes the app delaborator to try running app unexpanders on every prefix of an application, from longest to shortest prefix. For efficiency, it is careful to only try this when app delaborators do in fact exist for the head constant, and it also ensures arguments are only delaborated once. Then, in `(f + g) 1`, the `f + g` gets TermInfo registered for that subexpression, making it properly hoverable.
-
-  [#3375](https://github.com/leanprover/lean4/pull/3375)
-
-Breaking changes:
-* `Lean.withTraceNode` and variants got a stronger `MonadAlwaysExcept` assumption to
-  fix trace trees not being built on elaboration runtime exceptions. Instances for most elaboration
-  monads built on `EIO Exception` should be synthesized automatically.
-* The `match ... with.` and `fun.` notations previously in Std have been replaced by
-  `nomatch ...` and `nofun`. [#3279](https://github.com/leanprover/lean4/pull/3279) and [#3286](https://github.com/leanprover/lean4/pull/3286)
-
-
-Other improvements:
-* several bug fixes for `simp`:
-  * we should not crash when `simp` loops [#3269](https://github.com/leanprover/lean4/pull/3269)
-  * `simp` gets stuck on `autoParam` [#3315](https://github.com/leanprover/lean4/pull/3315)
-  * `simp` fails when custom discharger makes no progress [#3317](https://github.com/leanprover/lean4/pull/3317)
-  * `simp` fails to discharge `autoParam` premises even when it can reduce them to `True` [#3314](https://github.com/leanprover/lean4/pull/3314)
-  * `simp?` suggests generated equations lemma names, fixes [#3547](https://github.com/leanprover/lean4/pull/3547) [#3573](https://github.com/leanprover/lean4/pull/3573)
-* fixes for `match` expressions:
-  * fix regression with builtin literals [#3521](https://github.com/leanprover/lean4/pull/3521)
-  * accept `match` when patterns cover all cases of a `BitVec` finite type [#3538](https://github.com/leanprover/lean4/pull/3538)
-  * fix matching `Int` literals [#3504](https://github.com/leanprover/lean4/pull/3504)
-  * patterns containing int values and constructors [#3496](https://github.com/leanprover/lean4/pull/3496)
-* improve `termination_by` error messages [#3255](https://github.com/leanprover/lean4/pull/3255)
-* fix `rename_i` in macros, fixes [#3553](https://github.com/leanprover/lean4/pull/3553) [#3581](https://github.com/leanprover/lean4/pull/3581)
-* fix excessive resource usage in `generalize`, fixes [#3524](https://github.com/leanprover/lean4/pull/3524) [#3575](https://github.com/leanprover/lean4/pull/3575)
-* an equation lemma with autoParam arguments fails to rewrite, fixing [#2243](https://github.com/leanprover/lean4/pull/2243) [#3316](https://github.com/leanprover/lean4/pull/3316)
-* `add_decl_doc` should check that declarations are local [#3311](https://github.com/leanprover/lean4/pull/3311)
-* instantiate the types of inductives with the right parameters, closing [#3242](https://github.com/leanprover/lean4/pull/3242) [#3246](https://github.com/leanprover/lean4/pull/3246)
-* New simprocs for many basic types. [#3407](https://github.com/leanprover/lean4/pull/3407)
-
-Lake fixes:
-* Warn on fetch cloud release failure [#3401](https://github.com/leanprover/lean4/pull/3401)
-* Cloud release trace & `lake build :release` errors [#3248](https://github.com/leanprover/lean4/pull/3248)

releases/v4.8.0.md

@@ -1,494 +0,0 @@
-v4.8.0
----------
-
-### Language features, tactics, and metaprograms
-
-* **Functional induction principles.**
-  [#3432](https://github.com/leanprover/lean4/pull/3432), [#3620](https://github.com/leanprover/lean4/pull/3620),
-  [#3754](https://github.com/leanprover/lean4/pull/3754), [#3762](https://github.com/leanprover/lean4/pull/3762),
-  [#3738](https://github.com/leanprover/lean4/pull/3738), [#3776](https://github.com/leanprover/lean4/pull/3776),
-  [#3898](https://github.com/leanprover/lean4/pull/3898).
-
-  Derived from the definition of a (possibly mutually) recursive function,
-  a **functional induction principle** is created that is tailored to proofs about that function.
-
-  For example from:
-  ```
-  def ackermann : Nat → Nat → Nat
-    | 0, m => m + 1
-    | n+1, 0 => ackermann n 1
-    | n+1, m+1 => ackermann n (ackermann (n + 1) m)
-  ```
-  we get
-  ```
-  ackermann.induct (motive : Nat → Nat → Prop) (case1 : ∀ (m : Nat), motive 0 m)
-    (case2 : ∀ (n : Nat), motive n 1 → motive (Nat.succ n) 0)
-    (case3 : ∀ (n m : Nat), motive (n + 1) m → motive n (ackermann (n + 1) m) → motive (Nat.succ n) (Nat.succ m))
-    (x x : Nat) : motive x x
-  ```
-
-  It can be used in the `induction` tactic using the `using` syntax:
-  ```
-  induction n, m using ackermann.induct
-  ```
-* The termination checker now recognizes more recursion patterns without an
-  explicit `termination_by`. In particular the idiom of counting up to an upper
-  bound, as in
-  ```
-  def Array.sum (arr : Array Nat) (i acc : Nat) : Nat :=
-    if _ : i < arr.size then
-      Array.sum arr (i+1) (acc + arr[i])
-    else
-      acc
-  ```
-  is recognized without having to say `termination_by arr.size - i`.
-  * [#3630](https://github.com/leanprover/lean4/pull/3630) makes `termination_by?` not use `sizeOf` when not needed
-  * [#3652](https://github.com/leanprover/lean4/pull/3652) improves the `termination_by` syntax.
-  * [#3658](https://github.com/leanprover/lean4/pull/3658) changes how termination arguments are elaborated.
-  * [#3665](https://github.com/leanprover/lean4/pull/3665) refactors GuessLex to allow inferring more complex termination arguments
-  * [#3666](https://github.com/leanprover/lean4/pull/3666) infers termination arguments such as `xs.size - i`
-* [#3629](https://github.com/leanprover/lean4/pull/3629),
-  [#3655](https://github.com/leanprover/lean4/pull/3655),
-  [#3747](https://github.com/leanprover/lean4/pull/3747):
-  Adds `@[induction_eliminator]` and `@[cases_eliminator]` attributes to be able to define custom eliminators
-  for the `induction` and `cases` tactics, replacing the `@[eliminator]` attribute.
-  Gives custom eliminators for `Nat` so that `induction` and `cases` put goal states into terms of `0` and `n + 1`
-  rather than `Nat.zero` and `Nat.succ n`.
-  Added option `tactic.customEliminators` to control whether to use custom eliminators.
-  Added a hack for `rcases`/`rintro`/`obtain` to use the custom eliminator for `Nat`.
-* **Shorter instances names.** There is a new algorithm for generating names for anonymous instances.
-  Across Std and Mathlib, the median ratio between lengths of new names and of old names is about 72%.
-  With the old algorithm, the longest name was 1660 characters, and now the longest name is 202 characters.
-  The new algorithm's 95th percentile name length is 67 characters, versus 278 for the old algorithm.
-  While the new algorithm produces names that are 1.2% less unique,
-  it avoids cross-project collisions by adding a module-based suffix
-  when it does not refer to declarations from the same "project" (modules that share the same root).
-  [#3089](https://github.com/leanprover/lean4/pull/3089)
-  and [#3934](https://github.com/leanprover/lean4/pull/3934).
-* [8d2adf](https://github.com/leanprover/lean4/commit/8d2adf521d2b7636347a5b01bfe473bf0fcfaf31)
-  Importing two different files containing proofs of the same theorem is no longer considered an error.
-  This feature is particularly useful for theorems that are automatically generated on demand (e.g., equational theorems).
-* [84b091](https://github.com/leanprover/lean4/commit/84b0919a116e9be12f933e764474f45d964ce85c)
-  Lean now generates an error if the type of a theorem is **not** a proposition.
-* **Definition transparency.** [47a343](https://github.com/leanprover/lean4/commit/47a34316fc03ce936fddd2d3dce44784c5bcdfa9). `@[reducible]`, `@[semireducible]`, and `@[irreducible]` are now scoped and able to be set for imported declarations.
-* `simp`/`dsimp`
-  * [#3607](https://github.com/leanprover/lean4/pull/3607) enables kernel projection reduction in `dsimp`
-  * [b24fbf](https://github.com/leanprover/lean4/commit/b24fbf44f3aaa112f5d799ef2a341772d1eb222d)
-    and [acdb00](https://github.com/leanprover/lean4/commit/acdb0054d5a0efa724cff596ac26852fad5724c4):
-    `dsimproc` command
-    to define defeq-preserving simplification procedures.
-  * [#3624](https://github.com/leanprover/lean4/pull/3624) makes `dsimp` normalize raw nat literals as `OfNat.ofNat` applications.
-  * [#3628](https://github.com/leanprover/lean4/pull/3628) makes `simp` correctly handle `OfScientific.ofScientific` literals.
-  * [#3654](https://github.com/leanprover/lean4/pull/3654) makes `dsimp?` report used simprocs.
-  * [dee074](https://github.com/leanprover/lean4/commit/dee074dcde03a37b7895a4901df2e4fa490c73c7) fixes equation theorem
-    handling in `simp` for non-recursive definitions.
-  * [#3819](https://github.com/leanprover/lean4/pull/3819) improved performance when simp encounters a loop.
-  * [#3821](https://github.com/leanprover/lean4/pull/3821) fixes discharger/cache interaction.
-  * [#3824](https://github.com/leanprover/lean4/pull/3824) keeps `simp` from breaking `Char` literals.
-  * [#3838](https://github.com/leanprover/lean4/pull/3838) allows `Nat` instances matching to be more lenient.
-  * [#3870](https://github.com/leanprover/lean4/pull/3870) documentation for `simp` configuration options.
-  * [#3972](https://github.com/leanprover/lean4/pull/3972) fixes simp caching.
-  * [#4044](https://github.com/leanprover/lean4/pull/4044) improves cache behavior for "well-behaved" dischargers.
-* `omega`
-  * [#3639](https://github.com/leanprover/lean4/pull/3639), [#3766](https://github.com/leanprover/lean4/pull/3766),
-    [#3853](https://github.com/leanprover/lean4/pull/3853), [#3875](https://github.com/leanprover/lean4/pull/3875):
-    introduces a term canonicalizer.
-  * [#3736](https://github.com/leanprover/lean4/pull/3736) improves handling of positivity for the modulo operator for `Int`.
-  * [#3828](https://github.com/leanprover/lean4/pull/3828) makes it work as a `simp` discharger.
-  * [#3847](https://github.com/leanprover/lean4/pull/3847) adds helpful error messages.
-* `rfl`
-  * [#3671](https://github.com/leanprover/lean4/pull/3671), [#3708](https://github.com/leanprover/lean4/pull/3708): upstreams the `@[refl]` attribute and the `rfl` tactic.
-  * [#3751](https://github.com/leanprover/lean4/pull/3751) makes `apply_rfl` not operate on `Eq` itself.
-  * [#4067](https://github.com/leanprover/lean4/pull/4067) improves error message when there are no goals.
-* [#3719](https://github.com/leanprover/lean4/pull/3719) upstreams the `rw?` tactic, with fixes and improvements in
-  [#3783](https://github.com/leanprover/lean4/pull/3783), [#3794](https://github.com/leanprover/lean4/pull/3794),
-  [#3911](https://github.com/leanprover/lean4/pull/3911).
-* `conv`
-  * [#3659](https://github.com/leanprover/lean4/pull/3659) adds a `conv` version of the `calc` tactic.
-  * [#3763](https://github.com/leanprover/lean4/pull/3763) makes `conv` clean up using `try with_reducible rfl` instead of `try rfl`.
-* `#guard_msgs`
-  * [#3617](https://github.com/leanprover/lean4/pull/3617) introduces whitespace protection using the `⏎` character.
-  * [#3883](https://github.com/leanprover/lean4/pull/3883):
-    The `#guard_msgs` command now has options to change whitespace normalization and sensitivity to message ordering.
-    For example, `#guard_msgs (whitespace := lax) in cmd` collapses whitespace before checking messages,
-    and `#guard_msgs (ordering := sorted) in cmd` sorts the messages in lexicographic order before checking.
-  * [#3931](https://github.com/leanprover/lean4/pull/3931) adds an unused variables ignore function for `#guard_msgs`.
-  * [#3912](https://github.com/leanprover/lean4/pull/3912) adds a diff between the expected and actual outputs. This feature is currently
-    disabled by default, but can be enabled with `set_option guard_msgs.diff true`.
-    Depending on user feedback, this option may default to `true` in a future version of Lean.
-* `do` **notation**
-  * [#3820](https://github.com/leanprover/lean4/pull/3820) makes it an error to lift `(<- ...)` out of a pure `if ... then ... else ...`
-* **Lazy discrimination trees**
-  * [#3610](https://github.com/leanprover/lean4/pull/3610) fixes a name collision for `LazyDiscrTree` that could lead to cache poisoning.
-  * [#3677](https://github.com/leanprover/lean4/pull/3677) simplifies and fixes `LazyDiscrTree` handling for `exact?`/`apply?`.
-  * [#3685](https://github.com/leanprover/lean4/pull/3685) moves general `exact?`/`apply?` functionality into `LazyDiscrTree`.
-  * [#3769](https://github.com/leanprover/lean4/pull/3769) has lemma selection improvements for `rw?` and `LazyDiscrTree`.
-  * [#3818](https://github.com/leanprover/lean4/pull/3818) improves ordering of matches.
-* [#3590](https://github.com/leanprover/lean4/pull/3590) adds `inductive.autoPromoteIndices` option to be able to disable auto promotion of indices in the `inductive` command.
-* **Miscellaneous bug fixes and improvements**
-  * [#3606](https://github.com/leanprover/lean4/pull/3606) preserves `cache` and `dischargeDepth` fields in `Lean.Meta.Simp.Result.mkEqSymm`.
-  * [#3633](https://github.com/leanprover/lean4/pull/3633) makes `elabTermEnsuringType` respect `errToSorry`, improving error recovery of the `have` tactic.
-  * [#3647](https://github.com/leanprover/lean4/pull/3647) enables `noncomputable unsafe` definitions, for deferring implementations until later.
-  * [#3672](https://github.com/leanprover/lean4/pull/3672) adjust namespaces of tactics.
-  * [#3725](https://github.com/leanprover/lean4/pull/3725) fixes `Ord` derive handler for indexed inductive types with unused alternatives.
-  * [#3893](https://github.com/leanprover/lean4/pull/3893) improves performance of derived `Ord` instances.
-  * [#3771](https://github.com/leanprover/lean4/pull/3771) changes error reporting for failing tactic macros. Improves `rfl` error message.
-  * [#3745](https://github.com/leanprover/lean4/pull/3745) fixes elaboration of generalized field notation if the object of the notation is an optional parameter.
-  * [#3799](https://github.com/leanprover/lean4/pull/3799) makes commands such as `universe`, `variable`, `namespace`, etc. require that their argument appear in a later column.
-    Commands that can optionally parse an `ident` or parse any number of `ident`s generally should require
-    that the `ident` use `colGt`. This keeps typos in commands from being interpreted as identifiers.
-  * [#3815](https://github.com/leanprover/lean4/pull/3815) lets the `split` tactic be used for writing code.
-  * [#3822](https://github.com/leanprover/lean4/pull/3822) adds missing info in `induction` tactic for `with` clauses of the form `| cstr a b c => ?_`.
-  * [#3806](https://github.com/leanprover/lean4/pull/3806) fixes `withSetOptionIn` combinator.
-  * [#3844](https://github.com/leanprover/lean4/pull/3844) removes unused `trace.Elab.syntax` option.
-  * [#3896](https://github.com/leanprover/lean4/pull/3896) improves hover and go-to-def for `attribute` command.
-  * [#3989](https://github.com/leanprover/lean4/pull/3989) makes linter options more discoverable.
-  * [#3916](https://github.com/leanprover/lean4/pull/3916) fixes go-to-def for syntax defined with `@[builtin_term_parser]`.
-  * [#3962](https://github.com/leanprover/lean4/pull/3962) fixes how `solveByElim` handles `symm` lemmas, making `exact?`/`apply?` usable again.
-  * [#3968](https://github.com/leanprover/lean4/pull/3968) improves the `@[deprecated]` attribute, adding `(since := "<date>")` field.
-  * [#3768](https://github.com/leanprover/lean4/pull/3768) makes `#print` command show structure fields.
-  * [#3974](https://github.com/leanprover/lean4/pull/3974) makes `exact?%` behave like `by exact?` rather than `by apply?`.
-  * [#3994](https://github.com/leanprover/lean4/pull/3994) makes elaboration of `he ▸ h` notation more predictable.
-  * [#3991](https://github.com/leanprover/lean4/pull/3991) adjusts transparency for `decreasing_trivial` macros.
-  * [#4092](https://github.com/leanprover/lean4/pull/4092) improves performance of `binop%` and `binrel%` expression tree elaborators.
-* **Docs:** [#3748](https://github.com/leanprover/lean4/pull/3748), [#3796](https://github.com/leanprover/lean4/pull/3796),
-[#3800](https://github.com/leanprover/lean4/pull/3800), [#3874](https://github.com/leanprover/lean4/pull/3874),
-[#3863](https://github.com/leanprover/lean4/pull/3863), [#3862](https://github.com/leanprover/lean4/pull/3862),
-[#3891](https://github.com/leanprover/lean4/pull/3891), [#3873](https://github.com/leanprover/lean4/pull/3873),
-[#3908](https://github.com/leanprover/lean4/pull/3908), [#3872](https://github.com/leanprover/lean4/pull/3872).
-
-### Language server and IDE extensions
-
-* [#3602](https://github.com/leanprover/lean4/pull/3602) enables `import` auto-completions.
-* [#3608](https://github.com/leanprover/lean4/pull/3608) fixes issue [leanprover/vscode-lean4#392](https://github.com/leanprover/vscode-lean4/issues/392).
-  Diagnostic ranges had an off-by-one error that would misplace goal states for example.
-* [#3014](https://github.com/leanprover/lean4/pull/3014) introduces snapshot trees, foundational work for incremental tactics and parallelism.
-  [#3849](https://github.com/leanprover/lean4/pull/3849) adds basic incrementality API.
-* [#3271](https://github.com/leanprover/lean4/pull/3271) adds support for server-to-client requests.
-* [#3656](https://github.com/leanprover/lean4/pull/3656) fixes jump to definition when there are conflicting names from different files.
-  Fixes issue [#1170](https://github.com/leanprover/lean4/issues/1170).
-* [#3691](https://github.com/leanprover/lean4/pull/3691), [#3925](https://github.com/leanprover/lean4/pull/3925),
-  [#3932](https://github.com/leanprover/lean4/pull/3932) keep semantic tokens synchronized (used for semantic highlighting), with performance improvements.
-* [#3247](https://github.com/leanprover/lean4/pull/3247) and [#3730](https://github.com/leanprover/lean4/pull/3730)
-  add diagnostics to run "Restart File" when a file dependency is saved.
-* [#3722](https://github.com/leanprover/lean4/pull/3722) uses the correct module names when displaying references.
-* [#3728](https://github.com/leanprover/lean4/pull/3728) makes errors in header reliably appear and makes the "Import out of date" warning be at "hint" severity.
-  [#3739](https://github.com/leanprover/lean4/pull/3739) simplifies the text of this warning.
-* [#3778](https://github.com/leanprover/lean4/pull/3778) fixes [#3462](https://github.com/leanprover/lean4/issues/3462),
-  where info nodes from before the cursor would be used for computing completions.
-* [#3985](https://github.com/leanprover/lean4/pull/3985) makes trace timings appear in Infoview.
-
-### Pretty printing
-
-* [#3797](https://github.com/leanprover/lean4/pull/3797) fixes the hovers over binders so that they show their types.
-* [#3640](https://github.com/leanprover/lean4/pull/3640) and [#3735](https://github.com/leanprover/lean4/pull/3735): Adds attribute `@[pp_using_anonymous_constructor]` to make structures pretty print as `⟨x, y, z⟩`
-  rather than as `{a := x, b := y, c := z}`.
-  This attribute is applied to `Sigma`, `PSigma`, `PProd`, `Subtype`, `And`, and `Fin`.
-* [#3749](https://github.com/leanprover/lean4/pull/3749)
-  Now structure instances pretty print with parent structures' fields inlined.
-  That is, if `B` extends `A`, then `{ toA := { x := 1 }, y := 2 }` now pretty prints as `{ x := 1, y := 2 }`.
-  Setting option `pp.structureInstances.flatten` to false turns this off.
-* [#3737](https://github.com/leanprover/lean4/pull/3737), [#3744](https://github.com/leanprover/lean4/pull/3744)
-  and [#3750](https://github.com/leanprover/lean4/pull/3750):
-  Option `pp.structureProjections` is renamed to `pp.fieldNotation`, and there is now a suboption `pp.fieldNotation.generalized`
-  to enable pretty printing function applications using generalized field notation (defaults to true).
-  Field notation can be disabled on a function-by-function basis using the `@[pp_nodot]` attribute.
-  The notation is not used for theorems.
-* [#4071](https://github.com/leanprover/lean4/pull/4071) fixes interaction between app unexpanders and `pp.fieldNotation.generalized`
-* [#3625](https://github.com/leanprover/lean4/pull/3625) makes `delabConstWithSignature` (used by `#check`) have the ability to put arguments "after the colon"
-  to avoid printing inaccessible names.
-* [#3798](https://github.com/leanprover/lean4/pull/3798),
-  [#3978](https://github.com/leanprover/lean4/pull/3978),
-  [#3798](https://github.com/leanprover/lean4/pull/3980):
-  Adds options `pp.mvars` (default: true) and `pp.mvars.withType` (default: false).
-  When `pp.mvars` is false, expression metavariables pretty print as `?_` and universe metavariables pretty print as `_`.
-  When `pp.mvars.withType` is true, expression metavariables pretty print with a type ascription.
-  These can be set when using `#guard_msgs` to make tests not depend on the particular names of metavariables.
-* [#3917](https://github.com/leanprover/lean4/pull/3917) makes binders hoverable and gives them docstrings.
-* [#4034](https://github.com/leanprover/lean4/pull/4034) makes hovers for RHS terms in `match` expressions in the Infoview reliably show the correct term.
-
-### Library
-
-* `Bool`/`Prop`
-  * [#3508](https://github.com/leanprover/lean4/pull/3508) improves `simp` confluence for `Bool` and `Prop` terms.
-  * Theorems: [#3604](https://github.com/leanprover/lean4/pull/3604)
-* `Nat`
-  * [#3579](https://github.com/leanprover/lean4/pull/3579) makes `Nat.succ_eq_add_one` be a simp lemma, now that `induction`/`cases` uses `n + 1` instead of `Nat.succ n`.
-  * [#3808](https://github.com/leanprover/lean4/pull/3808) replaces `Nat.succ` simp rules with simprocs.
-  * [#3876](https://github.com/leanprover/lean4/pull/3876) adds faster `Nat.repr` implementation in C.
-* `Int`
-  * Theorems: [#3890](https://github.com/leanprover/lean4/pull/3890)
-* `UInt`s
-  * [#3960](https://github.com/leanprover/lean4/pull/3960) improves performance of upcasting.
-* `Array` and `Subarray`
-  * [#3676](https://github.com/leanprover/lean4/pull/3676) removes `Array.eraseIdxAux`, `Array.eraseIdxSzAux`, and `Array.eraseIdx'`.
-  * [#3648](https://github.com/leanprover/lean4/pull/3648) simplifies `Array.findIdx?`.
-  * [#3851](https://github.com/leanprover/lean4/pull/3851) renames fields of `Subarray`.
-* `List`
-  * [#3785](https://github.com/leanprover/lean4/pull/3785) upstreams tail-recursive List operations and `@[csimp]` lemmas.
-* `BitVec`
-  * Theorems: [#3593](https://github.com/leanprover/lean4/pull/3593),
-  [#3593](https://github.com/leanprover/lean4/pull/3593), [#3597](https://github.com/leanprover/lean4/pull/3597),
-  [#3598](https://github.com/leanprover/lean4/pull/3598), [#3721](https://github.com/leanprover/lean4/pull/3721),
-  [#3729](https://github.com/leanprover/lean4/pull/3729), [#3880](https://github.com/leanprover/lean4/pull/3880),
-  [#4039](https://github.com/leanprover/lean4/pull/4039).
-  * [#3884](https://github.com/leanprover/lean4/pull/3884) protects `Std.BitVec`.
-* `String`
-  * [#3832](https://github.com/leanprover/lean4/pull/3832) fixes `String.splitOn`.
-  * [#3959](https://github.com/leanprover/lean4/pull/3959) adds `String.Pos.isValid`.
-  * [#3959](https://github.com/leanprover/lean4/pull/3959) UTF-8 string validation.
-  * [#3961](https://github.com/leanprover/lean4/pull/3961) adds a model implementation for UTF-8 encoding and decoding.
-* `IO`
-  * [#4097](https://github.com/leanprover/lean4/pull/4097) adds `IO.getTaskState` which returns whether a task is finished, actively running, or waiting on other Tasks to finish.
-
-* **Refactors**
-  * [#3605](https://github.com/leanprover/lean4/pull/3605) reduces imports for `Init.Data.Nat` and `Init.Data.Int`.
-  * [#3613](https://github.com/leanprover/lean4/pull/3613) reduces imports for `Init.Omega.Int`.
-  * [#3634](https://github.com/leanprover/lean4/pull/3634) upstreams `Std.Data.Nat`
-    and [#3635](https://github.com/leanprover/lean4/pull/3635) upstreams `Std.Data.Int`.
-  * [#3790](https://github.com/leanprover/lean4/pull/3790) reduces more imports for `omega`.
-  * [#3694](https://github.com/leanprover/lean4/pull/3694) extends `GetElem` interface with `getElem!` and `getElem?` to simplify containers like `RBMap`.
-  * [#3865](https://github.com/leanprover/lean4/pull/3865) renames `Option.toMonad` (see breaking changes below).
-  * [#3882](https://github.com/leanprover/lean4/pull/3882) unifies `lexOrd` with `compareLex`.
-* **Other fixes or improvements**
-  * [#3765](https://github.com/leanprover/lean4/pull/3765) makes `Quotient.sound` be a `theorem`.
-  * [#3645](https://github.com/leanprover/lean4/pull/3645) fixes `System.FilePath.parent` in the case of absolute paths.
-  * [#3660](https://github.com/leanprover/lean4/pull/3660) `ByteArray.toUInt64LE!` and `ByteArray.toUInt64BE!` were swapped.
-  * [#3881](https://github.com/leanprover/lean4/pull/3881), [#3887](https://github.com/leanprover/lean4/pull/3887) fix linearity issues in `HashMap.insertIfNew`, `HashSet.erase`, and `HashMap.erase`.
-    The `HashMap.insertIfNew` fix improves `import` performance.
-  * [#3830](https://github.com/leanprover/lean4/pull/3830) ensures linearity in `Parsec.many*Core`.
-  * [#3930](https://github.com/leanprover/lean4/pull/3930) adds `FS.Stream.isTty` field.
-  * [#3866](https://github.com/leanprover/lean4/pull/3866) deprecates `Option.toBool` in favor of `Option.isSome`.
-  * [#3975](https://github.com/leanprover/lean4/pull/3975) upstreams `Data.List.Init` and `Data.Array.Init` material from Std.
-  * [#3942](https://github.com/leanprover/lean4/pull/3942) adds instances that make `ac_rfl` work without Mathlib.
-  * [#4010](https://github.com/leanprover/lean4/pull/4010) changes `Fin.induction` to use structural induction.
-  * [02753f](https://github.com/leanprover/lean4/commit/02753f6e4c510c385efcbf71fa9a6bec50fce9ab)
-    fixes bug in `reduceLeDiff` simproc.
-  * [#4097](https://github.com/leanprover/lean4/pull/4097)
-    adds `IO.TaskState` and `IO.getTaskState` to get the task from the Lean runtime's task manager.
-* **Docs:** [#3615](https://github.com/leanprover/lean4/pull/3615), [#3664](https://github.com/leanprover/lean4/pull/3664),
-  [#3707](https://github.com/leanprover/lean4/pull/3707), [#3734](https://github.com/leanprover/lean4/pull/3734),
-  [#3868](https://github.com/leanprover/lean4/pull/3868), [#3861](https://github.com/leanprover/lean4/pull/3861),
-  [#3869](https://github.com/leanprover/lean4/pull/3869), [#3858](https://github.com/leanprover/lean4/pull/3858),
-  [#3856](https://github.com/leanprover/lean4/pull/3856), [#3857](https://github.com/leanprover/lean4/pull/3857),
-  [#3867](https://github.com/leanprover/lean4/pull/3867), [#3864](https://github.com/leanprover/lean4/pull/3864),
-  [#3860](https://github.com/leanprover/lean4/pull/3860), [#3859](https://github.com/leanprover/lean4/pull/3859),
-  [#3871](https://github.com/leanprover/lean4/pull/3871), [#3919](https://github.com/leanprover/lean4/pull/3919).
-
-### Lean internals
-
-* **Defeq and WHNF algorithms**
-  * [#3616](https://github.com/leanprover/lean4/pull/3616) gives better support for reducing `Nat.rec` expressions.
-  * [#3774](https://github.com/leanprover/lean4/pull/3774) add tracing for "non-easy" WHNF cases.
-  * [#3807](https://github.com/leanprover/lean4/pull/3807) fixes an `isDefEq` performance issue, now trying structure eta *after* lazy delta reduction.
-  * [#3816](https://github.com/leanprover/lean4/pull/3816) fixes `.yesWithDeltaI` behavior to prevent increasing transparency level when reducing projections.
-  * [#3837](https://github.com/leanprover/lean4/pull/3837) improves heuristic at `isDefEq`.
-  * [#3965](https://github.com/leanprover/lean4/pull/3965) improves `isDefEq` for constraints of the form `t.i =?= s.i`.
-  * [#3977](https://github.com/leanprover/lean4/pull/3977) improves `isDefEqProj`.
-  * [#3981](https://github.com/leanprover/lean4/pull/3981) adds universe constraint approximations to be able to solve `u =?= max u ?v` using `?v = u`.
-    These approximations are only applied when universe constraints cannot be postponed anymore.
-  * [#4004](https://github.com/leanprover/lean4/pull/4004) improves `isDefEqProj` during typeclass resolution.
-  * [#4012](https://github.com/leanprover/lean4/pull/4012) adds `backward.isDefEq.lazyProjDelta` and `backward.isDefEq.lazyWhnfCore` backwards compatibility flags.
-* **Kernel**
-  * [#3966](https://github.com/leanprover/lean4/pull/3966) removes dead code.
-  * [#4035](https://github.com/leanprover/lean4/pull/4035) fixes mismatch for `TheoremVal` between Lean and C++.
-* **Discrimination trees**
-  * [423fed](https://github.com/leanprover/lean4/commit/423fed79a9de75705f34b3e8648db7e076c688d7)
-    and [3218b2](https://github.com/leanprover/lean4/commit/3218b25974d33e92807af3ce42198911c256ff1d):
-    simplify handling of dependent/non-dependent pi types.
-* **Typeclass instance synthesis**
-  * [#3638](https://github.com/leanprover/lean4/pull/3638) eta-reduces synthesized instances
-  * [ce350f](https://github.com/leanprover/lean4/commit/ce350f348161e63fccde6c4a5fe1fd2070e7ce0f) fixes a linearity issue
-  * [917a31](https://github.com/leanprover/lean4/commit/917a31f694f0db44d6907cc2b1485459afe74d49)
-    improves performance by considering at most one answer for subgoals not containing metavariables.
-    [#4008](https://github.com/leanprover/lean4/pull/4008) adds `backward.synthInstance.canonInstances` backward compatibility flag.
-* **Definition processing**
-  * [#3661](https://github.com/leanprover/lean4/pull/3661), [#3767](https://github.com/leanprover/lean4/pull/3767) changes automatically generated equational theorems to be named
-    using suffix `.eq_<idx>` instead of `._eq_<idx>`, and `.eq_def` instead of `._unfold`. (See breaking changes below.)
-    [#3675](https://github.com/leanprover/lean4/pull/3675) adds a mechanism to reserve names.
-    [#3803](https://github.com/leanprover/lean4/pull/3803) fixes reserved name resolution inside namespaces and fixes handling of `match`er declarations and equation lemmas.
-  * [#3662](https://github.com/leanprover/lean4/pull/3662) causes auxiliary definitions nested inside theorems to become `def`s if they are not proofs.
-  * [#4006](https://github.com/leanprover/lean4/pull/4006) makes proposition fields of `structure`s be theorems.
-  * [#4018](https://github.com/leanprover/lean4/pull/4018) makes it an error for a theorem to be `extern`.
-  * [#4047](https://github.com/leanprover/lean4/pull/4047) improves performance making equations for well-founded recursive definitions.
-* **Refactors**
-  * [#3614](https://github.com/leanprover/lean4/pull/3614) avoids unfolding in `Lean.Meta.evalNat`.
-  * [#3621](https://github.com/leanprover/lean4/pull/3621) centralizes functionality for `Fix`/`GuessLex`/`FunInd` in the `ArgsPacker` module.
-  * [#3186](https://github.com/leanprover/lean4/pull/3186) rewrites the UnusedVariable linter to be more performant.
-  * [#3589](https://github.com/leanprover/lean4/pull/3589) removes coercion from `String` to `Name` (see breaking changes below).
-  * [#3237](https://github.com/leanprover/lean4/pull/3237) removes the `lines` field from `FileMap`.
-  * [#3951](https://github.com/leanprover/lean4/pull/3951) makes msg parameter to `throwTacticEx` optional.
-* **Diagnostics**
-  * [#4016](https://github.com/leanprover/lean4/pull/4016), [#4019](https://github.com/leanprover/lean4/pull/4019),
-    [#4020](https://github.com/leanprover/lean4/pull/4020), [#4030](https://github.com/leanprover/lean4/pull/4030),
-    [#4031](https://github.com/leanprover/lean4/pull/4031),
-    [c3714b](https://github.com/leanprover/lean4/commit/c3714bdc6d46845c0428735b283c5b48b23cbcf7),
-    [#4049](https://github.com/leanprover/lean4/pull/4049) adds `set_option diagnostics true` for diagnostic counters.
-    Tracks number of unfolded declarations, instances, reducible declarations, used instances, recursor reductions,
-    `isDefEq` heuristic applications, among others.
-    This option is suggested in exceptional situations, such as at deterministic timeout and maximum recursion depth.
-  * [283587](https://github.com/leanprover/lean4/commit/283587987ab2eb3b56fbc3a19d5f33ab9e04a2ef)
-    adds diagnostic information for `simp`.
-  * [#4043](https://github.com/leanprover/lean4/pull/4043) adds diagnostic information for congruence theorems.
-  * [#4048](https://github.com/leanprover/lean4/pull/4048) display diagnostic information
-    for `set_option diagnostics true in <tactic>` and `set_option diagnostics true in <term>`.
-* **Other features**
-  * [#3800](https://github.com/leanprover/lean4/pull/3800) adds environment extension to record which definitions use structural or well-founded recursion.
-  * [#3801](https://github.com/leanprover/lean4/pull/3801) `trace.profiler` can now export to Firefox Profiler.
-  * [#3918](https://github.com/leanprover/lean4/pull/3918), [#3953](https://github.com/leanprover/lean4/pull/3953) adds `@[builtin_doc]` attribute to make docs and location of a declaration available as a builtin.
-  * [#3939](https://github.com/leanprover/lean4/pull/3939) adds the `lean --json` CLI option to print messages as JSON.
-  * [#3075](https://github.com/leanprover/lean4/pull/3075) improves `test_extern` command.
-  * [#3970](https://github.com/leanprover/lean4/pull/3970) gives monadic generalization of `FindExpr`.
-* **Docs:** [#3743](https://github.com/leanprover/lean4/pull/3743), [#3921](https://github.com/leanprover/lean4/pull/3921),
-  [#3954](https://github.com/leanprover/lean4/pull/3954).
-* **Other fixes:** [#3622](https://github.com/leanprover/lean4/pull/3622),
-  [#3726](https://github.com/leanprover/lean4/pull/3726), [#3823](https://github.com/leanprover/lean4/pull/3823),
-  [#3897](https://github.com/leanprover/lean4/pull/3897), [#3964](https://github.com/leanprover/lean4/pull/3964),
-  [#3946](https://github.com/leanprover/lean4/pull/3946), [#4007](https://github.com/leanprover/lean4/pull/4007),
-  [#4026](https://github.com/leanprover/lean4/pull/4026).
-
-### Compiler, runtime, and FFI
-
-* [#3632](https://github.com/leanprover/lean4/pull/3632) makes it possible to allocate and free thread-local runtime resources for threads not started by Lean itself.
-* [#3627](https://github.com/leanprover/lean4/pull/3627) improves error message about compacting closures.
-* [#3692](https://github.com/leanprover/lean4/pull/3692) fixes deadlock in `IO.Promise.resolve`.
-* [#3753](https://github.com/leanprover/lean4/pull/3753) catches error code from `MoveFileEx` on Windows.
-* [#4028](https://github.com/leanprover/lean4/pull/4028) fixes a double `reset` bug in `ResetReuse` transformation.
-* [6e731b](https://github.com/leanprover/lean4/commit/6e731b4370000a8e7a5cfb675a7f3d7635d21f58)
-  removes `interpreter` copy constructor to avoid potential memory safety issues.
-
-### Lake
-
-* **TOML Lake configurations**. [#3298](https://github.com/leanprover/lean4/pull/3298), [#4104](https://github.com/leanprover/lean4/pull/4104).
-
-  Lake packages can now use TOML as a alternative configuration file format instead of Lean. If the default `lakefile.lean` is missing, Lake will also look for a `lakefile.toml`. The TOML version of the configuration supports a restricted set of the Lake configuration options, only including those which can easily mapped to a TOML data structure. The TOML syntax itself fully compiles with the TOML v1.0.0 specification.
-
-  As part of the introduction of this new feature, we have been helping maintainers of some major packages within the ecosystem switch to this format. For example, the following is Aesop's new `lakefile.toml`:
-
-
-  **[leanprover-community/aesop/lakefile.toml](https://raw.githubusercontent.com/leanprover-community/aesop/de11e0ecf372976e6d627c210573146153090d2d/lakefile.toml)**
-  ```toml
-  name = "aesop"
-  defaultTargets = ["Aesop"]
-  testRunner = "test"
-  precompileModules = false
-
-  [[require]]
-  name = "batteries"
-  git = "https://github.com/leanprover-community/batteries"
-  rev = "main"
-
-  [[lean_lib]]
-  name = "Aesop"
-
-  [[lean_lib]]
-  name = "AesopTest"
-  globs = ["AesopTest.+"]
-  leanOptions = {linter.unusedVariables = false}
-
-  [[lean_exe]]
-  name = "test"
-  srcDir = "scripts"
-  ```
-
-  To assist users who wish to transition their packages between configuration file formats, there is also a new `lake translate-config` command for migrating to/from TOML.
-
-  Running `lake translate-config toml` will produce a `lakefile.toml` version of a package's `lakefile.lean`. Any configuration options unsupported by the TOML format will be discarded during translation, but the original `lakefile.lean` will remain so that you can verify the translation looks good before deleting it.
-
-* **Build progress overhaul.** [#3835](https://github.com/leanprover/lean4/pull/3835), [#4115](https://github.com/leanprover/lean4/pull/4115), [#4127](https://github.com/leanprover/lean4/pull/4127), [#4220](https://github.com/leanprover/lean4/pull/4220), [#4232](https://github.com/leanprover/lean4/pull/4232), [#4236](https://github.com/leanprover/lean4/pull/4236).
-
-  Builds are now managed by a top-level Lake build monitor, this makes the output of Lake builds more standardized and enables producing prettier and more configurable progress reports.
-
-  As part of this change, job isolation has improved. Stray I/O and other build related errors in custom targets are now properly isolated and caught as part of their job. Import errors no longer cause Lake to abort the entire build and are instead localized to the build jobs of the modules in question.
-
-  Lake also now uses ANSI escape sequences to add color and produce progress lines that update in-place; this can be toggled on and off using `--ansi` / `--no-ansi`.
-
-
-  `--wfail` and `--iofail` options have been added that causes a build to fail if any of the jobs log a warning (`--wfail`) or produce any output or log information messages (`--iofail`). Unlike some other build systems, these options do **NOT** convert these logs into errors, and Lake does not abort jobs on such a log (i.e., dependent jobs will still continue unimpeded).
-
-* `lake test`. [#3779](https://github.com/leanprover/lean4/pull/3779).
-
-  Lake now has a built-in `test` command which will run a script or executable labelled `@[test_runner]` (in Lean) or defined as the `testRunner` (in TOML) in the root package.
-
-  Lake also provides a `lake check-test` command which will exit with code `0` if the package has a properly configured test runner or error with `1` otherwise.
-
-* `lake lean`. [#3793](https://github.com/leanprover/lean4/pull/3793).
-
-  The new command `lake lean <file> [-- <args...>]` functions like `lake env lean <file> <args...>`, except that it builds the imports of `file` before running `lean`. This makes it very useful for running test or example code that imports modules that are not guaranteed to have been built beforehand.
-
-* **Miscellaneous bug fixes and improvements**
-  * [#3609](https://github.com/leanprover/lean4/pull/3609) `LEAN_GITHASH` environment variable to override the detected Git hash for Lean when computing traces, useful for testing custom builds of Lean.
-  * [#3795](https://github.com/leanprover/lean4/pull/3795) improves relative package directory path normalization in the pre-rename check.
-  * [#3957](https://github.com/leanprover/lean4/pull/3957) fixes handling of packages that appear multiple times in a dependency tree.
-  * [#3999](https://github.com/leanprover/lean4/pull/3999) makes it an error for there to be a mismatch between a package name and what it is required as. Also adds a special message for the `std`-to-`batteries` rename.
-  * [#4033](https://github.com/leanprover/lean4/pull/4033) fixes quiet mode.
-* **Docs:** [#3704](https://github.com/leanprover/lean4/pull/3704).
-
-### DevOps
-
-* [#3536](https://github.com/leanprover/lean4/pull/3536) and [#3833](https://github.com/leanprover/lean4/pull/3833)
-  add a checklist for the release process.
-* [#3600](https://github.com/leanprover/lean4/pull/3600) runs nix-ci more uniformly.
-* [#3612](https://github.com/leanprover/lean4/pull/3612) avoids argument limits when building on Windows.
-* [#3682](https://github.com/leanprover/lean4/pull/3682) builds Lean's `.o` files in parallel to rest of core.
-* [#3601](https://github.com/leanprover/lean4/pull/3601)
-  changes the way Lean is built on Windows (see breaking changes below).
-  As a result, Lake now dynamically links executables with `supportInterpreter := true` on Windows
-  to `libleanshared.dll` and `libInit_shared.dll`. Therefore, such executables will not run
-  unless those shared libraries are co-located with the executables or part of `PATH`.
-  Running the executable via `lake exe` will ensure these libraries are part of `PATH`.
-
-  In a related change, the signature of the `nativeFacets` Lake configuration options has changed
-  from a static `Array` to a function `(shouldExport : Bool) → Array`.
-  See its docstring or Lake's [README](src/lake/README.md) for further details on the changed option.
-* [#3690](https://github.com/leanprover/lean4/pull/3690) marks "Build matrix complete" as canceled if the build is canceled.
-* [#3700](https://github.com/leanprover/lean4/pull/3700), [#3702](https://github.com/leanprover/lean4/pull/3702),
-  [#3701](https://github.com/leanprover/lean4/pull/3701), [#3834](https://github.com/leanprover/lean4/pull/3834),
-  [#3923](https://github.com/leanprover/lean4/pull/3923): fixes and improvements for std and mathlib CI.
-* [#3712](https://github.com/leanprover/lean4/pull/3712) fixes `nix build .` on macOS.
-* [#3717](https://github.com/leanprover/lean4/pull/3717) replaces `shell.nix` in devShell with `flake.nix`.
-* [#3715](https://github.com/leanprover/lean4/pull/3715) and [#3790](https://github.com/leanprover/lean4/pull/3790) add test result summaries.
-* [#3971](https://github.com/leanprover/lean4/pull/3971) prevents stage0 changes via the merge queue.
-* [#3979](https://github.com/leanprover/lean4/pull/3979) adds handling for `changes-stage0` label.
-* [#3952](https://github.com/leanprover/lean4/pull/3952) adds a script to summarize GitHub issues.
-* [18a699](https://github.com/leanprover/lean4/commit/18a69914da53dbe37c91bc2b9ce65e1dc01752b6)
-  fixes asan linking
-
-### Breaking changes
-
-* Due to the major Lake build refactor, code using the affected parts of the Lake API or relying on the previous output format of Lake builds is likely to have been broken. We have tried to minimize the breakages and, where possible, old definitions have been marked `@[deprecated]` with a reference to the new alternative.
-
-* Executables configured with `supportInterpreter := true` on Windows should now be run via `lake exe` to function properly.
-
-* Automatically generated equational theorems are now named using suffix `.eq_<idx>` instead of `._eq_<idx>`, and `.eq_def` instead of `._unfold`. Example:
-```
-def fact : Nat → Nat
-  | 0 => 1
-  | n+1 => (n+1) * fact n
-
-theorem ex : fact 0 = 1 := by unfold fact; decide
-
-#check fact.eq_1
--- fact.eq_1 : fact 0 = 1
-
-#check fact.eq_2
--- fact.eq_2 (n : Nat) : fact (Nat.succ n) = (n + 1) * fact n
-
-#check fact.eq_def
-/-
-fact.eq_def :
-  ∀ (x : Nat),
-    fact x =
-      match x with
-      | 0 => 1
-      | Nat.succ n => (n + 1) * fact n
--/
-```
-
-* The coercion from `String` to `Name` was removed. Previously, it was `Name.mkSimple`, which does not separate strings at dots, but experience showed that this is not always the desired coercion. For the previous behavior, manually insert a call to `Name.mkSimple`.
-
-* The `Subarray` fields `as`, `h₁` and `h₂` have been renamed to `array`, `start_le_stop`, and `stop_le_array_size`, respectively. This more closely follows standard Lean conventions. Deprecated aliases for the field projections were added; these will be removed in a future release.
-
-* The change to the instance name algorithm (described above) can break projects that made use of the auto-generated names.
-
-* `Option.toMonad` has been renamed to `Option.getM` and the unneeded `[Monad m]` instance argument has been removed.

releases/v4.9.0.md

@@ -1,321 +0,0 @@
-v4.9.0
-----------
-
-### Language features, tactics, and metaprograms
-
-* **Definition transparency**
-  * [#4053](https://github.com/leanprover/lean4/pull/4053) adds the `seal` and `unseal` commands, which make definitions locally be irreducible or semireducible.
-  * [#4061](https://github.com/leanprover/lean4/pull/4061) marks functions defined by well-founded recursion with `@[irreducible]` by default,
-    which should prevent the expensive and often unfruitful unfolding of such definitions (see breaking changes below).
-* **Incrementality**
-  * [#3940](https://github.com/leanprover/lean4/pull/3940) extends incremental elaboration into various steps inside of declarations:
-    definition headers, bodies, and tactics.
-    ![Recording 2024-05-10](https://github.com/leanprover/lean4/assets/109126/c9d67b6f-c131-4bc3-a0de-7d63eaf1bfc9).
-  * [250994](https://github.com/leanprover/lean4/commit/250994166ce036ab8644e459129f51ea79c1c2d2)
-    and [67338b](https://github.com/leanprover/lean4/commit/67338bac2333fa39a8656e8f90574784e4c23d3d)
-    add `@[incremental]` attribute to mark an elaborator as supporting incremental elaboration.
-  * [#4259](https://github.com/leanprover/lean4/pull/4259) improves resilience by ensuring incremental commands and tactics are reached only in supported ways.
-  * [#4268](https://github.com/leanprover/lean4/pull/4268) adds special handling for `:= by` so that stray tokens in tactic blocks do not inhibit incrementality.
-  * [#4308](https://github.com/leanprover/lean4/pull/4308) adds incremental `have` tactic.
-  * [#4340](https://github.com/leanprover/lean4/pull/4340) fixes incorrect info tree reuse.
-  * [#4364](https://github.com/leanprover/lean4/pull/4364) adds incrementality for careful command macros such as `set_option in theorem`, `theorem foo.bar`, and `lemma`.
-  * [#4395](https://github.com/leanprover/lean4/pull/4395) adds conservative fix for whitespace handling to avoid incremental reuse leading to goals in front of the text cursor being shown.
-  * [#4407](https://github.com/leanprover/lean4/pull/4407) fixes non-incremental commands in macros blocking further incremental reporting.
-  * [#4436](https://github.com/leanprover/lean4/pull/4436) fixes incremental reporting when there are nested tactics in terms.
-  * [#4459](https://github.com/leanprover/lean4/pull/4459) adds incrementality support for `next` and `if` tactics.
-  * [#4554](https://github.com/leanprover/lean4/pull/4554) disables incrementality for tactics in terms in tactics.
-* **Functional induction**
-  * [#4135](https://github.com/leanprover/lean4/pull/4135) ensures that the names used for functional induction are reserved.
-  * [#4327](https://github.com/leanprover/lean4/pull/4327) adds support for structural recursion on reflexive types.
-    For example,
-    ```lean4
-    inductive Many (α : Type u) where
-      | none : Many α
-      | more : α → (Unit → Many α) → Many α
-
-    def Many.map {α β : Type u} (f : α → β) : Many α → Many β
-      | .none => .none
-      | .more x xs => .more (f x) (fun _ => (xs ()).map f)
-
-    #check Many.map.induct
-    /-
-    Many.map.induct {α β : Type u} (f : α → β) (motive : Many α → Prop)
-      (case1 : motive Many.none)
-      (case2 : ∀ (x : α) (xs : Unit → Many α), motive (xs ()) → motive (Many.more x xs)) :
-      ∀ (a : Many α), motive a
-    -/
-    ```
-* [#3903](https://github.com/leanprover/lean4/pull/3903) makes the Lean frontend normalize all line endings to LF before processing.
-  This lets Lean be insensitive to CRLF vs LF line endings, improving the cross-platform experience and making Lake hashes be faithful to what Lean processes.
-* [#4130](https://github.com/leanprover/lean4/pull/4130) makes the tactic framework be able to recover from runtime errors (for example, deterministic timeouts or maximum recursion depth errors).
-* `split` tactic
-  * [#4211](https://github.com/leanprover/lean4/pull/4211) fixes `split at h` when `h` has forward dependencies.
-  * [#4349](https://github.com/leanprover/lean4/pull/4349) allows `split` for `if`-expressions to work on non-propositional goals.
-* `apply` tactic
-  * [#3929](https://github.com/leanprover/lean4/pull/3929) makes error message for `apply` show implicit arguments in unification errors as needed.
-    Modifies `MessageData` type (see breaking changes below).
-* `cases` tactic
-  * [#4224](https://github.com/leanprover/lean4/pull/4224) adds support for unification of offsets such as `x + 20000 = 20001` in `cases` tactic.
-* `omega` tactic
-  * [#4073](https://github.com/leanprover/lean4/pull/4073) lets `omega` fall back to using classical `Decidable` instances when setting up contradiction proofs.
-  * [#4141](https://github.com/leanprover/lean4/pull/4141) and [#4184](https://github.com/leanprover/lean4/pull/4184) fix bugs.
-  * [#4264](https://github.com/leanprover/lean4/pull/4264) improves `omega` error message if no facts found in local context.
-  * [#4358](https://github.com/leanprover/lean4/pull/4358) improves expression matching in `omega` by using `match_expr`.
-* `simp` tactic
-  * [#4176](https://github.com/leanprover/lean4/pull/4176) makes names of erased lemmas clickable.
-  * [#4208](https://github.com/leanprover/lean4/pull/4208) adds a pretty printer for discrimination tree keys.
-  * [#4202](https://github.com/leanprover/lean4/pull/4202) adds `Simp.Config.index` configuration option,
-    which controls whether to use the full discrimination tree when selecting candidate simp lemmas.
-    When `index := false`, only the head function is taken into account, like in Lean 3.
-    This feature can help users diagnose tricky simp failures or issues in code from libraries
-    developed using Lean 3 and then ported to Lean 4.
-
-    In the following example, it will report that `foo` is a problematic theorem.
-    ```lean
-    opaque f : Nat → Nat → Nat
-
-    @[simp] theorem foo : f x (x, y).2 = y := by sorry
-
-    example : f a b ≤ b := by
-      set_option diagnostics true in
-      simp (config := { index := false })
-    /-
-    [simp] theorems with bad keys
-      foo, key: f _ (@Prod.mk ℕ ℕ _ _).2
-    -/
-    ```
-    With the information above, users can annotate theorems such as `foo` using `no_index` for problematic subterms. Example:
-    ```lean
-    opaque f : Nat → Nat → Nat
-
-    @[simp] theorem foo : f x (no_index (x, y).2) = y := by sorry
-
-    example : f a b ≤ b := by
-      simp -- `foo` is still applied with `index := true`
-    ```
-  * [#4274](https://github.com/leanprover/lean4/pull/4274) prevents internal `match` equational theorems from appearing in simp trace.
-  * [#4177](https://github.com/leanprover/lean4/pull/4177) and [#4359](https://github.com/leanprover/lean4/pull/4359) make `simp` continue even if a simp lemma does not elaborate, if the tactic state is in recovery mode.
-  * [#4341](https://github.com/leanprover/lean4/pull/4341) fixes panic when applying `@[simp]` to malformed theorem syntax.
-  * [#4345](https://github.com/leanprover/lean4/pull/4345) fixes `simp` so that it does not use the forward version of a user-specified backward theorem.
-  * [#4352](https://github.com/leanprover/lean4/pull/4352) adds missing `dsimp` simplifications for fixed parameters of generated congruence theorems.
-  * [#4362](https://github.com/leanprover/lean4/pull/4362) improves trace messages for `simp` so that constants are hoverable.
-* **Elaboration**
-  * [#4046](https://github.com/leanprover/lean4/pull/4046) makes subst notation (`he ▸ h`) try rewriting in both directions even when there is no expected type available.
-  * [#3328](https://github.com/leanprover/lean4/pull/3328) adds support for identifiers in autoparams (for example, `rfl` in `(h : x = y := by exact rfl)`).
-  * [#4096](https://github.com/leanprover/lean4/pull/4096) changes how the type in `let` and `have` is elaborated, requiring that any tactics in the type be evaluated before proceeding, improving performance.
-  * [#4215](https://github.com/leanprover/lean4/pull/4215) ensures the expression tree elaborator commits to the computed "max type" for the entire arithmetic expression.
-  * [#4267](https://github.com/leanprover/lean4/pull/4267) cases signature elaboration errors to show even if there are parse errors in the body.
-  * [#4368](https://github.com/leanprover/lean4/pull/4368) improves error messages when numeric literals fail to synthesize an `OfNat` instance,
-    including special messages warning when the expected type of the numeral can be a proposition.
-  * [#4643](https://github.com/leanprover/lean4/pull/4643) fixes issue leading to nested error messages and info trees vanishing, where snapshot subtrees were not restored on reuse.
-  * [#4657](https://github.com/leanprover/lean4/pull/4657) calculates error suppression per snapshot, letting elaboration errors appear even when there are later parse errors ([RFC #3556](https://github.com/leanprover/lean4/issues/3556)).
-* **Metaprogramming**
-  * [#4167](https://github.com/leanprover/lean4/pull/4167) adds `Lean.MVarId.revertAll` to revert all free variables.
-  * [#4169](https://github.com/leanprover/lean4/pull/4169) adds `Lean.MVarId.ensureNoMVar` to ensure the goal's target contains no expression metavariables.
-  * [#4180](https://github.com/leanprover/lean4/pull/4180) adds `cleanupAnnotations` parameter to `forallTelescope` methods.
-  * [#4307](https://github.com/leanprover/lean4/pull/4307) adds support for parser aliases in syntax quotations.
-* Work toward implementing `grind` tactic
-  * [0a515e](https://github.com/leanprover/lean4/commit/0a515e2ec939519dafb4b99daa81d6bf3c411404)
-    and [#4164](https://github.com/leanprover/lean4/pull/4164)
-    add `grind_norm` and `grind_norm_proc` attributes and `@[grind_norm]` theorems.
-  * [#4170](https://github.com/leanprover/lean4/pull/4170), [#4221](https://github.com/leanprover/lean4/pull/4221),
-    and [#4249](https://github.com/leanprover/lean4/pull/4249) create `grind` preprocessor and core module.
-  * [#4235](https://github.com/leanprover/lean4/pull/4235) and [d6709e](https://github.com/leanprover/lean4/commit/d6709eb1576c5d40fc80462637dc041f970e4d9f)
-    add special `cases` tactic to `grind` along with `@[grind_cases]` attribute to mark types that this `cases` tactic should automatically apply to.
-  * [#4243](https://github.com/leanprover/lean4/pull/4243) adds special `injection?` tactic to `grind`.
-* **Other fixes or improvements**
-  * [#4065](https://github.com/leanprover/lean4/pull/4065) fixes a bug in the `Nat.reduceLeDiff` simproc.
-  * [#3969](https://github.com/leanprover/lean4/pull/3969) makes deprecation warnings activate even for generalized field notation ("dot notation").
-  * [#4132](https://github.com/leanprover/lean4/pull/4132) fixes the `sorry` term so that it does not activate the implicit lambda feature
-  * [9803c5](https://github.com/leanprover/lean4/commit/9803c5dd63dc993628287d5f998525e74af03839)
-    and [47c8e3](https://github.com/leanprover/lean4/commit/47c8e340d65b01f4d9f011686e3dda0d4bb30a20)
-    move `cdot` and `calc` parsers to `Lean` namespace.
-  * [#4252](https://github.com/leanprover/lean4/pull/4252) fixes the `case` tactic so that it is usable in macros by having it erase macro scopes from the tag.
-  * [26b671](https://github.com/leanprover/lean4/commit/26b67184222e75529e1b166db050aaebee323d2d)
-    and [cc33c3](https://github.com/leanprover/lean4/commit/cc33c39cb022d8a3166b1e89677c78835ead1fc7)
-    extract `haveId` syntax.
-  * [#4335](https://github.com/leanprover/lean4/pull/4335) fixes bugs in partial `calc` tactic when there is mdata or metavariables.
-  * [#4329](https://github.com/leanprover/lean4/pull/4329) makes `termination_by?` report unused each unused parameter as `_`.
-* **Docs:** [#4238](https://github.com/leanprover/lean4/pull/4238), [#4294](https://github.com/leanprover/lean4/pull/4294),
-  [#4338](https://github.com/leanprover/lean4/pull/4338).
-
-### Language server, widgets, and IDE extensions
-* [#4066](https://github.com/leanprover/lean4/pull/4066) fixes features like "Find References" when browsing core Lean sources.
-* [#4254](https://github.com/leanprover/lean4/pull/4254) allows embedding user widgets in structured messages.
-  Companion PR is [vscode-lean4#449](https://github.com/leanprover/vscode-lean4/pull/449).
-* [#4445](https://github.com/leanprover/lean4/pull/4445) makes watchdog more resilient against badly behaving clients.
-
-### Library
-* [#4059](https://github.com/leanprover/lean4/pull/4059) upstreams many `List` and `Array` operations and theorems from Batteries.
-* [#4055](https://github.com/leanprover/lean4/pull/4055) removes the unused `Inhabited` instance for `Subtype`.
-* [#3967](https://github.com/leanprover/lean4/pull/3967) adds dates in existing `@[deprecated]` attributes.
-* [#4231](https://github.com/leanprover/lean4/pull/4231) adds boilerplate `Char`, `UInt`, and `Fin` theorems.
-* [#4205](https://github.com/leanprover/lean4/pull/4205) fixes the `MonadStore` type classes to use `semiOutParam`.
-* [#4350](https://github.com/leanprover/lean4/pull/4350) renames `IsLawfulSingleton` to `LawfulSingleton`.
-* `Nat`
-  * [#4094](https://github.com/leanprover/lean4/pull/4094) swaps `Nat.zero_or` and `Nat.or_zero`.
-  * [#4098](https://github.com/leanprover/lean4/pull/4098) and [#4145](https://github.com/leanprover/lean4/pull/4145)
-    change the definition of `Nat.mod` so that `n % (m + n)` reduces when `n` is literal without relying on well-founded recursion,
-    which becomes irreducible by default in [#4061](https://github.com/leanprover/lean4/pull/4061).
-  * [#4188](https://github.com/leanprover/lean4/pull/4188) redefines `Nat.testBit` to be more performant.
-  * Theorems: [#4199](https://github.com/leanprover/lean4/pull/4199).
-* `Array`
-  * [#4074](https://github.com/leanprover/lean4/pull/4074) improves the functional induction principle `Array.feraseIdx.induct`.
-* `List`
-  * [#4172](https://github.com/leanprover/lean4/pull/4172) removes `@[simp]` from `List.length_pos`.
-* `Option`
-  * [#4037](https://github.com/leanprover/lean4/pull/4037) adds theorems to simplify `Option`-valued dependent if-then-else.
-  * [#4314](https://github.com/leanprover/lean4/pull/4314) removes `@[simp]` from `Option.bind_eq_some`.
-* `BitVec`
-  * Theorems: [#3920](https://github.com/leanprover/lean4/pull/3920), [#4095](https://github.com/leanprover/lean4/pull/4095),
-    [#4075](https://github.com/leanprover/lean4/pull/4075), [#4148](https://github.com/leanprover/lean4/pull/4148),
-    [#4165](https://github.com/leanprover/lean4/pull/4165), [#4178](https://github.com/leanprover/lean4/pull/4178),
-    [#4200](https://github.com/leanprover/lean4/pull/4200), [#4201](https://github.com/leanprover/lean4/pull/4201),
-    [#4298](https://github.com/leanprover/lean4/pull/4298), [#4299](https://github.com/leanprover/lean4/pull/4299),
-    [#4257](https://github.com/leanprover/lean4/pull/4257), [#4179](https://github.com/leanprover/lean4/pull/4179),
-    [#4321](https://github.com/leanprover/lean4/pull/4321), [#4187](https://github.com/leanprover/lean4/pull/4187).
-  * [#4193](https://github.com/leanprover/lean4/pull/4193) adds simprocs for reducing `x >>> i` and `x <<< i` where `i` is a bitvector literal.
-  * [#4194](https://github.com/leanprover/lean4/pull/4194) adds simprocs for reducing `(x <<< i) <<< j` and `(x >>> i) >>> j` where `i` and `j` are natural number literals.
-  * [#4229](https://github.com/leanprover/lean4/pull/4229) redefines `rotateLeft`/`rotateRight` to use modulo reduction of shift offset.
-  * [0d3051](https://github.com/leanprover/lean4/commit/0d30517dca094a07bcb462252f718e713b93ffba) makes `<num>#<term>` bitvector literal notation global.
-* `Char`/`String`
-  * [#4143](https://github.com/leanprover/lean4/pull/4143) modifies `String.substrEq` to avoid linter warnings in downstream code.
-  * [#4233](https://github.com/leanprover/lean4/pull/4233) adds simprocs for `Char` and `String` inequalities.
-  * [#4348](https://github.com/leanprover/lean4/pull/4348) upstreams Mathlib lemmas.
-  * [#4354](https://github.com/leanprover/lean4/pull/4354) upstreams basic `String` lemmas.
-* `HashMap`
-  * [#4248](https://github.com/leanprover/lean4/pull/4248) fixes implicitness of typeclass arguments in `HashMap.ofList`.
-* `IO`
-  * [#4036](https://github.com/leanprover/lean4/pull/4036) adds `IO.Process.getCurrentDir` and `IO.Process.setCurrentDir` for adjusting the current process's working directory.
-* **Cleanup:** [#4077](https://github.com/leanprover/lean4/pull/4077), [#4189](https://github.com/leanprover/lean4/pull/4189),
-  [#4304](https://github.com/leanprover/lean4/pull/4304).
-* **Docs:** [#4001](https://github.com/leanprover/lean4/pull/4001), [#4166](https://github.com/leanprover/lean4/pull/4166),
-  [#4332](https://github.com/leanprover/lean4/pull/4332).
-
-### Lean internals
-* **Defeq and WHNF algorithms**
-  * [#4029](https://github.com/leanprover/lean4/pull/4029) remove unnecessary `checkpointDefEq`
-  * [#4206](https://github.com/leanprover/lean4/pull/4206) fixes `isReadOnlyOrSyntheticOpaque` to respect metavariable depth.
-  * [#4217](https://github.com/leanprover/lean4/pull/4217) fixes missing occurs check for delayed assignments.
-* **Definition transparency**
-  * [#4052](https://github.com/leanprover/lean4/pull/4052) adds validation to application of `@[reducible]`/`@[semireducible]`/`@[irreducible]` attributes (with `local`/`scoped` modifiers as well).
-    Setting `set_option allowUnsafeReductibility true` turns this validation off.
-* **Inductive types**
-  * [#3591](https://github.com/leanprover/lean4/pull/3591) fixes a bug where indices could be incorrectly promoted to parameters.
-  * [#3398](https://github.com/leanprover/lean4/pull/3398) fixes a bug in the injectivity theorem generator.
-  * [#4342](https://github.com/leanprover/lean4/pull/4342) fixes elaboration of mutual inductives with instance parameters.
-* **Diagnostics and profiling**
-  * [#3986](https://github.com/leanprover/lean4/pull/3986) adds option `trace.profiler.useHeartbeats` to switch `trace.profiler.threshold` to being in terms of heartbeats instead of milliseconds.
-  * [#4082](https://github.com/leanprover/lean4/pull/4082) makes `set_option diagnostics true` report kernel diagnostic information.
-* **Typeclass resolution**
-  * [#4119](https://github.com/leanprover/lean4/pull/4119) fixes multiple issues with TC caching interacting with `synthPendingDepth`, adds `maxSynthPendingDepth` option with default value `1`.
-  * [#4210](https://github.com/leanprover/lean4/pull/4210) ensures local instance cache does not contain multiple copies of the same instance.
-  * [#4216](https://github.com/leanprover/lean4/pull/4216) fix handling of metavariables, to avoid needing to set the option `backward.synthInstance.canonInstances` to `false`.
-* **Other fixes or improvements**
-  * [#4080](https://github.com/leanprover/lean4/pull/4080) fixes propagation of state for `Lean.Elab.Command.liftCoreM` and `Lean.Elab.Command.liftTermElabM`.
-  * [#3944](https://github.com/leanprover/lean4/pull/3944) makes the `Repr` deriving handler be consistent between `structure` and `inductive` for how types and proofs are erased.
-  * [#4113](https://github.com/leanprover/lean4/pull/4113) propagates `maxHeartbeats` to kernel to control "(kernel) deterministic timeout" error.
-  * [#4125](https://github.com/leanprover/lean4/pull/4125) reverts [#3970](https://github.com/leanprover/lean4/pull/3970) (monadic generalization of `FindExpr`).
-  * [#4128](https://github.com/leanprover/lean4/pull/4128) catches stack overflow in auto-bound implicits feature.
-  * [#4129](https://github.com/leanprover/lean4/pull/4129) adds `tryCatchRuntimeEx` combinator to replace `catchRuntimeEx` reader state.
-  * [#4155](https://github.com/leanprover/lean4/pull/4155) simplifies the expression canonicalizer.
-  * [#4151](https://github.com/leanprover/lean4/pull/4151) and [#4369](https://github.com/leanprover/lean4/pull/4369)
-    add many missing trace classes.
-  * [#4185](https://github.com/leanprover/lean4/pull/4185) makes congruence theorem generators clean up type annotations of argument types.
-  * [#4192](https://github.com/leanprover/lean4/pull/4192) fixes restoration of infotrees when auto-bound implicit feature is activated,
-    fixing a pretty printing error in hovers and strengthening the unused variable linter.
-  * [dfb496](https://github.com/leanprover/lean4/commit/dfb496a27123c3864571aec72f6278e2dad1cecf) fixes `declareBuiltin` to allow it to be called multiple times per declaration.
-  * [#4569](https://github.com/leanprover/lean4/pull/4569) fixes an issue introduced in a merge conflict, where the interrupt exception was swallowed by some `tryCatchRuntimeEx` uses.
-  * [#4584](https://github.com/leanprover/lean4/pull/4584) (backported as [b056a0](https://github.com/leanprover/lean4/commit/b056a0b395bb728512a3f3e83bf9a093059d4301)) adapts kernel interruption to the new cancellation system.
-  * Cleanup: [#4112](https://github.com/leanprover/lean4/pull/4112), [#4126](https://github.com/leanprover/lean4/pull/4126), [#4091](https://github.com/leanprover/lean4/pull/4091), [#4139](https://github.com/leanprover/lean4/pull/4139), [#4153](https://github.com/leanprover/lean4/pull/4153).
-  * Tests: [030406](https://github.com/leanprover/lean4/commit/03040618b8f9b35b7b757858483e57340900cdc4), [#4133](https://github.com/leanprover/lean4/pull/4133).
-
-### Compiler, runtime, and FFI
-* [#4100](https://github.com/leanprover/lean4/pull/4100) improves reset/reuse algorithm; it now runs a second pass relaxing the constraint that reused memory cells must only be for the exact same constructor.
-* [#2903](https://github.com/leanprover/lean4/pull/2903) fixes segfault in old compiler from mishandling `noConfusion` applications.
-* [#4311](https://github.com/leanprover/lean4/pull/4311) fixes bug in constant folding.
-* [#3915](https://github.com/leanprover/lean4/pull/3915) documents the runtime memory layout for inductive types.
-
-### Lake
-* [#4518](https://github.com/leanprover/lean4/pull/4518) makes trace reading more robust. Lake now rebuilds if trace files are invalid or unreadable and is backwards compatible with previous pure numeric traces.
-* [#4057](https://github.com/leanprover/lean4/pull/4057) adds support for docstrings on `require` commands.
-* [#4088](https://github.com/leanprover/lean4/pull/4088) improves hovers for `family_def` and `library_data` commands.
-* [#4147](https://github.com/leanprover/lean4/pull/4147) adds default `README.md` to package templates
-* [#4261](https://github.com/leanprover/lean4/pull/4261) extends `lake test` help page, adds help page for `lake check-test`,
-  adds `lake lint` and tag `@[lint_driver]`, adds support for specifying test and lint drivers from dependencies,
-  adds `testDriverArgs` and `lintDriverArgs` options, adds support for library test drivers,
-  makes `lake check-test` and `lake check-lint` only load the package without dependencies.
-* [#4270](https://github.com/leanprover/lean4/pull/4270) adds `lake pack` and `lake unpack` for packing and unpacking Lake build artifacts from an archive.
-* [#4083](https://github.com/leanprover/lean4/pull/4083)
-  Switches the manifest format to use `major.minor.patch` semantic
-  versions. Major version increments indicate breaking changes (e.g., new
-  required fields and semantic changes to existing fields). Minor version
-  increments (after `0.x`) indicate backwards-compatible extensions (e.g.,
-  adding optional fields, removing fields). This change is backwards
-  compatible. Lake will still successfully read old manifests with numeric
-  versions. It will treat the numeric version `N` as semantic version
-  `0.N.0`. Lake will also accept manifest versions with `-` suffixes
-  (e.g., `x.y.z-foo`) and then ignore the suffix.
-* [#4273](https://github.com/leanprover/lean4/pull/4273) adds a lift from `JobM` to `FetchM` for backwards compatibility reasons.
-* [#4351](https://github.com/leanprover/lean4/pull/4351) fixes `LogIO`-to-`CliM`-lifting performance issues.
-* [#4343](https://github.com/leanprover/lean4/pull/4343) make Lake store the dependency trace for a build in
-  the cached build long and then verifies that it matches the trace of the current build before replaying the log.
-* [#4402](https://github.com/leanprover/lean4/pull/4402) moves the cached log into the trace file (no more `.log.json`).
-  This means logs are no longer cached on fatal errors and this ensures that an out-of-date log is not associated with an up-to-date trace.
-  Separately, `.hash` file generation was changed to be more reliable as well.
-  The `.hash` files are deleted as part of the build and always regenerate with `--rehash`.
-* **Other fixes or improvements**
-  * [#4056](https://github.com/leanprover/lean4/pull/4056) cleans up tests
-  * [#4244](https://github.com/leanprover/lean4/pull/4244) fixes `noRelease` test when Lean repo is tagged
-  * [#4346](https://github.com/leanprover/lean4/pull/4346) improves `tests/serve`
-  * [#4356](https://github.com/leanprover/lean4/pull/4356) adds build log path to the warning for a missing or invalid build log.
-
-### DevOps
-* [#3984](https://github.com/leanprover/lean4/pull/3984) adds a script (`script/rebase-stage0.sh`) for `git rebase -i` that automatically updates each stage0.
-* [#4108](https://github.com/leanprover/lean4/pull/4108) finishes renamings from transition to Std to Batteries.
-* [#4109](https://github.com/leanprover/lean4/pull/4109) adjusts the Github bug template to mention testing using [live.lean-lang.org](https://live.lean-lang.org).
-* [#4136](https://github.com/leanprover/lean4/pull/4136) makes CI rerun only when `full-ci` label is added or removed.
-* [#4175](https://github.com/leanprover/lean4/pull/4175) and [72b345](https://github.com/leanprover/lean4/commit/72b345c621a9a06d3a5a656da2b793a5eea5f168)
-  switch to using `#guard_msgs` to run tests as much as possible.
-* [#3125](https://github.com/leanprover/lean4/pull/3125) explains the Lean4 `pygments` lexer.
-* [#4247](https://github.com/leanprover/lean4/pull/4247) sets up a procedure for preparing release notes.
-* [#4032](https://github.com/leanprover/lean4/pull/4032) modernizes build instructions and workflows.
-* [#4255](https://github.com/leanprover/lean4/pull/4255) moves some expensive checks from merge queue to releases.
-* [#4265](https://github.com/leanprover/lean4/pull/4265) adds aarch64 macOS as native compilation target for CI.
-* [f05a82](https://github.com/leanprover/lean4/commit/f05a82799a01569edeb5e2594cd7d56282320f9e) restores macOS aarch64 install suffix in CI
-* [#4317](https://github.com/leanprover/lean4/pull/4317) updates build instructions for macOS.
-* [#4333](https://github.com/leanprover/lean4/pull/4333) adjusts workflow to update Batteries in manifest when creating `lean-pr-testing-NNNN` Mathlib branches.
-* [#4355](https://github.com/leanprover/lean4/pull/4355) simplifies `lean4checker` step of release checklist.
-* [#4361](https://github.com/leanprover/lean4/pull/4361) adds installing elan to `pr-release` CI step.
-* [#4628](https://github.com/leanprover/lean4/pull/4628) fixes the Windows build, which was missing an exported symbol.
-
-### Breaking changes
-While most changes could be considered to be a breaking change, this section makes special note of API changes.
-
-* `Nat.zero_or` and `Nat.or_zero` have been swapped ([#4094](https://github.com/leanprover/lean4/pull/4094)).
-* `IsLawfulSingleton` is now `LawfulSingleton` ([#4350](https://github.com/leanprover/lean4/pull/4350)).
-* The `BitVec` literal notation is now `<num>#<term>` rather than `<term>#<term>`, and it is global rather than scoped. Use `BitVec.ofNat w x` rather than `x#w` when `x` is a not a numeric literal ([0d3051](https://github.com/leanprover/lean4/commit/0d30517dca094a07bcb462252f718e713b93ffba)).
-* `BitVec.rotateLeft` and `BitVec.rotateRight` now take the shift modulo the bitwidth ([#4229](https://github.com/leanprover/lean4/pull/4229)).
-* These are no longer simp lemmas:
-  `List.length_pos` ([#4172](https://github.com/leanprover/lean4/pull/4172)),
-  `Option.bind_eq_some` ([#4314](https://github.com/leanprover/lean4/pull/4314)).
-* Types in `let` and `have` (both the expressions and tactics) may fail to elaborate due to new restrictions on what sorts of elaboration problems may be postponed ([#4096](https://github.com/leanprover/lean4/pull/4096)).
-  In particular, tactics embedded in the type will no longer make use of the type of `value` in expressions such as `let x : type := value; body`.
-* Now functions defined by well-founded recursion are marked with `@[irreducible]` by default ([#4061](https://github.com/leanprover/lean4/pull/4061)).
-  Existing proofs that hold by definitional equality (e.g. `rfl`) can be
-  rewritten to explicitly unfold the function definition (using `simp`,
-  `unfold`, `rw`), or the recursive function can be temporarily made
-  semireducible (using `unseal f in` before the command), or the function
-  definition itself can be marked as `@[semireducible]` to get the previous
-  behavior.
-* Due to [#3929](https://github.com/leanprover/lean4/pull/3929):
-  * The `MessageData.ofPPFormat` constructor has been removed.
-    Its functionality has been split into two:
-
-    - for lazy structured messages, please use `MessageData.lazy`;
-    - for embedding `Format` or `FormatWithInfos`, use `MessageData.ofFormatWithInfos`.
-
-    An example migration can be found in [#3929](https://github.com/leanprover/lean4/pull/3929/files#diff-5910592ab7452a0e1b2616c62d22202d2291a9ebb463145f198685aed6299867L109).
-
-  * The `MessageData.ofFormat` constructor has been turned into a function.
-    If you need to inspect `MessageData`, you can pattern-match on `MessageData.ofFormatWithInfos`.

releases_drafts/README.md

@@ -1,22 +1,19 @@
 Draft release notes
 -------------------
 
-This folder contains drafts of release notes for inclusion in `RELEASES.md`.
+This folder contains drafts of release notes for the upcoming version.
 During the process to create a release candidate, we look through all the commits that make up the release
 to prepare the release notes, and in that process we take these drafts into account.
 
 Guidelines:
-- You should prefer adding release notes to commit messages over adding anything to this folder.
-  A release note should briefly explain the impact of a change from a user's point of view.
-  Please mark these parts out with words such as **release notes** and/or **breaking changes**.
-- It is not necessary to add anything to this folder. It is meant for larger features that span multiple PRs,
+- Write good commit messages
+  The first paragraph should briefly explain the impact of a change from a user's point of view.
+  (Recall: the first paragraph, which should begin with "This PR",
+  is automatically incorporated into the release notes by `script/release_notes.py`.
+  See `doc/dev/release_checklist.md` for more details.).
+- This folder is only needed for larger features that span multiple PRs,
   or for anything that would be helpful when preparing the release notes that might be missed
   by someone reading through the change log.
-- If the PR that adds a feature simultaneously adds a draft release note, including the PR number is not required
-  since it can be obtained from the git history for the file.
 
-When release notes are prepared, all the draft release notes are deleted from this folder.
-For release candidates beyond the first one, you can either update `RELEASE.md` directly
-or continue to add drafts.
-
-When a release is finalized, we will copy the completed release notes from `RELEASE.md` to the `master` branch.
+When notes from this folder are incorporated into the [Lean Language Reference](https://lean-lang.org/doc/reference/latest/releases/#release-notes),
+they should then be deleted from here.

releases_drafts/environment.md

@@ -0,0 +1,6 @@
+**Breaking Changes**
+
+* The functions `Lean.Environment.importModules` and `Lean.Environment.finalizeImport` have been extended with a new parameter `loadExts : Bool := false` that enables environment extension state loading.
+  Their previous behavior corresponds to setting the flag to `true` but is only safe to do in combination with `enableInitializersExecution`; see also the `importModules` docstring.
+  The new default value `false` ensures the functions can be used correctly multiple times within the same process when environment extension access is not needed.
+  The wrapper function `Lean.Environment.withImportModules` now always calls `importModules` with `loadExts := false` as it is incompatible with extension loading.

script/benchReelabRss.lean

@@ -0,0 +1,70 @@
+import Lean.Data.Lsp
+import Lean.Elab.Import
+open Lean
+open Lean.Lsp
+open Lean.JsonRpc
+
+/-!
+Tests language server memory use by repeatedly re-elaborate a given file.
+
+NOTE: only works on Linux for now.
+-/
+
+def main (args : List String) : IO Unit := do
+  let leanCmd :: file :: iters :: args := args | panic! "usage: script <lean> <file> <#iterations> <server-args>..."
+  let file ← IO.FS.realPath file
+  let uri := s!"file://{file}"
+  Ipc.runWith leanCmd (#["--worker", "-DstderrAsMessages=false"] ++ args ++ #[uri]) do
+  -- for use with heaptrack:
+  --Ipc.runWith "heaptrack" (#[leanCmd, "--worker", "-DstderrAsMessages=false"] ++ args ++ #[uri]) do
+  --  -- heaptrack has no quiet mode??
+  --  let _ ← (← Ipc.stdout).getLine
+  --  let _ ← (← Ipc.stdout).getLine
+    let capabilities := {
+      textDocument? := some {
+        completion? := some {
+          completionItem? := some {
+            insertReplaceSupport? := true
+          }
+        }
+      }
+    }
+    Ipc.writeRequest ⟨0, "initialize", { capabilities : InitializeParams }⟩
+
+    let text ← IO.FS.readFile file
+    let (_, headerEndPos, _) ← Elab.parseImports text
+    let headerEndPos := FileMap.ofString text |>.leanPosToLspPos headerEndPos
+    let mut requestNo : Nat := 1
+    let mut versionNo : Nat := 1
+    Ipc.writeNotification ⟨"textDocument/didOpen", {
+      textDocument := { uri := uri, languageId := "lean", version := 1, text := text } : DidOpenTextDocumentParams }⟩
+    for i in [0:iters.toNat!] do
+      if i > 0 then
+        versionNo := versionNo + 1
+        let params : DidChangeTextDocumentParams := {
+          textDocument := {
+            uri      := uri
+            version? := versionNo
+          }
+          contentChanges := #[TextDocumentContentChangeEvent.rangeChange {
+            start := headerEndPos
+            «end» := headerEndPos
+          } " "]
+        }
+        let params := toJson params
+        Ipc.writeNotification ⟨"textDocument/didChange", params⟩
+        requestNo := requestNo + 1
+
+      let diags ← Ipc.collectDiagnostics requestNo uri versionNo
+      if let some diags := diags then
+        for diag in diags.param.diagnostics do
+          IO.eprintln diag.message
+      requestNo := requestNo + 1
+
+      let status ← IO.FS.readFile s!"/proc/{(← read).pid}/status"
+      for line in status.splitOn "\n" |>.filter (·.startsWith "RssAnon") do
+        IO.eprintln line
+
+    let _ ← Ipc.collectDiagnostics requestNo uri versionNo
+    (← Ipc.stdin).writeLspMessage (Message.notification "exit" none)
+    discard <| Ipc.waitForExit

script/merge_remote.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+
+"""
+Merge a tag into a branch on a GitHub repository.
+
+This script checks if a specified tag can be merged cleanly into a branch and performs
+the merge if possible. If the merge cannot be done cleanly, it prints a helpful message.
+
+Usage:
+    python3 merge_remote.py <org/repo> <branch> <tag>
+
+Arguments:
+    org/repo: GitHub repository in the format 'organization/repository'
+    branch: The target branch to merge into
+    tag: The tag to merge from
+
+Example:
+    python3 merge_remote.py leanprover/mathlib4 stable v4.6.0
+
+The script uses the GitHub CLI (`gh`), so make sure it's installed and authenticated.
+"""
+
+import argparse
+import subprocess
+import sys
+import tempfile
+import os
+import shutil
+
+
+def run_command(command, check=True, capture_output=True):
+    """Run a shell command and return the result."""
+    try:
+        result = subprocess.run(
+            command,
+            check=check,
+            shell=True,
+            text=True,
+            capture_output=capture_output
+        )
+        return result
+    except subprocess.CalledProcessError as e:
+        if capture_output:
+            print(f"Command failed: {command}")
+            print(f"Error: {e.stderr}")
+        return e
+
+
+def clone_repo(repo, temp_dir):
+    """Clone the repository to a temporary directory."""
+    print(f"Cloning {repo}...")
+    # Remove shallow clone for better merge detection
+    clone_result = run_command(f"gh repo clone {repo} {temp_dir}", check=False)
+    if clone_result.returncode != 0:
+        print(f"Failed to clone repository {repo}.")
+        print(f"Error: {clone_result.stderr}")
+        return False
+    return True
+
+
+def check_and_merge(repo, branch, tag, temp_dir):
+    """Check if tag can be merged into branch and perform the merge if possible."""
+    # Change to the temporary directory
+    os.chdir(temp_dir)
+    
+    # First fetch the specific remote branch with its history
+    print(f"Fetching branch '{branch}'...")
+    fetch_branch = run_command(f"git fetch origin {branch}:refs/remotes/origin/{branch} --update-head-ok")
+    if fetch_branch.returncode != 0:
+        print(f"Error: Failed to fetch branch '{branch}'.")
+        return False
+    
+    # Then fetch the specific tag
+    print(f"Fetching tag '{tag}'...")
+    fetch_tag = run_command(f"git fetch origin tag {tag}")
+    if fetch_tag.returncode != 0:
+        print(f"Error: Failed to fetch tag '{tag}'.")
+        return False
+    
+    # Check if branch exists now that we've fetched it
+    branch_check = run_command(f"git branch -r | grep origin/{branch}")
+    if branch_check.returncode != 0:
+        print(f"Error: Branch '{branch}' does not exist in repository.")
+        return False
+
+    # Check if tag exists
+    tag_check = run_command(f"git tag -l {tag}")
+    if tag_check.returncode != 0 or not tag_check.stdout.strip():
+        print(f"Error: Tag '{tag}' does not exist in repository.")
+        return False
+
+    # Checkout the branch
+    print(f"Checking out branch '{branch}'...")
+    checkout_result = run_command(f"git checkout -b {branch} origin/{branch}")
+    if checkout_result.returncode != 0:
+        return False
+
+    # Try merging the tag directly
+    print(f"Merging {tag} into {branch}...")
+    merge_result = run_command(f"git merge {tag} --no-edit", check=False)
+    
+    if merge_result.returncode != 0:
+        print(f"Cannot merge {tag} cleanly into {branch}.")
+        print("Merge conflicts would occur. Aborting merge.")
+        run_command("git merge --abort")
+        return False
+    
+    print(f"Pushing changes to remote...")
+    push_result = run_command(f"git push origin {branch}")
+    if push_result.returncode != 0:
+        print(f"Failed to push changes to remote.")
+        return False
+    
+    print(f"Successfully merged {tag} into {branch} and pushed to remote.")
+    return True
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Merge a tag into a branch on a GitHub repository.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s leanprover/mathlib4 stable v4.6.0    Merge tag v4.6.0 into stable branch
+
+The script will:
+1. Clone the repository
+2. Check if the tag and branch exist
+3. Check if the tag can be merged cleanly into the branch
+4. Perform the merge and push to remote if possible
+        """
+    )
+    parser.add_argument("repo", help="GitHub repository in the format 'organization/repository'")
+    parser.add_argument("branch", help="The target branch to merge into")
+    parser.add_argument("tag", help="The tag to merge from")
+    
+    args = parser.parse_args()
+    
+    # Create a temporary directory for the repository
+    temp_dir = tempfile.mkdtemp()
+    try:
+        # Clone the repository
+        if not clone_repo(args.repo, temp_dir):
+            sys.exit(1)
+        
+        # Check if the tag can be merged and perform the merge
+        if not check_and_merge(args.repo, args.branch, args.tag, temp_dir):
+            sys.exit(1)
+        
+    finally:
+        # Clean up the temporary directory
+        print(f"Cleaning up temporary files...")
+        shutil.rmtree(temp_dir)
+
+
+if __name__ == "__main__":
+    main() 

script/prepare-llvm-linux.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-set -uo pipefail
+set -euxo pipefail
 
 # run from root build directory (from inside nix-shell or otherwise defining GLIBC/ZLIB/GMP) as in
 # ```
@@ -14,6 +14,7 @@ set -uo pipefail
 else
   ln -s llvm llvm-host
 fi
+mkdir -p stage0/lib
 mkdir -p stage1/{bin,lib,lib/glibc,include/clang}
 CP="cp -d"  # preserve symlinks
 # a C compiler!
@@ -25,6 +26,8 @@ cp -L llvm/bin/llvm-ar stage1/bin/
 # dependencies of the above
 $CP llvm/lib/lib{clang-cpp,LLVM}*.so* stage1/lib/
 $CP $ZLIB/lib/libz.so* stage1/lib/
+# also copy USE_LLVM deps into stage 0
+$CP llvm/lib/libLLVM*.so* $ZLIB/lib/libz.so* stage0/lib/
 # general clang++ dependency, breaks cross-library C++ exceptions if linked statically
 $CP $GCC_LIB/lib/libgcc_s.so* stage1/lib/
 # bundle libatomic (referenced by LLVM >= 15, and required by the lean executable to run)
@@ -39,20 +42,21 @@ $CP $GLIBC/lib/*crt* stage1/lib/
 # runtime
 (cd llvm; $CP --parents lib/clang/*/lib/*/{clang_rt.*.o,libclang_rt.builtins*} ../stage1)
 $CP llvm/lib/*/lib{c++,c++abi,unwind}.* $GMP/lib/libgmp.a $LIBUV/lib/libuv.a stage1/lib/
-# LLVM 15 appears to ship the dependencies in 'llvm/lib/<target-triple>/' and 'llvm/include/<target-triple>/'
-# but clang-15 that we use to compile is linked against 'llvm/lib/' and 'llvm/include'
+# LLVM 19 appears to ship the dependencies in 'llvm/lib/<target-triple>/' and 'llvm/include/<target-triple>/'
+# but clang-19 that we use to compile is linked against 'llvm/lib/' and 'llvm/include'
 # https://github.com/llvm/llvm-project/issues/54955
 $CP llvm/lib/*/lib{c++,c++abi,unwind}.* llvm/lib/
 $CP llvm-host/lib/*/lib{c++,c++abi,unwind}.* llvm-host/lib/
 # libc++ headers are looked up in the host compiler's root, so copy over target-specific includes
-$CP -r llvm/include/*-*-* llvm-host/include/
+$CP -r llvm/include/*-*-* llvm-host/include/ || true
 # glibc: use for linking (so Lean programs don't embed newer symbol versions), but not for running (because libc.so, librt.so, and ld.so must be compatible)!
 $CP $GLIBC/lib/libc_nonshared.a stage1/lib/glibc
 # libpthread_nonshared.a must be linked in order to be able to use `pthread_atfork(3)`. LibUV uses this function.
 $CP $GLIBC/lib/libpthread_nonshared.a stage1/lib/glibc
-for f in $GLIBC/lib/lib{c,dl,m,rt,pthread}-*; do b=$(basename $f); cp $f stage1/lib/glibc/${b%-*}.so; done
+for f in $GLIBC/lib/{ld,lib{c,dl,m,rt,pthread}}-*; do b=$(basename $f); cp $f stage1/lib/glibc/${b%-*}.so; done
 OPTIONS=()
-echo -n " -DLEAN_STANDALONE=ON"
+# We build cadical using the custom toolchain on Linux to avoid glibc versioning issues
+echo -n " -DLEAN_STANDALONE=ON -DCADICAL_USE_CUSTOM_CXX=ON"
 echo -n " -DCMAKE_CXX_COMPILER=$PWD/llvm-host/bin/clang++ -DLEAN_CXX_STDLIB='-Wl,-Bstatic -lc++ -lc++abi -Wl,-Bdynamic'"
 echo -n " -DLEAN_EXTRA_CXX_FLAGS='--sysroot $PWD/llvm -idirafter $GLIBC_DEV/include ${EXTRA_FLAGS:-}'"
 # use target compiler directly when not cross-compiling
@@ -64,7 +68,9 @@ fi
 # use `-nostdinc` to make sure headers are not visible by default (in particular, not to `#include_next` in the clang headers),
 # but do not change sysroot so users can still link against system libs
 echo -n " -DLEANC_INTERNAL_FLAGS='--sysroot ROOT -nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang"
-echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='--sysroot ROOT -L ROOT/lib -L ROOT/lib/glibc ROOT/lib/glibc/libc_nonshared.a ROOT/lib/glibc/libpthread_nonshared.a -Wl,--as-needed -Wl,-Bstatic -lgmp -lunwind -luv -Wl,-Bdynamic -Wl,--no-as-needed -fuse-ld=lld'"
+# ld.so is usually included by the libc.so linker script but we discard those. Make sure it is linked to only after `libc.so` like in the original
+# linker script so that no libc symbols are bound to it instead.
+echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='--sysroot ROOT -L ROOT/lib -L ROOT/lib/glibc -lc -lc_nonshared -Wl,--as-needed -l:ld.so -Wl,--no-as-needed -lpthread_nonshared -Wl,--as-needed -Wl,-Bstatic -lgmp -lunwind -luv -Wl,-Bdynamic -Wl,--no-as-needed -fuse-ld=lld'"
 # when not using the above flags, link GMP dynamically/as usual
 echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-Wl,--as-needed -lgmp -luv -lpthread -ldl -lrt -Wl,--no-as-needed'"
 # do not set `LEAN_CC` for tests

script/prepare-llvm-mingw.sh

@@ -25,7 +25,10 @@ cp llvm/lib/clang/*/include/{std*,__std*,limits}.h stage1/include/clang
 echo '
 // https://docs.microsoft.com/en-us/windows/win32/api/errhandlingapi/nf-errhandlingapi-seterrormode
 #define SEM_FAILCRITICALERRORS 0x0001
-__declspec(dllimport) __stdcall unsigned int SetErrorMode(unsigned int uMode);' > stage1/include/clang/windows.h
+__declspec(dllimport) __stdcall unsigned int SetErrorMode(unsigned int uMode);
+// https://docs.microsoft.com/en-us/windows/console/setconsoleoutputcp
+#define CP_UTF8 65001
+__declspec(dllimport) __stdcall int SetConsoleOutputCP(unsigned int wCodePageID);' > stage1/include/clang/windows.h
 # COFF dependencies
 cp /clang64/lib/{crtbegin,crtend,crt2,dllcrt2}.o stage1/lib/
 # runtime

script/release_checklist.py

@@ -7,6 +7,14 @@ import base64
 import subprocess
 import sys
 import os
+import re # Import re module
+# Import run_command from merge_remote.py
+from merge_remote import run_command
+
+def debug(verbose, message):
+    """Print debug message if verbose mode is enabled."""
+    if verbose:
+        print(f"    [DEBUG] {message}")
 
 def parse_repos_config(file_path):
     with open(file_path, "r") as f:
@@ -51,13 +59,29 @@ def release_page_exists(repo_url, tag_name, github_token):
     response = requests.get(api_url, headers=headers)
     return response.status_code == 200
 
-def get_release_notes(repo_url, tag_name, github_token):
-    api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + f"/releases/tags/{tag_name}"
-    headers = {'Authorization': f'token {github_token}'} if github_token else {}
-    response = requests.get(api_url, headers=headers)
-    if response.status_code == 200:
-        return response.json().get("body", "").strip()
-    return None
+def get_release_notes(tag_name):
+    """Fetch release notes page title from lean-lang.org."""
+    # Strip -rcX suffix if present for the URL
+    base_tag = tag_name.split('-')[0]
+    reference_url = f"https://lean-lang.org/doc/reference/latest/releases/{base_tag}/"
+    try:
+        response = requests.get(reference_url)
+        response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
+        
+        # Extract title using regex
+        match = re.search(r"<title>(.*?)</title>", response.text, re.IGNORECASE | re.DOTALL)
+        if match:
+            return match.group(1).strip()
+        else:
+            print(f"  ⚠️ Could not find <title> tag in {reference_url}")
+            return None
+            
+    except requests.exceptions.RequestException as e:
+        print(f"  ❌ Error fetching release notes from {reference_url}: {e}")
+        return None
+    except Exception as e:
+        print(f"  ❌ An unexpected error occurred while processing release notes: {e}")
+        return None
 
 def get_branch_content(repo_url, branch, file_path, github_token):
     api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + f"/contents/{file_path}?ref={branch}"
@@ -85,9 +109,12 @@ def parse_version(version_str):
 
 def is_version_gte(version1, version2):
     """Check if version1 >= version2, including proper handling of release candidates."""
+    # Check if version1 is a nightly toolchain
+    if version1.startswith("leanprover/lean4:nightly-"):
+        return False
     return parse_version(version1) >= parse_version(version2)
 
-def is_merged_into_stable(repo_url, tag_name, stable_branch, github_token):
+def is_merged_into_stable(repo_url, tag_name, stable_branch, github_token, verbose=False):
     # First get the commit SHA for the tag
     api_base = repo_url.replace("https://github.com/", "https://api.github.com/repos/")
     headers = {'Authorization': f'token {github_token}'} if github_token else {}
@@ -95,6 +122,7 @@ def is_merged_into_stable(repo_url, tag_name, stable_branch, github_token):
     # Get tag's commit SHA
     tag_response = requests.get(f"{api_base}/git/refs/tags/{tag_name}", headers=headers)
     if tag_response.status_code != 200:
+        debug(verbose, f"Could not fetch tag {tag_name}, status code: {tag_response.status_code}")
         return False
     
     # Handle both single object and array responses
@@ -103,22 +131,48 @@ def is_merged_into_stable(repo_url, tag_name, stable_branch, github_token):
         # Find the exact matching tag in the list
         matching_tags = [tag for tag in tag_data if tag['ref'] == f'refs/tags/{tag_name}']
         if not matching_tags:
+            debug(verbose, f"No matching tag found for {tag_name} in response list")
             return False
         tag_sha = matching_tags[0]['object']['sha']
     else:
         tag_sha = tag_data['object']['sha']
-
+    
+    # Check if the tag is an annotated tag and get the actual commit SHA
+    if tag_data.get('object', {}).get('type') == 'tag' or (
+        isinstance(tag_data, list) and 
+        matching_tags and 
+        matching_tags[0].get('object', {}).get('type') == 'tag'):
+        
+        # Get the commit that this tag points to
+        tag_obj_response = requests.get(f"{api_base}/git/tags/{tag_sha}", headers=headers)
+        if tag_obj_response.status_code == 200:
+            tag_obj = tag_obj_response.json()
+            if 'object' in tag_obj and tag_obj['object']['type'] == 'commit':
+                commit_sha = tag_obj['object']['sha']
+                debug(verbose, f"Tag is annotated. Resolved commit SHA: {commit_sha}")
+                tag_sha = commit_sha  # Use the actual commit SHA
+    
     # Get commits on stable branch containing this SHA
     commits_response = requests.get(
         f"{api_base}/commits?sha={stable_branch}&per_page=100",
         headers=headers
     )
     if commits_response.status_code != 200:
+        debug(verbose, f"Could not fetch commits for branch {stable_branch}, status code: {commits_response.status_code}")
         return False
 
     # Check if any commit in stable's history matches our tag's SHA
     stable_commits = [commit['sha'] for commit in commits_response.json()]
-    return tag_sha in stable_commits
+    
+    is_merged = tag_sha in stable_commits
+    
+    debug(verbose, f"Tag SHA: {tag_sha}")
+    debug(verbose, f"First 5 stable commits: {stable_commits[:5]}")
+    debug(verbose, f"Total stable commits fetched: {len(stable_commits)}")
+    if not is_merged:
+        debug(verbose, f"Tag SHA not found in first {len(stable_commits)} commits of stable branch")
+    
+    return is_merged
 
 def is_release_candidate(version):
     return "-rc" in version
@@ -178,51 +232,84 @@ def check_bump_branch_toolchain(url, bump_branch, github_token):
     print(f"  ✅ Bump branch correctly uses toolchain: {content}")
     return True
 
+def pr_exists_with_title(repo_url, title, github_token):
+    api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + "/pulls"
+    headers = {'Authorization': f'token {github_token}'} if github_token else {}
+    params = {'state': 'open'}
+    response = requests.get(api_url, headers=headers, params=params)
+    if response.status_code != 200:
+        return None
+    pull_requests = response.json()
+    for pr in pull_requests:
+        if pr['title'] == title:
+            return pr['number'], pr['html_url']
+    return None
+
 def main():
+    parser = argparse.ArgumentParser(description="Check release status of Lean4 repositories")
+    parser.add_argument("toolchain", help="The toolchain version to check (e.g., v4.6.0)")
+    parser.add_argument("--verbose", "-v", action="store_true", help="Enable verbose debugging output")
+    parser.add_argument("--dry-run", action="store_true", help="Dry run mode (no actions taken)")
+    args = parser.parse_args()
+
     github_token = get_github_token()
-
-    if len(sys.argv) != 2:
-        print("Usage: python3 release_checklist.py <toolchain>")
-        sys.exit(1)
-
-    toolchain = sys.argv[1]
+    toolchain = args.toolchain
+    verbose = args.verbose
+    # dry_run = args.dry_run  # Not used yet but available for future implementation
+    
     stripped_toolchain = strip_rc_suffix(toolchain)
     lean_repo_url = "https://github.com/leanprover/lean4"
 
-    # Preliminary checks
+    # Track repository status
+    repo_status = {}  # Will store True for success, False for failure
+
+    # Preliminary checks for lean4 itself
     print("\nPerforming preliminary checks...")
+    lean4_success = True
 
     # Check for branch releases/v4.Y.0
     version_major, version_minor, _ = map(int, stripped_toolchain.lstrip('v').split('.'))
     branch_name = f"releases/v{version_major}.{version_minor}.0"
-    if branch_exists(lean_repo_url, branch_name, github_token):
-        print(f"  ✅ Branch {branch_name} exists")
-
-        # Check CMake version settings
-        check_cmake_version(lean_repo_url, branch_name, version_major, version_minor, github_token)
-    else:
+    if not branch_exists(lean_repo_url, branch_name, github_token):
         print(f"  ❌ Branch {branch_name} does not exist")
-
-    # Check for tag v4.X.Y(-rcZ)
-    if tag_exists(lean_repo_url, toolchain, github_token):
-        print(f"  ✅ Tag {toolchain} exists")
+        print(f"  🟡 After creating the branch, we'll need to check CMake version settings.")
+        lean4_success = False
     else:
+        print(f"  ✅ Branch {branch_name} exists")
+        # Check CMake version settings
+        if not check_cmake_version(lean_repo_url, branch_name, version_major, version_minor, github_token):
+            lean4_success = False
+
+    # Check for tag and release page
+    if not tag_exists(lean_repo_url, toolchain, github_token):
         print(f"  ❌ Tag {toolchain} does not exist.")
-
-    # Check for release page
-    if release_page_exists(lean_repo_url, toolchain, github_token):
-        print(f"  ✅ Release page for {toolchain} exists")
-
-        # Check the first line of the release notes
-        release_notes = get_release_notes(lean_repo_url, toolchain, github_token)
-        if release_notes and toolchain in release_notes.splitlines()[0].strip():
-            print(f"  ✅ Release notes look good.")
-        else:
-            previous_minor_version = version_minor - 1
-            previous_release = f"v{version_major}.{previous_minor_version}.0"
-            print(f"  ❌ Release notes not published. Please run `script/release_notes.py --since {previous_release}` on branch `{branch_name}`.")
+        lean4_success = False
     else:
+        print(f"  ✅ Tag {toolchain} exists")
+
+    if not release_page_exists(lean_repo_url, toolchain, github_token):
         print(f"  ❌ Release page for {toolchain} does not exist")
+        lean4_success = False
+    else:
+        print(f"  ✅ Release page for {toolchain} exists")
+        
+    # Check the actual release notes page title
+    actual_title = get_release_notes(toolchain)
+    expected_title_prefix = f"Lean {toolchain.lstrip('v')}" # e.g., "Lean 4.19.0" or "Lean 4.19.0-rc1"
+
+    if actual_title is None:
+        # Error already printed by get_release_notes
+        lean4_success = False
+    elif not actual_title.startswith(expected_title_prefix):
+        # Construct URL for the error message (using the base tag)
+        base_tag = toolchain.split('-')[0]
+        check_url = f"https://lean-lang.org/doc/reference/latest/releases/{base_tag}/"
+        print(f"  ❌ Release notes page title mismatch. Expected prefix '{expected_title_prefix}', got '{actual_title}'. Check {check_url}")
+        lean4_success = False
+    else:
+        print(f"  ✅ Release notes page title looks good ('{actual_title}').")
+
+    repo_status["lean4"] = lean4_success
 
     # Load repositories and perform further checks
     print("\nChecking repositories...")
@@ -233,50 +320,114 @@ def main():
     for repo in repos:
         name = repo["name"]
         url = repo["url"]
+        org_repo = extract_org_repo_from_url(url)
         branch = repo["branch"]
         check_stable = repo["stable-branch"]
         check_tag = repo.get("toolchain-tag", True)
         check_bump = repo.get("bump-branch", False)
+        dependencies = repo.get("dependencies", [])
 
         print(f"\nRepository: {name}")
 
+        # Check if any dependencies have failed
+        failed_deps = [dep for dep in dependencies if dep in repo_status and not repo_status[dep]]
+        if failed_deps:
+            print(f"  🟡  Dependencies not ready: {', '.join(failed_deps)}")
+            repo_status[name] = False
+            continue
+
+        # Initialize success flag for this repo
+        success = True
+
         # Check if branch is on at least the target toolchain
         lean_toolchain_content = get_branch_content(url, branch, "lean-toolchain", github_token)
         if lean_toolchain_content is None:
             print(f"  ❌ No lean-toolchain file found in {branch} branch")
+            repo_status[name] = False
             continue
-
+        
         on_target_toolchain = is_version_gte(lean_toolchain_content.strip(), toolchain)
         if not on_target_toolchain:
             print(f"  ❌ Not on target toolchain (needs ≥ {toolchain}, but {branch} is on {lean_toolchain_content.strip()})")
+            pr_title = f"chore: bump toolchain to {toolchain}"
+            pr_info = pr_exists_with_title(url, pr_title, github_token)
+            if pr_info:
+                pr_number, pr_url = pr_info
+                print(f"  ✅ PR with title '{pr_title}' exists: #{pr_number} ({pr_url})")
+            else:
+                print(f"  ❌ PR with title '{pr_title}' does not exist")
+                print(f"     Run `script/release_steps.py {toolchain} {name}` to create it")
+            repo_status[name] = False
             continue
         print(f"  ✅ On compatible toolchain (>= {toolchain})")
 
-        # Only check for tag if toolchain-tag is true
         if check_tag:
-            if not tag_exists(url, toolchain, github_token):
-                print(f"  ❌ Tag {toolchain} does not exist. Run `script/push_repo_release_tag.py {extract_org_repo_from_url(url)} {branch} {toolchain}`.")
-            else:
-                print(f"  ✅ Tag {toolchain} exists")
+            tag_exists_initially = tag_exists(url, toolchain, github_token)
+            if not tag_exists_initially:                
+                if args.dry_run:
+                    print(f"  ❌ Tag {toolchain} does not exist. Run `script/push_repo_release_tag.py {org_repo} {branch} {toolchain}`.")
+                    repo_status[name] = False
+                    continue
+                else:
+                    print(f"  … Tag {toolchain} does not exist. Running `script/push_repo_release_tag.py {org_repo} {branch} {toolchain}`...")
+                    
+                    # Run the script to create the tag
+                    subprocess.run(["script/push_repo_release_tag.py", org_repo, branch, toolchain])
+                    
+                    # Check again if the tag exists now
+                    if not tag_exists(url, toolchain, github_token):
+                        print(f"  ❌ Manual intervention required.")
+                        repo_status[name] = False
+                        continue
+            
+            # This will print in all successful cases - whether tag existed initially or was created successfully
+            print(f"  ✅ Tag {toolchain} exists")
 
-        # Only check merging into stable if stable-branch is true and not a release candidate
         if check_stable and not is_release_candidate(toolchain):
-            if not is_merged_into_stable(url, toolchain, "stable", github_token):
-                print(f"  ❌ Tag {toolchain} is not merged into stable")
-            else:
-                print(f"  ✅ Tag {toolchain} is merged into stable")
+            if not is_merged_into_stable(url, toolchain, "stable", github_token, verbose):
+                org_repo = extract_org_repo_from_url(url)
+                if args.dry_run:
+                    print(f"  ❌ Tag {toolchain} is not merged into stable")
+                    print(f"     Run `script/merge_remote.py {org_repo} stable {toolchain}` to merge it")
+                    repo_status[name] = False
+                    continue
+                else:
+                    print(f"  … Tag {toolchain} is not merged into stable. Running `script/merge_remote.py {org_repo} stable {toolchain}`...")
+                    
+                    # Run the script to merge the tag
+                    subprocess.run(["script/merge_remote.py", org_repo, "stable", toolchain])
+                    
+                    # Check again if the tag is merged now
+                    if not is_merged_into_stable(url, toolchain, "stable", github_token, verbose):
+                        print(f"  ❌ Manual intervention required.")
+                        repo_status[name] = False
+                        continue
+            
+            # This will print in all successful cases - whether tag was merged initially or was merged successfully
+            print(f"  ✅ Tag {toolchain} is merged into stable")
 
-        # Check for bump branch if configured
         if check_bump:
             next_version = get_next_version(toolchain)
             bump_branch = f"bump/{next_version}"
-            if branch_exists(url, bump_branch, github_token):
-                print(f"  ✅ Bump branch {bump_branch} exists")
-                check_bump_branch_toolchain(url, bump_branch, github_token)
-            else:
-                print(f"  ❌ Bump branch {bump_branch} does not exist")
+            if not branch_exists(url, bump_branch, github_token):
+                if args.dry_run:
+                    print(f"  ❌ Bump branch {bump_branch} does not exist. Run `gh api -X POST /repos/{org_repo}/git/refs -f ref=refs/heads/{bump_branch} -f sha=$(gh api /repos/{org_repo}/git/refs/heads/{branch} --jq .object.sha)` to create it.")
+                    repo_status[name] = False
+                    continue
+                print(f"  … Bump branch {bump_branch} does not exist. Creating it...")
+                result = run_command(f"gh api -X POST /repos/{org_repo}/git/refs -f ref=refs/heads/{bump_branch} -f sha=$(gh api /repos/{org_repo}/git/refs/heads/{branch} --jq .object.sha)", check=False)
+                if result.returncode != 0:
+                    print(f"  ❌ Failed to create bump branch {bump_branch}")
+                    repo_status[name] = False
+                    continue
+            print(f"  ✅ Bump branch {bump_branch} exists")
+            if not check_bump_branch_toolchain(url, bump_branch, github_token):
+                repo_status[name] = False
+                continue
 
-    # Check lean4 master branch for next development cycle
+        repo_status[name] = success
+
+    # Final check for lean4 master branch
     print("\nChecking lean4 master branch configuration...")
     next_version = get_next_version(toolchain)
     next_minor = int(next_version.split('.')[1])

script/release_notes.py

@@ -65,20 +65,21 @@ def format_markdown_description(pr_number, description):
     link = f"[#{pr_number}](https://github.com/leanprover/lean4/pull/{pr_number})"
     return f"{link} {description}"
 
+def commit_types():
+    # see doc/dev/commit_convention.md
+    return ['feat', 'fix', 'doc', 'style', 'refactor', 'test', 'chore', 'perf']
+
 def count_commit_types(commits):
     counts = {
         'total': len(commits),
-        'feat': 0,
-        'fix': 0,
-        'refactor': 0,
-        'doc': 0,
-        'chore': 0
     }
+    for commit_type in commit_types():
+        counts[commit_type] = 0
     
     for _, first_line, _ in commits:
-        for commit_type in ['feat:', 'fix:', 'refactor:', 'doc:', 'chore:']:
-            if first_line.startswith(commit_type):
-                counts[commit_type.rstrip(':')] += 1
+        for commit_type in commit_types():
+            if first_line.startswith(f'{commit_type}:'):
+                counts[commit_type] += 1
                 break
     
     return counts
@@ -158,8 +159,9 @@ def main():
     counts = count_commit_types(commits)
     print(f"For this release, {counts['total']} changes landed. "
           f"In addition to the {counts['feat']} feature additions and {counts['fix']} fixes listed below "
-          f"there were {counts['refactor']} refactoring changes, {counts['doc']} documentation improvements "
-          f"and {counts['chore']} chores.\n")
+          f"there were {counts['refactor']} refactoring changes, {counts['doc']} documentation improvements, "
+          f"{counts['perf']} performance improvements, {counts['test']} improvements to the test suite "
+          f"and {counts['style'] + counts['chore']} other changes.\n")
 
     section_order = sort_sections_order()
     sorted_changelog = sorted(changelog.items(), key=lambda item: section_order.index(format_section_title(item[0])) if format_section_title(item[0]) in section_order else len(section_order))
@@ -168,7 +170,12 @@ def main():
         section_title = format_section_title(label) if label != "Uncategorised" else "Uncategorised"
         print(f"## {section_title}\n")
         for _, entry in sorted(entries, key=lambda x: x[0]):
-            print(f"* {entry}\n")
+            # Split entry into lines and indent all lines after the first
+            lines = entry.splitlines()
+            print(f"* {lines[0]}")
+            for line in lines[1:]:
+                print(f"  {line}")
+            print()  # Empty line after each entry
 
 if __name__ == "__main__":
     main()

script/release_repos.yml

@@ -1,5 +1,5 @@
 repositories:
-  - name: Batteries
+  - name: batteries
     url: https://github.com/leanprover-community/batteries
     toolchain-tag: true
     stable-branch: true
@@ -21,26 +21,33 @@ repositories:
     branch: master
     dependencies: []
 
-  - name: doc-gen4
-    url: https://github.com/leanprover/doc-gen4
+  - name: lean4-cli
+    url: https://github.com/leanprover/lean4-cli
     toolchain-tag: true
     stable-branch: false
     branch: main
     dependencies: []
 
-  - name: Verso
+  - name: doc-gen4
+    url: https://github.com/leanprover/doc-gen4
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies: [lean4-cli]
+
+  - name: verso
     url: https://github.com/leanprover/verso
     toolchain-tag: true
     stable-branch: false
     branch: main
     dependencies: []
 
-  - name: Cli
-    url: https://github.com/leanprover/lean4-cli
+  - name: reference-manual
+    url: https://github.com/leanprover/reference-manual
     toolchain-tag: true
     stable-branch: false
     branch: main
-    dependencies: []
+    dependencies: [verso]
 
   - name: ProofWidgets4
     url: https://github.com/leanprover-community/ProofWidgets4
@@ -48,22 +55,24 @@ repositories:
     stable-branch: false
     branch: main
     dependencies:
-      - Batteries
+      - batteries
 
-  - name: Aesop
+  - name: aesop
     url: https://github.com/leanprover-community/aesop
     toolchain-tag: true
     stable-branch: true
     branch: master
     dependencies:
-      - Batteries
+      - batteries
 
   - name: import-graph
     url: https://github.com/leanprover-community/import-graph
     toolchain-tag: true
     stable-branch: false
     branch: main
-    dependencies: []
+    dependencies:
+      - lean4-cli
+      - batteries
 
   - name: plausible
     url: https://github.com/leanprover-community/plausible
@@ -72,24 +81,26 @@ repositories:
     branch: main
     dependencies: []
 
-  - name: Mathlib
+  - name: mathlib4
     url: https://github.com/leanprover-community/mathlib4
     toolchain-tag: true
     stable-branch: true
     branch: master
     bump-branch: true
     dependencies:
-      - Aesop
+      - aesop
       - ProofWidgets4
       - lean4checker
-      - Batteries
+      - batteries
+      - lean4-cli
       - doc-gen4
       - import-graph
+      - plausible
 
-  - name: REPL
+  - name: repl
     url: https://github.com/leanprover-community/repl
     toolchain-tag: true
     stable-branch: true
     branch: master
     dependencies:
-      - Mathlib
+      - mathlib4

script/release_steps.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+
+"""
+Generate release steps script for Lean4 repositories.
+
+This script helps automate the release process for Lean4 and its dependent repositories
+by generating step-by-step instructions for updating toolchains, creating tags,
+and managing branches.
+
+Usage:
+    python3 release_steps.py <version> <repo>
+
+Arguments:
+    version: The version to set in the lean-toolchain file (e.g., v4.6.0)
+    repo: A substring of the repository name as specified in release_repos.yml
+
+Example:
+    python3 release_steps.py v4.6.0 mathlib
+    python3 release_steps.py v4.6.0 batt
+
+The script reads repository configurations from release_repos.yml in the same directory.
+Each repository may have specific requirements for:
+- Branch management
+- Toolchain updates
+- Dependency updates
+- Tagging conventions
+- Stable branch handling
+"""
+
+import argparse
+import yaml
+import os
+import sys
+import re
+
+def load_repos_config(file_path):
+    with open(file_path, "r") as f:
+        return yaml.safe_load(f)["repositories"]
+
+def find_repo(repo_substring, config):
+    pattern = re.compile(re.escape(repo_substring), re.IGNORECASE)
+    matching_repos = [r for r in config if pattern.search(r["name"])]
+    if not matching_repos:
+        print(f"Error: No repository matching '{repo_substring}' found in configuration.")
+        sys.exit(1)
+    if len(matching_repos) > 1:
+        print(f"Error: Multiple repositories matching '{repo_substring}' found in configuration: {', '.join(r['name'] for r in matching_repos)}")
+        sys.exit(1)
+    return matching_repos[0]
+
+def generate_script(repo, version, config):
+    repo_config = find_repo(repo, config)
+    repo_name = repo_config['name']
+    repo_url = repo_config['url']
+    # Extract the last component of the URL, removing the .git extension if present
+    repo_dir = repo_url.split('/')[-1].replace('.git', '')
+    default_branch = repo_config.get("branch", "main")
+    dependencies = repo_config.get("dependencies", [])
+    requires_tagging = repo_config.get("toolchain-tag", True)
+    has_stable_branch = repo_config.get("stable-branch", True)
+
+    script_lines = [
+        f"cd {repo_dir}",
+        "git fetch",
+        f"git checkout {default_branch} && git pull",
+        f"git checkout -b bump_to_{version}",
+        f"echo leanprover/lean4:{version} > lean-toolchain",
+    ]
+
+    # Special cases for specific repositories
+    if repo_name == "repl":
+        script_lines.extend([
+            "lake update",
+            "cd test/Mathlib",
+            f"perl -pi -e 's/rev = \"v\\d+\\.\\d+\\.\\d+(-rc\\d+)?\"/rev = \"{version}\"/g' lakefile.toml",
+            f"echo leanprover/lean4:{version} > lean-toolchain",
+            "lake update",
+            "cd ../..",
+            "./test.sh"
+        ])
+    elif dependencies:
+        script_lines.append('perl -pi -e \'s/"v4\\.[0-9]+(\\.[0-9]+)?(-rc[0-9]+)?"/"' + version + '"/g\' lakefile.*')
+        script_lines.append("lake update")
+
+    script_lines.append("")
+
+    script_lines.extend([
+        f'git commit -am "chore: bump toolchain to {version}"',
+        ""
+    ])
+
+    if re.search(r'rc\d+$', version) and repo_name in ["batteries", "mathlib4"]:
+        script_lines.extend([
+            "echo 'This repo has nightly-testing infrastructure'",
+            f"git merge origin/bump/{version.split('-rc')[0]}",
+            "echo 'Please resolve any conflicts.'",
+            ""
+        ])
+    if re.search(r'rc\d+$', version) and repo_name in ["verso", "reference-manual"]:
+        script_lines.extend([
+            "echo 'This repo does development on nightly-testing: remember to rebase merge the PR.'",
+            f"git merge origin/nightly-testing",
+            "echo 'Please resolve any conflicts.'",
+            ""
+        ])
+    if repo_name != "Mathlib":
+        script_lines.extend([
+            "lake build && if lake check-test; then lake test; fi",
+            ""
+        ])
+
+    script_lines.extend([
+        'gh pr create --title "chore: bump toolchain to ' + version + '" --body ""',
+        "echo 'Please review the PR and merge or rebase it.'",
+        ""
+    ])
+
+    return "\n".join(script_lines)
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate release steps script for Lean4 repositories.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s v4.6.0 mathlib    Generate steps for updating Mathlib to v4.6.0
+  %(prog)s v4.6.0 batt       Generate steps for updating Batteries to v4.6.0
+  
+The script will generate shell commands to:
+1. Update the lean-toolchain file
+2. Create appropriate branches and commits
+3. Create pull requests
+
+(Note that the steps of creating toolchain version tags, and merging these into `stable` branches,
+are handled by `script/release_checklist.py`.)
+"""
+    )
+    parser.add_argument("version", help="The version to set in the lean-toolchain file (e.g., v4.6.0)")
+    parser.add_argument("repo", help="A substring of the repository name as specified in release_repos.yml")
+    args = parser.parse_args()
+
+    config_path = os.path.join(os.path.dirname(__file__), "release_repos.yml")
+    config = load_repos_config(config_path)
+
+    script = generate_script(args.repo, args.version, config)
+    print(script)
+
+if __name__ == "__main__":
+    main()

src/CMakeLists.txt

@@ -10,7 +10,7 @@ endif()
 include(ExternalProject)
 project(LEAN CXX C)
 set(LEAN_VERSION_MAJOR 4)
-set(LEAN_VERSION_MINOR 18)
+set(LEAN_VERSION_MINOR 21)
 set(LEAN_VERSION_PATCH 0)
 set(LEAN_VERSION_IS_RELEASE 0)  # This number is 1 in the release revision, and 0 otherwise.
 set(LEAN_SPECIAL_VERSION_DESC "" CACHE STRING "Additional version description like 'nightly-2018-03-11'")
@@ -20,6 +20,11 @@ if (LEAN_SPECIAL_VERSION_DESC)
 elseif (NOT LEAN_VERSION_IS_RELEASE)
   string(APPEND LEAN_VERSION_STRING "-pre")
 endif()
+if (LEAN_VERSION_IS_RELEASE)
+  set(LEAN_MANUAL_ROOT "https://lean-lang.org/doc/reference/${LEAN_VERSION_STRING}/")
+else()
+  set(LEAN_MANUAL_ROOT "")
+endif()
 
 set(LEAN_PLATFORM_TARGET "" CACHE STRING "LLVM triple of the target platform")
 if (NOT LEAN_PLATFORM_TARGET)
@@ -69,12 +74,13 @@ option(TRACK_LIVE_EXPRS    "TRACK_LIVE_EXPRS" OFF)
 option(CUSTOM_ALLOCATORS   "CUSTOM_ALLOCATORS" ON)
 option(SAVE_SNAPSHOT       "SAVE_SNAPSHOT" ON)
 option(SAVE_INFO           "SAVE_INFO" ON)
-option(SMALL_ALLOCATOR     "SMALL_ALLOCATOR" ON)
+option(SMALL_ALLOCATOR     "SMALL_ALLOCATOR" OFF)
 option(MMAP                "MMAP" ON)
 option(LAZY_RC             "LAZY_RC" OFF)
 option(RUNTIME_STATS       "RUNTIME_STATS" OFF)
 option(BSYMBOLIC "Link with -Bsymbolic to reduce call overhead in shared libraries (Linux)" ON)
 option(USE_GMP "USE_GMP" ON)
+option(USE_MIMALLOC "use mimalloc" ON)
 
 # development-specific options
 option(CHECK_OLEAN_VERSION "Only load .olean files compiled with the current version of Lean" OFF)
@@ -87,6 +93,11 @@ if ("${LAZY_RC}" MATCHES "ON")
   set(LEAN_LAZY_RC "#define LEAN_LAZY_RC")
 endif()
 
+if (USE_MIMALLOC)
+  set(SMALL_ALLOCATOR OFF)
+  set(LEAN_MIMALLOC "#define LEAN_MIMALLOC")
+endif()
+
 if ("${SMALL_ALLOCATOR}" MATCHES "ON")
   set(LEAN_SMALL_ALLOCATOR "#define LEAN_SMALL_ALLOCATOR")
 endif()
@@ -180,10 +191,11 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules")
 
 # Initialize CXXFLAGS.
 set(CMAKE_CXX_FLAGS                "${LEAN_EXTRA_CXX_FLAGS} -DLEAN_BUILD_TYPE=\"${CMAKE_BUILD_TYPE}\" -DLEAN_EXPORTING")
-set(CMAKE_CXX_FLAGS_DEBUG          "-DLEAN_DEBUG -DLEAN_TRACE")
+set(CMAKE_CXX_FLAGS_DEBUG          "-DLEAN_DEBUG")
 set(CMAKE_CXX_FLAGS_MINSIZEREL     "-DNDEBUG")
 set(CMAKE_CXX_FLAGS_RELEASE        "-DNDEBUG")
 set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-DNDEBUG")
+set(CMAKE_CXX_FLAGS_RELWITHASSERT  "-DLEAN_DEBUG")
 
 # SPLIT_STACK
 if (SPLIT_STACK)
@@ -210,6 +222,7 @@ elseif (MSVC)
     set(CMAKE_CXX_FLAGS_DEBUG          "/Od /Zi ${CMAKE_CXX_FLAGS_DEBUG}")
     set(CMAKE_CXX_FLAGS_MINSIZEREL     "/Os /Zc:inline ${CMAKE_CXX_FLAGS_MINSIZEREL}")
     set(CMAKE_CXX_FLAGS_RELEASE        "/O2 /Oi /Oy /Zc:inline ${CMAKE_CXX_FLAGS_RELEASE}")
+    set(CMAKE_CXX_FLAGS_RELWITHASSERT  "/O2 /Oi /Oy /Zc:inline ${CMAKE_CXX_FLAGS_RELWITHASSERT}")
     set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/O2 /Oi /Zi ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
     set(LEAN_EXTRA_LINKER_FLAGS        "/LTCG:INCREMENTAL ${LEAN_EXTRA_LINKER_FLAGS}")
     set(CMAKE_STATIC_LINKER_FLAGS      "${CMAKE_STATIC_LINKER_FLAGS} ${LEAN_EXTRA_LINKER_FLAGS}")
@@ -229,11 +242,13 @@ if (NOT MSVC)
       set(CMAKE_CXX_FLAGS_MINSIZEREL     "-Os ${CMAKE_CXX_FLAGS_MINSIZEREL}")
     endif ()
     set(CMAKE_CXX_FLAGS_RELEASE        "-O3 ${CMAKE_CXX_FLAGS_RELEASE}")
+    set(CMAKE_CXX_FLAGS_RELWITHASSERT  "-O3 ${CMAKE_CXX_FLAGS_RELWITHASSERT}")
     set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g3 -fno-omit-frame-pointer ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
 elseif (MULTI_THREAD)
     set(CMAKE_CXX_FLAGS_DEBUG          "/MTd ${CMAKE_CXX_FLAGS_DEBUG}")
     set(CMAKE_CXX_FLAGS_MINSIZEREL     "/MT ${CMAKE_CXX_FLAGS_MINSIZEREL}")
     set(CMAKE_CXX_FLAGS_RELEASE        "/MT ${CMAKE_CXX_FLAGS_RELEASE}")
+    set(CMAKE_CXX_FLAGS_RELWITHASSERT  "/MT ${CMAKE_CXX_FLAGS_RELWITHASSERT}")
     set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/MT ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
 endif ()
 
@@ -354,8 +369,8 @@ if(LLVM)
   execute_process(COMMAND ${LLVM_CONFIG} --version COMMAND_ERROR_IS_FATAL ANY OUTPUT_VARIABLE LLVM_CONFIG_VERSION ECHO_OUTPUT_VARIABLE OUTPUT_STRIP_TRAILING_WHITESPACE)
   string(REGEX MATCH "^[0-9]*" LLVM_CONFIG_MAJOR_VERSION ${LLVM_CONFIG_VERSION})
   message(STATUS "Found 'llvm-config' at '${LLVM_CONFIG}' with version '${LLVM_CONFIG_VERSION}', major version '${LLVM_CONFIG_MAJOR_VERSION}'")
-  if (NOT LLVM_CONFIG_MAJOR_VERSION STREQUAL "15")
-    message(FATAL_ERROR "Unable to find llvm-config version 15. Found invalid version '${LLVM_CONFIG_MAJOR_VERSION}'")
+  if (NOT LLVM_CONFIG_MAJOR_VERSION STREQUAL "19")
+    message(FATAL_ERROR "Unable to find llvm-config version 19. Found invalid version '${LLVM_CONFIG_MAJOR_VERSION}'")
   endif()
   # -DLEAN_LLVM is used to conditionally compile Lean features that depend on LLVM
   string(APPEND CMAKE_CXX_FLAGS " -D LEAN_LLVM")
@@ -455,20 +470,20 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
   string(APPEND CMAKE_CXX_FLAGS " -fPIC -ftls-model=initial-exec")
   string(APPEND LEANC_EXTRA_CC_FLAGS " -fPIC")
   string(APPEND TOOLCHAIN_SHARED_LINKER_FLAGS " -Wl,-rpath=\\$$ORIGIN/..:\\$$ORIGIN")
-  string(APPEND LAKESHARED_LINKER_FLAGS " -Wl,--whole-archive ${CMAKE_BINARY_DIR}/lib/temp/libLake.a.export -Wl,--no-whole-archive")
-  string(APPEND CMAKE_EXE_LINKER_FLAGS " -Wl,-rpath=\\\$ORIGIN/../lib:\\\$ORIGIN/../lib/lean")
+  string(APPEND LAKESHARED_LINKER_FLAGS " -Wl,--whole-archive ${CMAKE_BINARY_DIR}/lib/lean/libLake.a.export -Wl,--no-whole-archive")
+  string(APPEND CMAKE_EXE_LINKER_FLAGS " -Wl,-rpath=$ORIGIN/../lib:$ORIGIN/../lib/lean")
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
   string(APPEND CMAKE_CXX_FLAGS " -ftls-model=initial-exec")
   string(APPEND INIT_SHARED_LINKER_FLAGS " -install_name @rpath/libInit_shared.dylib")
   string(APPEND LEANSHARED_1_LINKER_FLAGS " -install_name @rpath/libleanshared_1.dylib")
   string(APPEND LEANSHARED_LINKER_FLAGS " -install_name @rpath/libleanshared.dylib")
-  string(APPEND LAKESHARED_LINKER_FLAGS " -Wl,-force_load,${CMAKE_BINARY_DIR}/lib/temp/libLake.a.export -install_name @rpath/libLake_shared.dylib")
+  string(APPEND LAKESHARED_LINKER_FLAGS " -Wl,-force_load,${CMAKE_BINARY_DIR}/lib/lean/libLake.a.export -install_name @rpath/libLake_shared.dylib")
   string(APPEND CMAKE_EXE_LINKER_FLAGS " -Wl,-rpath,@executable_path/../lib -Wl,-rpath,@executable_path/../lib/lean")
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "Emscripten")
   string(APPEND CMAKE_CXX_FLAGS " -fPIC")
   string(APPEND LEANC_EXTRA_CC_FLAGS " -fPIC")
 elseif(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
-  string(APPEND LAKESHARED_LINKER_FLAGS " -Wl,--out-implib,${CMAKE_BINARY_DIR}/lib/lean/libLake_shared.dll.a -Wl,--whole-archive ${CMAKE_BINARY_DIR}/lib/temp/libLake.a.export -Wl,--no-whole-archive")
+  string(APPEND LAKESHARED_LINKER_FLAGS " -Wl,--out-implib,${CMAKE_BINARY_DIR}/lib/lean/libLake_shared.dll.a -Wl,--whole-archive ${CMAKE_BINARY_DIR}/lib/lean/libLake.a.export -Wl,--no-whole-archive")
 endif()
 
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
@@ -496,7 +511,10 @@ if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
   # import libraries created by the stdlib.make targets
   string(APPEND LEANC_SHARED_LINKER_FLAGS " -lInit_shared -lleanshared_1 -lleanshared")
 elseif("${CMAKE_SYSTEM_NAME}" MATCHES "Darwin")
-  string(APPEND LEANC_SHARED_LINKER_FLAGS " -Wl,-undefined,dynamic_lookup")
+  # The second flag is necessary to even *load* dylibs without resolved symbols, as can happen
+  # if a Lake `extern_lib` depends on a symbols defined by the Lean library but is loaded even
+  # before definition.
+  string(APPEND LEANC_SHARED_LINKER_FLAGS " -Wl,-undefined,dynamic_lookup -Wl,-no_fixup_chains")
 endif()
 # Linux ignores undefined symbols in shared libraries by default
 
@@ -515,7 +533,16 @@ if(USE_GITHASH)
     message(STATUS "git commit sha1: ${GIT_SHA1}")
   endif()
 else()
-  set(GIT_SHA1 "")
+  if(USE_LAKE AND ${STAGE} EQUAL 0)
+    # we need to embed *some* hash for Lake to invalidate stage 1 on stage 0 changes
+    execute_process(
+        COMMAND git ls-tree HEAD "${CMAKE_CURRENT_SOURCE_DIR}/../../stage0" --object-only
+        OUTPUT_VARIABLE GIT_SHA1
+        OUTPUT_STRIP_TRAILING_WHITESPACE)
+    message(STATUS "stage0 sha1: ${GIT_SHA1}")
+  else()
+    set(GIT_SHA1 "")
+  endif()
 endif()
 configure_file("${LEAN_SOURCE_DIR}/githash.h.in" "${LEAN_BINARY_DIR}/githash.h")
 
@@ -534,6 +561,9 @@ else()
   set(LEAN_IS_STAGE0 "#define LEAN_IS_STAGE0 0")
 endif()
 configure_file("${LEAN_SOURCE_DIR}/config.h.in" "${LEAN_BINARY_DIR}/include/lean/config.h")
+if (USE_MIMALLOC)
+  file(COPY "${LEAN_BINARY_DIR}/../mimalloc/src/mimalloc/include/mimalloc.h" DESTINATION "${LEAN_BINARY_DIR}/include/lean")
+endif()
 install(DIRECTORY ${LEAN_BINARY_DIR}/include/ DESTINATION include)
 configure_file(${LEAN_SOURCE_DIR}/lean.mk.in ${LEAN_BINARY_DIR}/share/lean/lean.mk)
 install(DIRECTORY ${LEAN_BINARY_DIR}/share/ DESTINATION share)
@@ -542,6 +572,9 @@ include_directories(${LEAN_SOURCE_DIR})
 include_directories(${CMAKE_BINARY_DIR})  # version.h etc., "private" headers
 include_directories(${CMAKE_BINARY_DIR}/include)  # config.h etc., "public" headers
 
+# Lean code only needs this one include
+string(APPEND LEANC_OPTS " -I${CMAKE_BINARY_DIR}/include")
+
 # Use CMake profile C++ flags for building Lean libraries, but do not embed in `leanc`
 string(TOUPPER "${CMAKE_BUILD_TYPE}" uppercase_CMAKE_BUILD_TYPE)
 string(APPEND LEANC_OPTS " ${CMAKE_CXX_FLAGS_${uppercase_CMAKE_BUILD_TYPE}}")
@@ -656,7 +689,7 @@ add_custom_target(make_stdlib ALL
   # The actual rule is in a separate makefile because we want to prefix it with '+' to use the Make job server
   # for a parallelized nested build, but CMake doesn't let us do that.
   # We use `lean` from the previous stage, but `leanc`, headers, etc. from the current stage
-  COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make Init Std Lean
+  COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make Init Std Lean Leanc
   VERBATIM)
 
 # if we have LLVM enabled, then build `lean.h.bc` which has the LLVM bitcode
@@ -735,7 +768,7 @@ if(${STAGE} GREATER 0 AND EXISTS ${LEAN_SOURCE_DIR}/Leanc.lean AND NOT ${CMAKE_S
   add_custom_target(leanc ALL
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/leanc
     DEPENDS leanshared
-    COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make Leanc
+    COMMAND $(MAKE) -f ${CMAKE_BINARY_DIR}/stdlib.make leanc
     VERBATIM)
 endif()
 
@@ -754,7 +787,11 @@ add_custom_target(clean-olean
   DEPENDS clean-stdlib)
 
 install(DIRECTORY "${CMAKE_BINARY_DIR}/lib/" DESTINATION lib
-  PATTERN temp EXCLUDE)
+  PATTERN temp EXCLUDE
+  PATTERN "*.export" EXCLUDE
+  PATTERN "*.hash" EXCLUDE
+  PATTERN "*.trace" EXCLUDE
+  PATTERN "*.rsp" EXCLUDE)
 
 # symlink source into expected installation location for go-to-definition, if file system allows it
 file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/src)
@@ -785,12 +822,31 @@ if(LEAN_INSTALL_PREFIX)
 endif()
 
 # Escape for `make`. Yes, twice.
-string(REPLACE "$" "$$" CMAKE_EXE_LINKER_FLAGS_MAKE "${CMAKE_EXE_LINKER_FLAGS}")
-string(REPLACE "$" "$$" CMAKE_EXE_LINKER_FLAGS_MAKE_MAKE "${CMAKE_EXE_LINKER_FLAGS_MAKE}")
+string(REPLACE "$" "\\\$$" CMAKE_EXE_LINKER_FLAGS_MAKE "${CMAKE_EXE_LINKER_FLAGS}")
 configure_file(${LEAN_SOURCE_DIR}/stdlib.make.in ${CMAKE_BINARY_DIR}/stdlib.make)
 
+# hacky
+function(toml_escape IN OUTVAR)
+  if(IN)
+    string(STRIP "${IN}" OUT)
+    string(REPLACE " " "\", \"" OUT "${OUT}")
+    set(${OUTVAR} "\"${OUT}\"" PARENT_SCOPE)
+  endif()
+endfunction()
+string(REPLACE "ROOT" "${CMAKE_BINARY_DIR}" LEANC_CC "${LEANC_CC}")
+string(REPLACE "ROOT" "${CMAKE_BINARY_DIR}" LEANC_INTERNAL_FLAGS "${LEANC_INTERNAL_FLAGS}")
+string(REPLACE "ROOT" "${CMAKE_BINARY_DIR}" LEANC_INTERNAL_LINKER_FLAGS "${LEANC_INTERNAL_LINKER_FLAGS}")
+set(LEANC_OPTS_TOML "${LEANC_OPTS} ${LEANC_EXTRA_CC_FLAGS} ${LEANC_INTERNAL_FLAGS}")
+set(LINK_OPTS_TOML "${LEANC_INTERNAL_LINKER_FLAGS} -L${CMAKE_BINARY_DIR}/lib/lean ${LEAN_EXTRA_LINKER_FLAGS}")
+
+toml_escape("${LEAN_EXTRA_MAKE_OPTS}" LEAN_EXTRA_OPTS_TOML)
+toml_escape("${LEANC_OPTS_TOML}" LEANC_OPTS_TOML)
+toml_escape("${LINK_OPTS_TOML}" LINK_OPTS_TOML)
+
+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)
-  configure_file(${LEAN_SOURCE_DIR}/lakefile.toml.in ${LEAN_SOURCE_DIR}/../tests/lakefile.toml)
-  configure_file(${LEAN_SOURCE_DIR}/lakefile.toml.in ${LEAN_SOURCE_DIR}/../lakefile.toml)
 endif()