chore: rename Array.setD to setIfInBounds

.github/workflows/check-prelude.yml

@@ -14,7 +14,6 @@ jobs:
           sparse-checkout: |
             src/Lean
             src/Std
-            src/lake/Lake
       - name: Check Prelude
         run: |
           failed_files=""
@@ -22,7 +21,7 @@ jobs:
             if ! grep -q "^prelude$" "$file"; then
               failed_files="$failed_files$file\n"
             fi
-          done < <(find src/Lean src/Std src/lake/Lake -name '*.lean' -print0)
+          done < <(find src/Lean src/Std -name '*.lean' -print0)
           if [ -n "$failed_files" ]; then
             echo -e "The following files should use 'prelude':\n$failed_files"
             exit 1

.github/workflows/ci.yml

@@ -137,6 +137,7 @@ jobs:
             let large = ${{ github.repository == 'leanprover/lean4' }};
             let matrix = [
               {
+                // portable release build: use channel with older glibc (2.27)
                 "name": "Linux LLVM",
                 "os": "ubuntu-latest",
                 "release": false,
@@ -151,7 +152,6 @@ jobs:
                 "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",
                 "os": large ? "nscloud-ubuntu-22.04-amd64-4x8" : "ubuntu-latest",
                 "release": true,
@@ -175,8 +175,8 @@ jobs:
                 "os": "ubuntu-latest",
                 "check-level": 2,
                 "CMAKE_PRESET": "debug",
-                // exclude seriously slow/stackoverflowing tests
-                "CTEST_OPTIONS": "-E 'interactivetest|leanpkgtest|laketest|benchtest|bv_bitblast_stress|3807'"
+                // exclude seriously slow tests
+                "CTEST_OPTIONS": "-E 'interactivetest|leanpkgtest|laketest|benchtest|bv_bitblast_stress'"
               },
               // TODO: suddenly started failing in CI
               /*{
@@ -238,27 +238,27 @@ jobs:
                 "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",
+                "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/",
                 "cmultilib": true,
                 "release": true,
                 "check-level": 2,
                 "cross": true,
                 "shell": "bash -euxo pipefail {0}"
+              },
+              {
+                "name": "Web Assembly",
+                "os": "ubuntu-latest",
+                // Build a native 32bit binary in stage0 and use it to compile the oleans and the wasm build
+                "CMAKE_OPTIONS": "-DCMAKE_C_COMPILER_WORKS=1 -DSTAGE0_USE_GMP=OFF -DSTAGE0_LEAN_EXTRA_CXX_FLAGS='-m32' -DSTAGE0_LEANC_OPTS='-m32' -DSTAGE0_CMAKE_CXX_COMPILER=clang++ -DSTAGE0_CMAKE_C_COMPILER=clang -DSTAGE0_CMAKE_EXECUTABLE_SUFFIX=\"\" -DUSE_GMP=OFF -DMMAP=OFF -DSTAGE0_MMAP=OFF -DCMAKE_AR=../emsdk/emsdk-main/upstream/emscripten/emar -DCMAKE_TOOLCHAIN_FILE=../emsdk/emsdk-main/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake -DLEAN_INSTALL_SUFFIX=-linux_wasm32 -DSTAGE0_CMAKE_LIBRARY_PATH=/usr/lib/i386-linux-gnu/",
+                "wasm": true,
+                "cmultilib": true,
+                "release": true,
+                "check-level": 2,
+                "cross": true,
+                "shell": "bash -euxo pipefail {0}",
+                // Just a few selected tests because wasm is slow
+                "CTEST_OPTIONS": "-R \"leantest_1007\\.lean|leantest_Format\\.lean|leanruntest\\_1037.lean|leanruntest_ac_rfl\\.lean|leanruntest_tempfile.lean\\.|leanruntest_libuv\\.lean\""
               }
-              // {
-              //   "name": "Web Assembly",
-              //   "os": "ubuntu-latest",
-              //   // Build a native 32bit binary in stage0 and use it to compile the oleans and the wasm build
-              //   "CMAKE_OPTIONS": "-DCMAKE_C_COMPILER_WORKS=1 -DSTAGE0_USE_GMP=OFF -DSTAGE0_LEAN_EXTRA_CXX_FLAGS='-m32' -DSTAGE0_LEANC_OPTS='-m32' -DSTAGE0_CMAKE_CXX_COMPILER=clang++ -DSTAGE0_CMAKE_C_COMPILER=clang -DSTAGE0_CMAKE_EXECUTABLE_SUFFIX=\"\" -DUSE_GMP=OFF -DMMAP=OFF -DSTAGE0_MMAP=OFF -DCMAKE_AR=../emsdk/emsdk-main/upstream/emscripten/emar -DCMAKE_TOOLCHAIN_FILE=../emsdk/emsdk-main/upstream/emscripten/cmake/Modules/Platform/Emscripten.cmake -DLEAN_INSTALL_SUFFIX=-linux_wasm32 -DSTAGE0_CMAKE_LIBRARY_PATH=/usr/lib/i386-linux-gnu/",
-              //   "wasm": true,
-              //   "cmultilib": true,
-              //   "release": true,
-              //   "check-level": 2,
-              //   "cross": true,
-              //   "shell": "bash -euxo pipefail {0}",
-              //   // Just a few selected tests because wasm is slow
-              //   "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"])
@@ -327,7 +327,7 @@ jobs:
         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
+          sudo apt-get install -y gcc-multilib g++-multilib ccache libuv1-dev:i386
         if: matrix.cmultilib
       - name: Cache
         uses: actions/cache@v4

.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@v6 # 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@v2.1.0
 
       # Check that the most recently nightly coincides with 'git merge-base HEAD master'
       - name: Check merge-base and nightly-testing-YYYY-MM-DD

.gitpod.Dockerfile

@@ -1,14 +0,0 @@
-# You can find the new timestamped tags here: https://hub.docker.com/r/gitpod/workspace-full/tags
-FROM gitpod/workspace-full
-
-USER root
-RUN apt-get update && apt-get install git libgmp-dev libuv1-dev cmake ccache clang -y && apt-get clean
-
-USER gitpod
-
-# Install and configure elan
-RUN curl https://raw.githubusercontent.com/leanprover/elan/master/elan-init.sh -sSf | sh -s -- -y --default-toolchain none
-ENV PATH="/home/gitpod/.elan/bin:${PATH}"
-# Create a dummy toolchain so that we can pre-register it with elan
-RUN mkdir -p /workspace/lean4/build/release/stage1/bin && touch /workspace/lean4/build/release/stage1/bin/lean && elan toolchain link lean4 /workspace/lean4/build/release/stage1
-RUN mkdir -p /workspace/lean4/build/release/stage0/bin && touch /workspace/lean4/build/release/stage0/bin/lean && elan toolchain link lean4-stage0 /workspace/lean4/build/release/stage0

.gitpod.yml

@@ -1,11 +0,0 @@
-image:
-    file: .gitpod.Dockerfile
-
-vscode:
-  extensions:
-    - leanprover.lean4
-
-tasks:
-  - name: Release build
-    init: cmake --preset release
-    command: make -C build/release -j$(nproc || sysctl -n hw.logicalcpu)

CMakeLists.txt

@@ -18,9 +18,6 @@ foreach(var ${vars})
     if("${var}" MATCHES "LLVM*")
       list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
     endif()
-    if("${var}" MATCHES "PKG_CONFIG*")
-      list(APPEND STAGE0_ARGS "-D${var}=${${var}}")
-    endif()
   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()

CMakePresets.json

@@ -26,7 +26,7 @@
       "displayName": "Sanitize build config",
       "cacheVariables": {
         "LEAN_EXTRA_CXX_FLAGS": "-fsanitize=address,undefined",
-        "LEANC_EXTRA_CC_FLAGS": "-fsanitize=address,undefined -fsanitize-link-c++-runtime",
+        "LEANC_EXTRA_FLAGS": "-fsanitize=address,undefined -fsanitize-link-c++-runtime",
         "SMALL_ALLOCATOR": "OFF",
         "BSYMBOLIC": "OFF"
       },

CODEOWNERS

@@ -4,7 +4,7 @@
 # Listed persons will automatically be asked by GitHub to review a PR touching these paths.
 # If multiple names are listed, a review by any of them is considered sufficient by default.
 
-/.github/ @kim-em
+/.github/ @Kha @kim-em
 /RELEASES.md @kim-em
 /src/kernel/ @leodemoura
 /src/lake/ @tydeu
@@ -14,7 +14,9 @@
 /src/Lean/Elab/Tactic/ @kim-em
 /src/Lean/Language/ @Kha
 /src/Lean/Meta/Tactic/ @leodemoura
-/src/Lean/PrettyPrinter/ @kmill
+/src/Lean/Parser/ @Kha
+/src/Lean/PrettyPrinter/ @Kha
+/src/Lean/PrettyPrinter/Delaborator/ @kmill
 /src/Lean/Server/ @mhuisi
 /src/Lean/Widget/ @Vtec234
 /src/Init/Data/ @kim-em

README.md

@@ -6,8 +6,7 @@ This is the repository for **Lean 4**.
 - [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/)
-- [Language Reference](https://lean-lang.org/doc/reference/latest/)
+- [Manual](https://lean-lang.org/lean4/doc/)
 - [Release notes](RELEASES.md) starting at v4.0.0-m3
 - [Examples](https://lean-lang.org/lean4/doc/examples.html)
 - [External Contribution Guidelines](CONTRIBUTING.md)

debug.log

@@ -0,0 +1 @@
+[0829/202002.254:ERROR:crashpad_client_win.cc(868)] not connected

doc/SUMMARY.md

@@ -13,13 +13,61 @@
   - [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)
+<!-- - [Using Lean](./using_lean.md) -->
+<!-- - [Lexical Structure](./lexical_structure.md) -->
+<!-- - [Expressions](./expressions.md) -->
+<!-- - [Declarations](./declarations.md) -->
+- [Organizational features](./organization.md)
+  - [Sections](./sections.md)
+  - [Namespaces](./namespaces.md)
+  - [Implicit Arguments](./implicit.md)
+  - [Auto Bound Implicit Arguments](./autobound.md)
+<!-- - [Dependent Types](./deptypes.md) -->
+<!--   - [Simple Type Theory](./simptypes.md) -->
+<!--   - [Types as objects](./typeobjs.md) -->
+<!--   - [Function Abstraction and Evaluation](./funabst.md) -->
+<!--   - [Introducing Definitions](./introdef.md) -->
+<!--   - [What makes dependent type theory dependent?](./dep.md) -->
+<!-- - [Tactics](./tactics.md) -->
+- [Syntax Extensions](./syntax.md)
+  - [The `do` Notation](./do.md)
+  - [String Interpolation](./stringinterp.md)
+  - [User-Defined Notation](./notation.md)
+  - [Macro Overview](./macro_overview.md)
+  - [Elaborators](./elaborators.md)
+  - [Examples](./syntax_examples.md)
+    - [Balanced Parentheses](./syntax_example.md)
+    - [Arithmetic DSL](./metaprogramming-arith.md)
+- [Declaring New Types](./decltypes.md)
+  - [Enumerated Types](./enum.md)
+  - [Inductive Types](./inductive.md)
+  - [Structures](./struct.md)
+  - [Type classes](./typeclass.md)
+  - [Unification Hints](./unifhint.md)
+- [Builtin Types](./builtintypes.md)
+  - [Natural number](./nat.md)
+  - [Integer](./int.md)
+  - [Fixed precision unsigned integer](./uint.md)
+  - [Float](./float.md)
+  - [Array](./array.md)
+  - [List](./list.md)
+  - [Character](./char.md)
+  - [String](./string.md)
+  - [Option](./option.md)
+  - [Thunk](./thunk.md)
+  - [Task and Thread](./task.md)
+- [Functions](./functions.md)
+- [Monads](./monads/intro.md)
+  - [Functor](./monads/functors.lean.md)
+  - [Applicative](./monads/applicatives.lean.md)
+  - [Monad](./monads/monads.lean.md)
+  - [Reader](./monads/readers.lean.md)
+  - [State](./monads/states.lean.md)
+  - [Except](./monads/except.lean.md)
+  - [Transformers](./monads/transformers.lean.md)
+  - [Laws](./monads/laws.lean.md)
 
 # Other
 

doc/array.md

@@ -0,0 +1,77 @@
+# Arrays
+
+The `Array` type implements a *dynamic* (aka growable) array.
+It is defined as
+```lean
+# namespace hidden
+structure Array (α : Type u) where
+  data : List α
+# end hidden
+```
+but its execution time representation is optimized, and it is similar to C++ `std::vector<T>` and Rust `Vec<T>`.
+The Lean type checker has no special support for reducing `Array`s.
+
+You can create arrays in several ways. You can create a small array by listing consecutive values between
+`#[` and `]` and separated by commas, as shown in the following examples.
+
+```lean
+#check #[1, 2, 3] -- Array Nat
+
+#check #[] -- Array ?m
+```
+
+The type of the array elements is inferred from the literals used and must be consistent.
+```lean
+#check #["hello", "world"] -- Array String
+
+-- The following is not valid
+#check_failure #[10, "hello"]
+```
+Recall that the command `#check_failure <term>` only succeeds when the given term is not type correct.
+
+To create an array of size `n` in which all the elements are initialized to some value `a`, use `mkArray`.
+```lean
+#eval mkArray 5 'a'
+-- #['a', 'a', 'a', 'a', 'a']
+```
+
+## Accessing elements
+
+You can access array elements by using brackets (`[` and `]`).
+```lean
+def f (a : Array Nat) (i : Fin a.size) :=
+  a[i] + a[i]
+```
+Note that the index `i` has type `Fin a.size`, i.e., it is natural number less than `a.size`.
+You can also write
+```lean
+def f (a : Array Nat) (i : Nat) (h  : i < a.size) :=
+  a[i] + a[i]
+```
+The bracket operator is whitespace sensitive.
+
+```lean
+def f (xs : List Nat) : List Nat :=
+  xs ++ xs
+
+def as : Array Nat :=
+  #[1, 2, 3, 4]
+
+def idx : Fin 4 :=
+  2
+
+#eval f [1, 2, 3] -- This is a function application
+
+#eval as[idx] -- This is an array access
+```
+The notation `a[i]` has two variants: `a[i]!` and `a[i]?`. In both cases, `i` has type `Nat`. The first one
+produces a panic error message if the index `i` is out of bounds. The latter returns an `Option` type.
+
+```lean
+#eval #['a', 'b', 'c'][1]?
+-- some 'b'
+#eval #['a', 'b', 'c'][5]?
+-- none
+#eval #['a', 'b', 'c'][1]!
+-- 'b!
+```

doc/autobound.md

@@ -0,0 +1,47 @@
+## Auto Bound Implicit Arguments
+
+In the previous section, we have shown how implicit arguments make functions more convenient to use.
+However, functions such as `compose` are still quite verbose to define. Note that the universe
+polymorphic `compose` is even more verbose than the one previously defined.
+
+```lean
+universe u v w
+def compose {α : Type u} {β : Type v} {γ : Type w}
+            (g : β → γ) (f : α → β) (x : α) : γ :=
+  g (f x)
+```
+
+You can avoid the `universe` command by providing the universe parameters when defining `compose`.
+
+```lean
+def compose.{u, v, w}
+            {α : Type u} {β : Type v} {γ : Type w}
+            (g : β → γ) (f : α → β) (x : α) : γ :=
+  g (f x)
+```
+
+Lean 4 supports a new feature called *auto bound implicit arguments*. It makes functions such as
+`compose` much more convenient to write. When Lean processes the header of a declaration,
+any unbound identifier is automatically added as an implicit argument *if* it is a single lower case or
+greek letter. With this feature, we can write `compose` as
+
+```lean
+def compose (g : β → γ) (f : α → β) (x : α) : γ :=
+  g (f x)
+
+#check @compose
+-- {β : Sort u_1} → {γ : Sort u_2} → {α : Sort u_3} → (β → γ) → (α → β) → α → γ
+```
+Note that, Lean inferred a more general type using `Sort` instead of `Type`.
+
+Although we love this feature and use it extensively when implementing Lean,
+we realize some users may feel uncomfortable with it. Thus, you can disable it using
+the command `set_option autoImplicit false`.
+```lean
+set_option autoImplicit false
+/- The following definition produces `unknown identifier` errors -/
+-- def compose (g : β → γ) (f : α → β) (x : α) : γ :=
+--   g (f x)
+```
+The Lean language server provides [semantic highlighting](./semantic_highlighting.md) information to editors, and it provides
+visual feedback whether an identifier has been interpreted as an auto bound implicit argument.

doc/book.toml

@@ -3,7 +3,7 @@ authors = ["Leonardo de Moura", "Sebastian Ullrich"]
 language = "en"
 multilingual = false
 src = "."
-title = "Lean Documentation Overview"
+title = "Lean Manual"
 
 [build]
 build-dir = "out"

doc/builtintypes.md

@@ -0,0 +1,25 @@
+# Builtin Types
+
+## Numeric Operations
+
+Lean supports the basic mathematical operations you’d expect for all of the number types: addition, subtraction, multiplication, division, and remainder.
+The following code shows how you’d use each one in a `def` commands:
+
+```lean
+-- addition
+def sum := 5 + 10
+
+-- subtraction
+def difference := 95.5 - 4.3
+
+-- multiplication
+def product := 4 * 30
+
+-- division
+def quotient := 53.7 / 32.2
+
+-- remainder/modulo
+def modulo := 43 % 5
+```
+
+Each expression in these statements uses a mathematical operator and evaluates to a single value.

doc/char.md

@@ -0,0 +1,11 @@
+# Characters
+
+A value of type `Char`, also known as a character, is a [Unicode scalar value](https://www.unicode.org/glossary/#unicode_scalar_value). It is represented using an unsigned 32-bit integer and is statically guaranteed to be a valid Unicode scalar value.
+
+Syntactically, character literals are enclosed in single quotes.
+```lean
+#eval 'a' -- 'a'
+#eval '∀' -- '∀'
+```
+
+Characters are ordered and can be decidably compared using the relational operators `=`, `<`, `≤`, `>`, `≥`.

doc/declarations.md

@@ -590,9 +590,9 @@ This table should be read as follows:
  * 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.
+Lean will print the termination argument 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
+If Lean does not find the termination argument, 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
 ```
@@ -672,7 +672,7 @@ def num_consts_lst : List Term → Nat
 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.
+In a set of mutually recursive function, either all or no functions must have an explicit termination argument (``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
@@ -764,12 +764,11 @@ 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 :=
+structure Foo (a : α) extends Bar, Baz : Sort u :=
 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``.
+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. 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:
 

doc/decltypes.md

@@ -0,0 +1,29 @@
+# Declaring New Types
+
+In Lean's library, every concrete type other than the universes and every type constructor other than the dependent function type is
+an instance of a general family of type constructions known as *inductive types*. It is remarkable that it is possible to develop
+complex programs and formalize mathematics based on nothing more than the type universes, dependent function types,
+and inductive types; everything else follows from those.
+
+Intuitively, an inductive type is built up from a specified list of constructors. In Lean, the basic syntax for specifying such a type is as follows:
+```
+inductive NewType where
+  | constructor_1 : ... → NewType
+  | constructor_2 : ... → NewType
+  ...
+  | constructor_n : ... → NewType
+```
+
+The intuition is that each constructor specifies a way of building new objects of ``NewType``, possibly from previously constructed values.
+The type ``NewType`` consists of nothing more than the objects that are constructed in this way.
+
+We will see below that the arguments to the constructors can include objects of type ``NewType``,
+subject to a certain "positivity" constraint, which guarantees that elements of ``NewType`` are built
+from the bottom up. Roughly speaking, each ``...`` can be any function type constructed from ``NewType``
+and previously defined types, in which ``NewType`` appears, if at all, only as the "target" of the function type.
+
+We will provide a number of examples of inductive types. We will also consider slight generalizations of the scheme above,
+to mutually defined inductive types, and so-called *inductive families*.
+
+Every inductive type comes with constructors, which show how to construct an element of the type, and elimination rules,
+which show how to "use" an element of the type in another construction.

doc/dev/bootstrap.md

@@ -103,21 +103,10 @@ your PR using rebase merge, bypassing the merge queue.
 As written above, changes in meta code in the current stage usually will only
 affect later stages. This is an issue in two specific cases.
 
-* For the special case of *quotations*, it is desirable to have changes in builtin parsers affect them immediately: when the changes in the parser become active in the next stage, builtin macros implemented via quotations should generate syntax trees compatible with the new parser, and quotation patterns in builtin macros and elaborators should be able to match syntax created by the new parser and macros.
-  Since quotations capture the syntax tree structure during execution of the current stage and turn it into code for the next stage, we need to run the current stage's builtin parsers in quotations via the interpreter for this to work.
-  Caveats:
-  * We activate this behavior by default when building stage 1 by setting `-Dinternal.parseQuotWithCurrentStage=true`.
-    We force-disable it inside `macro/macro_rules/elab/elab_rules` via `suppressInsideQuot` as they are guaranteed not to run in the next stage and may need to be run in the current one, so the stage 0 parser is the correct one to use for them.
-    It may be necessary to extend this disabling to functions that contain quotations and are (exclusively) used by one of the mentioned commands. A function using quotations should never be used by both builtin and non-builtin macros/elaborators. Example: https://github.com/leanprover/lean4/blob/f70b7e5722da6101572869d87832494e2f8534b7/src/Lean/Elab/Tactic/Config.lean#L118-L122
-  * The parser needs to be reachable via an `import` statement, otherwise the version of the previous stage will silently be used.
-  * Only the parser code (`Parser.fn`) is affected; all metadata such as leading tokens is taken from the previous stage.
-
-  For an example, see https://github.com/leanprover/lean4/commit/f9dcbbddc48ccab22c7674ba20c5f409823b4cc1#diff-371387aed38bb02bf7761084fd9460e4168ae16d1ffe5de041b47d3ad2d22422R13
-
 * For *non-builtin* meta code such as `notation`s or `macro`s in
   `Notation.lean`, we expect changes to affect the current file and all later
   files of the same stage immediately, just like outside the stdlib. To ensure
-  this, we build stage 1 using `-Dinterpreter.prefer_native=false` -
+  this, we need to build the stage using `-Dinterpreter.prefer_native=false` -
   otherwise, when executing a macro, the interpreter would notice that there is
   already a native symbol available for this function and run it instead of the
   new IR, but the symbol is from the previous stage!
@@ -135,11 +124,26 @@ affect later stages. This is an issue in two specific cases.
   further stages (e.g. after an `update-stage0`) will then need to be compiled
   with the flag set to `false` again since they will expect the new signature.
 
-  When enabling `prefer_native`, we usually want to *disable* `parseQuotWithCurrentStage` as it would otherwise make quotations use the interpreter after all.
-  However, there is a specific case where we want to set both options to `true`: when we make changes to a non-builtin parser like `simp` that has a builtin elaborator, we cannot have the new parser be active outside of quotations in stage 1 as the builtin elaborator from stage 0 would not understand them; on the other hand, we need quotations in e.g. the builtin `simp` elaborator to produce the new syntax in the next stage.
-  As this issue usually affects only tactics, enabling `debug.byAsSorry` instead of `prefer_native` can be a simpler solution.
+  For an example, see https://github.com/leanprover/lean4/commit/da4c46370d85add64ef7ca5e7cc4638b62823fbb.
 
-  For a `prefer_native` example, see https://github.com/leanprover/lean4/commit/da4c46370d85add64ef7ca5e7cc4638b62823fbb.
+* For the special case of *quotations*, it is desirable to have changes in
+  built-in parsers affect them immediately: when the changes in the parser
+  become active in the next stage, macros implemented via quotations should
+  generate syntax trees compatible with the new parser, and quotation patterns
+  in macro and elaborators should be able to match syntax created by the new
+  parser and macros. Since quotations capture the syntax tree structure during
+  execution of the current stage and turn it into code for the next stage, we
+  need to run the current stage's built-in parsers in quotation via the
+  interpreter for this to work. Caveats:
+  * Since interpreting full parsers is not nearly as cheap and we rarely change
+    built-in syntax, this needs to be opted in using `-Dinternal.parseQuotWithCurrentStage=true`.
+  * The parser needs to be reachable via an `import` statement, otherwise the
+    version of the previous stage will silently be used.
+  * Only the parser code (`Parser.fn`) is affected; all metadata such as leading
+    tokens is taken from the previous stage.
+
+  For an example, see https://github.com/leanprover/lean4/commit/f9dcbbddc48ccab22c7674ba20c5f409823b4cc1#diff-371387aed38bb02bf7761084fd9460e4168ae16d1ffe5de041b47d3ad2d22422
+  (from before the flag defaulted to `false`).
 
 To modify either of these flags both for building and editing the stdlib, adjust
 the code in `stage0/src/stdlib_flags.h`. The flags will automatically be reset

doc/dev/commit_convention.md

@@ -33,9 +33,6 @@ Format of the commit message
  - chore (maintain, ex: travis-ci)
  - perf (performance improvement, optimization, ...)
 
-Every `feat` or `fix` commit must have a `changelog-*` label, and a commit message
-beginning with "This PR " that will be included in the changelog.
-
 ``<subject>`` has the following constraints:
 
  - use imperative, present tense: "change" not "changed" nor "changes"
@@ -47,7 +44,6 @@ beginning with "This PR " that will be included in the changelog.
  - just as in ``<subject>``, use imperative, present tense
  - includes motivation for the change and contrasts with previous
    behavior
- - If a `changelog-*` label is present, the body must begin with "This PR ".
 
 ``<footer>`` is optional and may contain two items:
 
@@ -64,21 +60,17 @@ Examples
 
 fix: add declarations for operator<<(std::ostream&, expr const&) and operator<<(std::ostream&, context const&) in the kernel
 
-This PR adds declarations `operator<<` for raw printing.
 The actual implementation of these two operators is outside of the
-kernel. They are implemented in the file 'library/printer.cpp'.
-
-We declare them in the kernel to prevent the following problem.
-Suppose there is a file 'foo.cpp' that does not include 'library/printer.h',
+kernel. They are implemented in the file 'library/printer.cpp'. We
+declare them in the kernel to prevent the following problem. Suppose
+there is a file 'foo.cpp' that does not include 'library/printer.h',
 but contains
-```cpp
-expr a;
-...
-std::cout << a << "\n";
-...
-```
+
+    expr a;
+    ...
+    std::cout << a << "\n";
+    ...
 
 The compiler does not generate an error message. It silently uses the
 operator bool() to coerce the expression into a Boolean. This produces
 counter-intuitive behavior, and may confuse developers.
-

doc/dev/ffi.md

@@ -49,9 +49,8 @@ In the case of `@[extern]` all *irrelevant* types are removed first; see next se
   is represented by the representation of that parameter's type.
 
   For example, `{ x : α // p }`, the `Subtype` structure of a value of type `α` and an irrelevant proof, is represented by the representation of `α`.
-  Similarly, the signed integer types `Int8`, ..., `Int64`, `ISize` are also represented by the unsigned C types `uint8_t`, ..., `uint64_t`, `size_t`, respectively, because they have a trivial structure.
-* `Nat` and `Int` are represented by `lean_object *`.
-  Their runtime values is either a pointer to an opaque bignum object or, if the lowest bit of the "pointer" is 1 (`lean_is_scalar`), an encoded unboxed natural number or integer (`lean_box`/`lean_unbox`).
+* `Nat` is represented by `lean_object *`.
+  Its runtime value is either a pointer to an opaque bignum object or, if the lowest bit of the "pointer" is 1 (`lean_is_scalar`), an encoded unboxed natural number (`lean_box`/`lean_unbox`).
 * A universe `Sort u`, type constructor `... → Sort u`, or proposition `p : Prop` is *irrelevant* and is either statically erased (see above) or represented as a `lean_object *` with the runtime value `lean_box(0)`
 * Any other type is represented by `lean_object *`.
   Its runtime value is a pointer to an object of a subtype of `lean_object` (see the "Inductive types" section below) or the unboxed value `lean_box(cidx)` for the `cidx`th constructor of an inductive type if this constructor does not have any relevant parameters.
@@ -140,7 +139,7 @@ lean_object * initialize_C(uint8_t builtin, lean_object *);
 ...
 
 lean_initialize_runtime_module();
-//lean_initialize();  // necessary (and replaces `lean_initialize_runtime_module`) if you (indirectly) access the `Lean` package
+//lean_initialize();  // necessary if you (indirectly) access the `Lean` package
 
 lean_object * res;
 // use same default as for Lean executables

doc/dev/index.md

@@ -80,10 +80,3 @@ Unlike most Lean projects, all submodules of the `Lean` module begin with the
 `prelude` keyword. This disables the automated import of `Init`, meaning that
 developers need to figure out their own subset of `Init` to import. This is done
 such that changing files in `Init` doesn't force a full rebuild of `Lean`.
-
-### Testing against Mathlib/Batteries
-You can test a Lean PR against Mathlib and Batteries by rebasing your PR
-on to `nightly-with-mathlib` branch. (It is fine to force push after rebasing.)
-CI will generate a branch of Mathlib and Batteries called `lean-pr-testing-NNNN`
-that uses the toolchain for your PR, and will report back to the Lean PR with results from Mathlib CI.
-See https://leanprover-community.github.io/contribute/tags_and_branches.html for more details.

doc/dev/release_checklist.md

@@ -5,8 +5,11 @@ 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.
+- One week before the planned release, ensure that
+  (1) someone has written the release notes and
+  (2) someone has written the first draft of the release blog post.
+  If there is any material in `./releases_drafts/` on the `releases/v4.6.0` branch, then the release notes are not done.
+  (See the section "Writing the release notes".)
 - `git checkout releases/v4.6.0`
   (This branch should already exist, from the release candidates.)
 - `git pull`
@@ -22,28 +25,14 @@ We'll use `v4.6.0` as the intended release version as a running example.
   - This step can take up to an hour.
   - 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`.
-  - 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,
-    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").
 - 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
-    ----------
-    ```
+  - Edit the release notes on Github to select the "Set as the latest release".
+  - Follow the instructions in creating a release candidate for the "GitHub release notes" step,
+    now that we have a written `RELEASES.md` section.
+    Do a quick sanity check.
 - 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
@@ -53,38 +42,16 @@ We'll use `v4.6.0` as the intended release version as a running example.
     - 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)
+    - [Batteries](https://github.com/leanprover-community/batteries)
       - 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
-      - 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:
@@ -99,19 +66,27 @@ We'll use `v4.6.0` as the intended release version as a running example.
       - Toolchain bump PR including updated Lake manifest
       - 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
+      - Toolchain bump PR including updated Lake manifest
+      - Create and push the tag
+      - There is no `stable` branch; skip this step
     - [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`
+      - Dependencies: `Aesop`, `ProofWidgets4`, `lean4checker`, `Batteries`, `doc-gen4`, `import-graph`
       - Toolchain bump PR notes:
-        - Upstream dependencies should use their `main` or `master` branch, not toolchain tags.
-          (Unlike for other repos.)
+        - In addition to updating the `lean-toolchain` and `lakefile.lean`,
+          in `.github/workflows/lean4checker.yml` update the line
+          `git checkout v4.6.0` to the appropriate tag. 
         - 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`.
@@ -123,12 +98,16 @@ We'll use `v4.6.0` as the intended release version as a running example.
       - 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.
+- The `v4.6.0` section of `RELEASES.md` is out of sync between
+  `releases/v4.6.0` and `master`. This should be reconciled:
+  - Replace the `v4.6.0` section on `master` with the `v4.6.0` section on `releases/v4.6.0`
+    and commit this to `master`.
+- Merge the release announcement PR for the Lean website - it will be deployed automatically
 - 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.
   You will want a few bullet points for main topics from the release notes.
-  If there is a blog post, link to that from the zulip announcement.
+  Link to the blog post from the Zulip announcement.
 - Make sure that whoever is handling social media knows the release is out.
 
 ## Optimistic(?) time estimates:
@@ -148,8 +127,6 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
 
 - Decide which nightly release you want to turn into a release candidate.
   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.
 - 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`.
@@ -162,19 +139,24 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
     git checkout -b releases/v4.7.0
     ```
 - In `RELEASES.md` replace `Development in progress` in the `v4.7.0` section with `Release notes to be written.`
+- We will rely on automatically generated release notes for release candidates,
+  and the written release notes will be used for stable versions only.
+  It is essential to choose the nightly that will become the release candidate as early as possible, to avoid confusion.
 - 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`).
+  - `set(LEAN_VERSION_IS_RELEASE 1)` (this should be a change; on `master` and nightly releases it is always `0`).
   - Commit your changes to `src/CMakeLists.txt`, and push.
 - `git tag v4.7.0-rc1`
 - `git push origin v4.7.0-rc1`
+- Ping the FRO Zulip that release notes need to be written. The release notes do not block completing the rest of this checklist.
 - Now wait, while CI runs.
   - 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.
-    See the section "Writing the release notes" below for more information.
+  - In the "previous tag" dropdown, select `v4.6.0`, and click "Generate release notes".
+    This will add a list of all the commits since the last stable version.
+    - Delete "update stage0" commits, and anything with a completely inscrutable commit message.
 - 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.
@@ -199,11 +181,10 @@ We'll use `v4.7.0-rc1` as the intended release version in this example.
   - We do this for the same list of repositories as for stable releases, see above.
     As above, there are dependencies between these, and so the process above is iterative.
     It greatly helps if you can merge the `bump/v4.7.0` PRs yourself!
-  - It is essential for Mathlib and Batteries CI that you then create the next `bump/v4.8.0` branch
+    It is essential for Mathlib 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
+  - 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.
 - Make an announcement!
@@ -267,26 +248,15 @@ Please read https://leanprover-community.github.io/contribute/tags_and_branches.
 
 # Writing the release notes
 
-Release notes are automatically generated from the commit history, using `script/release_notes.py`.
+We are currently trying a system where release notes are compiled all at once from someone looking through the commit history.
+The exact steps are a work in progress.
+Here is the general idea:
 
-Run this as `script/release_notes.py --since v4.6.0`, where `v4.6.0` is the *previous* release version.
-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`.
-
-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.
-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.
+* The work is done right on the `releases/v4.6.0` branch sometime after it is created but before the stable release is made.
+  The release notes for `v4.6.0` will later be copied to `master` when we begin a new development cycle.
+* There can be material for release notes entries in commit messages.
+* There can also be pre-written entries in `./releases_drafts`, which should be all incorporated in the release notes and then deleted from the branch.
   See `./releases_drafts/README.md` for more information.
+* The release notes should be written from a downstream expert user's point of view.
 
-# `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`.
+This section will be updated when the next release notes are written (for `v4.10.0`).

doc/do.md

@@ -0,0 +1,417 @@
+# The `do` notation
+
+Lean is a pure functional programming language, but you can write effectful code using the `do` embedded domain specific language (DSL). The following simple program prints two strings "hello" and "world" in the standard output and terminates with exit code 0. Note that the type of the program is `IO UInt32`. You can read this type as the type of values that perform input-output effects and produce a value of type `UInt32`.
+
+```lean
+def main : IO UInt32 := do
+  IO.println "hello"
+  IO.println "world"
+  return 0
+```
+The type of `IO.println` is `String → IO Unit`. That is, it is a function from `String` to `IO Unit` which indicates it may perform input-output effects and produce a value of type `Unit`. We often say that functions that may perform effects are *methods*.
+We also say a method application, such as `IO.println "hello"` is an *action*.
+Note that the examples above also demonstrates that braceless `do` blocks are whitespace sensitive.
+If you like `;`s and curly braces, you can write the example above as
+```lean
+def main : IO UInt32 := do {
+  IO.println "hello";
+  IO.println "world";
+  return 0;
+}
+```
+Semicolons can be used even when curly braces are not used. They are particularly useful when you want to "pack" more than one action in a single line.
+```lean
+def main : IO UInt32 := do
+  IO.println "hello"; IO.println "world"
+  return 0
+```
+Whitespace sensitivity in programming languages is a controversial topic
+among programmers. You should use your own style. We, the Lean developers, **love** the
+braceless and semicolon-free style.
+We believe it is clean and beautiful.
+
+The `do` DSL expands into the core Lean language. Let's inspect the different components using the commands `#print` and `#check`.
+
+```lean
+# def main : IO UInt32 := do
+#  IO.println "hello"
+#  IO.println "world"
+#  return 0
+
+#check IO.println "hello"
+-- IO Unit
+#print main
+-- Output contains the infix operator `>>=` and `pure`
+-- The following `set_option` disables notation such as `>>=` in the output
+set_option pp.notation false in
+#print main
+-- Output contains `bind` and `pure`
+#print bind
+-- bind : {m : Type u → Type v} → [self : Bind m] → {α β : Type u} →
+--        m α → (α → m β) → m β
+#print pure
+-- pure : {m : Type u → Type v} → [self : Pure m] → {α : Type u} →
+--        α → m α
+
+-- IO implements the type classes `Bind` and `Pure`.
+#check (inferInstance : Bind IO)
+#check (inferInstance : Pure IO)
+```
+The types of `bind` and `pure` may look daunting at first sight.
+They both have many implicit arguments. Let's focus first on the explicit arguments.
+`bind` has two explicit arguments `m α` and `α → m β`. The first one should
+be viewed as an action with effects `m` and producing a value of type `α`.
+The second is a function that takes a value of type `α` and produces an action
+with effects `m` and a value of type `β`. The result is `m β`. The method `bind` is composing
+these two actions. We often say `bind` is an abstract semicolon. The method `pure` converts
+a value `α` into an action that produces an action `m α`.
+
+Here is the same function being defined using `bind` and `pure` without the `do` DSL.
+```lean
+def main : IO UInt32 :=
+  bind (IO.println "hello") fun _ =>
+  bind (IO.println "world") fun _ =>
+  pure 0
+```
+
+The notations `let x <- action1; action2` and `let x ← action1; action2` are just syntax sugar for `bind action1 fun x => action2`.
+Here is a small example using it.
+```lean
+def isGreaterThan0 (x : Nat) : IO Bool := do
+  IO.println s!"value: {x}"
+  return x > 0
+
+def f (x : Nat) : IO Unit := do
+  let c <- isGreaterThan0 x
+  if c then
+    IO.println s!"{x} is greater than 0"
+  else
+    pure ()
+
+#eval f 10
+-- value: 10
+-- 10 is greater than 0
+```
+
+
+## Nested actions
+
+Note that we cannot write `if isGreaterThan0 x then ... else ...` because the condition in a `if-then-else` is a **pure** value without effects, but `isGreaterThan0 x` has type `IO Bool`. You can use the nested action notation to avoid this annoyance. Here is an equivalent definition for `f` using a nested action.
+```lean
+# def isGreaterThan0 (x : Nat) : IO Bool := do
+#  IO.println s!"x: {x}"
+#  return x > 0
+
+def f (x : Nat) : IO Unit := do
+  if (<- isGreaterThan0 x) then
+    IO.println s!"{x} is greater than 0"
+  else
+    pure ()
+
+#print f
+```
+Lean "lifts" the nested actions and introduces the `bind` for us.
+Here is an example with two nested actions. Note that both actions are executed
+even if `x = 0`.
+```lean
+# def isGreaterThan0 (x : Nat) : IO Bool := do
+#  IO.println s!"x: {x}"
+#  return x > 0
+
+def f (x y : Nat) : IO Unit := do
+  if (<- isGreaterThan0 x) && (<- isGreaterThan0 y) then
+    IO.println s!"{x} and {y} are greater than 0"
+  else
+    pure ()
+
+#eval f 0 10
+-- value: 0
+-- value: 10
+
+-- The function `f` above is equivalent to
+def g (x y : Nat) : IO Unit := do
+  let c1 <- isGreaterThan0 x
+  let c2 <- isGreaterThan0 y
+  if c1 && c2 then
+    IO.println s!"{x} and {y} are greater than 0"
+  else
+    pure ()
+
+theorem fgEqual : f = g :=
+  rfl -- proof by reflexivity
+```
+Here are two ways to achieve the short-circuit semantics in the example above
+```lean
+# def isGreaterThan0 (x : Nat) : IO Bool := do
+#  IO.println s!"x: {x}"
+#  return x > 0
+
+def f1 (x y : Nat) : IO Unit := do
+  if (<- isGreaterThan0 x <&&> isGreaterThan0 y) then
+    IO.println s!"{x} and {y} are greater than 0"
+  else
+    pure ()
+
+-- `<&&>` is the effectful version of `&&`
+-- Given `x y : IO Bool`, `x <&&> y` : m Bool`
+-- It only executes `y` if `x` returns `true`.
+
+#eval f1 0 10
+-- value: 0
+#eval f1 1 10
+-- value: 1
+-- value: 10
+-- 1 and 10 are greater than 0
+
+def f2 (x y : Nat) : IO Unit := do
+  if (<- isGreaterThan0 x) then
+    if (<- isGreaterThan0 y) then
+      IO.println s!"{x} and {y} are greater than 0"
+    else
+      pure ()
+  else
+    pure ()
+```
+
+## `if-then` notation
+
+In the `do` DSL, we can write `if c then action` as a shorthand for `if c then action else pure ()`. Here is the method `f2` using this shorthand.
+```lean
+# def isGreaterThan0 (x : Nat) : IO Bool := do
+#  IO.println s!"x: {x}"
+#  return x > 0
+
+def f2 (x y : Nat) : IO Unit := do
+  if (<- isGreaterThan0 x) then
+    if (<- isGreaterThan0 y) then
+      IO.println s!"{x} and {y} are greater than 0"
+```
+
+## Reassignments
+
+When writing effectful code, it is natural to think imperatively.
+For example, suppose we want to create an empty array `xs`,
+add `0` if some condition holds, add `1` if another condition holds,
+and then print it. In the following example, we use variable
+"shadowing" to simulate this kind of "update".
+
+```lean
+def f (b1 b2 : Bool) : IO Unit := do
+  let xs := #[]
+  let xs := if b1 then xs.push 0 else xs
+  let xs := if b2 then xs.push 1 else xs
+  IO.println xs
+
+#eval f true true
+-- #[0, 1]
+#eval f false true
+-- #[1]
+#eval f true false
+-- #[0]
+#eval f false false
+-- #[]
+```
+
+We can use tuples to simulate updates on multiple variables.
+
+```lean
+def f (b1 b2 : Bool) : IO Unit := do
+  let xs := #[]
+  let ys := #[]
+  let (xs, ys) := if b1 then (xs.push 0, ys) else (xs, ys.push 0)
+  let (xs, ys) := if b2 then (xs.push 1, ys) else (xs, ys.push 1)
+  IO.println s!"xs: {xs}, ys: {ys}"
+
+#eval f true false
+-- xs: #[0], ys: #[1]
+```
+
+We can also simulate the control-flow above using *join-points*.
+A join-point is a `let` that is always tail called and fully applied.
+The Lean compiler implements them using `goto`s.
+Here is the same example using join-points.
+
+```lean
+def f (b1 b2 : Bool) : IO Unit := do
+  let jp1 xs ys := IO.println s!"xs: {xs}, ys: {ys}"
+  let jp2 xs ys := if b2 then jp1 (xs.push 1) ys else jp1 xs (ys.push 1)
+  let xs := #[]
+  let ys := #[]
+  if b1 then jp2 (xs.push 0) ys else jp2 xs (ys.push 0)
+
+#eval f true false
+-- xs: #[0], ys: #[1]
+```
+
+You can capture complex control-flow using join-points.
+The `do` DSL offers the variable reassignment feature to make this kind of code more comfortable to write. In the following example, the `mut` modifier at `let mut xs := #[]` indicates that variable `xs` can be reassigned. The example contains two reassignments `xs := xs.push 0` and `xs := xs.push 1`. The reassignments are compiled using join-points. There is no hidden state being updated.
+
+```lean
+def f (b1 b2 : Bool) : IO Unit := do
+  let mut xs := #[]
+  if b1 then xs := xs.push 0
+  if b2 then xs := xs.push 1
+  IO.println xs
+
+#eval f true true
+-- #[0, 1]
+```
+The notation `x <- action` reassigns `x` with the value produced by the action. It is equivalent to `x := (<- action)`
+
+## Iteration
+
+The `do` DSL provides a unified notation for iterating over datastructures. Here are a few examples.
+
+```lean
+def sum (xs : Array Nat) : IO Nat := do
+  let mut s := 0
+  for x in xs do
+    IO.println s!"x: {x}"
+    s := s + x
+  return s
+
+#eval sum #[1, 2, 3]
+-- x: 1
+-- x: 2
+-- x: 3
+-- 6
+
+-- We can write pure code using the `Id.run <| do` DSL too.
+def sum' (xs : Array Nat) : Nat := Id.run <| do
+  let mut s := 0
+  for x in xs do
+    s := s + x
+  return s
+
+#eval sum' #[1, 2, 3]
+-- 6
+
+def sumEven (xs : Array Nat) : IO Nat := do
+  let mut s := 0
+  for x in xs do
+    if x % 2 == 0 then
+      IO.println s!"x: {x}"
+      s := s + x
+  return s
+
+#eval sumEven #[1, 2, 3, 6]
+-- x: 2
+-- x: 6
+-- 8
+
+def splitEvenOdd (xs : List Nat) : IO Unit := do
+  let mut evens := #[]
+  let mut odds  := #[]
+  for x in xs do
+    if x % 2 == 0 then
+      evens := evens.push x
+    else
+      odds := odds.push x
+  IO.println s!"evens: {evens}, odds: {odds}"
+
+#eval splitEvenOdd [1, 2, 3, 4]
+-- evens: #[2, 4], odds: #[1, 3]
+
+def findNatLessThan (x : Nat) (p : Nat → Bool) : IO Nat := do
+  -- [:x] is notation for the range [0, x)
+  for i in [:x] do
+    if p i then
+      return i -- `return` from the `do` block
+  throw (IO.userError "value not found")
+
+#eval findNatLessThan 10 (fun x => x > 5 && x % 4 == 0)
+-- 8
+
+def sumOddUpTo (xs : List Nat) (threshold : Nat) : IO Nat := do
+  let mut s := 0
+  for x in xs do
+    if x % 2 == 0 then
+      continue -- it behaves like the `continue` statement in imperative languages
+    IO.println s!"x: {x}"
+    s := s + x
+    if s > threshold then
+      break -- it behaves like the `break` statement in imperative languages
+  IO.println s!"result: {s}"
+  return s
+
+#eval sumOddUpTo [2, 3, 4, 11, 20, 31, 41, 51, 107] 40
+-- x: 3
+-- x: 11
+-- x: 31
+-- result: 45
+-- 45
+```
+
+TODO: describe `forIn`
+
+## Try-catch
+
+TODO
+
+## Returning early from a failed match
+
+Inside a `do` block, the pattern `let _ ← <success> | <fail>` will continue with the rest of the block if the match on the left hand side succeeds, but will execute the right hand side and exit the block on failure:
+
+```lean
+def showUserInfo (getUsername getFavoriteColor : IO (Option String)) : IO Unit := do
+  let some n ← getUsername | IO.println "no username!"
+  IO.println s!"username: {n}"
+  let some c ← getFavoriteColor | IO.println "user didn't provide a favorite color!"
+  IO.println s!"favorite color: {c}"
+
+-- username: JohnDoe
+-- favorite color: red
+#eval showUserInfo (pure <| some "JohnDoe") (pure <| some "red")
+
+-- no username
+#eval showUserInfo (pure none) (pure <| some "purple")
+
+-- username: JaneDoe
+-- user didn't provide a favorite color
+#eval showUserInfo (pure <| some "JaneDoe") (pure none)
+```
+
+## If-let
+
+Inside a `do` block, users can employ the `if let` pattern to destructure actions:
+
+```lean
+def tryIncrement (getInput : IO (Option Nat)) : IO (Except String Nat) := do
+  if let some n ← getInput
+  then return Except.ok n.succ
+  else return Except.error "argument was `none`"
+
+-- Except.ok 2
+#eval tryIncrement (pure <| some 1)
+
+-- Except.error "argument was `none`"
+#eval tryIncrement (pure <| none)
+```
+
+## Pattern matching
+
+TODO
+
+## Monads
+
+TODO
+
+## ReaderT
+
+TODO
+
+## StateT
+
+TODO
+
+## StateRefT
+
+TODO
+
+## ExceptT
+
+TODO
+
+## MonadLift and automatic lifting
+
+TODO

doc/elaborators.md

@@ -0,0 +1,8 @@
+## Elaborators
+
+TODO. See [Lean Together 2021: Metaprogramming in Lean
+4](https://youtu.be/hxQ1vvhYN_U) for an overview as well [the
+continuation](https://youtu.be/vy4JWIiiXSY) about tactic programming.
+For more information on antiquotations, see also §4.1 of [Beyond
+Notations: Hygienic Macro Expansion for Theorem Proving
+Languages](https://arxiv.org/pdf/2001.10490.pdf#page=11).

doc/enum.md

@@ -0,0 +1,190 @@
+# Enumerated Types
+
+The simplest kind of inductive type is simply a type with a finite, enumerated list of elements.
+The following command declares the enumerated type `Weekday`.
+```lean
+inductive Weekday where
+  | sunday    : Weekday
+  | monday    : Weekday
+  | tuesday   : Weekday
+  | wednesday : Weekday
+  | thursday  : Weekday
+  | friday    : Weekday
+  | saturday  : Weekday
+```
+
+The `Weekday` type 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.
+```lean
+# inductive Weekday where
+#  | sunday    : Weekday
+#  | monday    : Weekday
+#  | tuesday   : Weekday
+#  | wednesday : Weekday
+#  | thursday  : Weekday
+#  | friday    : Weekday
+#  | saturday  : Weekday
+#check Weekday.sunday   -- Weekday
+#check Weekday.monday   -- Weekday
+```
+
+You can define functions by pattern matching.
+The following function converts a `Weekday` into a natural number.
+```lean
+# inductive Weekday where
+#  | sunday    : Weekday
+#  | monday    : Weekday
+#  | tuesday   : Weekday
+#  | wednesday : Weekday
+#  | thursday  : Weekday
+#  | friday    : Weekday
+#  | saturday  : Weekday
+def natOfWeekday (d : Weekday) : Nat :=
+  match d with
+  | Weekday.sunday    => 1
+  | Weekday.monday    => 2
+  | Weekday.tuesday   => 3
+  | Weekday.wednesday => 4
+  | Weekday.thursday  => 5
+  | Weekday.friday    => 6
+  | Weekday.saturday  => 7
+
+#eval natOfWeekday Weekday.tuesday -- 3
+```
+
+It is often useful to group definitions related to a type in a namespace with the same name.
+For example, we can put the function above into the ``Weekday`` namespace.
+We are then allowed to use the shorter name when we open the namespace.
+
+In the following example, we define functions from ``Weekday`` to ``Weekday`` in the namespace `Weekday`.
+```lean
+# inductive Weekday where
+#  | sunday    : Weekday
+#  | monday    : Weekday
+#  | tuesday   : Weekday
+#  | wednesday : Weekday
+#  | thursday  : Weekday
+#  | friday    : Weekday
+#  | saturday  : Weekday
+namespace Weekday
+
+def next (d : Weekday) : Weekday :=
+  match d with
+  | sunday    => monday
+  | monday    => tuesday
+  | tuesday   => wednesday
+  | wednesday => thursday
+  | thursday  => friday
+  | friday    => saturday
+  | saturday  => sunday
+
+end Weekday
+```
+It is so common to start a definition with a `match` in Lean, that Lean provides a syntax sugar for it.
+```lean
+# inductive Weekday where
+#  | sunday    : Weekday
+#  | monday    : Weekday
+#  | tuesday   : Weekday
+#  | wednesday : Weekday
+#  | thursday  : Weekday
+#  | friday    : Weekday
+#  | saturday  : Weekday
+# namespace Weekday
+def previous : Weekday -> Weekday
+  | sunday    => saturday
+  | monday    => sunday
+  | tuesday   => monday
+  | wednesday => tuesday
+  | thursday  => wednesday
+  | friday    => thursday
+  | saturday  => friday
+# end Weekday
+```
+We can use the command `#eval` to test our definitions.
+```lean
+# inductive Weekday where
+#  | sunday    : Weekday
+#  | monday    : Weekday
+#  | tuesday   : Weekday
+#  | wednesday : Weekday
+#  | thursday  : Weekday
+#  | friday    : Weekday
+#  | saturday  : Weekday
+# namespace Weekday
+# def next (d : Weekday) : Weekday :=
+#  match d with
+#  | sunday    => monday
+#  | monday    => tuesday
+#  | tuesday   => wednesday
+#  | wednesday => thursday
+#  | thursday  => friday
+#  | friday    => saturday
+#  | saturday  => sunday
+# def previous : Weekday -> Weekday
+#  | sunday    => saturday
+#  | monday    => sunday
+#  | tuesday   => monday
+#  | wednesday => tuesday
+#  | thursday  => wednesday
+#  | friday    => thursday
+#  | saturday  => friday
+def toString : Weekday -> String
+  | sunday    => "Sunday"
+  | monday    => "Monday"
+  | tuesday   => "Tuesday"
+  | wednesday => "Wednesday"
+  | thursday  => "Thursday"
+  | friday    => "Friday"
+  | saturday  => "Saturday"
+
+#eval toString (next sunday)             -- "Monday"
+#eval toString (next tuesday)            -- "Wednesday"
+#eval toString (previous wednesday)      -- "Tuesday"
+#eval toString (next (previous sunday))  -- "Sunday"
+#eval toString (next (previous monday))  -- "Monday"
+-- ..
+# end Weekday
+```
+We can now prove the general theorem that ``next (previous d) = d`` for any weekday ``d``.
+The idea is to perform a proof by cases using `match`, and rely on the fact for each constructor both
+sides of the equality reduce to the same term.
+```lean
+# inductive Weekday where
+#  | sunday    : Weekday
+#  | monday    : Weekday
+#  | tuesday   : Weekday
+#  | wednesday : Weekday
+#  | thursday  : Weekday
+#  | friday    : Weekday
+#  | saturday  : Weekday
+# namespace Weekday
+# def next (d : Weekday) : Weekday :=
+#  match d with
+#  | sunday    => monday
+#  | monday    => tuesday
+#  | tuesday   => wednesday
+#  | wednesday => thursday
+#  | thursday  => friday
+#  | friday    => saturday
+#  | saturday  => sunday
+# def previous : Weekday -> Weekday
+#  | sunday    => saturday
+#  | monday    => sunday
+#  | tuesday   => monday
+#  | wednesday => tuesday
+#  | thursday  => wednesday
+#  | friday    => thursday
+#  | saturday  => friday
+theorem nextOfPrevious (d : Weekday) : next (previous d) = d :=
+  match d with
+  | sunday    => rfl
+  | monday    => rfl
+  | tuesday   => rfl
+  | wednesday => rfl
+  | thursday  => rfl
+  | friday    => rfl
+  | saturday  => rfl
+# end Weekday
+```

doc/examples/ICERM2022/meta.lean

@@ -29,7 +29,7 @@ def ex3 (declName : Name) : MetaM Unit := do
     for x in xs do
       trace[Meta.debug] "{x} : {← inferType x}"
 
-def myMin [LT α] [DecidableLT α] (a b : α) : α :=
+def myMin [LT α] [DecidableRel (α := α) (·<·)] (a b : α) : α :=
   if a < b then
     a
   else

doc/examples/bintree.lean

@@ -179,7 +179,7 @@ local macro "have_eq " lhs:term:max rhs:term:max : tactic =>
   `(tactic|
     (have h : $lhs = $rhs :=
        -- TODO: replace with linarith
-       by simp +arith at *; apply Nat.le_antisymm <;> assumption
+       by simp_arith at *; apply Nat.le_antisymm <;> assumption
      try subst $lhs))
 
 /-!

doc/examples/interp.lean

@@ -12,17 +12,17 @@ Remark: this example is based on an example found in the Idris manual.
 Vectors
 --------
 
-A `Vec` is a list of size `n` whose elements belong to a type `α`.
+A `Vector` is a list of size `n` whose elements belong to a type `α`.
 -/
 
-inductive Vec (α : Type u) : Nat → Type u
-  | nil : Vec α 0
-  | cons : α → Vec α n → Vec α (n+1)
+inductive Vector (α : Type u) : Nat → Type u
+  | nil : Vector α 0
+  | cons : α → Vector α n → Vector α (n+1)
 
 /-!
-We can overload the `List.cons` notation `::` and use it to create `Vec`s.
+We can overload the `List.cons` notation `::` and use it to create `Vector`s.
 -/
-infix:67 " :: " => Vec.cons
+infix:67 " :: " => Vector.cons
 
 /-!
 Now, we define the types of our simple functional language.
@@ -50,11 +50,11 @@ the builtin instance for `Add Int` as the solution.
 /-!
 Expressions are indexed by the types of the local variables, and the type of the expression itself.
 -/
-inductive HasType : Fin n → Vec Ty n → Ty → Type where
+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
 
-inductive Expr : Vec Ty n → Ty → Type where
+inductive Expr : Vector Ty n → Ty → Type where
   | var   : HasType i ctx ty → Expr ctx ty
   | val   : Int → Expr ctx Ty.int
   | lam   : Expr (a :: ctx) ty → Expr ctx (Ty.fn a ty)
@@ -102,8 +102,8 @@ indexed over the types in scope. Since an environment is just another form of li
 to the vector of local variable types, we overload again the notation `::` so that we can use the usual list syntax.
 Given a proof that a variable is defined in the context, we can then produce a value from the environment.
 -/
-inductive Env : Vec Ty n → Type where
-  | nil  : Env Vec.nil
+inductive Env : Vector Ty n → Type where
+  | nil  : Env Vector.nil
   | cons : Ty.interp a → Env ctx → Env (a :: ctx)
 
 infix:67 " :: " => Env.cons

doc/examples/tc.lean

@@ -82,7 +82,9 @@ theorem Expr.typeCheck_correct (h₁ : HasType e ty) (h₂ : e.typeCheck ≠ .un
 /-!
 Now, we prove that if `Expr.typeCheck e` returns `Maybe.unknown`, then forall `ty`, `HasType e ty` does not hold.
 The notation `e.typeCheck` is sugar for `Expr.typeCheck e`. Lean can infer this because we explicitly said that `e` has type `Expr`.
-The proof is by induction on `e` and case analysis. Note that the tactic `simp [typeCheck]` is applied to all goal generated by the `induction` tactic, and closes
+The proof is by induction on `e` and case analysis. The tactic `rename_i` is used to rename "inaccessible" variables.
+We say a variable is inaccessible if it is introduced by a tactic (e.g., `cases`) or has been shadowed by another variable introduced
+by the user. Note that the tactic `simp [typeCheck]` is applied to all goal generated by the `induction` tactic, and closes
 the cases corresponding to the constructors `Expr.nat` and `Expr.bool`.
 -/
 theorem Expr.typeCheck_complete {e : Expr} : e.typeCheck = .unknown → ¬ HasType e ty := by

doc/examples/test_single.sh

@@ -1,4 +1,4 @@
 #!/usr/bin/env bash
 source ../../tests/common.sh
 
-exec_check_raw lean -Dlinter.all=false "$f"
+exec_check lean -Dlinter.all=false "$f"

doc/flake.nix

@@ -83,6 +83,7 @@
         src = ./.;
         roots = [
           { mod = "examples"; glob = "submodules"; }
+          { mod = "monads"; glob = "submodules"; }
         ];
       };
       inked = renderPackage literate;

doc/float.md

@@ -0,0 +1 @@
+# Float

doc/functions.md

@@ -0,0 +1,153 @@
+# Functions
+
+Functions are the fundamental unit of program execution in any programming language.
+As in other languages, a Lean function has a name, can have parameters and take arguments, and has a body.
+Lean also supports functional programming constructs such as treating functions as values,
+using unnamed functions in expressions, composition of functions to form new functions,
+curried functions, and the implicit definition of functions by way of
+the partial application of function arguments.
+
+You define functions by using the `def` keyword followed by its name, a parameter list, return type and its body.
+The parameter list consists of successive parameters that are separated by spaces.
+You can specify an explicit type for each parameter.
+If you do not specify a specific argument type, the compiler tries to infer the type from the function body.
+An error is returned when it cannot be inferred.
+The expression that makes up the function body is typically a compound expression consisting of a number of expressions
+that culminate in a final expression that is the return value.
+The return type is a colon followed by a type and is optional.
+If you do not specify the type of the return value explicitly,
+the compiler tries to determine the return type from the final expression.
+
+```lean
+def f x := x + 1
+```
+In the previous example, the function name is `f`, the argument is `x`, which has type `Nat`,
+the function body is `x + 1`, and the return value is of type `Nat`.
+The following example defines the factorial recursive function using pattern matching.
+```lean
+def fact x :=
+  match x with
+  | 0   => 1
+  | n+1 => (n+1) * fact n
+
+#eval fact 100
+```
+By default, Lean only accepts total functions.
+The `partial` keyword may be used to define a recursive function without a termination proof; `partial` functions compute in compiled programs, but are opaque in proofs and during type checking.
+```lean
+partial def g (x : Nat) (p : Nat -> Bool) : Nat :=
+  if p x then
+    x
+  else
+    g (x+1) p
+
+#eval g 0 (fun x => x > 10)
+```
+In the previous example, `g x p` only terminates if there is a `y >= x` such that `p y` returns `true`.
+Of course, `g 0 (fun x => false)` never terminates.
+
+However, the use of `partial` is restricted to functions whose return type is not empty so the soundness
+of the system is not compromised.
+
+```lean,ignore
+partial def loop? : α := -- failed to compile partial definition 'loop?', failed to
+  loop?                  -- show that type is inhabited and non empty
+
+partial def loop [Inhabited α] : α := -- compiles
+  loop
+
+example : True := -- accepted
+  loop
+
+example : False :=
+  loop -- failed to synthesize instance Inhabited False
+```
+
+If we were able to partially define `loop?`, we could prove `False` with it.
+
+# Lambda expressions
+
+A lambda expression is an unnamed function.
+You define lambda expressions by using the `fun` keyword. A lambda expression resembles a function definition, except that instead of the `:=` token,
+the `=>` token is used to separate the argument list from the function body. As in a regular function definition,
+the argument types can be inferred or specified explicitly, and the return type of the lambda expression is inferred from the type of the
+last expression in the body.
+
+```lean
+def twice (f : Nat -> Nat) (x : Nat) : Nat :=
+  f (f x)
+
+#eval twice (fun x => x + 1) 3
+#eval twice (fun (x : Nat) => x * 2) 3
+
+#eval List.map (fun x => x + 1) [1, 2, 3]
+-- [2, 3, 4]
+
+#eval List.map (fun (x, y) => x + y) [(1, 2), (3, 4)]
+-- [3, 7]
+```
+
+# Syntax sugar for simple lambda expressions
+
+Simple functions can be defined using parentheses and `·` as a placeholder.
+```lean
+#check (· + 1)
+-- fun a => a + 1
+#check (2 - ·)
+-- fun a => 2 - a
+#eval [1, 2, 3, 4, 5].foldl (· * ·) 1
+-- 120
+
+def h (x y z : Nat) :=
+  x + y + z
+
+#check (h · 1 ·)
+-- fun a b => h a 1 b
+
+#eval [(1, 2), (3, 4), (5, 6)].map (·.1)
+-- [1, 3, 5]
+```
+In the previous example, the term `(·.1)` is syntax sugar for `fun x => x.1`.
+
+# Pipelining
+
+Pipelining enables function calls to be chained together as successive operations. Pipelining works as follows:
+
+```lean
+def add1 x := x + 1
+def times2 x := x * 2
+
+#eval times2 (add1 100)
+#eval 100 |> add1 |> times2
+#eval times2 <| add1 <| 100
+```
+The result of the previous `#eval` commands is 202.
+The forward pipeline `|>` operator takes a function and an argument and return a value.
+In contrast, the backward pipeline `<|` operator takes an argument and a function and returns a value.
+These operators are useful for minimizing the number of parentheses.
+```lean
+def add1Times3FilterEven (xs : List Nat) :=
+  List.filter (· % 2 == 0) (List.map (· * 3) (List.map (· + 1) xs))
+
+#eval add1Times3FilterEven [1, 2, 3, 4]
+-- [6, 12]
+
+-- Define the same function using pipes
+def add1Times3FilterEven' (xs : List Nat) :=
+  xs |> List.map (· + 1) |> List.map (· * 3) |> List.filter (· % 2 == 0)
+
+#eval add1Times3FilterEven' [1, 2, 3, 4]
+-- [6, 12]
+```
+Lean also supports the operator `|>.` which combines forward pipeline `|>` operator with the `.` field notation.
+```lean
+-- Define the same function using pipes
+def add1Times3FilterEven'' (xs : List Nat) :=
+  xs.map (· + 1) |>.map (· * 3) |>.filter (· % 2 == 0)
+
+#eval add1Times3FilterEven'' [1, 2, 3, 4]
+-- [6, 12]
+```
+
+For users familiar with the Haskell programming language,
+Lean also supports the notation `f $ a` for the backward pipeline `f <| a`.

doc/implicit.md

@@ -0,0 +1,142 @@
+## Implicit Arguments
+
+Suppose we define the `compose` function as.
+
+```lean
+def compose (α β γ : Type) (g : β → γ) (f : α → β) (x : α) : γ :=
+  g (f x)
+```
+
+The function `compose` takes three types, ``α``, ``β``, and ``γ``, and two functions, ``g : β → γ`` and ``f : α → β``, a value `x : α`, and
+returns ``g (f x)``, the composition of ``g`` and ``f``.
+We say `compose` is polymorphic over types ``α``, ``β``, and ``γ``. Now, let's use `compose`:
+
+```lean
+# def compose (α β γ : Type) (g : β → γ) (f : α → β) (x : α) : γ :=
+#   g (f x)
+def double (x : Nat) := 2*x
+def triple (x : Nat) := 3*x
+
+#check compose Nat Nat Nat double triple 10 -- Nat
+#eval  compose Nat Nat Nat double triple 10 -- 60
+
+def appendWorld (s : String) := s ++ "world"
+#check String.length -- String → Nat
+
+#check compose String String Nat String.length appendWorld "hello" -- Nat
+#eval  compose String String Nat String.length appendWorld "hello" -- 10
+```
+
+Because `compose` is polymorphic over types ``α``, ``β``, and ``γ``, we have to provide them in the examples above.
+But this information is redundant: one can infer the types from the arguments ``g`` and ``f``.
+This is a central feature of dependent type theory: terms carry a lot of information, and often some of that information can be inferred from the context.
+In Lean, one uses an underscore, ``_``, to specify that the system should fill in the information automatically.
+
+```lean
+# def compose (α β γ : Type) (g : β → γ) (f : α → β) (x : α) : γ :=
+#  g (f x)
+# def double (x : Nat) := 2*x
+# def triple (x : Nat) := 3*x
+#check compose _ _ _ double triple 10 -- Nat
+#eval  compose Nat Nat Nat double triple 10 -- 60
+# def appendWorld (s : String) := s ++ "world"
+# #check String.length -- String → Nat
+#check compose _ _ _ String.length appendWorld "hello" -- Nat
+#eval  compose _ _ _ String.length appendWorld "hello" -- 10
+```
+It is still tedious, however, to type all these underscores. When a function takes an argument that can generally be inferred from context,
+Lean allows us to specify that this argument should, by default, be left implicit. This is done by putting the arguments in curly braces, as follows:
+
+```lean
+def compose {α β γ : Type} (g : β → γ) (f : α → β) (x : α) : γ :=
+  g (f x)
+# def double (x : Nat) := 2*x
+# def triple (x : Nat) := 3*x
+#check compose double triple 10 -- Nat
+#eval  compose double triple 10 -- 60
+# def appendWorld (s : String) := s ++ "world"
+# #check String.length -- String → Nat
+#check compose String.length appendWorld "hello" -- Nat
+#eval  compose String.length appendWorld "hello" -- 10
+```
+All that has changed are the braces around ``α β γ: Type``.
+It makes these three arguments implicit. Notationally, this hides the specification of the type,
+making it look as though ``compose`` simply takes 3 arguments.
+
+Variables can also be specified as implicit when they are declared with
+the ``variable`` command:
+
+```lean
+universe u
+
+section
+  variable {α : Type u}
+  variable (x : α)
+  def ident := x
+end
+
+variable (α β : Type u)
+variable (a : α) (b : β)
+
+#check ident
+#check ident a
+#check ident b
+```
+
+This definition of ``ident`` here has the same effect as the one above.
+
+Lean has very complex mechanisms for instantiating implicit arguments, and we will see that they can be used to infer function types, predicates, and even proofs.
+The process of instantiating these "holes," or "placeholders," in a term is part of a bigger process called *elaboration*.
+The presence of implicit arguments means that at times there may be insufficient information to fix the meaning of an expression precisely.
+An expression like ``ident`` is said to be *polymorphic*, because it can take on different meanings in different contexts.
+
+One can always specify the type ``T`` of an expression ``e`` by writing ``(e : T)``.
+This instructs Lean's elaborator to use the value ``T`` as the type of ``e`` when trying to elaborate it.
+In the following example, this mechanism is used to specify the desired types of the expressions ``ident``.
+
+```lean
+def ident {α : Type u} (a : α) : α := a
+
+#check (ident : Nat → Nat) -- Nat → Nat
+```
+
+Numerals are overloaded in Lean, but when the type of a numeral cannot be inferred, Lean assumes, by default, that it is a natural number.
+So the expressions in the first two ``#check`` commands below are elaborated in the same way, whereas the third ``#check`` command interprets ``2`` as an integer.
+
+```lean
+#check 2         -- Nat
+#check (2 : Nat) -- Nat
+#check (2 : Int) -- Int
+```
+
+Sometimes, however, we may find ourselves in a situation where we have declared an argument to a function to be implicit,
+but now want to provide the argument explicitly. If ``foo`` is such a function, the notation ``@foo`` denotes the same function with all
+the arguments made explicit.
+
+```lean
+# def ident {α : Type u} (a : α) : α := a
+variable (α β : Type)
+
+#check @ident           -- {α : Type u} → α → α
+#check @ident α         -- α → α
+#check @ident β         -- β → β
+#check @ident Nat       -- Nat → Nat
+#check @ident Bool true -- Bool
+```
+
+Notice that now the first ``#check`` command gives the type of the identifier, ``ident``, without inserting any placeholders.
+Moreover, the output indicates that the first argument is implicit.
+
+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. You can use them to specify explicit *and* implicit arguments.
+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 ident {α : Type u} (a : α) : α := a
+
+#check ident (α := Nat)  -- Nat → Nat
+#check ident (α := Bool) -- Bool → Bool
+```

doc/inductive.md

@@ -0,0 +1,3 @@
+# Inductive Types
+
+[Theorem Proving in Lean](https://lean-lang.org/theorem_proving_in_lean4/inductive_types.html) has a chapter about inductive datatypes.

doc/int.md

@@ -0,0 +1,37 @@
+# Integers
+
+The `Int` type represents the arbitrary-precision integers. There are no overflows.
+```lean
+#eval (100000000000000000 : Int) * 200000000000000000000 * 1000000000000000000000
+```
+Recall that nonnegative numerals are considered to be a `Nat` if there are no typing constraints.
+```lean
+#check 1 -- Nat
+#check -1 -- Int
+#check (1:Int) -- Int
+```
+
+The operator `/` for `Int` implements integer division.
+```lean
+#eval -10 / 4 -- -3
+```
+
+Similar to `Nat`, the internal representation of `Int` is optimized. Small integers are
+represented by a single machine word. Big integers are implemented using [GMP](https://gmplib.org/manual/) numbers.
+We recommend you use fixed precision numeric types only in performance critical code.
+
+The Lean kernel does not have special support for reducing `Int` during type checking.
+However, since `Int` is defined as
+```lean
+# namespace hidden
+inductive Int : Type where
+  | ofNat   : Nat → Int
+  | negSucc : Nat → Int
+# end hidden
+```
+the type checker will be able reduce `Int` expressions efficiently by relying on the special support for `Nat`.
+
+```lean
+theorem ex : -2000000000 * 1000000000 = -2000000000000000000 :=
+ rfl
+```

doc/lexical_structure.md

@@ -61,7 +61,7 @@ Parts of atomic names can be escaped by enclosing them in pairs of French double
    letterlike_symbols: [℀-⅏]
    escaped_ident_part: "«" [^«»\r\n\t]* "»"
    atomic_ident_rest: atomic_ident_start | [0-9'ⁿ] | subscript
-   subscript: [₀-₉ₐ-ₜᵢ-ᵪⱼ]
+   subscript: [₀-₉ₐ-ₜᵢ-ᵪ]
 ```
 
 String Literals
@@ -128,16 +128,16 @@ 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+)+
+   numeral10  : [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]
+   float    : [0-9]+ "." [0-9]+ [[eE[+-][0-9]+]
 ```
 
 For example:
@@ -147,7 +147,6 @@ 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:

doc/list.md

@@ -0,0 +1 @@
+# List

doc/macro_overview.md

@@ -0,0 +1,393 @@
+
+# Macro Overview
+
+The official paper describing the mechanics behind Lean 4's macro system can be
+found in [Beyond Notations: Hygienic Macro Expansion for Theorem Proving
+Languages](https://arxiv.org/abs/2001.10490) by Sebastian Ullrich and Leonardo
+de Moura, and the accompanying repo with example code can be found in the
+paper's code [supplement](https://github.com/Kha/macro-supplement). The
+supplement also includes a working implementation of the macro expander, so it's
+a good case study for people interested in the details.
+
+## What is a macro in Lean?
+
+A macro is a function that takes in a syntax tree and produces a new syntax
+tree. Macros are useful for many reasons, but two of the big ones are a)
+allowing users to extend the language with new syntactic constructs without
+having to actually expand the core language, and b) allowing users to automate
+tasks that would otherwise be extremely repetitive, time-consuming, and/or
+error-prone.
+
+A motivating example is set builder notation. We would like to be able to write
+the set of natural numbers 0, 1, and 2 as just `{0, 1, 2}`. However, Lean does
+not natively support this syntax, and the actual definition of a set in Mathlib
+does not let us just declare sets in this manner; naively using the set API
+would force us to write `Set.insert 1 (Set.insert 2 (Set.singleton 3))`.
+Instead, we can teach Lean's macro system to recognize `{0, 1, 2}` as a
+shorthand for a composition of existing methods and let it do the repetitive
+work of creating the `Set.insert...` invocation for us. In this way, we can have
+our more readable and more convenient syntax without having to extend Lean
+itself, and while retaining the simple insert/singleton API.
+
+## How macros are handled
+
+The general procedure is as follows:
+
+1. Lean parses a command, creating a Lean syntax tree which contains any
+   unexpanded macros.
+
+2. Lean repeats the cycle (elaboration ~> (macro hygiene and expansion) ~>
+   elaboration...)
+
+The cycle in step 2 repeats until there are no more macros which need to be
+expanded, and elaboration can finish normally. This repetition is required since
+macros can expand to other macros, and may expand to code that needs information
+from the elaborator. As you can see, the process of macro parsing and expansion
+is interleaved with the parsing and elaboration of non-macro code.
+
+By default, macros in Lean are hygienic, which means the system avoids
+accidental name capture when reusing the same name inside and outside the macro.
+Users may occasionally want to disable hygiene, which can be accomplished with
+the command `set_option hygiene false`. More in-depth information about hygiene
+and how it's implemented in the official paper and supplement linked at the top
+of this guide.
+
+## Elements of "a" macro (important types)
+
+
+In the big picture, a macro has two components that must be implemented by the
+user, parsers and syntax transformers, where the latter is a function that says
+what the input syntax should expand to. There is a third component, syntax
+categories, such as `term`, `tactic`, and `command`, but declaring a new syntax
+category is not always necessary. When we say "parser" in the context of a
+macro, we refer to the core type `Lean.ParserDescr`, which parses elements of
+type `Lean.Syntax`, where `Lean.Syntax` represents elements of a Lean syntax
+tree. Syntax transformers are functions of type `Syntax -> MacroM Syntax`. Lean
+has a synonym for this type, which is simply `Macro`. `MacroM` is a monad that
+carries state needed for macro expansion to work nicely, including the info
+needed to implement hygiene.
+
+As an example, we again refer to Mathlib's set builder notation:
+```lean
+/- Declares a parser -/
+syntax (priority := high) "{" term,+ "}" : term
+
+/- Declares two expansions/syntax transformers -/
+macro_rules
+  | `({$x}) => `(Set.singleton $x)
+  | `({$x, $xs:term,*}) => `(Set.insert $x {$xs,*})
+
+/- Provided `Set` has been imported (from Mathlib4), these are all we need for `{1, 2, 3}` to be valid notation to create a literal set -/
+
+```
+
+This example should also make clear the reason why macros (and pretty much all
+of Lean 4's metaprogramming facilities) are functions that take an argument of
+type `Syntax` e.g. `Syntax -> MacroM Syntax`; the leading syntax element is the
+thing that actually triggers the macro expansion by matching with the declared
+parser, and as a user, you will almost always be interested in inspecting and
+transforming that initial syntax element (though there are cases in which it can
+just be ignored, as in the parameter-less exfalso tactic).
+
+Returning briefly to the API provided by Lean, `Lean.Syntax`, is pretty much
+what you would expect a basic syntax tree type to look like. Below is a slightly
+simplified representation which omits details in the `atom` and `ident`
+constructors; users can create atoms and idents which comport with this
+simplified representation using the `mkAtom` and `mkIdent` methods provided in
+the `Lean` namespace.
+```lean
+# open Lean
+inductive Syntax where
+  | missing : Syntax
+  | node (kind : SyntaxNodeKind) (args : Array Syntax) : Syntax
+  | atom : String -> Syntax
+  | ident : Name -> Syntax
+```
+
+
+
+For those interested, `MacroM` is a `ReaderT`:
+```lean
+# open Lean
+abbrev MacroM := ReaderT Macro.Context (EStateM Macro.Exception Macro.State)
+```
+
+The other relevant components are defined as follows:
+```lean
+# open Lean
+structure Context where
+  methods        : MethodsRef
+  mainModule     : Name
+  currMacroScope : MacroScope
+  currRecDepth   : Nat := 0
+  maxRecDepth    : Nat := defaultMaxRecDepth
+  ref            : Syntax
+
+inductive Exception where
+  | error             : Syntax → String → Exception
+  | unsupportedSyntax : Exception
+
+structure State where
+  macroScope : MacroScope
+  traceMsgs  : List (Prod Name String) := List.nil
+  deriving Inhabited
+```
+
+As a review/checklist, the three (sometimes only two depending on whether you
+need a new syntax category) components users need to be concerned with are:
+
+0. You may or may not need to declare a new syntax category using
+   `declare_syntax_cat`
+1. Declare a parser with either `syntax` or `macro`
+2. Declare an expansion/syntax transformer with either `macro_rules` or `macro`
+
+Parsers and syntax transformers can be declared manually, but use of the pattern
+language and `syntax`, `macro_rules`, and `macro` is recommended.
+
+## syntax categories with declare_syntax_cat
+
+`declare_syntax_cat` declares a new syntax category, like `command`, `tactic`,
+or mathlib4's `binderterm`. These are the different categories of things that
+can be referred to in a quote/antiquote. `declare_syntax_cat` results in a call
+to `registerParserCategory` and produces a new parser descriptor:
+
+```lean
+set_option trace.Elab.definition true in
+declare_syntax_cat binderterm
+
+/-
+Output:
+
+[Elab.definition.body] binderterm.quot : Lean.ParserDescr :=
+Lean.ParserDescr.node `Lean.Parser.Term.quot 1024
+  (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.symbol "`(binderterm|")
+    (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.cat `binderterm 0)
+      (Lean.ParserDescr.symbol ")")))
+-/
+```
+
+Declaring a new syntax category like this one automatically declares a quotation
+operator `` `(binderterm| ...)``. These pipe prefixes `<thing>|` are used in
+syntax quotations to say what category a given quotation is expected to be an
+element of. The pipe prefixes are *not* used for elements in the `term` and
+`command` categories (since they're considered the default), but need to be used
+for everything else.
+
+## Parsers and the `syntax` keyword
+
+Internally, elements of type `Lean.ParserDescr` are implemented as parser
+combinators. However, Lean offers the ability to write parsers using the
+macro/pattern language by way of the `syntax` keyword. This is the recommended
+means of writing parsers. As an example, the parser for the `rwa` (rewrite, then
+use assumption) tactic is:
+
+```lean
+# open Lean.Parser.Tactic
+set_option trace.Elab.definition true in
+syntax "rwa " rwRuleSeq (location)? : tactic
+
+/-
+which expands to:
+[Elab.definition.body] tacticRwa__ : Lean.ParserDescr :=
+Lean.ParserDescr.node `tacticRwa__ 1022
+  (Lean.ParserDescr.binary `andthen
+    (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.nonReservedSymbol "rwa " false) Lean.Parser.Tactic.rwRuleSeq)
+    (Lean.ParserDescr.unary `optional Lean.Parser.Tactic.location))
+
+-/
+
+```
+
+Literals are written as double-quoted strings (`"rwa "` expects the literal
+sequence of characters `rwa`, while the trailing space provides a hint to the
+formatter that it should add a space after `rwa` when pretty printing this
+syntax); `rwRuleSeq` and `location` are themselves `ParserDescr`s, and we finish
+with `: tactic` specifying that the preceding parser is for an element in the
+`tactic` syntax category. The parentheses around `(location)?` are necessary
+(rather than `location?`) because Lean 4 allows question marks to be used in
+identifiers, so `location?` is one single identifier that ends with a question
+mark, which is not what we want.
+
+The name `tacticRwa__` is automatically generated. You can name parser
+descriptors declared with the `syntax` keyword like so:
+
+```lean
+set_option trace.Elab.definition true in
+syntax (name := introv) "introv " (colGt ident)* : tactic
+
+/-
+[Elab.definition.body] introv : Lean.ParserDescr :=
+Lean.ParserDescr.node `introv 1022
+  (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.nonReservedSymbol "introv " false)
+    (Lean.ParserDescr.unary `many
+      (Lean.ParserDescr.binary `andthen (Lean.ParserDescr.const `colGt) (Lean.ParserDescr.const `ident))))
+-/
+```
+
+## The pattern language
+
+Available quantifiers are `?` (one or zero occurrences, see note below), `*`
+(zero or more occurrences), and `+` (one or more occurrences).
+
+Keep in mind that Lean makes `?` available for use in identifiers, so if we want
+a parser to look for an optional `location`, we would need to write
+`(location)?` with parenthesis acting as a separator, since `location?` would
+look for something under the identifier `location?` (where the `?` is part of
+the identifier).
+
+Parentheses can be used as delimiters.
+
+Separated lists can be constructed like so: `$ts,*` for a comma separated list.
+
+"extended splices" can be constructed as `$[..]`. See the official paper (p. 12)
+for more details.
+
+Literals are written as double-quoted strings. A literal may use trailing
+whitespace (see e.g. the `rwa` or `introv` tactics) to tell the pretty-printer
+how it should be displayed, but such whitespace will not prevent a literal with
+no trailing whitespace from matching. The spaces are relevant, but not
+interpreted literally. When the ParserDescr is turned into a Parser, the actual
+token matcher [uses the .trim of the provided
+string](https://github.com/leanprover/lean4/blob/53ec43ff9b8f55989b12c271e368287b7b997b54/src/Lean/Parser/Basic.lean#L1193),
+but the generated formatter [uses the spaces as
+specified](https://github.com/leanprover/lean4/blob/8d370f151f7c88a687152a5b161dcb484c446ce2/src/Lean/PrettyPrinter/Formatter.lean#L328),
+that is, turning the atom "rwa" in the syntax into the string rwa as part of the
+pretty printed output.
+
+## Syntax expansions with `macro_rules`, and how it desugars.
+
+`macro_rules` lets you declare expansions for a given `Syntax` element using a
+syntax similar to a `match` statement. The left-hand side of a match arm is a
+quotation (with a leading `<cat>|` for categories other than `term` and
+`command`) in which users can specify the pattern they'd like to write an
+expansion for. The right-hand side returns a syntax quotation which is the
+output the user wants to expand to.
+
+A feature of Lean's macro system is that if there are multiple expansions for a
+particular match, Lean will try the most recently declared expansion first, and
+will retry with other matching expansions if the previous attempt failed. This
+is particularly useful for extending existing tactics.
+
+The following example shows both the retry behavior, and the fact that macros
+declared using the shorthand `macro` syntax can still have additional expansions
+declared with `macro_rules`. This `transitivity` tactic is implemented such that
+it will work for either Nat.le or Nat.lt. The Nat.lt version was declared "most
+recently", so it will be tried first, but if it fails (for example, if the
+actual term in question is Nat.le) the next potential expansion will be tried:
+```lean
+macro "transitivity" e:(colGt term) : tactic => `(tactic| apply Nat.le_trans (m := $e))
+macro_rules
+  | `(tactic| transitivity $e) => `(tactic| apply Nat.lt_trans (m := $e))
+
+example (a b c : Nat) (h0 : a < b) (h1 : b < c) : a < c := by
+  transitivity b <;>
+  assumption
+
+example (a b c : Nat) (h0 : a <= b) (h1 : b <= c) : a <= c := by
+  transitivity b <;>
+  assumption
+
+/- This will fail, but is interesting in that it exposes the "most-recent first" behavior, since the
+  error message complains about being unable to unify mvar1 <= mvar2, rather than mvar1 < mvar2. -/
+/-
+example (a b c : Nat) (h0 : a <= b) (h1 : b <= c) : False := by
+  transitivity b <;>
+  assumption
+-/
+```
+
+To see the desugared definition of the actual expansion, we can again use
+`set_option trace.Elab.definition true in` and observe the output of the humble
+`exfalso` tactic defined in Mathlib4:
+```lean
+
+set_option trace.Elab.definition true in
+macro "exfalso" : tactic => `(tactic| apply False.elim)
+
+/-
+Results in the expansion:
+
+[Elab.definition.body] _aux___macroRules_tacticExfalso_1 : Lean.Macro :=
+fun x =>
+  let discr := x;
+  /- This is where Lean tries to actually identify that it's an invocation of the exfalso tactic -/
+  if Lean.Syntax.isOfKind discr `tacticExfalso = true then
+    let discr := Lean.Syntax.getArg discr 0;
+    let x := discr;
+    do
+      /- Lean getting scope/meta info from the macro monad -/
+      let info ← Lean.MonadRef.mkInfoFromRefPos
+      let scp ← Lean.getCurrMacroScope
+      let mainModule ← Lean.getMainModule
+      pure
+          (Lean.Syntax.node Lean.SourceInfo.none `Lean.Parser.Tactic.seq1
+            #[Lean.Syntax.node Lean.SourceInfo.none `null
+                #[Lean.Syntax.node Lean.SourceInfo.none `Lean.Parser.Tactic.apply
+                    #[Lean.Syntax.atom info "apply",
+                      Lean.Syntax.ident info (String.toSubstring "False.elim")
+                        (Lean.addMacroScope mainModule `False.elim scp) [(`False.elim, [])]]]])
+  else
+    /- If this wasn't actually an invocation of the exfalso tactic, throw the "unsupportedSyntax" error -/
+    let discr := x;
+    throw Lean.Macro.Exception.unsupportedSyntax
+-/
+```
+
+We can also create the syntax transformer declaration ourselves instead of using
+`macro_rules`. We'll need to name our parser and use the attribute `@[macro
+myExFalsoParser]` to associate our declaration with the parser:
+```lean
+# open Lean
+syntax (name := myExfalsoParser) "myExfalso" : tactic
+
+-- remember that `Macro` is a synonym for `Syntax -> TacticM Unit`
+@[macro myExfalsoParser] def implMyExfalso : Macro :=
+fun stx => `(tactic| apply False.elim)
+
+example (p : Prop) (h : p) (f : p -> False) : 3 = 2 := by
+  myExfalso
+  exact f h
+```
+
+In the above example, we're still using the sugar Lean provides for creating
+quotations, as it feels more intuitive and saves us some work. It is possible to
+forego the sugar altogether:
+```lean
+syntax (name := myExfalsoParser) "myExfalso" : tactic
+
+@[macro myExfalsoParser] def implMyExfalso : Lean.Macro :=
+  fun stx => pure (Lean.mkNode `Lean.Parser.Tactic.apply
+    #[Lean.mkAtomFrom stx "apply", Lean.mkCIdentFrom stx ``False.elim])
+
+example (p : Prop) (h : p) (f : p -> False) : 3 = 2 := by
+  myExfalso
+  exact f h
+```
+
+## The `macro` keyword
+
+`macro` is a shortcut which allows users to declare both a parser and an
+expansion at the same time as a matter of convenience. Additional expansions for
+the parser generated by the `macro` invocation can be added with a separate
+`macro_rules` block (see the example in the `macro_rules` section).
+
+## Unexpanders
+
+TODO; for now, see the unexpander in Mathlib.Set for an example.
+
+## More illustrative examples:
+
+The
+[Tactic.Basic](https://github.com/leanprover-community/mathlib4/blob/master/Mathlib/Tactic/Basic.lean)
+file in Mathlib4 contains many good examples to learn from.
+
+## Practical tips:
+
+You can observe the output of commands and functions that in some way use the
+macro system by setting this option to true : `set_option trace.Elab.definition
+true`
+
+Lean also offers the option of limiting the region in which option is set with
+the syntax `set_option ... in`):
+
+Hygiene can be disabled with the command option `set_option hygiene false`

doc/make/osx-10.9.md

@@ -32,13 +32,12 @@ following to use `g++`.
 cmake -DCMAKE_CXX_COMPILER=g++ ...
 ```
 
-## Required Packages: CMake, GMP, libuv, pkgconf
+## Required Packages: CMake, GMP, libuv
 
 ```bash
 brew install cmake
 brew install gmp
 brew install libuv
-brew install pkgconf
 ```
 
 ## Recommended Packages: CCache

doc/make/ubuntu.md

@@ -8,5 +8,5 @@ follow the [generic build instructions](index.md).
 ## Basic packages
 
 ```bash
-sudo apt-get install git libgmp-dev libuv1-dev cmake ccache clang pkgconf
+sudo apt-get install git libgmp-dev libuv1-dev cmake ccache clang
 ```

doc/monads/.gitignore

@@ -0,0 +1 @@
+*.lean.md

doc/monads/applicatives.lean

@@ -0,0 +1,334 @@
+/-!
+# Applicative Functors
+
+Building on [Functors](functors.lean.md) is the [Applicative
+Functor](https://en.wikipedia.org/wiki/Applicative_functor). For simplicity, you can refer to these
+simply as "Applicatives". These are a little tricker than functors, but still simpler than monads.
+Let's see how they work!
+
+## What is an Applicative Functor?
+
+An applicative functor defines a default or "base" construction for an object and allows
+function application to be chained across multiple instances of the structure. All applicative
+functors are functors, meaning they must also support the "map" operation.
+
+## How are Applicatives represented in Lean?
+
+An [applicative functor](https://en.wikipedia.org/wiki/Applicative_functor) is an intermediate
+structure between `Functor` and `Monad`. It mainly consists of two operations:
+
+* `pure : α → F α`
+* `seq : F (α → β) → F α → F β` (written as `<*>`)
+
+The `pure` operator specifies how you can wrap a normal object `α` into an instance of this structure `F α`.
+This is the "default" mechanism mentioned above.
+
+The `seq` operator allows you to chain operations by wrapping a function in a structure. The name
+"applicative" comes from the fact that you "apply" functions from within the structure, rather than
+simply from outside the structure, as was the case with `Functor.map`.
+
+Applicative in Lean is built on some helper type classes, `Functor`, `Pure` and `Seq`:
+
+-/
+namespace hidden -- hidden
+class Applicative (f : Type u → Type v) extends Functor f, Pure f, Seq f, SeqLeft f, SeqRight f where
+  map      := fun x y => Seq.seq (pure x) fun _ => y
+  seqLeft  := fun a b => Seq.seq (Functor.map (Function.const _) a) b
+  seqRight := fun a b => Seq.seq (Functor.map (Function.const _ id) a) b
+end hidden -- hidden
+/-!
+Notice that as with `Functor` it is also a type transformer `(f : Type u → Type v)` and notice the
+`extends Functor f` is ensuring the base `Functor` also performs that same type transformation.
+
+As stated above, all applicatives are then functors. This means you can assume that `map` already
+exists for all these types.
+
+The `Pure` base type class is a very simple type class that supplies the `pure` function.
+
+-/
+namespace hidden -- hidden
+class Pure (f : Type u → Type v) where
+   pure {α : Type u} : α → f α
+end hidden -- hidden
+/-!
+
+You can think of it as lifting the result of a pure value to some monadic type. The simplest example
+of `pure` is the `Option` type:
+
+-/
+#eval (pure 10 : Option Nat)  -- some 10
+/-!
+
+Here we used the `Option` implementation of `pure` to wrap the `Nat 10` value in an `Option Nat`
+type resulting in the value `some 10`, and in fact if you look at the Monad instance of `Option` , you
+will see that `pure` is indeed implemented using `Option.some`:
+
+-/
+instance : Monad Option where
+    pure := Option.some
+/-!
+
+The `Seq` type class is also a simple type class that provides the `seq` operator which can
+also be written using the special syntax `<*>`.
+
+-/
+namespace hidden -- hidden
+class Seq (f : Type u → Type v) : Type (max (u+1) v) where
+  seq : {α β : Type u} → f (α → β) → (Unit → f α) → f β
+end hidden -- hidden
+/-!
+
+
+## Basic Applicative Examples
+
+Many of the basic functors also have instances of `Applicative`.
+For example, `Option` is also `Applicative`.
+
+So let's take a look and what the `seq` operator can do.  Suppose you want to multiply two `Option Nat`
+objects.  Your first attempt might be this:
+
+-/
+#check_failure (some 4) * (some 5)      -- failed to synthesize instance
+/-!
+
+You then might wonder how to use the `Functor.map` to solve this since you could do these before:
+
+-/
+#eval (some 4).map (fun x => x * 5)  -- some 20
+
+#eval (some 4).map (· * 5)  -- some 20
+
+#eval (· * 5) <$> (some 4)   -- some 20
+/-!
+
+Remember that `<$>` is the infix notation for `Functor.map`.
+
+The functor `map` operation can apply a multiplication to the value in the `Option` and then lift the
+result back up to become a new `Option` , but this isn't what you need here.
+
+The `Seq.seq` operator `<*>` can help since it can apply a function to the items inside a
+container and then lift the result back up to the desired type, namely `Option` .
+
+There are two ways to do this:
+
+-/
+#eval pure (.*.) <*> some 4 <*> some 5 -- some 20
+
+#eval (.*.) <$> some 4 <*> some 5 -- some 20
+/-!
+
+In the first way, we start off by wrapping the function in an applicative using pure. Then we apply
+this to the first `Option` , and again to the second `Option`  in a chain of operations.  So  you can see
+how `Seq.seq` can be chained in fact, `Seq.seq` is really all about chaining of operations.
+
+But in this case there is a simpler way.  In the second way, you can see that "applying" a single
+function to a container is the same as using `Functor.map`. So you use `<$>` to "transform" the first
+option into an `Option` containing a function, and then apply this function over the second value.
+
+Now if either side is `none`, the result is `none`, as expected, and in this case the
+`seq` operator was able to eliminate the multiplication:
+
+-/
+#eval (.*.) <$> none <*> some 5  -- none
+#eval (.*.) <$> some 4 <*> none  -- none
+/-!
+
+For a more interesting example, let's make `List` an applicative by adding the following
+definition:
+
+-/
+instance : Applicative List where
+  pure := List.singleton
+  seq f x := List.flatMap f fun y => Functor.map y (x ())
+/-!
+
+Notice you can now sequence a _list_ of functions and a _list_ of items.
+The trivial case of sequencing a singleton list is in fact the same as `map`, as you saw
+earlier with the `Option`  examples:
+
+-/
+#eval [ (·+2)] <*> [4, 6] -- [6, 8]
+#eval (·+2) <$> [4,6]    -- [6, 8]
+/-!
+
+But now with list it is easier to show the difference when you do this:
+
+-/
+#eval [(·+2), (· *3)] <*> [4, 6] -- [6, 8, 12, 18]
+/-!
+
+Why did this produce 4 values?  The reason is because `<*>` applies _every_ function to _every_
+value in a pairwise manner.  This makes sequence really convenient for solving certain problems. For
+example, how do you get the pairwise combinations of all values from two lists?
+
+-/
+#eval Prod.mk <$> [1, 2, 3] <*> [4, 5, 6]
+-- [(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]
+/-!
+
+How do you get the sum of these pairwise values?
+-/
+#eval (·+·) <$> [1, 2, 3] <*> [4, 5, 6]
+-- [5, 6, 7, 6, 7, 8, 7, 8, 9]
+/-!
+
+Here you can use `<$>` to "transform" each element of the first list into a function, and then apply
+these functions over the second list.
+
+If you have 3 lists, and want to find all combinations of 3 values across those lists you
+would need helper function that can create a tuple out of 3 values, and Lean provides a
+very convenient syntax for that `(·,·,·)`:
+
+-/
+#eval (·,·,·) <$> [1, 2] <*> [3, 4] <*> [5, 6]
+-- [(1, 3, 5), (1, 3, 6), (1, 4, 5), (1, 4, 6), (2, 3, 5), (2, 3, 6), (2, 4, 5), (2, 4, 6)]
+/-!
+
+And you could sum these combinations if you first define a sum function that takes three inputs and
+then you could chain apply this over the three lists.  Again lean can create such a function
+with the expression `(·+·+·)`:
+
+-/
+#eval (·+·+·) <$> [1, 2] <*> [3, 4] <*> [5, 6]
+-- [9, 10, 10, 11, 10, 11, 11, 12]
+/-!
+
+And indeed each sum here matches the expected values if you manually sum the triples we
+show above.
+
+**Side note:** there is another way to combine lists with a function that does not do the pairwise
+combinatorics, it is called `List.zipWith`:
+
+-/
+#eval List.zipWith (·+·) [1, 2, 3] [4, 5, 6]
+-- [5, 7, 9]
+/-!
+
+And there is a helper function named `List.zip` that calls `zipWith` using the function `Prod.mk`
+so you get a nice zipped list like this:
+
+-/
+#eval List.zip [1, 2, 3] [4, 5, 6]
+-- [(1, 4), (2, 5), (3, 6)]
+/-!
+
+And of course, as you would expect, there is an `unzip` also:
+
+-/
+#eval List.unzip (List.zip [1, 2, 3] [4, 5, 6])
+-- ([1, 2, 3], [4, 5, 6])
+/-!
+
+## Example: A Functor that is not Applicative
+
+From the chapter on [functors](functors.lean.md) you might remember this example of `LivingSpace`
+that had a `Functor` instance:
+
+-/
+structure LivingSpace (α : Type) where
+  totalSize : α
+  numBedrooms : Nat
+  masterBedroomSize : α
+  livingRoomSize : α
+  kitchenSize : α
+  deriving Repr, BEq
+
+def LivingSpace.map (f : α → β) (s : LivingSpace α) : LivingSpace β :=
+  { totalSize := f s.totalSize
+    numBedrooms := s.numBedrooms
+    masterBedroomSize := f s.masterBedroomSize
+    livingRoomSize := f s.livingRoomSize
+    kitchenSize := f s.kitchenSize }
+
+instance : Functor LivingSpace where
+  map := LivingSpace.map
+/-!
+
+It wouldn't really make sense to make an `Applicative` instance here. How would you write `pure` in
+the `Applicative` instance? By taking a single value and plugging it in for total size _and_ the
+master bedroom size _and_ the living room size? That wouldn't really make sense. And what would the
+numBedrooms value be for the default? What would it mean to "chain" two of these objects together?
+
+If you can't answer these questions very well, then it suggests this type isn't really an
+Applicative functor.
+
+## SeqLeft and SeqRight
+
+You may remember seeing the `SeqLeft` and `SeqRight` base types on `class Applicative` earlier.
+These provide the `seqLeft` and `seqRight` operations which also have some handy notation
+shorthands `<*` and `*>` respectively. Where: `x <* y` evaluates `x`, then `y`, and returns the
+result of `x` and `x *> y` evaluates `x`, then `y`,  and returns the result of `y`.
+
+To make it easier to remember, notice that it returns that value that the `<*` or `*>` notation is
+pointing at.  For example:
+
+-/
+#eval (some 1) *> (some 2) -- Some 2
+#eval (some 1) <* (some 2) -- Some 1
+/-!
+
+So these are a kind of "discard" operation.  Run all the actions, but only return the values that you
+care about. It will be easier to see these in action when you get to full Monads, but they are used
+heavily in the Lean `Parsec` parser combinator library where you will find parsing functions like
+this one which parses the XML declaration `<?xml version="1.0" encoding='utf-8' standalone="yes">`:
+
+```lean
+def XMLdecl : Parsec Unit := do
+  skipString "<?xml"
+  VersionInfo
+  optional EncodingDecl *> optional SDDecl *> optional S *> skipString "?>"
+```
+
+But you will need to understand full Monads before this will make sense.
+
+## Lazy Evaluation
+
+Diving a bit deeper, (you can skip this and jump to the [Applicative
+Laws](laws.lean.md#what-are-the-applicative-laws) if don't want to dive into this implementation detail right
+now). But, if you write a simple `Option` example `(.*.) <$> some 4 <*> some 5` that produces `some 20`
+using `Seq.seq` you will see something interesting:
+
+-/
+#eval Seq.seq ((.*.) <$> some 4) (fun (_ : Unit) => some 5) -- some 20
+/-!
+
+This may look a bit cumbersome, specifically, why did we need to invent this funny looking function
+`fun (_ : Unit) => (some 5)`?
+
+Well if you take a close look at the type class definition:
+```lean
+class Seq (f : Type u → Type v) where
+  seq : {α β : Type u} → f (α → β) → (Unit → f α) → f β
+```
+
+You will see this function defined here: `(Unit → f α)`, this is a function that takes `Unit` as input
+and produces the output of type `f α` where `f` is the container type `Type u -> Type v`, in this example `Option`
+and `α` is the element type `Nat`, so `fun (_ : Unit) => some 5` matches this definition because
+it is taking an input of type Unit and producing `some 5` which is type `Option Nat`.
+
+The that `seq` is defined this way is because Lean is an eagerly evaluated language
+(call-by-value), you have to use this kind of Unit function whenever you want to explicitly delay
+evaluation and `seq` wants that so it can eliminate unnecessary function evaluations whenever
+possible.
+
+Fortunately the `<*>` infix notation hides this from you by creating this wrapper function for you.
+If you look up the notation using F12 in VS Code you will find it contains `(fun _ : Unit => b)`.
+
+Now to complete this picture you will find the default implementation of `seq` on the Lean `Monad`
+type class:
+
+```lean
+class Monad (m : Type u → Type v) extends Applicative m, Bind m where
+  seq      f x := bind f fun y => Functor.map y (x ())
+```
+
+Notice here that `x` is the `(Unit → f α)` function, and it is calling that function by passing the
+Unit value `()`, which is the Unit value (Unit.unit).  All this just to ensure delayed evaluation.
+
+## How do Applicatives help with Monads?
+
+Applicatives are helpful for the same reasons as functors. They're a relatively simple abstract
+structure that has practical applications in your code. Now that you understand how chaining
+operations can fit into a structure definition, you're in a good position to start learning about
+[Monads](monads.lean.md)!
+-/

doc/monads/except.lean

@@ -0,0 +1,178 @@
+/-!
+# Except
+
+The `Except` Monad adds exception handling behavior to your functions.  Exception handling
+in other languages like Python or Java is done with a built in `throw` method that you
+can use anywhere.  In `Lean` you can only `throw` an exception when your function is
+executing in the context of an `Except` monad.
+
+-/
+def divide (x y: Float): Except String Float :=
+  if y == 0 then
+    throw "can't divide by zero"
+  else
+    pure (x / y)
+
+#eval divide 5 2  -- Except.ok 2.500000
+#eval divide 5 0  -- Except.error "can't divide by zero"
+
+/-!
+
+Just as the `read` operation was available from the `ReaderM` monad and the `get` and `set`
+operations came with the `StateM` monad, here you can see a `throw` operation is provided by the
+`Except` monad.
+
+So in Lean, `throw` is not available everywhere like it is in most imperative programming languages.
+You have to declare your function can throw by changing the type signature to `Except String Float`.
+This creates a function that might return an error of type `String` or it might return a value of
+type `Float` in the non-error case.
+
+Once your function is monadic you also need to use the `pure` constructor of the `Except` monad to
+convert the pure non-monadic value `x / y` into the required `Except` object.  See
+[Applicatives](applicatives.lean.md) for details on `pure`.
+
+Now this return typing would get tedious if you had to include it everywhere that you call this
+function, however, Lean type inference can clean this up. For example, you can define a test
+function that calls the `divide` function and you don't need to say anything here about the fact that
+it might throw an error, because that is inferred:
+-/
+def test := divide 5 0
+
+#check test     -- Except String Float
+/-!
+
+Notice the Lean compiler infers the required `Except String Float` type information for you.
+And now you can run this test and get the expected exception:
+
+-/
+#eval test      -- Except.error "can't divide by zero"
+/-!
+
+
+## Chaining
+
+Now as before you can build a chain of monadic actions that can be composed together using `bind (>>=)`:
+-/
+def square (x : Float) : Except String Float :=
+  if x >= 100 then
+    throw "it's absolutely huge"
+  else
+    pure (x * x)
+
+#eval divide 6 2 >>= square  -- Except.ok 9.000000
+#eval divide 6 0 >>= square  -- Except.error "can't divide by zero"
+#eval divide 100 1 >>= square  -- Except.error "it's absolutely huge"
+
+def chainUsingDoNotation := do
+  let r ← divide 6 0
+  square r
+
+#eval chainUsingDoNotation  -- Except.error "can't divide by zero"
+
+/-!
+Notice in the second `divide 6 0` the exception from that division was nicely propagated along
+to the final result and the square function was ignored in that case.  You can see why the
+`square` function was ignored if you look at the implementation of `Except.bind`:
+-/
+def bind (ma : Except ε α) (f : α → Except ε β) : Except ε β :=
+  match ma with
+  | Except.error err => Except.error err
+  | Except.ok v      => f v
+/-!
+
+Specifically notice that it only calls the next function `f v` in the `Except.ok`, and
+in the error case it simply passes the same error along.
+
+Remember also that you can chain the actions with implicit binding by using the `do` notation
+as you see in the `chainUsingDoNotation` function above.
+
+## Try/Catch
+
+Now with all good exception handling you also want to be able to catch exceptions so your program
+can continue on or do some error recovery task, which you can do like this:
+-/
+def testCatch :=
+  try
+    let r ← divide 8 0  -- 'r' is type Float
+    pure (toString r)
+  catch e =>
+    pure s!"Caught exception: {e}"
+
+#check testCatch -- Except String String
+/-!
+
+Note that the type inferred by Lean for this function is `Except String String` so unlike the
+`test` function earlier, this time Lean type inference has figured out that since the pure
+value `(toString r)` is of type `String`, then this function must have type `Except String String`
+so you don't have to explicitly state this. You can always hover your mouse over `testCatch`
+or use `#check testCatch` to query Lean interactively to figure out what type inference
+has decided.  Lean type inference makes life easy for you, so it's good to use it
+when you can.
+
+You can now see the try/catch working in this eval:
+-/
+#eval testCatch -- Except.ok "Caught exception: can't divide by zero"
+/-!
+
+Notice the `Caught exception:` wrapped message is returned, and that it is returned as an
+`Except.ok` value, meaning `testCatch` eliminated the error result as expected.
+
+So you've interleaved a new concept into your functions (exception handling) and the compiler is still
+able to type check everything just as well as it does for pure functions and it's been able to infer
+some things along the way to make it even easier to manage.
+
+Now you might be wondering why `testCatch` doesn't infer the return type `String`? Lean does this as a
+convenience since you could have a rethrow in or after the catch block. If you really want to stop
+the `Except` type from bubbling up you can unwrap it like this:
+
+-/
+def testUnwrap : String := Id.run do
+  let r ← divide 8 0 -- r is type Except String Float
+  match r with
+  | .ok a => toString a -- 'a' is type Float
+  | .error e => s!"Caught exception: {e}"
+
+#check testUnwrap -- String
+#eval testUnwrap -- "Caught exception: can't divide by zero"
+
+/-!
+
+The `Id.run` function is a helper function that executes the `do` block and returns the result where
+`Id` is the _identity monad_.  So `Id.run do` is a pattern you can use to execute monads in a
+function that is not itself monadic.  This works for all monads except `IO` which, as stated earlier,
+you cannot invent out of thin air, you must use the `IO` monad given to your `main` function.
+
+## Monadic functions
+
+You can also write functions that are designed to operate in the context of a monad.
+These functions typically end in upper case M like `List.forM` used below:
+-/
+
+def validateList (x : List Nat) (max : Nat): Except String Unit := do
+  x.forM fun a => do
+    if a > max then throw "illegal value found in list"
+
+#eval validateList [1, 2, 5, 3, 8] 10 -- Except.ok ()
+#eval validateList [1, 2, 5, 3, 8] 5 -- Except.error "illegal value found in list"
+
+/-!
+Notice here that the `List.forM` function passes the monadic context through to the inner function
+so it can use the `throw` function from the `Except` monad.
+
+The `List.forM` function is defined like this where `[Monad m]` means "in the context of a monad `m`":
+
+-/
+def forM [Monad m] (as : List α) (f : α → m PUnit) : m PUnit :=
+  match as with
+  | []      => pure ⟨⟩
+  | a :: as => do f a; List.forM as f
+/-!
+
+## Summary
+
+Now that you know all these different monad constructs, you might be wondering how you can combine
+them. What if there was some part of your state that you wanted to be able to modify (using the
+State monad), but you also needed exception handling. How can you get multiple monadic capabilities
+in the same function. To learn the answer, head to [Monad Transformers](transformers.lean.md).
+
+-/

doc/monads/functors.lean

@@ -0,0 +1,227 @@
+/-!
+# Functor
+
+A `Functor` is any type that can act as a generic container that allows you to transform the
+underlying values inside the container using a function, so that the values are all updated, but the
+structure of the container is the same. This is called "mapping".
+
+A List is one of the most basic examples of a `Functor`.
+
+A list contains zero or more elements of the same, underlying type.  When you `map` a function over
+a list, you create a new list with the same number of elements, where each has been transformed by
+the function:
+-/
+#eval List.map (λ x => toString x) [1,2,3] -- ["1", "2", "3"]
+
+-- you can also write this using dot notation on the List object
+#eval [1,2,3].map (λ x => toString x)  -- ["1", "2", "3"]
+
+/-!
+Here we converted a list of natural numbers (Nat) to a list of strings where the lambda function
+here used `toString` to do the transformation of each element. Notice that when you apply `map` the
+"structure" of the object remains the same, in this case the result is always a `List` of the same
+size.
+
+Note that in Lean a lambda function can be written using `fun` keyword or the unicode
+symbol `λ` which you can type in VS code using `\la `.
+
+List has a specialized version of `map` defined as follows:
+-/
+def map (f : α → β) : List α → List β
+  | []    => []
+  | a::as => f a :: map f as
+
+/-!
+This is a very generic `map` function that can take any function that converts `(α → β)` and use it
+to convert `List α → List β`. Notice the function call `f a` above, this application of `f` is
+producing the converted items for the new list.
+
+Let's look at some more examples:
+
+-/
+-- List String → List Nat
+#eval ["elephant", "tiger", "giraffe"].map (fun s => s.length)
+-- [8, 5, 7]
+
+-- List Nat → List Float
+#eval [1,2,3,4,5].map (fun s => (s.toFloat) ^ 3.0)
+-- [1.000000, 8.000000, 27.000000, 64.000000, 125.000000]
+
+--- List String → List String
+#eval ["chris", "david", "mark"].map (fun s => s.capitalize)
+-- ["Chris", "David", "Mark"]
+/-!
+
+Another example of a functor is the `Option` type. Option contains a value or nothing and is handy
+for code that has to deal with optional values, like optional command line arguments.
+
+Remember you can construct an Option using the type constructors `some` or `none`:
+
+-/
+#check some 5 -- Option Nat
+#eval some 5  -- some 5
+#eval (some 5).map (fun x => x + 1) -- some 6
+#eval (some 5).map (fun x => toString x) -- some "5"
+/-!
+
+Lean also provides a convenient short hand syntax for `(fun x => x + 1)`, namely `(· + 1)`
+using the middle dot unicode character which you can type in VS code using `\. `.
+
+-/
+#eval (some 4).map (· * 5)  -- some 20
+/-!
+
+The `map` function preserves the `none` state of the Option, so again
+map preserves the structure of the object.
+
+-/
+def x : Option Nat := none
+#eval x.map (fun x => toString x) -- none
+#check x.map (fun x => toString x) -- Option String
+/-!
+
+Notice that even in the `none` case it has transformed `Option Nat` into `Option String` as
+you see in the `#check` command.
+
+## How to make a Functor Instance?
+
+The `List` type is made an official `Functor` by the following type class instance:
+
+-/
+instance : Functor List where
+  map := List.map
+/-!
+
+Notice all you need to do is provide the `map` function implementation.  For a quick
+example, let's supposed you create a new type describing the measurements of a home
+or apartment:
+
+-/
+structure LivingSpace (α : Type) where
+  totalSize : α
+  numBedrooms : Nat
+  masterBedroomSize : α
+  livingRoomSize : α
+  kitchenSize : α
+  deriving Repr, BEq
+/-!
+
+Now you can construct a `LivingSpace` in square feet using floating point values:
+-/
+abbrev SquareFeet := Float
+
+def mySpace : LivingSpace SquareFeet :=
+  { totalSize := 1800, numBedrooms := 4, masterBedroomSize := 500,
+    livingRoomSize := 900, kitchenSize := 400 }
+/-!
+
+Now, suppose you want anyone to be able to map a `LivingSpace` from one type of measurement unit to
+another.  Then you would provide a `Functor` instance as follows:
+
+-/
+def LivingSpace.map (f : α → β) (s : LivingSpace α) : LivingSpace β :=
+  { totalSize := f s.totalSize
+    numBedrooms := s.numBedrooms
+    masterBedroomSize := f s.masterBedroomSize
+    livingRoomSize := f s.livingRoomSize
+    kitchenSize := f s.kitchenSize }
+
+instance : Functor LivingSpace where
+  map := LivingSpace.map
+/-!
+
+Notice this functor instance takes `LivingSpace` and not the fully qualified type `LivingSpace SquareFeet`.
+Notice below that `LivingSpace` is a function from Type to Type.  For example, if you give it type `SquareFeet`
+it gives you back the fully qualified type `LivingSpace SquareFeet`.
+
+-/
+#check LivingSpace -- Type → Type
+/-!
+
+So the `instance : Functor` then is operating on the more abstract, or generic `LivingSpace` saying
+for the whole family of types `LivingSpace α` you can map to `LivingSpace β` using the generic
+`LivingSpace.map` map function by simply providing a function that does the more primitive mapping
+from `(f : α → β)`.  So `LivingSpace.map` is a sort of function applicator.
+This is called a "higher order function" because it takes a function as input
+`(α → β)` and returns another function as output `F α → F β`.
+
+Notice that `LivingSpace.map` applies a function `f` to convert the units of all the LivingSpace
+fields, except for `numBedrooms` which is a count (and therefore is not a measurement that needs
+converting).
+
+So now you can define a simple conversion function, let's say you want square meters instead:
+
+-/
+abbrev SquareMeters := Float
+def squareFeetToMeters (ft : SquareFeet ) : SquareMeters := (ft / 10.7639104)
+/-!
+
+and now bringing it all together you can use the simple function `squareFeetToMeters` to map
+`mySpace` to square meters:
+
+-/
+#eval mySpace.map squareFeetToMeters
+/-
+{ totalSize := 167.225472,
+  numBedrooms := 4,
+  masterBedroomSize := 46.451520,
+  livingRoomSize := 83.612736,
+  kitchenSize := 37.161216 }
+  -/
+/-!
+
+Lean also defines custom infix operator `<$>` for `Functor.map` which allows you to write this:
+-/
+#eval (fun s => s.length) <$> ["elephant", "tiger", "giraffe"] -- [8, 5, 7]
+#eval (fun x => x + 1) <$> (some 5) -- some 6
+/-!
+
+Note that the infix operator is left associative which means it binds more tightly to the
+function on the left than to the expression on the right, this means you can often drop the
+parentheses on the right like this:
+
+-/
+#eval (fun x => x + 1) <$> some 5 -- some 6
+/-!
+
+Note that Lean lets you define your own syntax, so `<$>` is nothing special.
+You can define your own infix operator like this:
+
+-/
+infixr:100 " doodle " => Functor.map
+
+#eval (· * 5) doodle [1, 2, 3]  -- [5, 10, 15]
+
+/-!
+Wow, this is pretty powerful.  By providing a functor instance on `LivingSpace` with an
+implementation of the `map` function it is now super easy for anyone to come along and
+transform the units of a `LivingSpace` using very simple functions like `squareFeetToMeters`. Notice
+that squareFeetToMeters knows nothing about `LivingSpace`.
+
+## How do Functors help with Monads ?
+
+Functors are an abstract mathematical structure that is represented in Lean with a type class. The
+Lean functor defines both `map` and a special case for working on constants more efficiently called
+`mapConst`:
+
+```lean
+class Functor (f : Type u → Type v) : Type (max (u+1) v) where
+  map : {α β : Type u} → (α → β) → f α → f β
+  mapConst : {α β : Type u} → α → f β → f α
+```
+
+Note that `mapConst` has a default implementation, namely:
+`mapConst : {α β : Type u} → α → f β → f α := Function.comp map (Function.const _)` in the `Functor`
+type class.  So you can use this default implementation and you only need to replace it if
+your functor has a more specialized variant than this (usually the custom version is more performant).
+
+In general then, a functor is a function on types `F : Type u → Type v` equipped with an operator
+called `map` such that if you have a function `f` of type `α → β` then `map f` will convert your
+container type from `F α → F β`. This corresponds to the category-theory notion of
+[functor](https://en.wikipedia.org/wiki/Functor) in the special case where the category is the
+category of types and functions between them.
+
+Understanding abstract mathematical structures is a little tricky for most people. So it helps to
+start with a simpler idea like functors before you try to understand monads.  Building on
+functors is the next abstraction called [Applicatives](applicatives.lean.md).
+-/

doc/monads/intro.md

@@ -0,0 +1,63 @@
+# Monads
+
+Monads are used heavily in Lean, as they are also in Haskell. Monads come from the wonderful world
+of [Category Theory](https://en.wikipedia.org/wiki/Monad_%28category_theory%29).
+
+Monads in Lean are so similar to Haskell that this introduction to monads is heavily based on the
+similar chapter of the [Monday Morning Haskell](https://mmhaskell.com/monads/). Many thanks to
+the authors of that material for allowing us to reuse it here.
+
+Monads build on the following fundamental type classes which you will need to understand
+first before fully understanding monads. Shown in light blue are some concrete functors
+and monads that will also be covered in this chapter:
+
+![image](../images/monads.svg)
+
+This chapter is organized to give you a bottom up introduction to monads, starting with functors and
+applicative functors, you'll get an intuition for how these abstract structures work in Lean. Then
+you'll dive into monads and learn how to use some of the most useful built-in ones.
+
+## [Functor](functors.lean.md)
+A functor is a type class that provides a map function and the map function is something many
+people are already familiar with so this should be easy to follow.  Here you will see some
+concrete examples in action with `List` and `Option`.
+
+## [Applicative Functors](applicatives.lean.md)
+Applicatives are a little more difficult to understand than functors, but their functionality can
+still be summed up in a couple simple functions.  Here you will learn how to create an
+`Applicative List` and a completely custom `Applicative` type.
+
+## [Monads Tutorial](monads.lean.md)
+Now that you have an intuition for how abstract structures work, you'll examine some of the problems
+that functors and applicative functors don't help you solve. Then you'll learn the specifics of how
+to actually use monads with some examples using the `Option` monad and the all important `IO` monad.
+
+## [Reader Monad](readers.lean.md)
+Now that you understand the details of what makes a monadic structure work, in this section, you'll
+learn about one of the most useful built in monads `ReaderM`, which gives your programs a
+global read-only context.
+
+## [State Monad](states.lean.md)
+This section introduces the `StateM` monad. This monad allows you to access a particular type that you can
+both read from and write to. It opens the door to fully stateful programming, allowing you to do many
+of the things a function programming language supposedly "can't" do.
+
+## [Except Monad](except.lean.md)
+
+Similar to the `Option` monad the `Except` monad allows you to change the signature of a function so
+that it can return an `ok` value or an `error` and it provides the classic exception handling
+operations `throw/try/catch` so that your programs can do monad-based exception handling.
+
+## [Monad Transformers](transformers.lean.md)
+
+Now that you are familiar with all the above monads it is time to answer the question - how you can
+make them work together? After all, there are definitely times when you need multiple kinds of
+monadic behavior. This section introduces the concept of monad transformers, which allow you to
+combine multiple monads into one.
+
+## [Monad Laws](laws.lean.md)
+This section examines what makes a monad a legal monad. You could just implement your monadic type
+classes any way you want and write "monad" instances, but starting back with functors and
+applicative functors, you'll learn that all these structures have "laws" that they are expected to
+obey with respect to their behavior. You can make instances that don't follow these laws. But you do
+so at your peril, as other programmers will be very confused when they try to use them.

doc/monads/laws.lean

@@ -0,0 +1,322 @@
+/-!
+# Monad Laws
+
+In the previous sections you learned how to use [Functors](functors.lean.md),
+[Applicatives](applicatives.lean.md), and [Monads](monads.lean.md), and you played with some useful
+instances including [Option](monads.lean.md), [IO](monads.lean.md), [Reader](readers.lean.md),
+[State](states.lean.md) and [Except](except.lean.md) and you learned about composition using [Monad
+Transformers](transformers.lean.md).
+
+So far, you've learned the concrete details you need in order to _use_ monads in your Lean programs.
+But there's still one more important concept you need if you want to _create_ new functors,
+applicatives and monads. Namely, the notion of _structural "laws"_ -- rules that these type
+classes should follow in order to meet other programmers' expectations about your code.
+
+## Life without Laws
+
+Remember Lean represents each of these abstract structures by a type class. Each of these type classes
+has one or two main functions. So, as long as you implement those functions and it type checks, you
+have a new functor, applicative, or monad, right?
+
+Well not quite. Yes, your program will compile and you'll be able to use the instances. But this
+doesn't mean your instances follow the mathematical constructs. If they don't, your instances won't
+fulfill other programmers' expectations. Each type class has its own "laws". For instance, suppose
+you have the following Point Functor:
+-/
+structure Point (α : Type) where
+  x : α
+  y : α
+  deriving Repr, BEq
+
+def Point.map (f : α → β) (s : Point α) : Point β :=
+  { x := f s.y,  -- an example of something weird
+    y := f s.x }
+
+instance : Functor Point where
+  map := Point.map
+
+#eval (·+2) <$> (Point.mk 1 2) -- { x := 4, y := 3 }
+
+/-!
+This Point does something weird, when you `map` it because it transposes the `x` and `y` coordinates
+which is not what other people would expect from a `map` function.  In fact, it breaks the rules
+as you will see below.
+
+## What are the Functor laws?
+
+Functors have two laws: the _identity_ law, and the _composition_ law. These laws express behaviors that
+your functor instances should follow. If they don't, other programmers will be very confused at the
+effect your instances have on their program.
+
+The identity law says that if you "map" the identity function (`id`) over your functor, the
+resulting functor should be the same. A succinct way of showing this on a `List` functor is:
+
+-/
+def list1 := [1,2,3]
+
+#eval id <$> list1 == list1 -- true
+/-!
+
+Now let's try the same test on the `Point` functor:
+-/
+
+def p1 : Point Nat := (Point.mk 1 2)
+
+#eval id <$> p1 == p1 -- false
+
+/-!
+Oh, and look while the `List` is behaving well, the `Point` functor fails this identity test.
+
+The _composition_ law says that if you "map" two functions in succession over a functor, this
+should be the same as "composing" the functions and simply mapping that one super-function over the
+functor.  In Lean you can compose two functions using `Function.comp f g` (or the syntax `f ∘ g`,
+which you can type in VS code using `\o `) and you will get the same results from both of these
+showing that the composition law holds for `List Nat`:
+
+-/
+def double (x : Nat) := x + x
+def square (x : Nat) := x * x
+
+#eval double <$> (square <$> list1) -- [2, 8, 18]
+
+#eval (double <$> (square <$> list1)) == ((double ∘ square) <$> list1) -- true
+
+-- ok, what about the Point class?
+#eval double <$> (square <$> p1) -- { x := 2, y := 8 }
+#eval (double ∘ square) <$> p1   -- { x := 8, y := 2 }
+
+#eval double <$> (square <$> p1) == (double ∘ square) <$> p1  -- false
+/-!
+Note that composition also fails on the bad `Point` because the x/y transpose.
+
+As you can see this bad `Point` implementation violates both of the functor laws. In this case it
+would not be a true functor. Its behavior would confuse any other programmers trying to use it. You
+should take care to make sure that your instances make sense. Once you get a feel for these type
+classes, the likelihood is that the instances you'll create will follow the laws.
+
+You can also write a bad functor that passes one law but not the other like this:
+-/
+def bad_option_map {α β : Type u} : (α → β) → Option α → Option β
+  | _, _ => none
+
+instance : Functor Option where
+    map := bad_option_map
+
+def t1 : Option Nat := some 10
+
+#eval id <$> t1 == t1 -- false
+#eval double <$> (square <$> t1) == (double ∘ square) <$> t1  -- true
+/-!
+
+This fails the id law but obeys the composition law. Hopefully this explains the value of these
+laws, and you don't need to see any more bad examples!
+
+## What are the Applicative Laws?
+
+While functors have two laws, applicatives have four laws:
+
+- Identity
+- Homomorphism
+- Interchange
+- Composition
+
+### Identity
+
+`pure id <*> v = v`
+
+Applying the identity function through an applicative structure should not change the underlying
+values or structure.  For example:
+-/
+instance : Applicative List where
+  pure := List.singleton
+  seq f x := List.flatMap f fun y => Functor.map y (x ())
+
+#eval pure id <*> [1, 2, 3]  -- [1, 2, 3]
+/-!
+
+The `pure id` statement here is wrapping the identity function in an applicative structure
+so that you can apply that over the container `[1, 2, 3]` using the Applicative `seq` operation
+which has the notation `<*>`.
+
+To prove this for all values `v` and any applicative `m` you can write this theorem:
+-/
+example [Applicative m] [LawfulApplicative m] (v : m α) :
+  pure id <*> v = v :=
+  by simp -- Goals accomplished 🎉
+/-!
+
+### Homomorphism
+
+`pure f <*> pure x = pure (f x)`
+
+Suppose you wrap a function and an object in `pure`. You can then apply the wrapped function over the
+wrapped object. Of course, you could also apply the normal function over the normal object, and then
+wrap it in `pure`. The homomorphism law states these results should be the same.
+
+For example:
+
+-/
+def x := 1
+def f := (· + 2)
+
+#eval pure f <*> pure x = (pure (f x) : List Nat) -- true
+/-!
+
+You should see a distinct pattern here. The overriding theme of almost all these laws is that these
+`Applicative` types should behave like normal containers. The `Applicative` functions should not
+have any side effects. All they should do is facilitate the wrapping, unwrapping, and transformation
+of data contained in the container resulting in a new container that has the same structure.
+
+### Interchange
+
+`u <*> pure y = pure (. y) <*> u`.
+
+This law is a little more complicated, so don't sweat it too much. It states that the order that
+you wrap things shouldn't matter. One the left, you apply any applicative `u` over a pure wrapped
+object. On the right, you first wrap a function applying the object as an argument. Note that `(·
+y)` is short hand for: `fun f => f y`. Then you apply this to the first applicative `u`. These
+should be the same.
+
+For example:
+
+-/
+def y := 4
+def g : List (Nat → Nat) := [(· + 2)]
+
+#eval g <*> pure y = pure (· y) <*> g      -- true
+/-!
+
+You can prove this with the following theorem:
+-/
+example [Applicative m] [LawfulApplicative m] (u : m (α → β)) (y : α) :
+  u <*> pure y = pure (· y) <*> u :=
+  by simp [pure_seq] -- Goals accomplished 🎉
+
+/-!
+
+### Composition:
+
+`u <*> v <*> w = u <*> (v <*> w)`
+
+This final applicative law mimics the second functor law. It is a composition law. It states that
+function composition holds across applications within the applicative:
+
+For example:
+
+-/
+def u := [1, 2]
+def v := [3, 4]
+def w := [5, 6]
+
+#eval pure (·+·+·) <*> u <*> v <*> w
+-- [9, 10, 10, 11, 10, 11, 11, 12]
+
+#eval let grouping := pure (·+·) <*> v <*> w
+      pure (·+·) <*> u <*> grouping
+-- [9, 10, 10, 11, 10, 11, 11, 12]
+/-!
+
+To test composition you see the separate grouping `(v <*> w)` then that can be used in the outer
+sequence `u <*> grouping` to get the same final result `[9, 10, 10, 11, 10, 11, 11, 12]`.
+
+## What are the Monad Laws?
+
+Monads have three laws:
+
+- Left Identity
+- Right Identity
+- Associativity
+
+### Left Identity
+
+Identity laws for monads specify that `pure` by itself shouldn't really change anything about the
+structure or its values.
+
+Left identity is `x >>= pure = x` and is demonstrated by the following examples on a monadic `List`:
+-/
+instance : Monad List  where
+  pure := List.singleton
+  bind := List.flatMap
+
+def a := ["apple", "orange"]
+
+#eval a >>= pure      -- ["apple", "orange"]
+
+#eval a >>= pure = a  -- true
+
+/-!
+
+### Right Identity
+
+Right identity is `pure x >>= f = f x` and is demonstrated by the following example:
+-/
+def h (x : Nat) : Option Nat :=  some (x + 1)
+def z := 5
+
+#eval pure z >>= h                  -- some 6
+#eval h z                           -- some 6
+
+#eval pure z >>= h = h z            -- true
+/-!
+
+So in this example, with this specific `z` and `h`, you see that the rule holds true.
+
+
+### Associativity
+
+The associativity law is written as:
+```lean,ignore
+  x >>= f >>= g = x >>= (λ x => f x >>= g)
+```
+where `(x : m α)` and `(f : α → m β)` and `(g : β → m γ)`.
+
+The associativity law is difficult to parse like some of the applicative laws, but what it is saying
+is that if you change the grouping of `bind` operations, you should still get the same result.
+This law has a parallel structure to the other composition laws.
+
+You can see this in action in the following rewrite of `runOptionFuncsBind` from [monads](monads.lean.md):
+-/
+def optionFunc1 : String -> Option Nat
+  | "" => none
+  | str => some str.length
+
+def optionFunc2 (i : Nat) : Option Float :=
+  if i % 2 == 0 then none else some (i.toFloat * 3.14159)
+
+def optionFunc3 (f : Float) : Option (List Nat) :=
+  if f > 15.0 then none else some [f.floor.toUInt32.toNat, f.ceil.toUInt32.toNat]
+
+
+def runOptionFuncsBind (input : String) : Option (List Nat) :=
+   optionFunc1 input >>= optionFunc2 >>= optionFunc3
+
+def runOptionFuncsBindGrouped (input : String) : Option (List Nat) :=
+   optionFunc1 input >>= (λ x => optionFunc2 x >>= optionFunc3)
+
+#eval runOptionFuncsBind "big"        -- some [9, 10]
+#eval runOptionFuncsBindGrouped "big" -- some [9, 10]
+/-!
+
+Notice here we had to insert a `λ` function just like the definition says: `(λ x => f x >>= g)`.
+This is because unlike applicatives, you can't resolve the structure of later operations without the
+results of earlier operations quite as well because of the extra context monads provide. But you can
+still group their later operations into composite functions taking their inputs from earlier on, and
+the result should be the same.
+
+
+## Summary
+
+While these laws may be a bit difficult to understand just by looking at them, the good news is that
+most of the instances you'll make will naturally follow the laws so long as you keep it simple, so
+you shouldn't have to worry about them too much.
+
+There are two main ideas from all the laws:
+
+1. Applying the identity or pure function should not change the underlying values or structure.
+1. It should not matter what order you group operations in.  Another way to state this is function
+   composition should hold across your structures.
+
+Following these laws will ensure other programmers are not confused by the behavior of your
+new functors, applicatives and monads.
+
+-/

doc/monads/monads.lean

@@ -0,0 +1,300 @@
+/-!
+# Monads
+
+Building on [Functors](functors.lean.md) and [Applicatives](applicatives.lean.md) we can now
+introduce [monads](https://en.wikipedia.org/wiki/Monad_%28category_theory%29).
+
+A monad is another type of abstract, functional structure. Let's explore what makes it different
+from the first two structures.
+
+## What is a Monad?
+
+A monad is a computational context. It provides a structure that allows you to chain together
+operations that have some kind of shared state or similar effect. Whereas pure functional code can
+only operate on explicit input parameters and affect the program through explicit return values,
+operations in a monad can affect other computations in the chain implicitly through side effects,
+especially modification of an implicitly shared value.
+
+## How are monads represented in Lean?
+
+Like functors and applicatives, monads are represented with a type class in Lean:
+
+```lean,ignore
+class Monad (m : Type u → Type v) extends Applicative m, Bind m where
+```
+
+Just as every applicative is a functor, every monad is also an applicative and there's one more new
+base type class used here that you need to understand, namely, `Bind`.
+
+```lean,ignore
+class Bind (f : Type u → Type v) where
+  bind : {α β : Type u} → f α → (α → f β) → f β
+```
+
+The `bind` operator also has infix notation `>>=` where `x >>= g` represents the result of executing
+`x` to get a value of type `f α` then unwrapping the value `α` from that and passing it to function
+`g` of type `α → f β` returning the result of type `f β` where `f` is the target structure type
+(like `Option` or List)
+
+This `bind` operation looks similar to the other ones you've seen so far, if you put them all
+together `Monad` has the following operations:
+
+```lean,ignore
+class Monad (f : Type u → Type v) extends Applicative f, Bind f where
+  pure {α : Type u} : α → f α
+  map : {α β : Type u} → (α → β) → f α → f β
+  seq : {α β : Type u} → f (α → β) → (Unit → f α) → f β
+  bind : {α β : Type u} → f α → (α → f β) → f β
+  ...
+```
+
+Notice `Monad` also contains `pure` it must also have a "default" way to wrap a value in the
+structure.
+
+The `bind` operator is similar to the applicative `seq` operator in that it chains two operations,
+with one of them being function related. Notice that `bind`, `seq` and `map` all take a function of
+some kind.  Let's examine those function types:
+
+- map: `(α → β)`
+- seq: `f (α → β)`
+- bind: `(α → f β)`
+
+So `map` is a pure function, `seq` is a pure function wrapped in the structure, and `bind` takes a
+pure input but produces an output wrapped in the structure.
+
+Note: we are ignoring the `(Unit → f α)` function used by `seq` here since that has a special
+purpose explained in [Applicatives Lazy Evaluation](applicatives.lean.md#lazy-evaluation).
+
+## Basic Monad Example
+
+Just as `Option` is a functor and an applicative functor, it is also a monad! Let's start with how
+`Option` implements the Monad type class.
+
+-/
+instance : Monad Option where
+  pure := Option.some
+  bind := Option.bind
+/-!
+
+where:
+
+```lean,ignore
+def Option.bind : Option α → (α → Option β) → Option β
+  | none,   _ => none
+  | some a, f => f a
+```
+
+> **Side note**: this function definition is using a special shorthand syntax in Lean where the `:=
+match a, b with` code can be collapsed away. To make this more clear consider the following simpler
+example, where `Option.bind` is using the second form like `bar`:
+
+-/
+def foo (x : Option Nat) (y : Nat) : Option Nat :=
+  match x, y with
+  | none, _ => none
+  | some x, y => some (x + y)
+
+def bar : Option Nat → Nat → Option Nat
+  | none, _ => none
+  | some x, y => some (x + y)
+
+#eval foo (some 1) 2  -- some 3
+#eval bar (some 1) 2  -- some 3
+/-!
+What is important is that `Option.bind` is using a `match` statement to unwrap the input value
+`Option α`, if it is `none` then it does nothing and returns `none`, if it has a value of type `α`
+then it applies the function in the second argument `(α → Option β)` to this value, which is
+the expression `f a` that you see in the line `  | some a, f => f a` above.  The function
+returns a result of type `Option β` which then becomes the return value for `bind`.  So there
+is no structure wrapping required on the return value since the input function already did that.
+
+But let's bring in the definition of a monad. What does it mean to describe `Option` as a
+computational context?
+
+The `Option` monad encapsulates the context of failure. Essentially, the `Option` monad lets us
+abort a series of operations whenever one of them fails. This allows future operations to assume
+that all previous operations have succeeded. Here's some code to motivate this idea:
+
+-/
+def optionFunc1 : String -> Option Nat
+  | "" => none
+  | str => some str.length
+
+def optionFunc2 (i : Nat) : Option Float :=
+  if i % 2 == 0 then none else some (i.toFloat * 3.14159)
+
+def optionFunc3 (f : Float) : Option (List Nat) :=
+  if f > 15.0 then none else some [f.floor.toUInt32.toNat, f.ceil.toUInt32.toNat]
+
+def runOptionFuncs (input : String) : Option (List Nat) :=
+  match optionFunc1 input with
+  | none => none
+  | some i => match optionFunc2 i with
+    | none => none
+    | some f => optionFunc3 f
+
+#eval runOptionFuncs "big" -- some [9, 10]
+/-!
+
+Here you see three different functions that could fail. These are then combined in `runOptionFuncs`.
+But then you have to use nested `match` expressions to check if the previous result succeeded. It
+would be very tedious to continue this pattern much longer.
+
+The `Option` monad helps you fix this. Here's what this function looks like using the `bind`
+operator.
+
+-/
+
+def runOptionFuncsBind (input : String) : Option (List Nat) :=
+  optionFunc1 input >>= optionFunc2 >>= optionFunc3
+
+#eval runOptionFuncsBind "big" -- some [9, 10]
+/-!
+
+It's much cleaner now! You take the first result and pass it into the second and third functions
+using the `bind` operation. The monad instance handles all the failure cases so you don't have to!
+
+Let's see why the types work out. The result of `optionFunc1` input is simply `Option Nat`. Then the
+bind operator allows you to take this `Option Nat` value and combine it with `optionFunc2`, whose type
+is `Nat → Option Float` The **bind operator resolves** these to an `Option Float`. Then you pass this
+similarly through the bind operator to `optionFunc3`, resulting in the final type, `Option (List Nat)`.
+
+Your functions will not always combine so cleanly though. This is where `do` notation comes into play.
+This notation allows you to write monadic operations one after another, line-by-line. It almost makes
+your code look like imperative programming. You can rewrite the above as:
+-/
+
+def runOptionFuncsDo (input : String) : Option (List Nat) := do
+  let i ← optionFunc1 input
+  let f ← optionFunc2 i
+  optionFunc3 f
+
+#eval runOptionFuncsDo "big" -- some [9, 10]
+/-!
+
+The `←` operator used here is special. It effectively unwraps the value on the right-hand side from
+the monad. This means the value `i` has type `Nat`, _even though_ the result of `optionFunc1` is
+`Option Nat`. This is done using a `bind` operation under the hood.
+
+> Note you can use `<-` or the nice unicode symbol `←` which you can type into VS code by typing
+these characters `\l `.  When you type the final space, `\l` is replaced with `←`.
+
+Observe that we do not unwrap the final line of the computation. The function result is `Option
+(List Nat)` which matches what `optionFunc3` returns. At first glance, this may look more complicated
+than the `bind` example. However, it gives you a lot more flexibility, like mixing monadic and
+non-monadic statements, using if then/else structures with their own local do blocks and so on. It
+is particularly helpful when one monadic function depends on multiple previous functions.
+
+## Example using List
+
+You can easily make `List` into a monad with the following, since List already provides an
+implementation of `pure` and `bind`.
+
+-/
+instance : Monad List  where
+  pure := List.singleton
+  bind := List.flatMap
+/-!
+
+Like you saw with the applicative `seq` operator, the `bind` operator applies the given function
+to every element of the list.  It is useful to look at the bind implementation for List:
+
+-/
+open List
+def bind (a : List α) (b : α → List β) : List β := join (map b a)
+/-!
+
+So `Functor.map` is used to apply the function `b` to every element of `a` but this would
+return a whole bunch of little lists, so `join` is used to turn those back into a single list.
+
+Here's an example where you use `bind` to convert a list of strings into a combined list of chars:
+
+-/
+
+#eval "apple".toList  -- ['a', 'p', 'p', 'l', 'e']
+
+#eval ["apple", "orange"] >>= String.toList
+-- ['a', 'p', 'p', 'l', 'e', 'o', 'r', 'a', 'n', 'g', 'e']
+
+/-!
+
+
+## The IO Monad
+
+The `IO Monad` is perhaps the most important monad in Lean. It is also one of the hardest monads to
+understand starting out. Its actual implementation is too intricate to discuss when first learning
+monads. So it is best to learn by example.
+
+What is the **computational context** that describes the IO monad? IO operations can read
+information from or write information to the terminal, file system, operating system, and/or
+network. They interact with systems outside of your program. If you want to get user input, print a
+message to the user, read information from a file, or make a network call, you'll need to do so
+within the IO Monad.
+
+The state of the world outside your program can change at virtually any moment, and so this IO
+context is particularly special. So these IO operations are "side effects" which means you cannot
+perform them from "pure" Lean functions.
+
+Now, the most important job of pretty much any computer program is precisely to perform this
+interaction with the outside world. For this reason, the root of all executable Lean code is a
+function called main, with the type `IO Unit`. So every program starts in the IO monad!
+
+When your function is `IO` monadic, you can get any input you need, call into "pure" code with the
+inputs, and then output the result in some way. The reverse does not work. You cannot call into IO
+code from pure code like you can call into a function that takes `Option` as input. Another way to
+say this is you cannot invent an `IO` context out of thin air, it has to be given to you in your
+`main` function.
+
+Let's look at a simple program showing a few of the basic IO functions. It also uses `do` notation
+to make the code read nicely:
+-/
+def main : IO Unit := do
+  IO.println "enter a line of text:"
+  let stdin ← IO.getStdin            -- IO IO.FS.Stream (monadic)
+  let input ← stdin.getLine          -- IO.FS.Stream → IO String (monadic)
+  let uppercased := input.toUpper    -- String → String (pure)
+  IO.println uppercased              -- IO Unit (monadic)
+/-!
+
+So, once again you can see that the `do` notation lets you chain a series of monadic actions.
+`IO.getStdin` is of type `IO IO.FS.Stream` and `stdin.getLine` is of type `IO String`
+and `IO.println` is of type `IO Unit`.
+
+In between you see a non-monadic expression `let uppercased := input.toUpper` which is fine too.
+A let statement can occur in any monad. Just as you could unwrap `i` from `Option Nat` to get the
+inner Nat, you can use `←` to unwrap the result of `getLine` to get a String. You can then manipulate
+this value using normal pure string functions like `toUpper`, and then you can pass the result to the
+`IO.println` function.
+
+This is a simple echo program. It reads a line from the terminal, and then prints the line back out
+capitalized to the terminal. Hopefully it gives you a basic understanding of how IO works.
+
+You can test this program using `lean --run` as follows:
+
+```
+> lean --run Main.lean
+enter a line of text:
+the quick brown fox
+THE QUICK BROWN FOX
+```
+
+Here the user entered the string `the quick brown fox` and got back the uppercase result.
+
+## What separates Monads from Applicatives?
+
+The key that separates these is **context**. You cannot really determine the structure of
+"future" operations without knowing the results of "past" operations, because the past can alter the
+context in which the future operations work. With applicatives, you can't get the final function
+result without evaluating everything, but you can determine the structure of how the operation will
+take place. This allows some degree of parallelism with applicatives that is not generally possible
+with monads.
+
+
+## Conclusion
+
+Hopefully you now have a basic level understanding of what a monad is. But perhaps some more
+examples of what a "computational context" means would be useful to you. The Reader, State and
+Except monads each provide a concrete and easily understood context that can be compared easily to
+function parameters. You can learn more about those in [Reader monads](readers.lean.md),
+[State monads](states.lean.md), and the [Except monad](except.lean.md).
+-/

doc/monads/readers.lean

@@ -0,0 +1,199 @@
+/-!
+# Readers
+
+In the [previous section](monads.lean.md) you learned about the conceptual idea of monads. You learned
+what they are, and saw how some common types like `IO` and `Option` work as monads. Now in this
+section, you will be looking at some other useful monads. In particular, the `ReaderM` monad.
+
+## How to do Global Variables in Lean?
+
+In Lean, your code is generally "pure", meaning functions can only interact with the arguments
+passed to them. This effectively means you cannot have global variables. You can have global
+definitions, but these are fixed at compile time. If some user behavior might change them, you would have
+to wrap them in the `IO` monad, which means they can't be used from pure code.
+
+Consider this example. Here, you want to have an `Environment` containing different parameters as a
+global variable. However, you want to load these parameters from the process environment variables,
+which requires the `IO` monad.
+-/
+
+structure Environment where
+  path : String
+  home : String
+  user : String
+  deriving Repr
+
+def getEnvDefault (name : String): IO String := do
+  let val? ← IO.getEnv name
+  pure <| match val? with
+          | none => ""
+          | some s => s
+
+def loadEnv : IO Environment := do
+  let path ← getEnvDefault "PATH"
+  let home ← getEnvDefault "HOME"
+  let user ← getEnvDefault "USER"
+  pure { path, home, user }
+
+def func1 (e : Environment) : Float :=
+  let l1 := e.path.length
+  let l2 := e.home.length * 2
+  let l3 := e.user.length * 3
+  (l1 + l2 + l3).toFloat * 2.1
+
+def func2 (env : Environment) : Nat :=
+  2 + (func1 env).floor.toUInt32.toNat
+
+def func3 (env : Environment) : String :=
+  "Result: " ++ (toString (func2 env))
+
+def main : IO Unit := do
+  let env ← loadEnv
+  let str := func3 env
+  IO.println str
+
+#eval main -- Result: 7538
+
+/-!
+The only function actually using the environment is func1. However func1 is a pure function. This
+means it cannot directly call loadEnv, an impure function in the IO monad. This means the
+environment has to be passed through as a variable to the other functions, just so they can
+ultimately pass it to func1. In a language with global variables, you could save env as a global
+value in main. Then func1 could access it directly. There would be no need to have it as a parameter
+to func1, func2 and func3. In larger programs, these "pass-through" variables can cause a lot of
+headaches.
+
+## The Reader Solution
+
+The `ReaderM` monad solves this problem. It effectively creates a global read-only value of a
+specified type. All functions within the monad can "read" the type. Let's look at how the `ReaderM`
+monad changes the shape of this code. Now the functions **no longer need** to be given the
+`Environment` as an explicit parameter, as they can access it through the monad.
+-/
+
+def readerFunc1 : ReaderM Environment Float := do
+  let env ← read
+  let l1 := env.path.length
+  let l2 := env.home.length * 2
+  let l3 := env.user.length * 3
+  return (l1 + l2 + l3).toFloat * 2.1
+
+def readerFunc2 : ReaderM Environment Nat :=
+  readerFunc1 >>= (fun x => return 2 + (x.floor.toUInt32.toNat))
+
+def readerFunc3 : ReaderM Environment String := do
+  let x ← readerFunc2
+  return "Result: " ++ toString x
+
+def main2 : IO Unit := do
+  let env ← loadEnv
+  let str := readerFunc3.run env
+  IO.println str
+
+#eval main2 -- Result: 7538
+/-!
+The `ReaderM` monad provides a `run` method and it is the `ReaderM` run method that takes the initial
+`Environment` context.  So here you see `main2` loads the environment as before, and establishes
+the `ReaderM` context by passing `env` to the `run` method.
+
+> **Side note 1**: The `return` statement used above also needs some explanation.  The `return`
+statement in Lean is closely related to `pure`, but a little different. First the similarity is that
+`return` and `pure` both lift a pure value up to the Monad type. But `return` is a keyword so you do
+not need to parenthesize the expression like you do when using `pure`.  (Note: you can avoid
+parentheses when using `pure` by using the `<|` operator like we did above in the initial
+`getEnvDefault` function).  Furthermore, `return` can also cause an early `return` in a monadic
+function similar to how it can in an imperative language while `pure` cannot.
+
+> So technically if `return` is the last statement in a function it could be replaced with `pure <|`,
+but one could argue that `return` is still a little easier for most folks to read, just so long as
+you understand that `return` is doing more than other languages, it is also wrapping pure values in
+the monadic container type.
+
+> **Side note 2**: If the function `readerFunc3` also took some explicit arguments then you would have
+to write `(readerFunc3 args).run env` and this is a bit ugly, so Lean provides an infix operator
+`|>` that eliminates those parentheses so you can write `readerFunc3 args |>.run env` and then you can
+chain multiple monadic actions like this `m1 args1 |>.run args2 |>.run args3` and this is the
+recommended style.  You will see this pattern used heavily in Lean code.
+
+The `let env ← read` expression in `readerFunc1` unwraps the environment from the `ReaderM` so we
+can use it. Each type of monad might provide one or more extra functions like this, functions that
+become available only when you are in the context of that monad.
+
+Here the `readerFunc2` function uses the `bind` operator `>>=` just to show you that there are bind
+operations happening here.  The `readerFunc3` function uses the `do` notation you learned about in
+[Monads](monads.lean.md) which hides that bind operation and can make the code look cleaner.
+So the expression `let x ← readerFunc2` is also calling the `bind` function under the covers,
+so that you can access the unwrapped value `x` needed for the `toString x` conversion.
+
+The important difference here to the earlier code is that `readerFunc3` and `readerFunc2` no longer
+have an **explicit** Environment input parameter that needs to be passed along all the way to
+`readerFunc1`.  Instead, the `ReaderM` monad is taking care of that for you, which gives you the
+illusion of something like global context where the context is now available to all functions that use
+the `ReaderM` monad.
+
+The above code also introduces an important idea. Whenever you learn about a monad "X", there's
+often (but not always) a `run` function to execute that monad, and sometimes some additional
+functions like `read` that interact with the monad context.
+
+You might be wondering, how does the context actually move through the `ReaderM` monad? How can you
+add an input argument to a function by modifying its return type?  There is a special command in
+Lean that will show you the reduced types:
+-/
+#reduce ReaderM Environment String   -- Environment → String
+/-!
+And you can see here that this type is actually a function!  It's a function that takes an
+`Environment` as input and returns a `String`.
+
+Now, remember in Lean that a function that takes an argument of type `Nat` and returns a `String`
+like `def f (a : Nat) : String` is the same as this function `def f : Nat → String`.  These are
+exactly equal as types.  Well this is being used by the `ReaderM` Monad to add an input argument to
+all the functions that use the `ReaderM` monad and this is why `main` is able to start things off by
+simply passing that new input argument in `readerFunc3.run env`. So now that you know the implementation
+details of the `ReaderM` monad you can see that what it is doing looks very much like the original
+code we wrote at the beginning of this section, only it's taking a lot of the tedious work off your
+plate and it is creating a nice clean separation between what your pure functions are doing, and the
+global context idea that the `ReaderM` adds.
+
+## withReader
+
+One `ReaderM` function can call another with a modified version of the `ReaderM` context. You can
+use the `withReader` function from the `MonadWithReader` type class to do this:
+
+-/
+def readerFunc3WithReader : ReaderM Environment String := do
+  let x ← withReader (λ env => { env with user := "new user" }) readerFunc2
+  return "Result: " ++ toString x
+
+/-!
+Here we changed the `user` in the `Environment` context to "new user" and then we passed that
+modified context to `readerFunc2`.
+
+So `withReader f m` executes monad `m` in the `ReaderM` context modified by `f`.
+
+## Handy shortcut with (← e)
+
+If you use the operator `←` in a let expression and the variable is only used once you can
+eliminate the let expression and place the `←` operator in parentheses like this
+call to loadEnv:
+-/
+def main3 : IO Unit := do
+  let str := readerFunc3 (← loadEnv)
+  IO.println str
+/-!
+
+## Conclusion
+
+It might not seem like much has been accomplished with this `ReaderM Environment` monad, but you will
+find that in larger code bases, with many different types of monads all composed together this
+greatly cleans up the code. Monads provide a beautiful functional way of managing cross-cutting
+concerns that would otherwise make your code very messy.
+
+Having this control over the inherited `ReaderM` context via `withReader` is actually very useful
+and something that is quite messy if you try and do this sort of thing with global variables, saving
+the old value, setting the new one, calling the function, then restoring the old value, making sure
+you do that in a try/finally block and so on. The `ReaderM` design pattern avoids that mess
+entirely.
+
+Now it's time to move on to [StateM Monad](states.lean.md) which is like a `ReaderM` that is
+also updatable.
+-/

doc/monads/states.lean

@@ -0,0 +1,265 @@
+import Lean.Data.HashMap
+/-!
+# State
+
+In the [previous section](readers.lean.md), you learned about the `ReaderM` monad. Hopefully this gave you
+a new perspective on Lean. It showed that, in fact, you _can_ have global variables of some sort;
+you just need to encode them in the type signature somehow, and this is what monads are for! In this
+part, you will explore the `StateM` monad, which is like a `ReaderM` only the state can also be updated.
+
+## Motivating example: Tic Tac Toe
+
+For this section, let's build a simple model for a Tic Tace Toe game. The main object is the `GameState`
+data type containing several important pieces of information. First and foremost, it has the
+"board", a map from 2D tile indices to the "Tile State" (X, O or empty). Then it also knows the
+current player, and it has a random generator.
+-/
+
+open Batteries (HashMap)
+abbrev TileIndex := Nat × Nat -- a 2D index
+
+inductive TileState where
+  | TileEmpty | TileX | TileO
+  deriving Repr, BEq
+
+inductive Player where
+  | XPlayer | OPlayer
+  deriving Repr, BEq
+
+abbrev Board := HashMap TileIndex TileState
+
+structure GameState where
+  board : Board
+  currentPlayer : Player
+  generator : StdGen
+
+/-!
+Let's think at a high level about how some of the game functions would work. You could, for
+instance, have a function for selecting a random move. This would output a `TileIndex` to play and
+alter the game's number generator. You would then make a move based on the selected move and the
+current player. This would change the board state as well as swap the current player. In other
+words, you have operations that depend on the current state of the game, but also need to **update
+that state**.
+
+## The StateM Monad to the Rescue
+
+This is exactly the situation the `StateM` monad deals with. The `StateM` monad wraps computations in
+the context of reading and modifying a global state object.
+
+It is parameterized by a single type parameter `s`, the state type in use. So just like the `ReaderM`
+has a single type you read from, the `StateM` has a single type you can both **read from and write
+to**. There are three primary actions you can take within the `StateM`monad:
+
+- **get** - retrieves the state, like Reader.read
+- **set** - updates the state
+- **modifyGet** - retrieves the state, then updates it
+
+There is also a `run` function, similar to `run` on `ReaderM`. Like the `ReaderM` monad, you must
+provide an initial state, in addition to the computation to run. `StateM` then produces two outputs:
+the result of the computation combined with the final updated state.
+
+If you wish to discard the final state and just get the computation's result, you can use
+`run'` method instead.  Yes in Lean, the apostrophe can be part of a name, you read this "run
+prime", and the general naming convention is that the prime method discards something.
+
+So for your Tic Tac Toe game, many of your functions will have a signature like `State GameState a`.
+
+## Stateful Functions
+
+Now you can examine some of the different functions mentioned above and determine their types.
+You can, for instance, pick a random move:
+
+-/
+open TileState
+
+def findOpen : StateM GameState (List TileIndex) := do
+  let game ← get
+  return game.board.toList.filterMap fun (i, x) => guard (x == TileEmpty) *> pure i
+
+def chooseRandomMove : StateM GameState TileIndex := do
+  let game ← get
+  let openSpots ← findOpen
+  let gen := game.generator
+  let (i, gen') := randNat gen 0 (openSpots.length - 1)
+  set { game with generator := gen' }
+  return openSpots[i]!
+
+/-!
+This returns a `TileIndex` and modifies the random number generator stored in the `GameState`!
+Notice you have a fun little use of the `Applicative.seqRight` operator `*>` in `findOpen`
+as described in [Applicatives](applicatives.lean.md).
+
+Now you can create the function that can make a move:
+-/
+open Player
+
+def tileStateForPlayer : Player → TileState
+| XPlayer => TileX
+| OPlayer => TileO
+
+def nextPlayer : Player →  Player
+| XPlayer => OPlayer
+| OPlayer => XPlayer
+
+def applyMove (i : TileIndex): StateM GameState Unit := do
+  let game ← get
+  let p := game.currentPlayer
+  let newBoard := game.board.insert i (tileStateForPlayer p)
+  set { game with currentPlayer := nextPlayer p, board := newBoard }
+
+/-!
+This updates the board in the `GameState` with the new tile, and then changes the current player,
+providing no output (`Unit` return type).
+
+So finally, you can combine these functions together with `do` notation, and it actually looks quite
+clean! You don't need to worry about the side effects. The different monadic functions handle them.
+Here's a sample of what your function might look like to play one turn of the game. At the end, it
+returns a boolean determining if all the spaces have been filled.
+
+Notice in `isGameDone` and `nextTurn` we have stopped providing the full return type
+`StateM GameState Unit`.  This is because Lean is able to infer the correct monadic return type
+from the context and as a result the code is now looking really clean.
+-/
+
+def isGameDone := do
+  return (← findOpen).isEmpty
+
+def nextTurn := do
+  let i ← chooseRandomMove
+  applyMove i
+  isGameDone
+
+/-!
+To give you a quick test harness that runs all moves for both players you can run this:
+-/
+
+def initBoard : Board := Id.run do
+  let mut board := HashMap.empty
+  for i in [0:3] do
+    for j in [0:3] do
+      let t : TileIndex := (i, j)
+      board := board.insert t TileEmpty
+  board
+
+def printBoard (board : Board) : IO Unit := do
+  let mut row : List String := []
+  for i in board.toList do
+    let s := match i.2 with
+      | TileEmpty => " "
+      | TileX => "X"
+      | TileO => "O"
+    row := row.append [s]
+    if row.length == 3 then
+      IO.println row
+      row := []
+
+def playGame := do
+  while true do
+    let finished ← nextTurn
+    if finished then return
+
+def main : IO Unit := do
+  let gen ← IO.stdGenRef.get
+  let (x, gen') := randNat gen 0 1
+  let gs := {
+    board := initBoard,
+    currentPlayer := if x = 0 then XPlayer else OPlayer,
+    generator := gen' }
+  let (_, g) := playGame |>.run gs
+  printBoard g.board
+
+#eval main
+-- [X, X, O]
+-- [X, O, O]
+-- [O, O, X]
+
+/-!
+
+Note that when you run the above code interactively the random number generator always starts in the
+same place.  But if you run `lean --run states.lean` then you will see randomness in the result.
+
+## Implementation
+
+It may be helpful to see how the `StateM` monad adds the input state and output state.  If you look
+at the reduced Type for `nextTurn`:
+-/
+#reduce StateM GameState Bool
+-- GameState → Bool × GameState
+/-!
+
+So a function like `nextTurn` that might have just returned a `Bool` has been modified by the
+`StateM` monad such that the initial `GameState` is passed in as a new input argument, and the output
+value has been changed to the pair `Bool × GameState` so that it can return the pure `Bool` and the
+updated `GameState`.  So `playGame` then is automatically saving that updated game state so that each
+time around the `while` loop it is acting on the new state, otherwise that would be an infinite loop!
+
+It is also interesting to see how much work the `do` and `←` notation are doing for you.  To
+implement the `nextTurn` function without these you would have to write this, manually plumbing
+the state all the way through:
+-/
+def nextTurnManually : StateM GameState Bool
+| state =>
+  let (i, gs) := chooseRandomMove |>.run state
+  let (_, gs') := applyMove i  |>.run gs
+  let (result, gs'') := isGameDone |>.run gs'
+  (result, gs'')
+
+/-!
+
+This expression `let (i, gs)` conveniently breaks a returned pair up into 2 variables.
+In the expression `let (_, gs')` we didn't care what the first value was so we used underscore.
+Notice that nextTurn is capturing the updated game state from `chooseRandomMove` in the variable
+`gs`, which it is then passing to `applyMove` which returns `gs'` which is passed to `isGameDone`
+and that function returns `gs''` which we then return from `nextTurnManually`.  Phew, what a lot
+of work you don't have to do when you use `do` notation!
+
+## StateM vs ReaderM
+
+While `ReaderM` functions can use `withReader` to modify the context before calling another function,
+`StateM` functions are a little more powerful, let's look at this function again:
+```
+def nextTurn : StateM GameState Bool := do
+  let i ← chooseRandomMove
+  applyMove i
+  isGameDone
+```
+
+In this function `chooseRandomMove` is modifying the state that `applyMove` is getting
+and `chooseRandomMove` knows nothing about `applyMove`.  So `StateM` functions can have this
+kind of downstream effect outside their own scope, whereas, `withReader` cannot do that.
+
+So there is no equivalent to `withReader` for `StateM`, besides you can always use the `StateM`
+`set` function to modify the state before calling the next function anyway.  You could however,
+manually call a `StateM` function like you see in `nextTurnManually` and completely override
+the state at any point that way.
+
+## State, IO and other languages
+
+When thinking about Lean, it is often seen as a restriction that you can't have global variables or
+`static` variables like you can with other languages like Python or C++. However, hopefully you see
+now this isn't true. You can have a data type with exactly the same functionality as a Python class.
+You would simply have many functions that can modify some global state using the `StateM` monad.
+
+The difference is in Lean you simply put a label on these types of functions. You don't allow it to
+happen for free anywhere in an uncontrolled fashion because that results in too many sleepless
+nights debugging nasty code. You want to know when side effects can potentially happen, because
+knowing when they can happen makes your code easier to reason about. In a Python class, many of the
+methods won't actually need to modify the global state. But they could, which makes it harder to
+debug them. In Lean you can simply make these pure functions, and the compiler will ensure they stay
+pure and cannot modify any global state.
+
+IO is the same way. It's not like you can't perform IO in Lean. Instead, you want to label the areas
+where you can, to increase your certainty about the areas where you don't need to. When you know part of
+your code cannot communicate with the outside world, you can be far more certain of its behavior.
+
+The `StateM` monad is also a more disciplined way of managing side effects. Top level code could
+call a `StateM` function multiple times with different independent initial states, even doing that
+across multiple tasks in parallel and each of these cannot clobber the state belonging to other
+tasks. Monadic code is more predictable and reusable than code that uses global variables.
+
+## Summary
+
+That wraps it up for the `StateM` monad! There is one more very useful monad that can be used to do
+exception handling which will be covered in the [next section](except.lean.md).
+
+-/

doc/monads/transformers.lean

@@ -0,0 +1,316 @@
+/-!
+# Monad Transformers
+
+In the previous sections you learned about some handy monads [Option](monads.lean.md),
+[IO](monads.lean.md), [Reader](readers.lean.md), [State](states.lean.md) and
+[Except](except.lean.md), and you now know how to make your function use one of these, but what you
+do not yet know is how to make your function use multiple monads at once.
+
+For example, suppose you need a function that wants to access some Reader context and optionally throw
+an exception?  This would require composition of two monads `ReaderM` and `Except` and this is what
+monad transformers are for.
+
+A monad transformer is fundamentally a wrapper type. It is generally parameterized by another
+monadic type. You can then run actions from the inner monad, while adding your own customized
+behavior for combining actions in this new monad. The common transformers add `T` to the end of an
+existing monad name. You will find `OptionT`, `ExceptT`, `ReaderT`, `StateT` but there is no transformer
+for `IO`.  So generally if you need `IO` it becomes the innermost wrapped monad.
+
+In the following example we use `ReaderT` to provide some read only context to a function
+and this `ReaderT` transformer will wrap an `Except` monad.  If all goes well the
+`requiredArgument` returns the value of a required argument and `optionalSwitch`
+returns true if the optional argument is present.
+
+-/
+abbrev Arguments := List String
+
+def indexOf? [BEq α] (xs : List α) (s : α) (start := 0): Option Nat :=
+  match xs with
+  | [] => none
+  | a :: tail => if a == s then some start else indexOf? tail s (start+1)
+
+def requiredArgument (name : String) : ReaderT Arguments (Except String) String := do
+  let args ← read
+  let value := match indexOf? args name with
+    | some i => if i + 1 < args.length then args[i+1]! else ""
+    | none => ""
+  if value == "" then throw s!"Command line argument {name} missing"
+  return value
+
+def optionalSwitch (name : String) : ReaderT Arguments (Except String) Bool := do
+  let args ← read
+  return match (indexOf? args name) with
+  | some _ => true
+  | none => false
+
+#eval requiredArgument "--input" |>.run ["--input", "foo"]
+-- Except.ok "foo"
+
+#eval requiredArgument "--input" |>.run ["foo", "bar"]
+-- Except.error "Command line argument --input missing"
+
+#eval optionalSwitch "--help" |>.run ["--help"]
+-- Except.ok true
+
+#eval optionalSwitch "--help" |>.run []
+-- Except.ok false
+
+/-!
+Notice that `throw` was available from the inner `Except` monad. The cool thing is you can switch
+this around and get the exact same result using `ExceptT` as the outer monad transformer and
+`ReaderM` as the wrapped monad. Try changing requiredArgument to `ExceptT String (ReaderM Arguments) Bool`.
+
+Note: the `|>.` notation is described in [Readers](readers.lean.md#the-reader-solution).
+
+## Adding more layers
+
+Here's the best part about monad transformers. Since the result of a monad transformer is itself a
+monad, you can wrap it inside another transformer! Suppose you need to pass in some read only context
+like the command line arguments, update some read-write state (like program Config) and optionally
+throw an exception, then you could write this:
+
+-/
+structure Config where
+  help : Bool := false
+  verbose : Bool := false
+  input : String := ""
+  deriving Repr
+
+abbrev CliConfigM := StateT Config (ReaderT Arguments (Except String))
+
+def parseArguments : CliConfigM Bool := do
+  let mut config ← get
+  if (← optionalSwitch "--help") then
+    throw "Usage: example [--help] [--verbose] [--input <input file>]"
+  config := { config with
+    verbose := (← optionalSwitch "--verbose"),
+    input := (← requiredArgument "--input") }
+  set config
+  return true
+
+def main (args : List String) : IO Unit := do
+  let config : Config := { input := "default"}
+  match parseArguments |>.run config |>.run args with
+  | Except.ok (_, c) => do
+    IO.println s!"Processing input '{c.input}' with verbose={c.verbose}"
+  | Except.error s => IO.println s
+
+
+#eval main ["--help"]
+-- Usage: example [--help] [--verbose] [--input <input file>]
+
+#eval main ["--input", "foo"]
+-- Processing input file 'foo' with verbose=false
+
+#eval main ["--verbose", "--input", "bar"]
+-- Processing input 'bar' with verbose=true
+
+/-!
+In this example `parseArguments` is actually three stacked monads, `StateM`, `ReaderM`, `Except`. Notice
+the convention of abbreviating long monadic types with an alias like `CliConfigM`.
+
+## Monad Lifting
+
+Lean makes it easy to compose functions that use different monads using a concept of automatic monad
+lifting.  You already used lifting in the above code, because you were able to compose
+`optionalSwitch` which has type `ReaderT Arguments (Except String) Bool` and call it from
+`parseArguments` which has a bigger type `StateT Config (ReaderT Arguments (Except String))`.
+This "just worked" because Lean did some magic with monad lifting.
+
+To give you a simpler example of this, suppose you have the following function:
+-/
+def divide (x : Float ) (y : Float): ExceptT String Id Float :=
+  if y == 0 then
+    throw "can't divide by zero"
+  else
+    pure (x / y)
+
+#eval divide 6 3 -- Except.ok 2.000000
+#eval divide 1 0 -- Except.error "can't divide by zero"
+/-!
+
+Notice here we used the `ExceptT` transformer, but we composed it with the `Id` identity monad.
+This is then the same as writing `Except String Float` since the identity monad does nothing.
+
+Now suppose you want to count the number of times divide is called and store the result in some
+global state:
+-/
+
+def divideCounter (x : Float) (y : Float) : StateT Nat (ExceptT String Id) Float := do
+  modify fun s => s + 1
+  divide x y
+
+#eval divideCounter 6 3 |>.run 0    -- Except.ok (2.000000, 1)
+#eval divideCounter 1 0 |>.run 0    -- Except.error "can't divide by zero"
+
+/-!
+
+The `modify` function is a helper which makes it easier to use `modifyGet` from the `StateM` monad.
+But something interesting is happening here, `divideCounter` is returning the value of
+`divide`, but the types don't match, yet it works?  This is monad lifting in action.
+
+You can see this more clearly with the following test:
+
+-/
+def liftTest (x : Except String Float) :
+  StateT Nat (Except String) Float := x
+
+#eval liftTest (divide 5 1) |>.run 3 -- Except.ok (5.000000, 3)
+
+/-!
+
+Notice that `liftTest` returned `x` without doing anything to it, yet that matched the return type
+`StateT Nat (Except String) Float`.  Monad lifting is provided by monad transformers.  if you
+`#print liftTest` you will see that Lean is implementing this using a call to a function named
+`monadLift` from the `MonadLift` type class:
+
+```lean,ignore
+class MonadLift (m : Type u → Type v) (n : Type u → Type w) where
+  monadLift : {α : Type u} → m α → n α
+```
+
+So `monadLift` is a function for lifting a computation from an inner `Monad m α ` to an outer `Monad n α`.
+You could replace `x` in `liftTest` with `monadLift x` if you want to be explicit about it.
+
+The StateT monad transformer defines an instance of `MonadLift` like this:
+
+```lean
+@[inline] protected def lift {α : Type u} (t : m α) : StateT σ m α :=
+  fun s => do let a ← t; pure (a, s)
+
+instance : MonadLift m (StateT σ m) := ⟨StateT.lift⟩
+```
+This means that any monad `m` can be wrapped in a `StateT` monad by using the function
+`fun s => do let a ← t; pure (a, s)` that takes state `s`, runs the inner monad action `t`, and
+returns the result and the new state in a pair `(a, s)` without making any changes to `s`.
+
+Because `MonadLift` is a type class, Lean can automatically find the required `monadLift`
+instances in order to make your code compile and in this way it was able to find the `StateT.lift`
+function and use it to wrap the result of `divide` so that the correct type is returned from
+`divideCounter`.
+
+If you have an instance `MonadLift m n` that means there is a way to turn a computation that happens
+inside of `m` into one that happens inside of `n` and (this is the key part) usually *without* the
+instance itself creating any additional data that feeds into the computation. This means you can in
+principle declare lifting instances from any monad to any other monad, it does not, however, mean
+that you should do this in all cases.  You can get a very nice report on how all this was done by
+adding the line `set_option trace.Meta.synthInstance true in` before `divideCounter` and moving you
+cursor to the end of the first line after `do`.
+
+This was a lot of detail, but it is very important to understand how monad lifting works because it
+is used heavily in Lean programs.
+
+## Transitive lifting
+
+There is also a transitive version of `MonadLift` called `MonadLiftT` which can lift multiple
+monad layers at once.  In the following example we added another monad layer with
+`ReaderT String ...` and notice that `x` is also automatically lifted to match.
+
+-/
+def liftTest2 (x : Except String Float) :
+  ReaderT String (StateT Nat (Except String)) Float := x
+
+#eval liftTest2 (divide 5 1) |>.run "" |>.run 3
+-- Except.ok (5.000000, 3)
+
+/-!
+
+The ReaderT monadLift is even simpler than the one for StateT:
+
+```lean,ignore
+instance  : MonadLift m (ReaderT ρ m) where
+  monadLift x := fun _ => x
+```
+
+This lift operation creates a function that defines the required `ReaderT` input
+argument, but the inner monad doesn't know or care about `ReaderT` so the
+monadLift function throws it away with the `_` then calls the inner monad action `x`.
+This is a perfectly legal implementation of the `ReaderM` monad.
+
+## Add your own Custom MonadLift
+
+This does not compile:
+-/
+def main2 : IO Unit := do
+  try
+    let ret ← divideCounter 5 2 |>.run 0
+    IO.println (toString ret)
+  catch e =>
+    IO.println e
+
+/-!
+saying:
+```
+typeclass instance problem is stuck, it is often due to metavariables
+  ToString ?m.4786
+```
+
+The reason is `divideCounter` returns the big `StateT Nat (ExceptT String Id) Float` and that type
+cannot be automatically lifted into the `main` return type of `IO Unit` unless you give it some
+help.
+
+The following custom `MonadLift` solves this problem:
+
+-/
+def liftIO (t : ExceptT String Id α) : IO α := do
+  match t with
+  | .ok r => EStateM.Result.ok r
+  | .error s => EStateM.Result.error s
+
+instance : MonadLift (ExceptT String Id) IO where
+  monadLift := liftIO
+
+def main3 : IO Unit := do
+  try
+    let ret ← divideCounter 5 2 |>.run 0
+    IO.println (toString ret)
+  catch e =>
+    IO.println e
+
+#eval main3 -- (2.500000, 1)
+/-!
+
+It turns out that the `IO` monad you see in your `main` function is based on the `EStateM.Result` type
+which is similar to the `Except` type but it has an additional return value. The `liftIO` function
+converts any `Except String α` into `IO α` by simply mapping the ok case of the `Except` to the
+`Result.ok` and the error case to the `Result.error`.
+
+## Lifting ExceptT
+
+In the previous [Except](except.lean.md) section you saw functions that `throw` Except
+values. When you get all the way back up to your `main` function which has type `IO Unit` you have
+the same problem you had above, because `Except String Float` doesn't match even if you use a
+`try/catch`.
+
+-/
+
+def main4 : IO Unit := do
+  try
+    let ret ← divide 5 0
+    IO.println (toString ret)  -- lifting happens here.
+  catch e =>
+    IO.println s!"Unhandled exception: {e}"
+
+#eval main4 -- Unhandled exception: can't divide by zero
+
+/-!
+
+Without the `liftIO` the `(toString ret)` expression would not compile with a similar error:
+
+```
+typeclass instance problem is stuck, it is often due to metavariables
+  ToString ?m.6007
+```
+
+So the general lesson is that if you see an error like this when using monads, check for
+a missing `MonadLift`.
+
+## Summary
+
+Now that you know how to combine your monads together, you're almost done with understanding the key
+concepts of monads! You could probably go out now and start writing some pretty nice code! But to
+truly master monads, you should know how to make your own, and there's one final concept that you
+should understand for that. This is the idea of type "laws". Each of the structures you've learned
+so far has a series of laws associated with it. And for your instances of these classes to make
+sense, they should follow the laws! Check out [Monad Laws](laws.lean.md).
+-/

doc/namespaces.md

@@ -0,0 +1,108 @@
+# Namespaces
+
+Lean provides us with the ability to group definitions into nested, hierarchical *namespaces*:
+
+```lean
+namespace Foo
+  def a : Nat := 5
+  def f (x : Nat) : Nat := x + 7
+
+  def fa : Nat := f a
+  def ffa : Nat := f (f a)
+
+  #check a
+  #check f
+  #check fa
+  #check ffa
+  #check Foo.fa
+end Foo
+
+-- #check a  -- error
+-- #check f  -- error
+#check Foo.a
+#check Foo.f
+#check Foo.fa
+#check Foo.ffa
+
+open Foo
+
+#check a
+#check f
+#check fa
+#check Foo.fa
+```
+
+When we declare that we are working in the namespace ``Foo``, every identifier we declare has
+a full name with prefix "``Foo.``" Within the namespace, we can refer to identifiers
+by their shorter names, but once we end the namespace, we have to use the longer names.
+
+The ``open`` command brings the shorter names into the current context. Often, when we import a
+module, we will want to open one or more of the namespaces it contains, to have access to the short identifiers.
+But sometimes we will want to leave this information hidden, for example, when they conflict with
+identifiers in another namespace we want to use. Thus namespaces give us a way to manage our working environment.
+
+For example, Lean groups definitions and theorems involving lists into a namespace ``List``.
+```lean
+#check List.nil
+#check List.cons
+#check List.map
+```
+We will discuss their types, below. The command ``open List`` allows us to use the shorter names:
+```lean
+open List
+
+#check nil
+#check cons
+#check map
+```
+Like sections, namespaces can be nested:
+```lean
+namespace Foo
+  def a : Nat := 5
+  def f (x : Nat) : Nat := x + 7
+
+  def fa : Nat := f a
+
+  namespace Bar
+    def ffa : Nat := f (f a)
+
+    #check fa
+    #check ffa
+  end Bar
+
+  #check fa
+  #check Bar.ffa
+end Foo
+
+#check Foo.fa
+#check Foo.Bar.ffa
+
+open Foo
+
+#check fa
+#check Bar.ffa
+```
+Namespaces that have been closed can later be reopened, even in another file:
+```lean
+namespace Foo
+  def a : Nat := 5
+  def f (x : Nat) : Nat := x + 7
+
+  def fa : Nat := f a
+end Foo
+
+#check Foo.a
+#check Foo.f
+
+namespace Foo
+  def ffa : Nat := f (f a)
+end Foo
+```
+
+Like sections, nested namespaces have to be closed in the order they are opened.
+Namespaces and sections serve different purposes: namespaces organize data and sections declare variables for insertion in definitions.
+Sections are also useful for delimiting the scope of commands such as ``set_option`` and ``open``.
+
+In many respects, however, a ``namespace ... end`` block behaves the same as a ``section ... end`` block.
+In particular, if you use the ``variable`` command within a namespace, its scope is limited to the namespace.
+Similarly, if you use an ``open`` command within a namespace, its effects disappear when the namespace is closed.

doc/nat.md

@@ -0,0 +1,68 @@
+# Natural numbers
+
+The `Nat` type represents the natural numbers, i.e., arbitrary-precision unsigned integers.
+There are no overflows.
+
+```lean
+#eval 100000000000000000 * 200000000000000000000 * 1000000000000000000000
+```
+
+A numeral is considered to be a `Nat` if there are no typing constraints.
+```lean
+#check 10    -- Nat
+#check id 10 -- Nat
+
+def f (x : Int) : Int :=
+  x - 1
+
+#eval f (3 - 5) -- 3 and 5 are `Int` since `f` expects an `Int`.
+-- -3
+```
+
+The operator `-` for `Nat` implements truncated subtraction.
+```lean
+#eval 10 - 5 -- 5
+#eval 5 - 10 -- 0
+
+theorem ex : 5 - 10 = 0 :=
+  rfl
+
+#eval (5:Int) - 10 -- -5
+```
+
+The operator `/` for `Nat` implements Euclidean division.
+```lean
+#eval 10 / 4 -- 2
+
+#check 10.0 / 4.0 -- Float
+#eval 10.0 / 4.0  -- 2.5
+```
+
+As we described in the previous sections, we define the `Nat` type as an `inductive` datatype.
+```lean
+# namespace hidden
+inductive Nat where
+  | zero : Nat
+  | succ : Nat → Nat
+# end hidden
+```
+However, the internal representation of `Nat` is optimized. Small natural numbers (i.e., < `2^63` in a 64-bit machine) are
+represented by a single machine word. Big numbers are implemented using [GMP](https://gmplib.org/manual/) numbers.
+We recommend you use fixed precision numeric types only in performance critical code.
+
+The Lean kernel has builtin support for the `Nat` type too, and can efficiently reduce `Nat` expressions during type checking.
+```lean
+#reduce 100000000000000000 * 200000000000000000000 * 1000000000000000000000
+
+theorem ex
+      : 1000000000000000 * 2000000000000000000 = 2000000000000000000000000000000000 :=
+  rfl
+```
+The sharp-eyed reader will notice that GMP is part of the Lean kernel trusted code base.
+We believe this is not a problem because you can use external type checkers to double-check your developments,
+and we consider GMP very trustworthy.
+Existing external type checkers for Lean 3 (e.g., [Trepplein](https://github.com/gebner/trepplein) and [TC](https://github.com/leanprover/tc))
+can be easily adapted to Lean 4.
+If you are still concerned after checking your development with multiple different external checkers because
+they may all rely on buggy arbitrary-precision libraries,
+you can develop your own certified arbitrary-precision library and use it to implement your own type checker for Lean.

doc/notation.md

@@ -0,0 +1,78 @@
+# Notations and Precedence
+
+The most basic syntax extension commands allow introducing new (or
+overloading existing) prefix, infix, and postfix operators.
+
+```lean
+infixl:65   " + " => HAdd.hAdd  -- left-associative
+infix:50    " = " => Eq         -- non-associative
+infixr:80   " ^ " => HPow.hPow  -- right-associative
+prefix:75  "-"   => Neg.neg
+# set_option quotPrecheck false
+postfix:max "⁻¹"  => Inv.inv
+```
+
+After the initial command name describing the operator kind (its
+"fixity"), we give the *parsing precedence* of the operator preceded
+by a colon `:`, then a new or existing token surrounded by double
+quotes (the whitespace is used for pretty printing), then the function
+this operator should be translated to after the arrow `=>`.
+
+The precedence is a natural number describing how "tightly" an
+operator binds to its arguments, encoding the order of operations. We
+can make this more precise by looking at what the commands above unfold to:
+
+```lean
+notation:65 lhs:65 " + " rhs:66 => HAdd.hAdd lhs rhs
+notation:50 lhs:51 " = " rhs:51 => Eq lhs rhs
+notation:80 lhs:81 " ^ " rhs:80 => HPow.hPow lhs rhs
+notation:75 "-" arg:75 => Neg.neg arg
+# set_option quotPrecheck false
+notation:1024 arg:1024 "⁻¹" => Inv.inv arg  -- `max` is a shorthand for precedence 1024
+```
+
+It turns out that all commands from the first code block are in fact
+command *macros* translating to the more general `notation` command.
+We will learn about writing such macros below. Instead of a single
+token, the `notation` command accepts a mixed sequence of tokens and
+named term placeholders with precedences, which can be referenced on
+the right-hand side of `=>` and will be replaced by the respective
+term parsed at that position. A placeholder with precedence `p`
+accepts only notations with precedence at least `p` in that place.
+Thus the string `a + b + c` cannot be parsed as the equivalent of `a +
+(b + c)` because the right-hand side operand of an `infixl` notation
+has precedence one greater than the notation itself. In contrast,
+`infixr` reuses the notation's precedence for the right-hand side
+operand, so `a ^ b ^ c` *can* be parsed as `a ^ (b ^ c)`. Note that if
+we used `notation` directly to introduce an infix notation like
+```lean
+# set_option quotPrecheck false
+notation:65 lhs:65 " ~ " rhs:65 => wobble lhs rhs
+```
+where the precedences do not sufficiently determine associativity,
+Lean's parser will default to right associativity. More precisely,
+Lean's parser follows a local *longest parse* rule in the presence of
+ambiguous grammars: when parsing the right-hand side of `a ~` in `a ~
+b ~ c`, it will continue parsing as long as possible (as the current
+precedence allows), not stopping after `b` but parsing `~ c` as well.
+Thus the term is equivalent to `a ~ (b ~ c)`.
+
+As mentioned above, the `notation` command allows us to define
+arbitrary *mixfix* syntax freely mixing tokens and placeholders.
+```lean
+# set_option quotPrecheck false
+notation:max "(" e ")" => e
+notation:10 Γ " ⊢ " e " : " τ => Typing Γ e τ
+```
+Placeholders without precedence default to `0`, i.e. they accept
+notations of any precedence in their place. If two notations overlap,
+we again apply the longest parse rule:
+```lean
+notation:65 a " + " b:66 " + " c:66 => a + b - c
+#eval 1 + 2 + 3  -- 0
+```
+The new notation is preferred to the binary notation since the latter,
+before chaining, would stop parsing after `1 + 2`. If there are
+multiple notations accepting the same longest parse, the choice will
+be delayed until elaboration, which will fail unless exactly one
+overload is type correct.

doc/option.md

@@ -0,0 +1 @@
+# Option

doc/organization.md

@@ -0,0 +1,4 @@
+# Organizational features
+
+In this section we introduce some organizational features of Lean that are not a part of its kernel per se,
+but make it possible to work in the framework more efficiently.

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/sections.md

@@ -0,0 +1,70 @@
+# Variables and Sections
+
+Consider the following three function definitions:
+```lean
+def compose (α β γ : Type) (g : β → γ) (f : α → β) (x : α) : γ :=
+  g (f x)
+
+def doTwice (α : Type) (h : α → α) (x : α) : α :=
+  h (h x)
+
+def doThrice (α : Type) (h : α → α) (x : α) : α :=
+  h (h (h x))
+```
+
+Lean provides us with the ``variable`` command to make such declarations look more compact:
+
+```lean
+variable (α β γ : Type)
+
+def compose (g : β → γ) (f : α → β) (x : α) : γ :=
+  g (f x)
+
+def doTwice (h : α → α) (x : α) : α :=
+  h (h x)
+
+def doThrice (h : α → α) (x : α) : α :=
+  h (h (h x))
+```
+We can declare variables of any type, not just ``Type`` itself:
+```lean
+variable (α β γ : Type)
+variable (g : β → γ) (f : α → β) (h : α → α)
+variable (x : α)
+
+def compose := g (f x)
+def doTwice := h (h x)
+def doThrice := h (h (h x))
+
+#print compose
+#print doTwice
+#print doThrice
+```
+Printing them out shows that all three groups of definitions have exactly the same effect.
+
+The ``variable`` command instructs Lean to insert the declared variables as bound variables in definitions that refer to them.
+Lean is smart enough to figure out which variables are used explicitly or implicitly in a definition. We can therefore proceed as
+though ``α``, ``β``, ``γ``, ``g``, ``f``, ``h``, and ``x`` are fixed objects when we write our definitions, and let Lean abstract
+the definitions for us automatically.
+
+When declared in this way, a variable stays in scope until the end of the file we are working on.
+Sometimes, however, it is useful to limit the scope of a variable. For that purpose, Lean provides the notion of a ``section``:
+
+```lean
+section useful
+  variable (α β γ : Type)
+  variable (g : β → γ) (f : α → β) (h : α → α)
+  variable (x : α)
+
+  def compose := g (f x)
+  def doTwice := h (h x)
+  def doThrice := h (h (h x))
+end useful
+```
+
+When the section is closed, the variables go out of scope, and become nothing more than a distant memory.
+
+You do not have to indent the lines within a section. Nor do you have to name a section, which is to say,
+you can use an anonymous ``section`` / ``end`` pair.
+If you do name a section, however, you have to close it using the same name.
+Sections can also be nested, which allows you to declare new variables incrementally.

doc/setup.md

@@ -4,7 +4,7 @@
 
 Platforms built & tested by our CI, available as binary releases via elan (see below)
 
-* x86-64 Linux with glibc 2.26+
+* x86-64 Linux with glibc 2.27+
 * 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

doc/std/README.md

@@ -1,9 +0,0 @@
-# The Lean standard library
-
-This directory contains development information about the Lean standard library. The user-facing documentation of the standard library
-is part of the [Lean Language Reference](https://lean-lang.org/doc/reference/latest/).
-
-Here you will find
-* the [standard library vision document](./vision.md), including the call for contributions,
-* the [standard library style guide](./style.md), and
-* the [standard library naming conventions](./naming.md).

doc/std/naming.md

@@ -1,260 +0,0 @@
-# Standard library naming conventions
-
-The easiest way to access a result in the standard library is to correctly guess the name of the declaration (possibly with the help of identifier autocompletion). This is faster and has lower friction than more sophisticated search tools, so easily guessable names (which are still reasonably short) make Lean users more productive.
-
-The guide that follows contains very few hard rules, many heuristics and a selection of examples. It cannot and does not present a deterministic algorithm for choosing good names in all situations. It is intended as a living document that gets clarified and expanded as situations arise during code reviews for the standard library. If applying one of the suggestions in this guide leads to nonsensical results in a certain situation, it is
-probably safe to ignore the suggestion (or even better, suggest a way to improve the suggestion).
-
-## Prelude
-
-Identifiers use a mix of `UpperCamelCase`, `lowerCamelCase` and `snake_case`, used for types, data, and theorems, respectively.
-
-Structure fields should be named such that the projections have the correct names.
-
-## Naming convention for types
-
-When defining a type, i.e., a (possibly 0-ary) function whose codomain is Sort u for some u, it should be named in UpperCamelCase. Examples include `List`, and `List.IsPrefix`.
-
-When defining a predicate, prefix the name by `Is`, like in `List.IsPrefix`. The `Is` prefix may be omitted if
-* the resulting name would be ungrammatical, or
-* the predicate depends on additional data in a way where the `Is` prefix would be confusing (like `List.Pairwise`), or
-* the name is an adjective (like `Std.Time.Month.Ordinal.Valid`)
-
-## Namespaces and generalized projection notation
-
-Almost always, definitions and theorems relating to a type should be placed in a namespace with the same name as the type. For example, operations and theorems about lists should be placed in the `List` namespace, and operations and theorems about `Std.Time.PlainDate` should be placed in the `Std.Time.PlainDate` namespace.
-
-Declarations in the root namespace will be relatively rare. The most common type of declaration in the root namespace are declarations about data and properties exported by notation type classes, as long as they are not about a specific type implementing that type class. For example, we have
-
-```lean
-theorem beq_iff_eq [BEq α] [LawfulBEq α] {a b : α} : a == b ↔ a = b := sorry
-```
-
-in the root namespace, but
-
-```lean
-theorem List.cons_beq_cons [BEq α] {a b : α} {l₁ l₂ : List α} :
-    (a :: l₁ == b :: l₂) = (a == b && l₁ == l₂) := rfl
-```
-
-belongs in the `List` namespace.
-
-Subtleties arise when multiple namespaces are in play. Generally, place your theorem in the most specific namespace that appears in one of the hypotheses of the theorem. The following names are both correct according to this convention:
-
-```lean
-theorem List.Sublist.reverse : l₁ <+ l₂ → l₁.reverse <+ l₂.reverse := sorry
-theorem List.reverse_sublist : l₁.reverse <+ l₂.reverse ↔ l₁ <+ l₂ := sorry
-```
-
-Notice that the second theorem does not have a hypothesis of type `List.Sublist l` for some `l`, so the name `List.Sublist.reverse_iff` would be incorrect.
-
-The advantage of placing results in a namespace like `List.Sublist` is that it enables generalized projection notation, i.e., given `h : l₁ <+ l₂`,
-one can write `h.reverse` to obtain a proof of `l₁.reverse <+ l₂.reverse`. Thinking about which dot notations are convenient can act as a guideline
-for deciding where to place a theorem, and is, on occasion, a good reason to duplicate a theorem into multiple namespaces.
-
-### The `Std` namespace
-
-New types that are added will usually be placed in the `Std` namespace and in the `Std/` source directory, unless there are good reasons to place
-them elsewhere.
-
-Inside the `Std` namespace, all internal declarations should be `private` or else have a name component that clearly marks them as internal, preferably
-`Internal`.
-
-
-## Naming convention for data
-
-When defining data, i.e., a (possibly 0-ary) function whose codomain is not Sort u, but has type Type u for some u, it should be named in lowerCamelCase. Examples include `List.append` and `List.isPrefixOf`.
-If your data is morally fully specified by its type, then use the naming procedure for theorems described below and convert the result to lower camel case.
-
-If your function returns an `Option`, consider adding `?` as a suffix. If your function may panic, consider adding `!` as a suffix. In many cases, there will be multiple variants of a function; one returning an option, one that may panic and possibly one that takes a proof argument.
-
-## Naming algorithm for theorems and some definitions
-
-There is, in principle, a general algorithm for naming a theorem. The problem with this algorithm is that it produces very long and unwieldy names which need to be shortened. So choosing a name for a declaration can be thought of as consisting of a mechanical part and a creative part.
-
-Usually the first part is to decide which namespace the result should live in, according to the guidelines described above.
-
-Next, consider the type of your declaration as a tree. Inner nodes of this tree are function types or function applications. Leaves of the tree are 0-ary functions or bound variables.
-
-As an example, consider the following result from the standard library:
-
-```lean
-example {α : Type u} {β : Type v} [BEq α] [Hashable α] [EquivBEq α] [LawfulHashable α]
-    [Inhabited β] {m : Std.HashMap α β} {a : α} {h' : a ∈ m} : m[a]? = some (m[a]'h') :=
-  sorry
-```
-
-The correct namespace is clearly `Std.HashMap`. The corresponding tree looks like this:
-
-![](naming-tree.svg)
-
-The preferred spelling of a notation can be looked up by hovering over the notation.
-
-Now traverse the tree and build a name according to the following rules:
-
-* When encountering a function type, first turn the result type into a name, then all of the argument types from left to right, and join the names using `_of_`.
-* When encountering a function that is neither an infix notation nor a structure projection, first put the function name and then the arguments, joined by an underscore.
-* When encountering an infix notation, join the arguments using the name of the notation, separated by underscores.
-* When encountering a structure projection, proceed as for normal functions, but put the name of the projection last.
-* When encountering a name, put it in lower camel case.
-* Skip bound variables and proofs.
-* Type class arguments are also generally skipped.
-
-When encountering namespaces names, concatenate them in lower camel case.
-
-Applying this algorithm to our example yields the name `Std.HashMap.getElem?_eq_optionSome_getElem_of_mem`.
-
-From there, the name should be shortened, using the following heuristics:
-
-* The namespace of functions can be omitted if it is clear from context or if the namespace is the current one. This is almost always the case.
-* For infix operators, it is possible to leave out the RHS or the name of the notation and the RHS if they are clear from context.
-* Hypotheses can be left out if it is clear that they are required or if they appear in the conclusion.
-
-Based on this, here are some possible names for our example:
-
-1. `Std.HashMap.getElem?_eq`
-2. `Std.HashMap.getElem?_eq_of_mem`
-3. `Std.HashMap.getElem?_eq_some`
-4. `Std.HashMap.getElem?_eq_some_of_mem`
-5. `Std.HashMap.getElem?_eq_some_getElem`
-6. `Std.Hashmap.getElem?_eq_some_getElem_of_mem`
-
-Choosing a good name among these then requires considering the context of the lemma. In this case it turns out that the first four options are underspecified as there is also a lemma relating `m[a]?` and `m[a]!` which could have the same name. This leaves the last two options, the first of which is shorter, and this is how the lemma is called in the Lean standard library.
-
-Here are some additional examples:
-
-```lean
-example {x y : List α} (h : x <+: y) (hx : x ≠ []) :
-  x.head hx = y.head (h.ne_nil hx) := sorry
-```
-
-Since we have an `IsPrefix` parameter, this should live in the `List.IsPrefix` namespace, and the algorithm suggests `List.IsPrefix.head_eq_head_of_ne_nil`, which is shortened to `List.IsPrefix.head`. Note here the difference between the namespace name (`IsPrefix`) and the recommended spelling of the corresponding notation (`prefix`).
-
-```lean
-example : l₁ <+: l₂ → reverse l₁ <:+ reverse l₂ := sorry
-```
-
-Again, this result should be in the `List.IsPrefix` namespace; the algorithm suggests `List.IsPrefix.reverse_prefix_reverse`, which becomes `List.IsPrefix.reverse`.
-
-The following examples show how the traversal order often matters.
-
-```lean
-theorem Nat.mul_zero (n : Nat) : n * 0 = 0 := sorry
-theorem Nat.zero_mul (n : Nat) : 0 * n = 0 := sorry
-```
-
-Here we see that one name may be a prefix of another name:
-
-```lean
-theorem Int.mul_ne_zero {a b : Int} (a0 : a ≠ 0) (b0 : b ≠ 0) : a * b ≠ 0 := sorry
-theorem Int.mul_ne_zero_iff {a b : Int} : a * b ≠ 0 ↔ a ≠ 0 ∧ b ≠ 0 := sorry
-```
-
-It is usually a good idea to include the `iff` in a theorem name even if the name would still be unique without the name. For example,
-
-```lean
-theorem List.head?_eq_none_iff : l.head? = none ↔ l = [] := sorry
-```
-
-is a good name: if the lemma was simply called `List.head?_eq_none`, users might try to `apply` it when the goal is `l.head? = none`, leading
-to confusion.
-
-The more common you expect (or want) a theorem to be, the shorter you should try to make the name. For example, we have both
-
-```lean
-theorem Std.HashMap.getElem?_eq_none_of_contains_eq_false {a : α} : m.contains a = false → m[a]? = none := sorry
-theorem Std.HashMap.getElem?_eq_none {a : α} : ¬a ∈ m → m[a]? = none := sorry
-```
-
-As users of the hash map are encouraged to use ∈ rather than contains, the second lemma gets the shorter name.
-
-## Special cases
-
-There are certain special “keywords” that may appear in identifiers.
-
-| Keyword | Meaning | Example |
-| :---- | :---- | :---- |
-| `def` | Unfold a definition. Avoid this for public APIs. | `Nat.max_def` |
-| `refl` | Theorems of the form `a R a`, where R is a reflexive relation and `a` is an explicit parameter | `Nat.le_refl` |
-| `rfl` | Like `refl`, but with `a` implicit | `Nat.le_rfl` |
-| `irrefl` | Theorems of the form `¬a R a`, where R is an irreflexive relation | `Nat.lt_irrefl` |
-| `symm` | Theorems of the form `a R b → b R a`, where R is a symmetric relation (compare `comm` below) | `Eq.symm` |
-| `trans` | Theorems of the form `a R b → b R c → a R c`, where R is a transitive relation (R may carry data) | `Eq.trans` |
-| `antisymmm` | Theorems of the form `a R b → b R a → a = b`, where R is an antisymmetric relation | `Nat.le_antisymm` |
-| `congr` | Theorems of the form `a R b → f a S f b`, where R and S are usually equivalence relations | `Std.HashMap.mem_congr` |
-| `comm` | Theorems of the form `f a b = f b a` (compare `symm` above) | `Eq.comm`, `Nat.add_comm` |
-| `assoc` | Theorems of the form `g (f a b) c = f a (g b c)` (note the order! In most cases, we have f = g) | `Nat.add_sub_assoc` |
-| `distrib` | Theorems of the form `f (g a b) = g (f a) (f b)` | `Nat.add_left_distrib` |
-| `self` | May be used if a variable appears multiple times in the conclusion | `List.mem_cons_self` |
-| `inj` | Theorems of the form `f a = f b ↔ a = b`. | `Int.neg_inj`, `Nat.add_left_inj` |
-| `cancel` | Theorems which have one of the forms `f a = f b → a = b` or `g (f a) = a`, where `f` and `g` usually involve a binary operator | `Nat.add_sub_cancel` |
-| `cancel_iff` | Same as `inj`, but with different conventions for left and right (see below) | `Nat.add_right_cancel_iff` |
-| `ext` | Theorems of the form `f a = f b → a = b`, where `f` usually involves some kind of projection | `List.ext_getElem`
-| `mono` | Theorems of the form `a R b → f a R f b`, where `R` is a transitive relation | `List.countP_mono_left`
-
-### Left and right
-
-The keywords left and right are useful to disambiguate symmetric variants of theorems.
-
-```lean
-theorem imp_congr_left (h : a ↔ b) : (a → c) ↔ (b → c) := sorry
-theorem imp_congr_right (h : a → (b ↔ c)) : (a → b) ↔ (a → c) := sorry
-```
-
-It is not always obvious which version of a theorem should be “left” and which should be “right”.
-Heuristically, the theorem should name the side which is “more variable”, but there are exceptions. For some of the special keywords discussed in this section, there are conventions which should be followed, as laid out in the following examples:
-
-```lean
-theorem Nat.left_distrib (n m k : Nat) : n * (m + k) = n * m + n * k := sorry
-theorem Nat.right_distrib (n m k : Nat) : (n + m) * k = n * k + m * k := sorry
-theorem Nat.add_left_cancel {n m k : Nat} : n + m = n + k → m = k := sorry
-theorem Nat.add_right_cancel {n m k : Nat} : n + m = k + m → n = k := sorry
-theorem Nat.add_left_cancel_iff {m k n : Nat} : n + m = n + k ↔ m = k := sorry
-theorem Nat.add_right_cancel_iff {m k n : Nat} : m + n = k + n ↔ m = k := sorry
-theorem Nat.add_left_inj {m k n : Nat} : m + n = k + n ↔ m = k := sorry
-theorem Nat.add_right_inj {m k n : Nat} : n + m = n + k ↔ m = k := sorry
-```
-
-Note in particular that the convention is opposite for `cancel_iff` and `inj`.
-
-```lean
-theorem Nat.add_sub_self_left (a b : Nat) : (a + b) - a = b := sorry
-theorem Nat.add_sub_self_right (a b : Nat) : (a + b) - b = a := sorry
-theorem Nat.add_sub_cancel (n m : Nat) : (n + m) - m = n := sorry
-```
-
-## Primed names
-
-Avoid disambiguating variants of a concept by appending the `'` character (e.g., introducing both `BitVec.sshiftRight` and `BitVec.sshiftRight'`), as it is impossible to tell the difference without looking at the type signature, the documentation or even the code, and even if you know what the two variants are there is no way to tell which is which. Prefer descriptive pairs `BitVec.sshiftRightNat`/`BitVec.sshiftRight`.
-
-## Acronyms
-
-For acronyms which are three letters or shorter, all letters should use the same case as dictated by the convention. For example, `IO` is a correct name for a type and the name `IO.Ref` may become `IORef` when used as part of a definition name and `ioRef` when used as part of a theorem name.
-
-For acronyms which are at least four letters long, switch to lower case starting from the second letter. For example, `Json` is a correct name for a type, as is `JsonRPC`.
-
-If an acronym is typically spelled using mixed case, this mixed spelling may be used in identifiers (for example `Std.Net.IPv4Addr`).
-
-## Simp sets
-
-Simp sets centered around a conversion function should be called `source_to_target`. For example, a simp set for the `BitVec.toNat` function, which goes from `BitVec` to
-`Nat`, should be called `bitvec_to_nat`.
-
-## Variable names
-
-We make the following recommendations for variable names, but without insisting on them:
-* Simple hypotheses should be named `h`, `h'`, or using a numerical sequence `h₁`, `h₂`, etc.
-* Another common name for a simple hypothesis is `w` (for "witness").
-* `List`s should be named `l`, `l'`, `l₁`, etc, or `as`, `bs`, etc.
-  (Use of `as`, `bs` is encouraged when the lists are of different types, e.g. `as : List α` and `bs : List β`.)
-  `xs`, `ys`, `zs` are allowed, but it is better if these are reserved for `Array` and `Vector`.
-  A list of lists may be named `L`.
-* `Array`s should be named `xs`, `ys`, `zs`, although `as`, `bs` are encouraged when the arrays are of different types, e.g. `as : Array α` and `bs : Array β`.
-  An array of arrays may be named `xss`.
-* `Vector`s should be named `xs`, `ys`, `zs`, although `as`, `bs` are encouraged when the vectors are of different types, e.g. `as : Vector α n` and `bs : Vector β n`.
-  A vector of vectors may be named `xss`.
-* A common exception for `List` / `Array` / `Vector` is to use `acc` for an accumulator in a recursive function.
-* `i`, `j`, `k` are preferred for numerical indices.
-  Descriptive names such as `start`, `stop`, `lo`, and `hi` are encouraged when they increase readability.
-* `n`, `m` are preferred for sizes, e.g. in `Vector α n` or `xs.size = n`.
-* `w` is preferred for the width of a `BitVec`.

doc/std/style.md

@@ -1,522 +0,0 @@
-# Standard library style
-
-Please take some time to familiarize yourself with the stylistic conventions of
-the project and the specific part of the library you are planning to contribute
-to. While the Lean compiler may not enforce strict formatting rules,
-consistently formatted code is much easier for others to read and maintain.
-Attention to formatting is more than a cosmetic concern—it reflects the same
-level of precision and care required to meet the deeper standards of the Lean 4
-standard library.
-
-Below we will give specific formatting prescriptions for various language constructs. Note that this style guide only applies to the Lean standard library, even though some examples in the guide are taken from other parts of the Lean code base.
-
-## Basic whitespace rules
-
-Syntactic elements (like `:`, `:=`, `|`, `::`) are surrounded by single spaces, with the exception of `,` and `;`, which are followed by a space but not preceded by one. Delimiters (like `()`, `{}`) do not have spaces on the inside, with the exceptions of subtype notation and structure instance notation.
-
-Examples of correctly formatted function parameters:
-
-* `{α : Type u}`
-* `[BEq α]`
-* `(cmp : α → α → Ordering)`
-* `(hab : a = b)`
-* `{d : { l : List ((n : Nat) × Vector Nat n) // l.length % 2 = 0 }}`
-
-Examples of correctly formatted terms:
-
-* `1 :: [2, 3]`
-* `letI : Ord α := ⟨cmp⟩; True`
-* `(⟨2, 3⟩ : Nat × Nat)`
-* `((2, 3) : Nat × Nat)`
-* `{ x with fst := f (4 + f 0), snd := 4, .. }`
-* `match 1 with | 0 => 0 | _ => 0`
-* `fun ⟨a, b⟩ _ _ => by cases hab <;> apply id; rw [hbc]`
-
-Configure your editor to remove trailing whitespace. If you have set up Visual Studio Code for Lean development in the recommended way then the correct setting is applied automatically.
-
-## Splitting terms across multiple lines
-
-When splitting a term across multiple lines, increase indentation by two spaces starting from the second line. When splitting a function application, try to split at argument boundaries. If an argument itself needs to be split, increase indentation further as appropriate.
-
-When splitting at an infix operator, the operator goes at the end of the first line, not at the beginning of the second line. When splitting at an infix operator, you may or may not increase indentation depth, depending on what is more readable.
-
-When splitting an `if`-`then`-`else` expression, the `then` keyword wants to stay with the condition and the `else` keyword wants to stay with the alternative term. Otherwise, indent as if the `if` and `else` keywords were arguments to the same function.
-
-When splitting a comma-separated bracketed sequence (i.e., anonymous constructor application, list/array/vector literal, tuple) it is allowed to indent subsequent lines for alignment, but indenting by two spaces is also allowed.
-
-Do not orphan parentheses.
-
-Correct:
-```lean
-def MacroScopesView.isPrefixOf (v₁ v₂ : MacroScopesView) : Bool :=
-  v₁.name.isPrefixOf v₂.name &&
-  v₁.scopes == v₂.scopes &&
-  v₁.mainModule == v₂.mainModule &&
-  v₁.imported == v₂.imported
-```
-
-Correct:
-```lean
-theorem eraseP_eq_iff {p} {l : List α} :
-    l.eraseP p = l' ↔
-      ((∀ a ∈ l, ¬ p a) ∧ l = l') ∨
-        ∃ a l₁ l₂, (∀ b ∈ l₁, ¬ p b) ∧ p a ∧
-          l = l₁ ++ a :: l₂ ∧ l' = l₁ ++ l₂ :=
-  sorry
-```
-
-Correct:
-```lean
-example : Nat :=
-  functionWithAVeryLongNameSoThatSomeArgumentsWillNotFit firstArgument secondArgument
-    (firstArgumentWithAnEquallyLongNameAndThatFunctionDoesHaveMoreArguments firstArgument
-      secondArgument)
-    secondArgument
-```
-
-Correct:
-```lean
-theorem size_alter [LawfulBEq α] {k : α} {f : Option (β k) → Option (β k)} (h : m.WF) :
-    (m.alter k f).size =
-      if m.contains k && (f (m.get? k)).isNone then
-        m.size - 1
-      else if !m.contains k && (f (m.get? k)).isSome then
-        m.size + 1
-      else
-        m.size := by
- simp_to_raw using Raw₀.size_alter
-```
-
-Correct:
-```lean
-theorem get?_alter [LawfulBEq α] {k k' : α} {f : Option (β k) → Option (β k)} (h : m.WF) :
-    (m.alter k f).get? k' =
-      if h : k == k' then
-        cast (congrArg (Option ∘ β) (eq_of_beq h)) (f (m.get? k))
-      else m.get? k' := by
- simp_to_raw using Raw₀.get?_alter
-```
-
-Correct:
-```lean
-example : Nat × Nat :=
-  ⟨imagineThisWasALongTerm,
-   imagineThisWasAnotherLongTerm⟩
-```
-
-Correct:
-```lean
-example : Nat × Nat :=
-  ⟨imagineThisWasALongTerm,
-    imagineThisWasAnotherLongTerm⟩
-```
-
-Correct:
-```lean
-example : Vector Nat :=
-  #v[imagineThisWasALongTerm,
-     imagineThisWasAnotherLongTerm]
-```
-
-## Basic file structure
-
-Every file should start with a copyright header, imports (in the standard library, this always includes a `prelude` declaration) and a module documentation string. There should not be a blank line between the copyright header and the imports. There should be a blank line between the imports and the module documentation string.
-
-If you explicitly declare universe variables, do so at the top of the file, after the module documentation.
-
-Correct:
-```lean
-/-
-Copyright (c) 2014 Parikshit Khanna. All rights reserved.
-Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro,
-  Yury Kudryashov
--/
-prelude
-import Init.Data.List.Pairwise
-import Init.Data.List.Find
-
-/-!
-**# Lemmas about `List.eraseP` and `List.erase`.**
--/
-
-universe u u'
-```
-
-Syntax that is not supposed to be user-facing must be scoped. New public syntax must always be discussed explicitly in an RFC.
-
-## Top-level commands and declarations
-
-All top-level commands are unindented. Sectioning commands like `section` and `namespace` do not increase the indentation level.
-
-Attributes may be placed on the same line as the rest of the command or on a separate line.
-
-Multi-line declaration headers are indented by four spaces starting from the second line. The colon that indicates the type of a declaration may not be placed at the start of a line or on its own line.
-
-Declaration bodies are indented by two spaces. Short declaration bodies may be placed on the same line as the declaration type.
-
-Correct:
-```lean
-theorem eraseP_eq_iff {p} {l : List α} :
-    l.eraseP p = l' ↔
-      ((∀ a ∈ l, ¬ p a) ∧ l = l') ∨
-        ∃ a l₁ l₂, (∀ b ∈ l₁, ¬ p b) ∧ p a ∧
-          l = l₁ ++ a :: l₂ ∧ l' = l₁ ++ l₂ :=
-  sorry
-```
-
-Correct:
-```lean
-@[simp] theorem eraseP_nil : [].eraseP p = [] := rfl
-```
-
-Correct:
-```lean
-@[simp]
-theorem eraseP_nil : [].eraseP p = [] := rfl
-```
-
-### Documentation comments
-
-Note to external contributors: this is a section where the Lean style and the mathlib style are different.
-
-Declarations should be documented as required by the `docBlame` linter, which may be activated in a file using
-`set_option linter.missingDocs true` (we allow these to stay in the file).
-
-Single-line documentation comments should go on the same line as `/--`/`-/`, while multi-line documentation strings
-should have these delimiters on their own line, with the documentation comment itself unindented.
-
-Documentation comments must be written in the indicative mood. Use American orthography.
-
-Correct:
-```lean
-/-- Carries out a monadic action on each mapping in the hash map in some order. -/
-@[inline] def forM (f : (a : α) → β a → m PUnit) (b : Raw α β) : m PUnit :=
-  b.buckets.forM (AssocList.forM f)
-```
-
-Correct:
-```lean
-/--
-Monadically computes a value by folding the given function over the mappings in the hash
-map in some order.
--/
-@[inline] def foldM (f : δ → (a : α) → β a → m δ) (init : δ) (b : Raw α β) : m δ :=
-  b.buckets.foldlM (fun acc l => l.foldlM f acc) init
-```
-
-### Where clauses
-
-The `where` keyword should be unindented, and all declarations bound by it should be indented with two spaces.
-
-Blank lines before and after `where` and between declarations bound by `where` are optional and should be chosen
-to maximize readability.
-
-Correct:
-```lean
-@[simp] theorem partition_eq_filter_filter (p : α → Bool) (l : List α) :
-    partition p l = (filter p l, filter (not ∘ p) l) := by
-  simp [partition, aux]
-where
-  aux (l) {as bs} : partition.loop p l (as, bs) =
-      (as.reverse ++ filter p l, bs.reverse ++ filter (not ∘ p) l) :=
-    match l with
-    | [] => by simp [partition.loop, filter]
-    | a :: l => by cases pa : p a <;> simp [partition.loop, pa, aux, filter, append_assoc]
-```
-
-### Termination arguments
-
-The `termination_by`, `decreasing_by`, `partial_fixpoint` keywords should be unindented. The associated terms should be indented like declaration bodies.
-
-Correct:
-```lean
-@[inline] def multiShortOption (handle : Char → m PUnit) (opt : String) : m PUnit := do
-  let rec loop (p : String.Pos) := do
-    if h : opt.atEnd p then
-      return
-    else
-      handle (opt.get' p h)
-      loop (opt.next' p h)
-  termination_by opt.utf8ByteSize - p.byteIdx
-  decreasing_by
-    simp [String.atEnd] at h
-    apply Nat.sub_lt_sub_left h
-    simp [String.lt_next opt p]
-  loop ⟨1⟩
-```
-
-Correct:
-```lean
-def substrEq (s1 : String) (off1 : String.Pos) (s2 : String) (off2 : String.Pos) (sz : Nat) : Bool :=
-  off1.byteIdx + sz ≤ s1.endPos.byteIdx && off2.byteIdx + sz ≤ s2.endPos.byteIdx && loop off1 off2 { byteIdx := off1.byteIdx + sz }
-where
-  loop (off1 off2 stop1 : Pos) :=
-    if _h : off1.byteIdx < stop1.byteIdx then
-      let c₁ := s1.get off1
-      let c₂ := s2.get off2
-      c₁ == c₂ && loop (off1 + c₁) (off2 + c₂) stop1
-    else true
-  termination_by stop1.1 - off1.1
-  decreasing_by
-    have := Nat.sub_lt_sub_left _h (Nat.add_lt_add_left c₁.utf8Size_pos off1.1)
-    decreasing_tactic
-```
-
-Correct:
-```lean
-theorem div_add_mod (m n : Nat) : n * (m / n) + m % n = m := by
-  rw [div_eq, mod_eq]
-  have h : Decidable (0 < n ∧ n ≤ m) := inferInstance
-  cases h with
-  | isFalse h => simp [h]
-  | isTrue h =>
-    simp [h]
-    have ih := div_add_mod (m - n) n
-    rw [Nat.left_distrib, Nat.mul_one, Nat.add_assoc, Nat.add_left_comm, ih, Nat.add_comm, Nat.sub_add_cancel h.2]
-decreasing_by apply div_rec_lemma; assumption
-```
-
-### Deriving
-
-The `deriving` clause should be unindented.
-
-Correct:
-```lean
-structure Iterator where
-  array : ByteArray
-  idx : Nat
-deriving Inhabited
-```
-
-## Notation and Unicode
-
-We generally prefer to use notation as available. We usually prefer the Unicode versions of notations over non-Unicode alternatives.
-
-There are some rules and exceptions regarding specific notations which are listed below:
-
-* Sigma types: use `(a : α) × β a` instead of `Σ a, β a` or `Sigma β`.
-* Function arrows: use `fun a => f x` instead of `fun x ↦ f x` or `λ x => f x` or any other variant.
-
-## Language constructs
-
-### Pattern matching, induction etc.
-
-Match arms are indented at the indentation level that the match statement would have if it was on its own line. If the match is implicit, then the arms should be indented as if the match was explicitly given. The content of match arms is indented two spaces, so that it appears on the same level as the match pattern.
-
-Correct:
-```lean
-def alter [BEq α] {β : Type v} (a : α) (f : Option β → Option β) :
-    AssocList α (fun _ => β) → AssocList α (fun _ => β)
-  | nil => match f none with
-    | none => nil
-    | some b => AssocList.cons a b nil
-  | cons k v l =>
-    if k == a then
-      match f v with
-      | none => l
-      | some b => cons a b l
-    else
-      cons k v (alter a f l)
-```
-
-Correct:
-```lean
-theorem eq_append_cons_of_mem {a : α} {xs : List α} (h : a ∈ xs) :
-    ∃ as bs, xs = as ++ a :: bs ∧ a ∉ as := by
-  induction xs with
-  | nil => cases h
-  | cons x xs ih =>
-    simp at h
-    cases h with
-    | inl h => exact ⟨[], xs, by simp_all⟩
-    | inr h =>
-      by_cases h' : a = x
-      · subst h'
-        exact ⟨[], xs, by simp⟩
-      · obtain ⟨as, bs, rfl, h⟩ := ih h
-        exact ⟨x :: as, bs, rfl, by simp_all⟩
-```
-
-Aligning match arms is allowed, but not required.
-
-Correct:
-```lean
-def mkEqTrans? (h₁? h₂? : Option Expr) : MetaM (Option Expr) :=
-  match h₁?, h₂? with
-  | none, none       => return none
-  | none, some h     => return h
-  | some h, none     => return h
-  | some h₁, some h₂ => mkEqTrans h₁ h₂
-```
-
-Correct:
-```lean
-def mkEqTrans? (h₁? h₂? : Option Expr) : MetaM (Option Expr) :=
-  match h₁?, h₂? with
-  | none, none => return none
-  | none, some h => return h
-  | some h, none => return h
-  | some h₁, some h₂ => mkEqTrans h₁ h₂
-```
-
-Correct:
-```lean
-def mkEqTrans? (h₁? h₂? : Option Expr) : MetaM (Option Expr) :=
-  match h₁?, h₂? with
-  | none,    none    => return none
-  | none,    some h  => return h
-  | some h,  none    => return h
-  | some h₁, some h₂ => mkEqTrans h₁ h₂
-```
-
-### Structures
-
-Note to external contributors: this is a section where the Lean style and the mathlib style are different.
-
-When using structure instance syntax over multiple lines, the opening brace should go on the preceding line, while the closing brace should go on its own line. The rest of the syntax should be indented by one level. During structure updates, the `with` clause goes on the same line as the opening brace. Aligning at the assignment symbol is allowed but not required.
-
-Correct:
-```lean
-def addConstAsync (env : Environment) (constName : Name) (kind : ConstantKind) (reportExts := true) :
-    IO AddConstAsyncResult := do
-  let sigPromise ← IO.Promise.new
-  let infoPromise ← IO.Promise.new
-  let extensionsPromise ← IO.Promise.new
-  let checkedEnvPromise ← IO.Promise.new
-  let asyncConst := {
-    constInfo := {
-      name := constName
-      kind
-      sig := sigPromise.result
-      constInfo := infoPromise.result
-    }
-    exts? := guard reportExts *> some extensionsPromise.result
-  }
-  return {
-    constName, kind
-    mainEnv := { env with
-      asyncConsts := env.asyncConsts.add asyncConst
-      checked := checkedEnvPromise.result }
-    asyncEnv := { env with
-      asyncCtx? := some { declPrefix := privateToUserName constName.eraseMacroScopes }
-    }
-    sigPromise, infoPromise, extensionsPromise, checkedEnvPromise
-  }
-```
-
-Correct:
-```lean
-instance [Inhabited α] : Inhabited (Descr α β σ) where
-  default := {
-    name         := default
-    mkInitial    := default
-    ofOLeanEntry := default
-    toOLeanEntry := default
-    addEntry     := fun s _ => s
-  }
-```
-
-### Declaring structures
-
-When defining structure types, do not parenthesize structure fields.
-
-When declaring a structure type with a custom constructor name, put the custom name on its own line, indented like the
-structure fields, and add a documentation comment.
-
-Correct:
-
-```lean
-/--
-A bitvector of the specified width.
-
-This is represented as the underlying `Nat` number in both the runtime
-and the kernel, inheriting all the special support for `Nat`.
--/
-structure BitVec (w : Nat) where
-  /--
-  Constructs a `BitVec w` from a number less than `2^w`.
-  O(1), because we use `Fin` as the internal representation of a bitvector.
-  -/
-  ofFin ::
-  /--
-  Interprets a bitvector as a number less than `2^w`.
-  O(1), because we use `Fin` as the internal representation of a bitvector.
-  -/
-  toFin : Fin (2 ^ w)
-```
-
-## Tactic proofs
-
-Tactic proofs are the most common thing to break during any kind of upgrade, so it is important to write them in a way that minimizes the likelihood of proofs breaking and that makes it easy to debug breakages if they do occur.
-
-If there are multiple goals, either use a tactic combinator (like `all_goals`) to operate on all of them or a clearly specified subset, or use focus dots to work on goals one at a time. Using structured proofs (e.g., `induction … with`) is encouraged but not mandatory.
-
-Squeeze non-terminal `simp`s (i.e., calls to `simp` which do not close the goal). Squeezing terminal `simp`s is generally discouraged, although there are exceptions (for example if squeezing yields a noticeable performance improvement).
-
-Do not over-golf proofs in ways that are likely to lead to hard-to-debug breakage. Examples of things to avoid include complex multi-goal manipulation using lots of tactic combinators, complex uses of the substitution operator (`▸`) and clever point-free expressions (possibly involving anonymous function notation for multiple arguments).
-
-Do not under-golf proofs: for routine tasks, use the most powerful tactics available.
-
-Do not use `erw`. Avoid using `rfl` after `simp` or `rw`, as this usually indicates a missing lemma that should be used instead of `rfl`.
-
-Use `(d)simp` or `rw` instead of `delta` or `unfold`. Use `refine` instead of `refine’`. Use `haveI` and `letI` only if they are actually required.
-
-Prefer highly automated tactics (like `grind` and `omega`) over low-level proofs, unless the automated tactic requires unacceptable additional imports or has bad performance. If you decide against using a highly automated tactic, leave a comment explaining the decision.
-
-## `do` notation
-
-The `do` keyword goes on the same line as the corresponding `:=` (or `=>`, or similar). `Id.run do` should be treated as if it was a bare `do`.
-
-Use early `return` statements to reduce nesting depth and make the non-exceptional control flow of a function easier to see.
-
-Alternatives for `let` matches may be placed in the same line or in the next line, indented by two spaces. If the term that is
-being matched on is itself more than one line and there is an alternative present, consider breaking immediately after `←` and indent
-as far as necessary to ensure readability.
-
-Correct:
-```lean
-def getFunDecl (fvarId : FVarId) : CompilerM FunDecl := do
-  let some decl ← findFunDecl? fvarId | throwError "unknown local function {fvarId.name}"
-  return decl
-```
-
-Correct:
-```lean
-def getFunDecl (fvarId : FVarId) : CompilerM FunDecl := do
-  let some decl ←
-        findFunDecl? fvarId
-    | throwError "unknown local function {fvarId.name}"
-  return decl
-```
-
-Correct:
-```lean
-def getFunDecl (fvarId : FVarId) : CompilerM FunDecl := do
-  let some decl ← findFunDecl?
-      fvarId
-    | throwError "unknown local function {fvarId.name}"
-  return decl
-```
-
-Correct:
-```lean
-def tagUntaggedGoals (parentTag : Name) (newSuffix : Name) (newGoals : List MVarId) : TacticM Unit := do
-  let mctx ← getMCtx
-  let mut numAnonymous := 0
-  for g in newGoals do
-    if mctx.isAnonymousMVar g then
-      numAnonymous := numAnonymous + 1
-  modifyMCtx fun mctx => Id.run do
-    let mut mctx := mctx
-    let mut idx  := 1
-    for g in newGoals do
-      if mctx.isAnonymousMVar g then
-        if numAnonymous == 1 then
-          mctx := mctx.setMVarUserName g parentTag
-        else
-          mctx := mctx.setMVarUserName g (parentTag ++ newSuffix.appendIndexAfter idx)
-        idx := idx + 1
-    pure mctx
-```
-

doc/std/vision.md

@@ -1,98 +0,0 @@
-# The Lean 4 standard library
-
-Maintainer team (in alphabetical order): Henrik Böving, Markus Himmel
-(community contact & external contribution coordinator), Kim Morrison, Paul
-Reichert, Sofia Rodrigues.
-
-The Lean 4 standard library is a core part of the Lean distribution, providing
-essential building blocks for functional programming, verified software
-development, and software verification. Unlike the standard libraries of most
-other languages, many of its components are formally verified and can be used
-as part of verified applications.
-
-The standard library is a public API that contains the components listed in the
-standard library outline below. Not all public APIs in the Lean distribution
-are part of the standard library, and the standard library does not correspond
-to a certain directory within the Lean source repository (like `Std`). For
-example, the metaprogramming framework is not part of the standard library, but
-basic types like `True` and `Nat` are.
-
-The standard library is under active development. Our guiding principles are:
-
-* Provide comprehensive, verified building blocks for real-world software.
-* Build a public API of the highest quality with excellent internal consistency.
-* Carefully optimize components that may be used in performance-critical software.
-* Ensure smooth adoption and maintenance for users.
-* Offer excellent documentation, example projects, and guides.
-* Provide a reliable and extensible basis that libraries for software
-  development, software verification and mathematics can build on.
-
-The standard library is principally developed by the Lean FRO. Community
-contributions are welcome. If you would like to contribute, please refer to the
-call for contributions below.
-
-### Standard library outline
-
-1. Core types and operations
-   1. Basic types
-   2. Numeric types, including floating point numbers
-   3. Containers
-   4. Strings and formatting
-2. Language constructs
-   1. Ranges and iterators
-   2. Comparison, ordering, hashing and related type classes
-   3. Basic monad infrastructure
-3. Libraries
-   1. Random numbers
-   2. Dates and times
-4. Operating system abstractions
-   1. Concurrency and parallelism primitives
-   2. Asynchronous I/O
-   3. FFI helpers
-   4. Environment, file system, processes
-   5. Locales
-
-The material covered in the first three sections (core types and operations,
-language constructs and libraries) will be verified, with the exception of
-floating point numbers and the parts of the libraries that interface with the
-operating system (e.g., sources of operating system randomness or time zone
-database access).
-
-### Call for contributions
-
-Thank you for taking interest in contributing to the Lean standard library\!
-There are two main ways for community members to contribute to the Lean
-standard library: by contributing experience reports or by contributing code
-and lemmas.
-
-**If you are using Lean for software verification or verified software
-development:** hearing about your experiences using Lean and its standard
-library for software verification is extremely valuable to us. We are committed
-to building a standard library suitable for real-world applications and your
-input will directly influence the continued evolution of the Lean standard
-library. Please reach out to the standard library maintainer team via Zulip
-(either in a public thread in the \#lean4 channel or via direct message). Even
-just a link to your code helps. Thanks\!
-
-**If you have code that you believe could enhance the Lean 4 standard
-library:** we encourage you to initiate a discussion in the \#lean4 channel on
-Zulip. This is the most effective way to receive preliminary feedback on your
-contribution. The Lean standard library has a very precise scope and it has
-very high quality standards, so at the moment we are mostly interested in
-contributions that expand upon existing material rather than introducing novel
-concepts.
-
-**If you would like to contribute code to the standard library but don’t know
-what to work on:** we are always excited to meet motivated community members
-who would like to contribute, and there is always impactful work that is
-suitable for new contributors. Please reach out to Markus Himmel on Zulip to
-discuss possible contributions.
-
-As laid out in the [project-wide External Contribution
-Guidelines](../../CONTRIBUTING.md),
-PRs are much more likely to be merged if they are preceded by an RFC or if you
-discussed your planned contribution with a member of the standard library
-maintainer team. When in doubt, introducing yourself is always a good idea.
-
-All code in the standard library is expected to strictly adhere to the
-[standard library coding conventions](./style.md).

doc/string.md

@@ -0,0 +1 @@
+# Strings

doc/stringinterp.md

@@ -0,0 +1,58 @@
+# String interpolation
+
+The `s!` prefix identifies a string literal as an interpolated string.
+An interpolated string is a string literal that might contain interpolation expressions.
+When an interpolated string is resolved to a result string, items with interpolation expressions are
+replaced by the string representations of the expression results. The polymorphic method `toString` is used
+to convert the value into a string.
+
+String interpolation provides a more readable and convenient syntax to create formatted strings than
+a string composite formatting feature. The following example uses both features to produce the same output:
+
+```lean
+def name := "John"
+def age  := 28
+
+#eval IO.println s!"Hello, {name}! Are you {age} years old?"
+
+#eval IO.println ("Hello, " ++ name ++ "! Are you " ++ toString age ++ " years old?")
+
+-- `println! <interpolated-string>` is a macro for `IO.println s!<interpolated-string>`
+#eval println! "Hello, {name}! Are you {age} years old?"
+```
+
+# Structure of an interpolated string
+
+To identify a string literal as an interpolated string, prepend it with `s!`.
+Terms inside braces `{}` are ordinary expressions whose type implements the type class `ToString`.
+To include a curly brace `{` in your interpolated string, you must escape it using `\{`.
+You can nest interpolated strings inside interpolated strings.
+
+```lean
+def vals := [1, 2, 3]
+
+#eval IO.println s!"\{ vals := {vals} }"
+
+#eval IO.println s!"variables: {vals.map (fun i => s!"x_{i}")}"
+```
+
+# `ToString` instances
+
+You can define a `ToString` instance for your own datatypes.
+
+```lean
+structure Person where
+  name : String
+  age  : Nat
+
+instance : ToString Person where
+  toString : Person -> String
+    | { name := n, age := v } => s!"\{ name := {n}, age := {v} }"
+
+def person1 : Person := {
+  name := "John"
+  age  := 28
+}
+
+#eval println! "person1: {person1}"
+```

doc/struct.md

@@ -0,0 +1,227 @@
+# Structures
+
+Structure is a special case of inductive datatype. It has only one constructor and is not recursive.
+Similar to the `inductive` command, the `structure` command introduces a namespace with the same name.
+The general form is as follows:
+```
+structure <name> <parameters> <parent-structures> where
+  <constructor-name> :: <fields>
+```
+Most parts are optional. Here is our first example.
+```lean
+structure Point (α : Type u) where
+  x : α
+  y : α
+```
+In the example above, the constructor name is not provided. So, the constructor is named `mk` by Lean.
+Values of type ``Point`` are created using `Point.mk a b` or `{ x := a, y := b : Point α }`. The latter can be
+written as `{ x := a, y := b }` when the expected type is known.
+The fields of a point ``p`` are accessed using ``Point.x p`` and ``Point.y p``. You can also the more compact notation `p.x` and `p.y` as a shorthand
+for `Point.x p` and `Point.y p`.
+```lean
+# structure Point (α : Type u) where
+#  x : α
+#  y : α
+#check Point
+#check Point       -- Type u -> Type u
+#check @Point.mk   -- {α : Type u} → α → α → Point α
+#check @Point.x    -- {α : Type u} → Point α → α
+#check @Point.y    -- {α : Type u} → Point α → α
+
+#check Point.mk 10 20                   -- Point Nat
+#check { x := 10, y := 20 : Point Nat } -- Point Nat
+
+def mkPoint (a : Nat) : Point Nat :=
+  { x := a, y := a }
+
+#eval (Point.mk 10 20).x                   -- 10
+#eval (Point.mk 10 20).y                   -- 20
+#eval { x := 10, y := 20 : Point Nat }.x   -- 10
+#eval { x := 10, y := 20 : Point Nat }.y   -- 20
+
+def addXY (p : Point Nat) : Nat :=
+  p.x + p.y
+
+#eval addXY { x := 10, y := 20 }    -- 30
+```
+In the notation `{ ... }`, if the fields are in different lines, the `,` is optional.
+```lean
+# structure Point (α : Type u) where
+#  x : α
+#  y : α
+def mkPoint (a : Nat) : Point Nat := {
+  x := a
+  y := a
+}
+```
+You can also use `where` instead of `:= { ... }`.
+```lean
+# structure Point (α : Type u) where
+#  x : α
+#  y : α
+def mkPoint (a : Nat) : Point Nat where
+  x := a
+  y := a
+```
+
+Here are some simple theorems about our `Point` type.
+```lean
+# structure Point (α : Type u) where
+#  x : α
+#  y : α
+theorem ex1 (a b : α) : (Point.mk a b).x = a :=
+  rfl
+
+theorem ex2 (a b : α) : (Point.mk a b).y = b :=
+  rfl
+
+theorem ex3 (a b : α) : Point.mk a b = { x := a, y := b } :=
+  rfl
+```
+
+The dot notation is convenient not just for accessing the projections of a structure,
+but also for applying functions defined in a namespace with the same name.
+If ``p`` has type ``Point``, the expression ``p.foo`` is interpreted as ``Point.foo p``,
+assuming that the first argument to ``foo`` has type ``Point``.
+The expression ``p.add q`` is therefore shorthand for ``Point.add p q`` in the example below.
+```lean
+structure Point (α : Type u) where
+  x : α
+  y : α
+
+def Point.add (p q : Point Nat) : Point Nat :=
+  { x := p.x + q.x, y := p.y + q.y }
+
+def p : Point Nat := Point.mk 1 2
+def q : Point Nat := Point.mk 3 4
+
+#eval (p.add q).x  -- 4
+#eval (p.add q).y  -- 6
+```
+
+After we introduce type classes, we show how to define a function like ``add`` so that
+it works generically for elements of ``Point α`` rather than just ``Point Nat``,
+assuming ``α`` has an associated addition operation.
+
+More generally, given an expression ``p.foo x y z``, Lean will insert ``p`` at the first argument to ``foo`` of type ``Point``.
+For example, with the definition of scalar multiplication below, ``p.smul 3`` is interpreted as ``Point.smul 3 p``.
+
+```lean
+structure Point (α : Type u) where
+  x : α
+  y : α
+
+def Point.smul (n : Nat) (p : Point Nat) :=
+  Point.mk (n * p.x) (n * p.y)
+
+def p : Point Nat :=
+  Point.mk 1 2
+
+#eval (p.smul 3).x -- 3
+#eval (p.smul 3).y -- 6
+```
+
+##  Inheritance
+
+We can *extend* existing structures by adding new fields. This feature allows us to simulate a form of *inheritance*.
+
+```lean
+structure Point (α : Type u) where
+  x : α
+  y : α
+
+inductive Color where
+  | red
+  | green
+  | blue
+
+structure ColorPoint (α : Type u) extends Point α where
+  color : Color
+
+#check { x := 10, y := 20, color := Color.red : ColorPoint Nat }
+-- { toPoint := { x := 10, y := 20 }, color := Color.red }
+```
+The output for the `check` command above suggests how Lean encoded inheritance and multiple inheritance.
+Lean uses fields to each parent structure.
+
+```lean
+structure Foo where
+  x : Nat
+  y : Nat
+
+structure Boo where
+  w : Nat
+  z : Nat
+
+structure Bla extends Foo, Boo where
+  bit : Bool
+
+#check Bla.mk -- Foo → Boo → Bool → Bla
+#check Bla.mk { x := 10, y := 20 } { w := 30, z := 40 } true
+#check { x := 10, y := 20, w := 30, z := 40, bit := true : Bla }
+#check { toFoo := { x := 10, y := 20 },
+         toBoo := { w := 30, z := 40 },
+         bit := true : Bla }
+
+theorem ex :
+    Bla.mk { x := x, y := y } { w := w, z := z } b
+    =
+    { x := x, y := y, w := w, z := z, bit := b } :=
+  rfl
+```
+
+## Default field values
+
+You can assign default value to fields when declaring a new structure.
+```lean
+inductive MessageSeverity
+  | error | warning
+
+structure Message where
+  fileName : String
+  pos      : Option Nat      := none
+  severity : MessageSeverity := MessageSeverity.error
+  caption  : String          := ""
+  data     : String
+
+def msg1 : Message :=
+  { fileName := "foo.lean", data := "failed to import file" }
+
+#eval msg1.pos      -- none
+#eval msg1.fileName -- "foo.lean"
+#eval msg1.caption  -- ""
+```
+When extending a structure, you can not only add new fields, but provide new default values for existing fields.
+```lean
+# inductive MessageSeverity
+#  | error | warning
+# structure Message where
+#  fileName : String
+#  pos      : Option Nat      := none
+#  severity : MessageSeverity := MessageSeverity.error
+#  caption  : String          := ""
+#  data     : String
+structure MessageExt extends Message where
+  timestamp : Nat
+  caption   := "extended" -- new default value for field `caption`
+
+def msg2 : MessageExt where
+  fileName  := "bar.lean"
+  data      := "error at initialization"
+  timestamp := 10
+
+#eval msg2.fileName  -- "bar.lean"
+#eval msg2.timestamp -- 10
+#eval msg2.caption   -- "extended"
+```
+
+## Updating structure fields
+
+Structure fields can be updated using `{ <struct-val> with <field> := <new-value>, ... }`:
+
+```lean
+# structure Point (α : Type u) where
+#  x : α
+#  y : α
+def incrementX (p : Point Nat) : Point Nat := { p with x := p.x + 1 }
+```

doc/syntax.md

@@ -0,0 +1,20 @@
+# Syntax Extensions
+
+Lean's syntax can be extended and customized
+by users at every level, ranging from [basic "mixfix" notations](./notation.md)
+over [macro transformers](./macro_overview.md) to
+[type-aware elaborators](./elaborators.md). In fact, all builtin syntax is parsed and
+processed using the same mechanisms and APIs open to users. In this
+section, we will describe and explain the various extension points.
+Significant syntax extensions already builtin into Lean such as the
+[`do` notation](./do.md) are described in subsections.
+
+While introducing new syntax is a relatively rare feature in
+programming languages and sometimes even frowned upon because of its
+potential to obscure code, it is an invaluable tool in formalization
+for expressing established conventions and notations of the respective
+field succinctly in code. Going beyond basic notations, Lean's ability
+to factor out common boilerplate code into (well-behaved) macros and
+to embed entire custom domain specific languages (DSLs) to textually
+encode subproblems efficiently and readably can be of great benefit to
+both programmers and proof engineers alike.

doc/task.md

@@ -0,0 +1 @@
+# Task

doc/thunk.md

@@ -0,0 +1,104 @@
+# Thunks, Tasks, and Threads
+
+A `Thunk` is defined as
+```lean
+# namespace Ex
+# universe u
+structure Thunk (α : Type u) : Type u where
+  fn : Unit → α
+# end Ex
+```
+A `Thunk` encapsulates a computation without evaluation.
+That is, a `Thunk` stores the way of how the value would be computed.
+The Lean runtime has special support for `Thunk`s. It caches their values
+after they are computed for the first time. This feature is useful for implementing
+data structures such as lazy lists.
+Here is a small example using a `Thunk`.
+```lean
+def fib : Nat → Nat
+  | 0   => 0
+  | 1   => 1
+  | x+2 => fib (x+1) + fib x
+
+def f (c : Bool) (x : Thunk Nat) : Nat :=
+  if c then
+    x.get
+  else
+    0
+
+def g (c : Bool) (x : Nat) : Nat :=
+  f c (Thunk.mk (fun _ => fib x))
+
+#eval g false 1000
+```
+The function `f` above uses `x.get` to evaluate the `Thunk` `x`.
+The expression `Thunk.mk (fun _ => fib x)` creates a `Thunk` for computing `fib x`.
+Note that `fib` is a very naive function for computing the Fibonacci numbers,
+and it would an unreasonable amount of time to compute `fib 1000`. However, our
+test terminates instantaneously because the `Thunk` is not evaluated when `c` is `false`.
+Lean has a builtin coercion from any type `a` to `Thunk a`. You write the function `g` above as
+```lean
+# def fib : Nat → Nat
+#  | 0   => 0
+#  | 1   => 1
+#  | x+2 => fib (x+1) + fib x
+# def f (c : Bool) (x : Thunk Nat) : Nat :=
+#  if c then
+#    x.get
+#  else
+#    0
+def g (c : Bool) (x : Nat) : Nat :=
+  f c (fib x)
+
+#eval g false 1000
+```
+In the following example, we use the macro `dbg_trace` to demonstrate
+that the Lean runtime caches the value computed by a `Thunk`.
+We remark that the macro `dbg_trace` should be used for debugging purposes
+only.
+```lean
+def add1 (x : Nat) : Nat :=
+  dbg_trace "add1: {x}"
+  x + 1
+
+def double (x : Thunk Nat) : Nat :=
+  x.get + x.get
+
+def triple (x : Thunk Nat) : Nat :=
+  double x + x.get
+
+def test (x : Nat) : Nat :=
+  triple (add1 x)
+
+#eval test 2
+-- add1: 2
+-- 9
+```
+Note that the message `add1: 2` is printed only once.
+Now, consider the same example using `Unit -> Nat` instead of `Thunk Nat`.
+```lean
+def add1 (x : Nat) : Nat :=
+  dbg_trace "add1: {x}"
+  x + 1
+
+def double (x : Unit -> Nat) : Nat :=
+  x () + x ()
+
+def triple (x : Unit -> Nat) : Nat :=
+  double x + x ()
+
+def test (x : Nat) : Nat :=
+  triple (fun _ => add1 x)
+
+#eval test 2
+-- add1: 2
+-- add1: 2
+-- 9
+```
+Now, the message `add1: 2` is printed twice.
+It may come as a surprise that it was printed twice instead of three times.
+As we pointed out, `dbg_trace` is a macro used for debugging purposes only,
+and `add1` is still considered to be a pure function.
+The Lean compiler performs common subexpression elimination when compiling `double`,
+and the produced code for `double` executes `x ()` only once instead of twice.
+This transformation is safe because `x : Unit -> Nat` is pure.

doc/typeclass.md

@@ -0,0 +1,457 @@
+# Type classes
+
+Typeclasses were introduced as a principled way of enabling
+ad-hoc polymorphism in functional programming languages. We first observe that it
+would be easy to implement an ad-hoc polymorphic function (such as addition) if the
+function simply took the type-specific implementation of addition as an argument
+and then called that implementation on the remaining arguments. For example,
+suppose we declare a structure in Lean to hold implementations of addition
+```lean
+# namespace Ex
+structure Add (a : Type) where
+  add : a -> a -> a
+
+#check @Add.add
+-- Add.add : {a : Type} → Add a → a → a → a
+# end Ex
+```
+In the above Lean code, the field `add` has type
+`Add.add : {α : Type} → Add α → α → α → α`
+where the curly braces around the type `a` mean that it is an implicit argument.
+We could implement `double` by
+```lean
+# namespace Ex
+# structure Add (a : Type) where
+#  add : a -> a -> a
+def double (s : Add a) (x : a) : a :=
+  s.add x x
+
+#eval double { add := Nat.add } 10
+-- 20
+
+#eval double { add := Nat.mul } 10
+-- 100
+
+#eval double { add := Int.add } 10
+-- 20
+
+# end Ex
+```
+Note that you can double a natural number `n` by `double { add := Nat.add } n`.
+Of course, it would be highly cumbersome for users to manually pass the
+implementations around in this way.
+Indeed, it would defeat most of the potential benefits of ad-hoc
+polymorphism.
+
+The main idea behind typeclasses is to make arguments such as `Add a` implicit,
+and to use a database of user-defined instances to synthesize the desired instances
+automatically through a process known as typeclass resolution. In Lean, by changing
+`structure` to `class` in the example above, the type of `Add.add` becomes
+```lean
+# namespace Ex
+class Add (a : Type) where
+  add : a -> a -> a
+
+#check @Add.add
+-- Add.add : {a : Type} → [self : Add a] → a → a → a
+# end Ex
+```
+where the square brackets indicate that the argument of type `Add a` is *instance implicit*,
+i.e. that it should be synthesized using typeclass resolution. This version of
+`add` is the Lean analogue of the Haskell term `add :: Add a => a -> a -> a`.
+Similarly, we can register an instance by
+```lean
+# namespace Ex
+# class Add (a : Type) where
+#  add : a -> a -> a
+instance : Add Nat where
+  add := Nat.add
+
+# end Ex
+```
+Then for `n : Nat` and `m : Nat`, the term `Add.add n m` triggers typeclass resolution with the goal
+of `Add Nat`, and typeclass resolution will synthesize the instance above. In
+general, instances may depend on other instances in complicated ways. For example,
+you can declare an (anonymous) instance stating that if `a` has addition, then `Array a`
+has addition:
+```lean
+instance [Add a] : Add (Array a) where
+  add x y := Array.zipWith x y (· + ·)
+
+#eval Add.add #[1, 2] #[3, 4]
+-- #[4, 6]
+
+#eval #[1, 2] + #[3, 4]
+-- #[4, 6]
+```
+Note that `x + y` is notation for `Add.add x y` in Lean.
+
+The example above demonstrates how type classes are used to overload notation.
+Now, we explore another application. We often need an arbitrary element of a given type.
+Recall that types may not have any elements in Lean.
+It often happens that we would like a definition to return an arbitrary element in a "corner case."
+For example, we may like the expression ``head xs`` to be of type ``a`` when ``xs`` is of type ``List a``.
+Similarly, many theorems hold under the additional assumption that a type is not empty.
+For example, if ``a`` is a type, ``exists x : a, x = x`` is true only if ``a`` is not empty.
+The standard library defines a type class ``Inhabited`` to enable type class inference to infer a
+"default" or "arbitrary" element of an inhabited type.
+Let us start with the first step of the program above, declaring an appropriate class:
+
+```lean
+# namespace Ex
+class Inhabited (a : Sort u) where
+  default : a
+
+#check @Inhabited.default
+-- Inhabited.default : {a : Sort u} → [self : Inhabited a] → a
+# end Ex
+```
+Note `Inhabited.default` doesn't have any explicit argument.
+
+An element of the class ``Inhabited a`` is simply an expression of the form ``Inhabited.mk x``, for some element ``x : a``.
+The projection ``Inhabited.default`` will allow us to "extract" such an element of ``a`` from an element of ``Inhabited a``.
+Now we populate the class with some instances:
+
+```lean
+# namespace Ex
+# class Inhabited (a : Sort _) where
+#  default : a
+instance : Inhabited Bool where
+  default := true
+
+instance : Inhabited Nat where
+  default := 0
+
+instance : Inhabited Unit where
+  default := ()
+
+instance : Inhabited Prop where
+  default := True
+
+#eval (Inhabited.default : Nat)
+-- 0
+
+#eval (Inhabited.default : Bool)
+-- true
+# end Ex
+```
+You can use the command `export` to create the alias `default` for `Inhabited.default`
+```lean
+# namespace Ex
+# class Inhabited (a : Sort _) where
+#  default : a
+# instance : Inhabited Bool where
+#  default := true
+# instance : Inhabited Nat where
+#  default := 0
+# instance : Inhabited Unit where
+#  default := ()
+# instance : Inhabited Prop where
+#  default := True
+export Inhabited (default)
+
+#eval (default : Nat)
+-- 0
+
+#eval (default : Bool)
+-- true
+# end Ex
+```
+
+## Chaining Instances
+
+If that were the extent of type class inference, it would not be all that impressive;
+it would be simply a mechanism of storing a list of instances for the elaborator to find in a lookup table.
+What makes type class inference powerful is that one can *chain* instances. That is,
+an instance declaration can in turn depend on an implicit instance of a type class.
+This causes class inference to chain through instances recursively, backtracking when necessary, in a Prolog-like search.
+
+For example, the following definition shows that if two types ``a`` and ``b`` are inhabited, then so is their product:
+```lean
+instance [Inhabited a] [Inhabited b] : Inhabited (a × b) where
+  default := (default, default)
+```
+With this added to the earlier instance declarations, type class instance can infer, for example, a default element of ``Nat × Bool``:
+```lean
+# namespace Ex
+# class Inhabited (a : Sort u) where
+#  default : a
+# instance : Inhabited Bool where
+#  default := true
+# instance : Inhabited Nat where
+#  default := 0
+# opaque default [Inhabited a] : a :=
+#  Inhabited.default
+instance [Inhabited a] [Inhabited b] : Inhabited (a × b) where
+  default := (default, default)
+
+#eval (default : Nat × Bool)
+-- (0, true)
+# end Ex
+```
+Similarly, we can inhabit type function with suitable constant functions:
+```lean
+# namespace Ex
+# class Inhabited (a : Sort u) where
+#  default : a
+# opaque default [Inhabited a] : a :=
+#  Inhabited.default
+instance [Inhabited b] : Inhabited (a -> b) where
+  default := fun _ => default
+# end Ex
+```
+As an exercise, try defining default instances for other types, such as `List` and `Sum` types.
+
+The Lean standard library contains the definition `inferInstance`. It has type `{α : Sort u} → [i : α] → α`,
+and is useful for triggering the type class resolution procedure when the expected type is an instance.
+```lean
+#check (inferInstance : Inhabited Nat) -- Inhabited Nat
+
+def foo : Inhabited (Nat × Nat) :=
+  inferInstance
+
+theorem ex : foo.default = (default, default) :=
+  rfl
+```
+You can use the command `#print` to inspect how simple `inferInstance` is.
+```lean
+#print inferInstance
+```
+
+## ToString
+
+The polymorphic method `toString` has type `{α : Type u} → [ToString α] → α → String`. You implement the instance
+for your own types and use chaining to convert complex values into strings. Lean comes with `ToString` instances
+for most builtin types.
+```lean
+structure Person where
+  name : String
+  age  : Nat
+
+instance : ToString Person where
+  toString p := p.name ++ "@" ++ toString p.age
+
+#eval toString { name := "Leo", age := 542 : Person }
+#eval toString ({ name := "Daniel", age := 18 : Person }, "hello")
+```
+## Numerals
+
+Numerals are polymorphic in Lean. You can use a numeral (e.g., `2`) to denote an element of any type that implements
+the type class `OfNat`.
+```lean
+structure Rational where
+  num : Int
+  den : Nat
+  inv : den ≠ 0
+
+instance : OfNat Rational n where
+  ofNat := { num := n, den := 1, inv := by decide }
+
+instance : ToString Rational where
+  toString r := s!"{r.num}/{r.den}"
+
+#eval (2 : Rational) -- 2/1
+
+#check (2 : Rational) -- Rational
+#check (2 : Nat)      -- Nat
+```
+Lean elaborate the terms `(2 : Nat)` and `(2 : Rational)` as
+`OfNat.ofNat Nat 2 (instOfNatNat 2)` and
+`OfNat.ofNat Rational 2 (instOfNatRational 2)` respectively.
+We say the numerals `2` occurring in the elaborated terms are *raw* natural numbers.
+You can input the raw natural number `2` using the macro `nat_lit 2`.
+```lean
+#check nat_lit 2  -- Nat
+```
+Raw natural numbers are *not* polymorphic.
+
+The `OfNat` instance is parametric on the numeral. So, you can define instances for particular numerals.
+The second argument is often a variable as in the example above, or a *raw* natural number.
+```lean
+class Monoid (α : Type u) where
+  unit : α
+  op   : α → α → α
+
+instance [s : Monoid α] : OfNat α (nat_lit 1) where
+  ofNat := s.unit
+
+def getUnit [Monoid α] : α :=
+  1
+```
+
+Because many users were forgetting the `nat_lit` when defining `OfNat` instances, Lean also accepts `OfNat` instance
+declarations not using `nat_lit`. Thus, the following is also accepted.
+```lean
+class Monoid (α : Type u) where
+  unit : α
+  op   : α → α → α
+
+instance [s : Monoid α] : OfNat α 1 where
+  ofNat := s.unit
+
+def getUnit [Monoid α] : α :=
+  1
+```
+
+## Output parameters
+
+By default, Lean only tries to synthesize an instance `Inhabited T` when the term `T` is known and does not
+contain missing parts. The following command produces the error
+"failed to create type class instance for `Inhabited (Nat × ?m.1499)`" because the type has a missing part (i.e., the `_`).
+```lean
+# -- FIXME: should fail
+#check (inferInstance : Inhabited (Nat × _))
+```
+You can view the parameter of the type class `Inhabited` as an *input* value for the type class synthesizer.
+When a type class has multiple parameters, you can mark some of them as output parameters.
+Lean will start type class synthesizer even when these parameters have missing parts.
+In the following example, we use output parameters to define a *heterogeneous* polymorphic
+multiplication.
+```lean
+# namespace Ex
+class HMul (α : Type u) (β : Type v) (γ : outParam (Type w)) where
+  hMul : α → β → γ
+
+export HMul (hMul)
+
+instance : HMul Nat Nat Nat where
+  hMul := Nat.mul
+
+instance : HMul Nat (Array Nat) (Array Nat) where
+  hMul a bs := bs.map (fun b => hMul a b)
+
+#eval hMul 4 3           -- 12
+#eval hMul 4 #[2, 3, 4]  -- #[8, 12, 16]
+# end Ex
+```
+The parameters `α` and `β` are considered input parameters and `γ` an output one.
+Given an application `hMul a b`, after types of `a` and `b` are known, the type class
+synthesizer is invoked, and the resulting type is obtained from the output parameter `γ`.
+In the example above, we defined two instances. The first one is the homogeneous
+multiplication for natural numbers. The second is the scalar multiplication for arrays.
+Note that, you chain instances and generalize the second instance.
+```lean
+# namespace Ex
+class HMul (α : Type u) (β : Type v) (γ : outParam (Type w)) where
+  hMul : α → β → γ
+
+export HMul (hMul)
+
+instance : HMul Nat Nat Nat where
+  hMul := Nat.mul
+
+instance : HMul Int Int Int where
+  hMul := Int.mul
+
+instance [HMul α β γ] : HMul α (Array β) (Array γ) where
+  hMul a bs := bs.map (fun b => hMul a b)
+
+#eval hMul 4 3                    -- 12
+#eval hMul 4 #[2, 3, 4]           -- #[8, 12, 16]
+#eval hMul (-2) #[3, -1, 4]       -- #[-6, 2, -8]
+#eval hMul 2 #[#[2, 3], #[0, 4]]  -- #[#[4, 6], #[0, 8]]
+# end Ex
+```
+You can use our new scalar array multiplication instance on arrays of type `Array β`
+with a scalar of type `α` whenever you have an instance `HMul α β γ`.
+In the last `#eval`, note that the instance was used twice on an array of arrays.
+
+## Default instances
+
+In the class `HMul`, the parameters `α` and `β` are treated as input values.
+Thus, type class synthesis only starts after these two types are known. This may often
+be too restrictive.
+```lean
+# namespace Ex
+class HMul (α : Type u) (β : Type v) (γ : outParam (Type w)) where
+  hMul : α → β → γ
+
+export HMul (hMul)
+
+instance : HMul Int Int Int where
+  hMul := Int.mul
+
+def xs : List Int := [1, 2, 3]
+
+# -- TODO: fix error message
+-- Error "failed to create type class instance for HMul Int ?m.1767 (?m.1797 x)"
+-- #check fun y => xs.map (fun x => hMul x y)
+# end Ex
+```
+The instance `HMul` is not synthesized by Lean because the type of `y` has not been provided.
+However, it is natural to assume that the type of `y` and `x` should be the same in
+this kind of situation. We can achieve exactly that using *default instances*.
+```lean
+# namespace Ex
+class HMul (α : Type u) (β : Type v) (γ : outParam (Type w)) where
+  hMul : α → β → γ
+
+export HMul (hMul)
+
+@[default_instance]
+instance : HMul Int Int Int where
+  hMul := Int.mul
+
+def xs : List Int := [1, 2, 3]
+
+#check fun y => xs.map (fun x => hMul x y)  -- Int -> List Int
+# end Ex
+```
+By tagging the instance above with the attribute `default_instance`, we are instructing Lean
+to use this instance on pending type class synthesis problems.
+The actual Lean implementation defines homogeneous and heterogeneous classes for arithmetical operators.
+Moreover, `a+b`, `a*b`, `a-b`, `a/b`, and `a%b` are notations for the heterogeneous versions.
+The instance `OfNat Nat n` is the default instance (with priority `100`) for the `OfNat` class. This is why the numeral
+`2` has type `Nat` when the expected type is not known. You can define default instances with higher
+priority to override the builtin ones.
+```lean
+structure Rational where
+  num : Int
+  den : Nat
+  inv : den ≠ 0
+
+@[default_instance 200]
+instance : OfNat Rational n where
+  ofNat := { num := n, den := 1, inv := by decide }
+
+instance : ToString Rational where
+  toString r := s!"{r.num}/{r.den}"
+
+#check 2 -- Rational
+```
+Priorities are also useful to control the interaction between different default instances.
+For example, suppose `xs` has type `α`, when elaboration `xs.map (fun x => 2 * x)`, we want the homogeneous instance for multiplication
+to have higher priority than the default instance for `OfNat`. This is particularly important when we have implemented only the instance
+`HMul α α α`, and did not implement `HMul Nat α α`.
+Now, we reveal how the notation `a*b` is defined in Lean.
+```lean
+# namespace Ex
+class OfNat (α : Type u) (n : Nat) where
+  ofNat : α
+
+@[default_instance]
+instance (n : Nat) : OfNat Nat n where
+  ofNat := n
+
+class HMul (α : Type u) (β : Type v) (γ : outParam (Type w)) where
+  hMul : α → β → γ
+
+class Mul (α : Type u) where
+  mul : α → α → α
+
+@[default_instance 10]
+instance [Mul α] : HMul α α α where
+  hMul a b := Mul.mul a b
+
+infixl:70 " * "  => HMul.hMul
+# end Ex
+```
+The `Mul` class is convenient for types that only implement the homogeneous multiplication.
+
+## Scoped Instances
+
+TODO
+
+## Local Instances
+
+TODO

doc/uint.md

@@ -0,0 +1 @@
+# Fixed precision unsigned integers

doc/unifhint.md

@@ -0,0 +1,5 @@
+# Unification Hints
+
+
+
+TODO

flake.lock

@@ -67,30 +67,12 @@
         "type": "github"
       }
     },
-    "nixpkgs-older": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1523316493,
-        "narHash": "sha256-5qJS+i5ECICPAKA6FhPLIWkhPKDnOZsZbh2PHYF1Kbs=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "0b307aa73804bbd7a7172899e59ae0b8c347a62d",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "0b307aa73804bbd7a7172899e59ae0b8c347a62d",
-        "type": "github"
-      }
-    },
     "root": {
       "inputs": {
         "flake-utils": "flake-utils",
         "nixpkgs": "nixpkgs",
         "nixpkgs-cadical": "nixpkgs-cadical",
-        "nixpkgs-old": "nixpkgs-old",
-        "nixpkgs-older": "nixpkgs-older"
+        "nixpkgs-old": "nixpkgs-old"
       }
     },
     "systems": {

flake.nix

@@ -5,20 +5,17 @@
   # old nixpkgs used for portable release with older glibc (2.27)
   inputs.nixpkgs-old.url = "github:NixOS/nixpkgs/nixos-19.03";
   inputs.nixpkgs-old.flake = false;
-  # old nixpkgs used for portable release with older glibc (2.26)
-  inputs.nixpkgs-older.url = "github:NixOS/nixpkgs/0b307aa73804bbd7a7172899e59ae0b8c347a62d";
-  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 = { self, nixpkgs, nixpkgs-old, flake-utils, ... }@inputs: flake-utils.lib.eachDefaultSystem (system:
     let
-      pkgs = import inputs.nixpkgs { inherit system; };
+      pkgs = import nixpkgs { inherit system; };
       # An old nixpkgs for creating releases with an old glibc
-      pkgsDist-old = import inputs.nixpkgs-older { inherit system; };
+      pkgsDist-old = import nixpkgs-old { 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"; };
+      pkgsDist-old-aarch = import 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
@@ -31,7 +28,7 @@
           stdenv = pkgs.overrideCC pkgs.stdenv lean-packages.llvmPackages.clang;
         } ({
           buildInputs = with pkgs; [
-            cmake gmp libuv ccache cadical pkg-config
+            cmake gmp libuv ccache cadical
             lean-packages.llvmPackages.llvm  # llvm-symbolizer for asan/lsan
             gdb
             tree  # for CI

nix/bootstrap.nix

@@ -1,12 +1,12 @@
 { src, debug ? false, stage0debug ? false, extraCMakeFlags ? [],
-  stdenv, lib, cmake, pkg-config, gmp, libuv, cadical, git, gnumake, bash, buildLeanPackage, writeShellScriptBin, runCommand, symlinkJoin, lndir, perl, gnused, darwin, llvmPackages, linkFarmFromDrvs,
+  stdenv, lib, cmake, gmp, libuv, cadical, git, gnumake, bash, buildLeanPackage, writeShellScriptBin, runCommand, symlinkJoin, lndir, perl, gnused, darwin, llvmPackages, linkFarmFromDrvs,
   ... } @ args:
 with builtins;
 lib.warn "The Nix-based build is deprecated" rec {
   inherit stdenv;
   sourceByRegex = p: rs: lib.sourceByRegex p (map (r: "(/src/)?${r}") rs);
   buildCMake = args: stdenv.mkDerivation ({
-    nativeBuildInputs = [ cmake pkg-config ];
+    nativeBuildInputs = [ cmake ];
     buildInputs = [ gmp libuv llvmPackages.llvm ];
     # https://github.com/NixOS/nixpkgs/issues/60919
     hardeningDisable = [ "all" ];

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`.

script/mathlib-bench

@@ -1,12 +0,0 @@
-#! /bin/env bash
-# Open a Mathlib4 PR for benchmarking a given Lean 4 PR
-
-set -euo pipefail
-
-[ $# -eq 1 ] || (echo "usage: $0 <lean4 PR #>"; exit 1)
-
-LEAN_PR=$1
-PR_RESPONSE=$(gh api repos/leanprover-community/mathlib4/pulls -X POST -f head=lean-pr-testing-$LEAN_PR -f base=nightly-testing -f title="leanprover/lean4#$LEAN_PR benchmarking" -f draft=true -f body="ignore me")
-PR_NUMBER=$(echo "$PR_RESPONSE" | jq '.number')
-echo "opened https://github.com/leanprover-community/mathlib4/pull/$PR_NUMBER"
-gh api repos/leanprover-community/mathlib4/issues/$PR_NUMBER/comments -X POST -f body="!bench" > /dev/null

script/prepare-llvm-linux.sh

@@ -63,8 +63,8 @@ else
 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'"
+echo -n " -DLEANC_INTERNAL_FLAGS='-nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang"
+echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-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'"
 # 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