doc: commit conventions and Mathlib CI

Users have requested toolchain tags on `lean4-cli`, so let's add it to
the release checklist to make sure these get added regularly.

Previously, `lean4-cli` has used more complicated tags, but going
forward we're going to just use the simple `v4.16.0` style tags, with no
repository-specific versioning.

---------

Co-authored-by: Markus Himmel <markus@lean-fro.org>

.github/workflows/ci.yml

@@ -244,21 +244,21 @@ jobs:
                 "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"])

README.md

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

doc/SUMMARY.md

@@ -13,61 +13,13 @@
   - [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)
-
-# Language Manual
-<!-- - [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)
+  - [Syntax 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)
+
+# Language Manual
+
+- [The Lean Reference Manual](./reference.md)
 
 # Other
 

doc/array.md

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

@@ -1,47 +0,0 @@
-## 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 Manual"
+title = "Lean Documentation Overview"
 
 [build]
 build-dir = "out"

doc/builtintypes.md

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

@@ -1,11 +0,0 @@
-# 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/decltypes.md

@@ -1,29 +0,0 @@
-# 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/commit_convention.md

@@ -33,6 +33,9 @@ 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"
@@ -44,6 +47,7 @@ Format of the commit message
  - 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:
 
@@ -60,17 +64,21 @@ 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',
-but contains
+kernel. They are implemented in the file 'library/printer.cpp'.
 
-    expr a;
-    ...
-    std::cout << a << "\n";
-    ...
+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";
+...
+```
 
 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,8 +49,9 @@ 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 `α`.
-* `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`).
+  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`).
 * 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.

doc/dev/index.md

@@ -80,3 +80,10 @@ 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,11 +5,6 @@ See below for the checklist for release candidates.
 
 We'll use `v4.6.0` as the intended release version as a running example.
 
-- One week before the planned release, ensure that
-  (1) someone has written the release notes and
-  (2) someone has written the first draft of the release blog post.
-  If there is any material in `./releases_drafts/` on the `releases/v4.6.0` branch, then the release notes are not done.
-  (See the section "Writing the release notes".)
 - `git checkout releases/v4.6.0`
   (This branch should already exist, from the release candidates.)
 - `git pull`
@@ -42,16 +37,32 @@ 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:
-    - [lean4checker](https://github.com/leanprover/lean4checker)
-      - No dependencies
-      - Toolchain bump PR
-      - Create and push the tag
-      - Merge the tag into `stable`
     - [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`
+    - [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
+    - [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:
@@ -66,27 +77,20 @@ 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`, `import-graph`
       - Toolchain bump PR notes:
         - 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. 
+          `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`.
@@ -98,6 +102,7 @@ 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 `scripts/release_checklist.py v4.6.0` 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`
@@ -139,16 +144,13 @@ 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.
+- 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.
   - `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.
@@ -248,15 +250,12 @@ Please read https://leanprover-community.github.io/contribute/tags_and_branches.
 
 # Writing the release notes
 
-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:
+Release notes are automatically generated from the commit history, using `script/release_notes.py`.
 
-* 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.
+Run this as `script/release_notes.py v4.6.0`, where `v4.6.0` is the *previous* release version. 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`.
+
+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.
 
-This section will be updated when the next release notes are written (for `v4.10.0`).

doc/do.md

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

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

@@ -1,190 +0,0 @@
-# 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/flake.nix

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

doc/float.md

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

doc/functions.md

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

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

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

@@ -1,37 +0,0 @@
-# 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/list.md

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

doc/macro_overview.md

@@ -1,393 +0,0 @@
-
-# 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/monads/.gitignore

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

doc/monads/applicatives.lean

@@ -1,334 +0,0 @@
-/-!
-# 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

@@ -1,178 +0,0 @@
-/-!
-# 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

@@ -1,227 +0,0 @@
-/-!
-# 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

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

@@ -1,322 +0,0 @@
-/-!
-# 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

@@ -1,300 +0,0 @@
-/-!
-# 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

@@ -1,199 +0,0 @@
-/-!
-# 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 (types := true) 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

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

@@ -1,316 +0,0 @@
-/-!
-# 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

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

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

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

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

doc/organization.md

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

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

@@ -1,70 +0,0 @@
-# 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/string.md

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

doc/stringinterp.md

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

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

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

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

doc/thunk.md

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

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

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

doc/unifhint.md

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

releases_drafts/list_lex.md

@@ -1,16 +0,0 @@
-We replace 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 subtely 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.

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='-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'"
+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'"
 # when not using the above flags, link GMP dynamically/as usual
 echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-Wl,--as-needed -lgmp -luv -lpthread -ldl -lrt -Wl,--no-as-needed'"
 # do not set `LEAN_CC` for tests

script/prepare-llvm-macos.sh

@@ -48,12 +48,11 @@ if [[ -L llvm-host ]]; then
   echo -n " -DCMAKE_C_COMPILER=$PWD/stage1/bin/clang"
   gcp $GMP/lib/libgmp.a stage1/lib/
   gcp $LIBUV/lib/libuv.a stage1/lib/
-  echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -L ROOT/lib/libc -fuse-ld=lld'"
   echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-lgmp -luv'"
 else
   echo -n " -DCMAKE_C_COMPILER=$PWD/llvm-host/bin/clang -DLEANC_OPTS='--sysroot $PWD/stage1 -resource-dir $PWD/stage1/lib/clang/15.0.1 ${EXTRA_FLAGS:-}'"
-  echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -L ROOT/lib/libc -fuse-ld=lld'"
 fi
-echo -n " -DLEANC_INTERNAL_FLAGS='-nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang"
+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/libc -fuse-ld=lld'"
 # do not set `LEAN_CC` for tests
 echo -n " -DLEAN_TEST_VARS=''"

script/prepare-llvm-mingw.sh

@@ -43,7 +43,7 @@ echo -n " -DCMAKE_C_COMPILER=$PWD/stage1/bin/clang.exe -DCMAKE_C_COMPILER_WORKS=
 echo -n " -DSTAGE0_CMAKE_C_COMPILER=clang -DSTAGE0_CMAKE_CXX_COMPILER=clang++"
 echo -n " -DLEAN_EXTRA_CXX_FLAGS='--sysroot $PWD/llvm -idirafter /clang64/include/'"
 echo -n " -DLEANC_INTERNAL_FLAGS='--sysroot ROOT -nostdinc -isystem ROOT/include/clang' -DLEANC_CC=ROOT/bin/clang.exe"
-echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='-L ROOT/lib -static-libgcc -Wl,-Bstatic -lgmp $(pkg-config --static --libs libuv) -lunwind -Wl,-Bdynamic -fuse-ld=lld'"
+echo -n " -DLEANC_INTERNAL_LINKER_FLAGS='--sysroot ROOT -L ROOT/lib -Wl,-Bstatic -lgmp $(pkg-config --static --libs libuv) -lunwind -Wl,-Bdynamic -fuse-ld=lld'"
 # when not using the above flags, link GMP dynamically/as usual. Always link ICU dynamically.
 echo -n " -DLEAN_EXTRA_LINKER_FLAGS='-lgmp $(pkg-config --libs libuv) -lucrtbase'"
 # do not set `LEAN_CC` for tests

script/release_checklist.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+
+import argparse
+import yaml
+import requests
+import base64
+import subprocess
+import sys
+import os
+
+def parse_repos_config(file_path):
+    with open(file_path, "r") as f:
+        return yaml.safe_load(f)["repositories"]
+
+def get_github_token():
+    try:
+        import subprocess
+        result = subprocess.run(['gh', 'auth', 'token'], capture_output=True, text=True)
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except FileNotFoundError:
+        print("Warning: 'gh' CLI not found. Some API calls may be rate-limited.")
+    return None
+
+def get_branch_content(repo_url, branch, file_path, github_token):
+    api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + f"/contents/{file_path}?ref={branch}"
+    headers = {'Authorization': f'token {github_token}'} if github_token else {}
+    response = requests.get(api_url, headers=headers)
+    if response.status_code == 200:
+        content = response.json().get("content", "")
+        content = content.replace("\n", "")
+        try:
+            return base64.b64decode(content).decode('utf-8').strip()
+        except Exception:
+            return None
+    return None
+
+def tag_exists(repo_url, tag_name, github_token):
+    api_url = repo_url.replace("https://github.com/", "https://api.github.com/repos/") + f"/git/refs/tags/{tag_name}"
+    headers = {'Authorization': f'token {github_token}'} if github_token else {}
+    response = requests.get(api_url, headers=headers)
+    return response.status_code == 200
+
+def is_merged_into_stable(repo_url, tag_name, stable_branch, github_token):
+    # First get the commit SHA for the tag
+    api_base = repo_url.replace("https://github.com/", "https://api.github.com/repos/")
+    headers = {'Authorization': f'token {github_token}'} if github_token else {}
+
+    # Get tag's commit SHA
+    tag_response = requests.get(f"{api_base}/git/refs/tags/{tag_name}", headers=headers)
+    if tag_response.status_code != 200:
+        return False
+    tag_sha = tag_response.json()['object']['sha']
+
+    # Get commits on stable branch containing this SHA
+    commits_response = requests.get(
+        f"{api_base}/commits?sha={stable_branch}&per_page=100",
+        headers=headers
+    )
+    if commits_response.status_code != 200:
+        return False
+
+    # Check if any commit in stable's history matches our tag's SHA
+    stable_commits = [commit['sha'] for commit in commits_response.json()]
+    return tag_sha in stable_commits
+
+def parse_version(version_str):
+    # Remove 'v' prefix and split into components
+    # Handle Lean toolchain format (leanprover/lean4:v4.x.y)
+    if ':' in version_str:
+        version_str = version_str.split(':')[1]
+    version = version_str.lstrip('v')
+    # Handle release candidates by removing -rc part for comparison
+    version = version.split('-')[0]
+    return tuple(map(int, version.split('.')))
+
+def is_version_gte(version1, version2):
+    """Check if version1 >= version2"""
+    return parse_version(version1) >= parse_version(version2)
+
+def is_release_candidate(version):
+    return "-rc" in version
+
+def main():
+    github_token = get_github_token()
+
+    if len(sys.argv) != 2:
+        print("Usage: python3 release_checklist.py <toolchain>")
+        sys.exit(1)
+
+    toolchain = sys.argv[1]
+
+    with open(os.path.join(os.path.dirname(__file__), "release_repos.yml")) as f:
+        repos = yaml.safe_load(f)["repositories"]
+
+    for repo in repos:
+        name = repo["name"]
+        url = repo["url"]
+        branch = repo["branch"]
+        check_stable = repo["stable-branch"]
+        check_tag = repo.get("toolchain-tag", True)
+
+        print(f"\nRepository: {name}")
+
+        # Check if branch is on at least the target toolchain
+        lean_toolchain_content = get_branch_content(url, branch, "lean-toolchain", github_token)
+        if lean_toolchain_content is None:
+            print(f"  ❌ No lean-toolchain file found in {branch} branch")
+            continue
+
+        on_target_toolchain = is_version_gte(lean_toolchain_content.strip(), toolchain)
+        if not on_target_toolchain:
+            print(f"  ❌ Not on target toolchain (needs ≥ {toolchain}, but {branch} is on {lean_toolchain_content.strip()})")
+            continue
+        print(f"  ✅ On compatible toolchain (>= {toolchain})")
+
+        # Only check for tag if toolchain-tag is true
+        if check_tag:
+            if not tag_exists(url, toolchain, github_token):
+                print(f"  ❌ Tag {toolchain} does not exist")
+                continue
+            print(f"  ✅ Tag {toolchain} exists")
+
+        # Only check merging into stable if stable-branch is true and not a release candidate
+        if check_stable and not is_release_candidate(toolchain):
+            if not is_merged_into_stable(url, toolchain, "stable", github_token):
+                print(f"  ❌ Tag {toolchain} is not merged into stable")
+                continue
+            print(f"  ✅ Tag {toolchain} is merged into stable")
+
+if __name__ == "__main__":
+    main()

script/release_notes.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+
+import sys
+import re
+import json
+import requests
+import subprocess
+from collections import defaultdict
+from git import Repo
+
+def get_commits_since_tag(repo, tag):
+    try:
+        tag_commit = repo.commit(tag)
+        commits = list(repo.iter_commits(f"{tag_commit.hexsha}..HEAD"))
+        return [
+            (commit.hexsha, commit.message.splitlines()[0], commit.message)
+            for commit in commits
+        ]
+    except Exception as e:
+        sys.stderr.write(f"Error retrieving commits: {e}\n")
+        sys.exit(1)
+
+def check_pr_number(first_line):
+    match = re.search(r"\(\#(\d+)\)$", first_line)
+    if match:
+        return int(match.group(1))
+    return None
+
+def fetch_pr_labels(pr_number):
+    try:
+        # Use gh CLI to fetch PR details
+        result = subprocess.run([
+            "gh", "api", f"repos/leanprover/lean4/pulls/{pr_number}"
+        ], capture_output=True, text=True, check=True)
+        pr_data = result.stdout
+        pr_json = json.loads(pr_data)
+        return [label["name"] for label in pr_json.get("labels", [])]
+    except subprocess.CalledProcessError as e:
+        sys.stderr.write(f"Failed to fetch PR #{pr_number} using gh: {e.stderr}\n")
+        return []
+
+def format_section_title(label):
+    title = label.replace("changelog-", "").capitalize()
+    if title == "Doc":
+        return "Documentation"
+    elif title == "Pp":
+        return "Pretty Printing"
+    return title
+
+def sort_sections_order():
+    return [
+        "Language",
+        "Library",
+        "Compiler",
+        "Pretty Printing",
+        "Documentation",
+        "Server",
+        "Lake",
+        "Other",
+        "Uncategorised"
+    ]
+
+def format_markdown_description(pr_number, description):
+    link = f"[#{pr_number}](https://github.com/leanprover/lean4/pull/{pr_number})"
+    return f"{link} {description}"
+
+def main():
+    if len(sys.argv) != 2:
+        sys.stderr.write("Usage: script.py <git-tag>\n")
+        sys.exit(1)
+
+    tag = sys.argv[1]
+    try:
+        repo = Repo(".")
+    except Exception as e:
+        sys.stderr.write(f"Error opening Git repository: {e}\n")
+        sys.exit(1)
+
+    commits = get_commits_since_tag(repo, tag)
+
+    sys.stderr.write(f"Found {len(commits)} commits since tag {tag}:\n")
+    for commit_hash, first_line, _ in commits:
+        sys.stderr.write(f"- {commit_hash}: {first_line}\n")
+
+    changelog = defaultdict(list)
+
+    for commit_hash, first_line, full_message in commits:
+        # Skip commits with the specific first lines
+        if first_line == "chore: update stage0" or first_line.startswith("chore: CI: bump "):
+            continue
+
+        pr_number = check_pr_number(first_line)
+
+        if not pr_number:
+            sys.stderr.write(f"No PR number found in {first_line}\n")
+            continue
+
+        # Remove the first line from the full_message for further processing
+        body = full_message[len(first_line):].strip()
+
+        paragraphs = body.split('\n\n')
+        second_paragraph = paragraphs[0] if len(paragraphs) > 0 else ""
+
+        labels = fetch_pr_labels(pr_number)
+
+        # Skip entries with the "changelog-no" label
+        if "changelog-no" in labels:
+            continue
+
+        report_errors = first_line.startswith("feat:") or first_line.startswith("fix:")
+
+        if not second_paragraph.startswith("This PR "):
+            if report_errors:
+                sys.stderr.write(f"No PR description found in commit:\n{commit_hash}\n{first_line}\n{body}\n\n")
+                fallback_description = re.sub(r":$", "", first_line.split(" ", 1)[1]).rsplit(" (#", 1)[0]
+                markdown_description = format_markdown_description(pr_number, fallback_description)
+            else:
+                continue
+        else:
+            markdown_description = format_markdown_description(pr_number, second_paragraph.replace("This PR ", ""))
+
+        changelog_labels = [label for label in labels if label.startswith("changelog-")]
+        if len(changelog_labels) > 1:
+            sys.stderr.write(f"Warning: Multiple changelog-* labels found for PR #{pr_number}: {changelog_labels}\n")
+
+        if not changelog_labels:
+            if report_errors:
+                sys.stderr.write(f"Warning: No changelog-* label found for PR #{pr_number}\n")
+            else:
+                continue
+
+        for label in changelog_labels:
+            changelog[label].append((pr_number, markdown_description))
+
+    section_order = sort_sections_order()
+    sorted_changelog = sorted(changelog.items(), key=lambda item: section_order.index(format_section_title(item[0])) if format_section_title(item[0]) in section_order else len(section_order))
+
+    for label, entries in sorted_changelog:
+        section_title = format_section_title(label) if label != "Uncategorised" else "Uncategorised"
+        print(f"## {section_title}\n")
+        for _, entry in sorted(entries, key=lambda x: x[0]):
+            print(f"* {entry}\n")
+
+if __name__ == "__main__":
+    main()

script/release_repos.yml

@@ -0,0 +1,86 @@
+repositories:
+  - name: Batteries
+    url: https://github.com/leanprover-community/batteries
+    toolchain-tag: true
+    stable-branch: true
+    branch: main
+    dependencies: []
+
+  - name: lean4checker
+    url: https://github.com/leanprover/lean4checker
+    toolchain-tag: true
+    stable-branch: true
+    branch: master
+    dependencies: []
+
+  - name: doc-gen4
+    url: https://github.com/leanprover/doc-gen4
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies: []
+
+  - name: Verso
+    url: https://github.com/leanprover/verso
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies: []
+
+  - name: Cli
+    url: https://github.com/leanprover/lean4-cli
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies: []
+
+  - name: ProofWidgets4
+    url: https://github.com/leanprover-community/ProofWidgets4
+    toolchain-tag: false
+    stable-branch: false
+    branch: main
+    dependencies:
+      - Batteries
+
+  - name: Aesop
+    url: https://github.com/leanprover-community/aesop
+    toolchain-tag: true
+    stable-branch: true
+    branch: master
+    dependencies:
+      - Batteries
+
+  - name: import-graph
+    url: https://github.com/leanprover-community/import-graph
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies: []
+
+  - name: plausible
+    url: https://github.com/leanprover-community/plausible
+    toolchain-tag: true
+    stable-branch: false
+    branch: main
+    dependencies: []
+
+  - name: Mathlib
+    url: https://github.com/leanprover-community/mathlib4
+    toolchain-tag: true
+    stable-branch: true
+    branch: master
+    dependencies:
+      - Aesop
+      - ProofWidgets4
+      - lean4checker
+      - Batteries
+      - doc-gen4
+      - import-graph
+
+  - name: REPL
+    url: https://github.com/leanprover-community/repl
+    toolchain-tag: true
+    stable-branch: true
+    branch: master
+    dependencies:
+      - Mathlib

src/Init.lean

@@ -37,3 +37,4 @@ import Init.MacroTrace
 import Init.Grind
 import Init.While
 import Init.Syntax
+import Init.Internal

src/Init/Conv.lean

@@ -150,6 +150,10 @@ See the `simp` tactic for more information. -/
 syntax (name := simp) "simp" optConfig (discharger)? (&" only")?
   (" [" withoutPosition((simpStar <|> simpErase <|> simpLemma),*) "]")? : conv
 
+/-- `simp?` takes the same arguments as `simp`, but reports an equivalent call to `simp only`
+that would be sufficient to close the goal. See the `simp?` tactic for more information. -/
+syntax (name := simpTrace) "simp?" optConfig (discharger)? (&" only")? (simpArgs)? : conv
+
 /--
 `dsimp` is the definitional simplifier in `conv`-mode. It differs from `simp` in that it only
 applies theorems that hold by reflexivity.
@@ -167,6 +171,9 @@ example (a : Nat): (0 + 0) = a - a := by
 syntax (name := dsimp) "dsimp" optConfig (discharger)? (&" only")?
   (" [" withoutPosition((simpErase <|> simpLemma),*) "]")? : conv
 
+@[inherit_doc simpTrace]
+syntax (name := dsimpTrace) "dsimp?" optConfig (&" only")? (dsimpArgs)? : conv
+
 /-- `simp_match` simplifies match expressions. For example,
 ```
 match [a, b] with

src/Init/Core.lean

@@ -2116,16 +2116,14 @@ instance : Commutative Or := ⟨fun _ _ => propext or_comm⟩
 instance : Commutative And := ⟨fun _ _ => propext and_comm⟩
 instance : Commutative Iff := ⟨fun _ _ => propext iff_comm⟩
 
-/-- `IsRefl X r` means the binary relation `r` on `X` is reflexive. -/
+/-- `Refl r` means the binary relation `r` is reflexive, that is, `r x x` always holds. -/
 class Refl (r : α → α → Prop) : Prop where
   /-- A reflexive relation satisfies `r a a`. -/
   refl : ∀ a, r a a
 
-/--
-`Antisymm (·≤·)` says that `(·≤·)` is antisymmetric, that is, `a ≤ b → b ≤ a → a = b`.
--/
+/-- `Antisymm r` says that `r` is antisymmetric, that is, `r a b → r b a → a = b`. -/
 class Antisymm (r : α → α → Prop) : Prop where
-  /-- An antisymmetric relation `(·≤·)` satisfies `a ≤ b → b ≤ a → a = b`. -/
+  /-- An antisymmetric relation `r` satisfies `r a b → r b a → a = b`. -/
   antisymm (a b : α) : r a b → r b a → a = b
 
 @[deprecated Antisymm (since := "2024-10-16"), inherit_doc Antisymm]
@@ -2143,8 +2141,8 @@ class Total (r : α → α → Prop) : Prop where
   /-- A total relation satisfies `r a b ∨ r b a`. -/
   total : ∀ a b, r a b ∨ r b a
 
-/-- `Irrefl X r` means the binary relation `r` on `X` is irreflexive (that is, `r x x` never
-holds). -/
+/-- `Irrefl r` means the binary relation `r` is irreflexive, that is, `r x x` never
+holds. -/
 class Irrefl (r : α → α → Prop) : Prop where
   /-- An irreflexive relation satisfies `¬ r a a`. -/
   irrefl : ∀ a, ¬r a a

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

@@ -11,11 +11,14 @@ namespace Array
 
 /-! ### Lexicographic ordering -/
 
-@[simp] theorem lt_toArray [LT α] (l₁ l₂ : List α) : l₁.toArray < l₂.toArray ↔ l₁ < l₂ := Iff.rfl
-@[simp] theorem le_toArray [LT α] (l₁ l₂ : List α) : l₁.toArray ≤ l₂.toArray ↔ l₁ ≤ l₂ := Iff.rfl
+@[simp] theorem _root_.List.lt_toArray [LT α] (l₁ l₂ : List α) : l₁.toArray < l₂.toArray ↔ l₁ < l₂ := Iff.rfl
+@[simp] theorem _root_.List.le_toArray [LT α] (l₁ l₂ : List α) : l₁.toArray ≤ l₂.toArray ↔ l₁ ≤ l₂ := Iff.rfl
 
-theorem not_lt_iff_ge [LT α] (l₁ l₂ : List α) : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
-theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] (l₁ l₂ : List α) :
+@[simp] theorem lt_toList [LT α] (l₁ l₂ : Array α) : l₁.toList < l₂.toList ↔ l₁ < l₂ := Iff.rfl
+@[simp] theorem le_toList [LT α] (l₁ l₂ : Array α) : l₁.toList ≤ l₂.toList ↔ l₁ ≤ l₂ := Iff.rfl
+
+protected theorem not_lt_iff_ge [LT α] (l₁ l₂ : List α) : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
+protected theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] (l₁ l₂ : List α) :
     ¬ l₁ ≤ l₂ ↔ l₂ < l₁ :=
   Decidable.not_not
 
@@ -59,6 +62,7 @@ protected theorem lt_irrefl [LT α] [Std.Irrefl (· < · : α → α → Prop)]
 instance ltIrrefl [LT α] [Std.Irrefl (· < · : α → α → Prop)] : Std.Irrefl (α := Array α) (· < ·) where
   irrefl := Array.lt_irrefl
 
+@[simp] theorem not_lt_empty [LT α] (l : Array α) : ¬ l < #[] := List.not_lt_nil l.toList
 @[simp] theorem empty_le [LT α] (l : Array α) : #[] ≤ l := List.nil_le l.toList
 
 @[simp] theorem le_empty [LT α] (l : Array α) : l ≤ #[] ↔ l = #[] := by
@@ -74,13 +78,12 @@ protected theorem le_refl [LT α] [i₀ : Std.Irrefl (· < · : α → α → Pr
 instance [LT α] [Std.Irrefl (· < · : α → α → Prop)] : Std.Refl (· ≤ · : Array α → Array α → Prop) where
   refl := Array.le_refl
 
-protected theorem lt_trans [LT α] [DecidableLT α]
+protected theorem lt_trans [LT α]
     [i₁ : Trans (· < · : α → α → Prop) (· < ·) (· < ·)]
     {l₁ l₂ l₃ : Array α} (h₁ : l₁ < l₂) (h₂ : l₂ < l₃) : l₁ < l₃ :=
   List.lt_trans h₁ h₂
 
-instance [LT α] [DecidableLT α]
-    [Trans (· < · : α → α → Prop) (· < ·) (· < ·)] :
+instance [LT α] [Trans (· < · : α → α → Prop) (· < ·) (· < ·)] :
     Trans (· < · : Array α → Array α → Prop) (· < ·) (· < ·) where
   trans h₁ h₂ := Array.lt_trans h₁ h₂
 
@@ -108,7 +111,7 @@ instance [DecidableEq α] [LT α] [DecidableLT α]
     Trans (· ≤ · : Array α → Array α → Prop) (· ≤ ·) (· ≤ ·) where
   trans h₁ h₂ := Array.le_trans h₁ h₂
 
-protected theorem lt_asymm [DecidableEq α] [LT α] [DecidableLT α]
+protected theorem lt_asymm [LT α]
     [i : Std.Asymm (· < · : α → α → Prop)]
     {l₁ l₂ : Array α} (h : l₁ < l₂) : ¬ l₂ < l₁ := List.lt_asymm h
 
@@ -118,13 +121,31 @@ instance [DecidableEq α] [LT α] [DecidableLT α]
   asymm _ _ := Array.lt_asymm
 
 protected theorem le_total [DecidableEq α] [LT α] [DecidableLT α]
-    [i : Std.Total (¬ · < · : α → α → Prop)] {l₁ l₂ : Array α} : l₁ ≤ l₂ ∨ l₂ ≤ l₁ :=
-  List.le_total
+    [i : Std.Total (¬ · < · : α → α → Prop)] (l₁ l₂ : Array α) : l₁ ≤ l₂ ∨ l₂ ≤ l₁ :=
+  List.le_total _ _
+
+@[simp] protected theorem not_lt [LT α]
+    {l₁ l₂ : Array α} : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
+
+@[simp] protected theorem not_le [DecidableEq α] [LT α] [DecidableLT α]
+    {l₁ l₂ : Array α} : ¬ l₂ ≤ l₁ ↔ l₁ < l₂ := Decidable.not_not
+
+protected theorem le_of_lt [DecidableEq α] [LT α] [DecidableLT α]
+    [i : Std.Total (¬ · < · : α → α → Prop)]
+    {l₁ l₂ : Array α} (h : l₁ < l₂) : l₁ ≤ l₂ :=
+  List.le_of_lt h
+
+protected theorem le_iff_lt_or_eq [DecidableEq α] [LT α] [DecidableLT α]
+    [Std.Irrefl (· < · : α → α → Prop)]
+    [Std.Antisymm (¬ · < · : α → α → Prop)]
+    [Std.Total (¬ · < · : α → α → Prop)]
+    {l₁ l₂ : Array α} : l₁ ≤ l₂ ↔ l₁ < l₂ ∨ l₁ = l₂ := by
+  simpa using List.le_iff_lt_or_eq (l₁ := l₁.toList) (l₂ := l₂.toList)
 
 instance [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Total (¬ · < · : α → α → Prop)] :
     Std.Total (· ≤ · : Array α → Array α → Prop) where
-  total _ _ := Array.le_total
+  total := Array.le_total
 
 @[simp] theorem lex_eq_true_iff_lt [DecidableEq α] [LT α] [DecidableLT α]
     {l₁ l₂ : Array α} : lex l₁ l₂ = true ↔ l₁ < l₂ := by
@@ -190,7 +211,7 @@ theorem lex_eq_false_iff_exists [BEq α] [PartialEquivBEq α] (lt : α → α
   cases l₂
   simp_all [List.lex_eq_false_iff_exists]
 
-theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Array α} :
+protected theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Array α} :
     l₁ < l₂ ↔
       (l₁ = l₂.take l₁.size ∧ l₁.size < l₂.size) ∨
         (∃ (i : Nat) (h₁ : i < l₁.size) (h₂ : i < l₂.size),
@@ -200,7 +221,7 @@ theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Arr
   cases l₂
   simp [List.lt_iff_exists]
 
-theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
+protected theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Asymm (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)] {l₁ l₂ : Array α} :
@@ -213,4 +234,48 @@ theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
   cases l₂
   simp [List.le_iff_exists]
 
+theorem append_left_lt [LT α] {l₁ l₂ l₃ : Array α} (h : l₂ < l₃) :
+    l₁ ++ l₂ < l₁ ++ l₃ := by
+  cases l₁
+  cases l₂
+  cases l₃
+  simpa using List.append_left_lt h
+
+theorem append_left_le [DecidableEq α] [LT α] [DecidableLT α]
+    [Std.Irrefl (· < · : α → α → Prop)]
+    [Std.Asymm (· < · : α → α → Prop)]
+    [Std.Antisymm (¬ · < · : α → α → Prop)]
+    {l₁ l₂ l₃ : Array α} (h : l₂ ≤ l₃) :
+    l₁ ++ l₂ ≤ l₁ ++ l₃ := by
+  cases l₁
+  cases l₂
+  cases l₃
+  simpa using List.append_left_le h
+
+theorem le_append_left [LT α] [Std.Irrefl (· < · : α → α → Prop)]
+    {l₁ l₂ : Array α} : l₁ ≤ l₁ ++ l₂ := by
+  cases l₁
+  cases l₂
+  simpa using List.le_append_left
+
+protected theorem map_lt [LT α] [LT β]
+    {l₁ l₂ : Array α} {f : α → β} (w : ∀ x y, x < y → f x < f y) (h : l₁ < l₂) :
+    map f l₁ < map f l₂ := by
+  cases l₁
+  cases l₂
+  simpa using List.map_lt w h
+
+protected theorem map_le [DecidableEq α] [LT α] [DecidableLT α] [DecidableEq β] [LT β] [DecidableLT β]
+    [Std.Irrefl (· < · : α → α → Prop)]
+    [Std.Asymm (· < · : α → α → Prop)]
+    [Std.Antisymm (¬ · < · : α → α → Prop)]
+    [Std.Irrefl (· < · : β → β → Prop)]
+    [Std.Asymm (· < · : β → β → Prop)]
+    [Std.Antisymm (¬ · < · : β → β → Prop)]
+    {l₁ l₂ : Array α} {f : α → β} (w : ∀ x y, x < y → f x < f y) (h : l₁ ≤ l₂) :
+    map f l₁ ≤ map f l₂ := by
+  cases l₁
+  cases l₂
+  simpa using List.map_le w h
+
 end Array

src/Init/Data/BitVec/Lemmas.lean

@@ -9,7 +9,9 @@ import Init.Data.Bool
 import Init.Data.BitVec.Basic
 import Init.Data.Fin.Lemmas
 import Init.Data.Nat.Lemmas
+import Init.Data.Nat.Div.Lemmas
 import Init.Data.Nat.Mod
+import Init.Data.Nat.Div.Lemmas
 import Init.Data.Int.Bitwise.Lemmas
 import Init.Data.Int.Pow
 
@@ -98,6 +100,12 @@ theorem ofFin_eq_ofNat : @BitVec.ofFin w (Fin.mk x lt) = BitVec.ofNat w x := by
 theorem eq_of_toNat_eq {n} : ∀ {x y : BitVec n}, x.toNat = y.toNat → x = y
   | ⟨_, _⟩, ⟨_, _⟩, rfl => rfl
 
+/-- Prove nonequality of bitvectors in terms of nat operations. -/
+theorem toNat_ne_iff_ne {n} {x y : BitVec n} : x.toNat ≠ y.toNat ↔ x ≠ y := by
+  constructor
+  · rintro h rfl; apply h rfl
+  · intro h h_eq; apply h <| eq_of_toNat_eq h_eq
+
 @[simp] theorem val_toFin (x : BitVec w) : x.toFin.val = x.toNat := rfl
 
 @[bv_toNat] theorem toNat_eq {x y : BitVec n} : x = y ↔ x.toNat = y.toNat :=
@@ -442,6 +450,10 @@ theorem toInt_eq_toNat_cond (x : BitVec n) :
         (x.toNat : Int) - (2^n : Nat) :=
   rfl
 
+theorem toInt_eq_toNat_of_lt {x : BitVec n} (h : 2 * x.toNat < 2^n) :
+    x.toInt = x.toNat := by
+  simp [toInt_eq_toNat_cond, h]
+
 theorem msb_eq_false_iff_two_mul_lt {x : BitVec w} : x.msb = false ↔ 2 * x.toNat < 2^w := by
   cases w <;> simp [Nat.pow_succ, Nat.mul_comm _ 2, msb_eq_decide, toNat_of_zero_length]
 
@@ -454,6 +466,9 @@ theorem toInt_eq_msb_cond (x : BitVec w) :
   simp only [BitVec.toInt, ← msb_eq_false_iff_two_mul_lt]
   cases x.msb <;> rfl
 
+theorem toInt_eq_toNat_of_msb {x : BitVec w} (h : x.msb = false) :
+    x.toInt = x.toNat := by
+  simp [toInt_eq_msb_cond, h]
 
 theorem toInt_eq_toNat_bmod (x : BitVec n) : x.toInt = Int.bmod x.toNat (2^n) := by
   simp only [toInt_eq_toNat_cond]
@@ -785,6 +800,19 @@ theorem extractLsb'_eq_extractLsb {w : Nat} (x : BitVec w) (start len : Nat) (h
   unfold allOnes
   simp
 
+@[simp] theorem toInt_allOnes : (allOnes w).toInt = if 0 < w then -1 else 0 := by
+  norm_cast
+  by_cases h : w = 0
+  · subst h
+    simp
+  · have : 1 < 2 ^ w := by simp [h]
+    simp [BitVec.toInt]
+    omega
+
+@[simp] theorem toFin_allOnes : (allOnes w).toFin = Fin.ofNat' (2^w) (2^w - 1) := by
+  ext
+  simp
+
 @[simp] theorem getLsbD_allOnes : (allOnes v).getLsbD i = decide (i < v) := by
   simp [allOnes]
 
@@ -1142,11 +1170,16 @@ theorem getMsb_not {x : BitVec w} :
 /-! ### shiftLeft -/
 
 @[simp, bv_toNat] theorem toNat_shiftLeft {x : BitVec v} :
-    BitVec.toNat (x <<< n) = BitVec.toNat x <<< n % 2^v :=
+    (x <<< n).toNat = x.toNat <<< n % 2^v :=
   BitVec.toNat_ofNat _ _
 
+@[simp] theorem toInt_shiftLeft {x : BitVec w} :
+    (x <<< n).toInt = (x.toNat <<< n : Int).bmod (2^w) := by
+  rw [toInt_eq_toNat_bmod, toNat_shiftLeft, Nat.shiftLeft_eq]
+  simp
+
 @[simp] theorem toFin_shiftLeft {n : Nat} (x : BitVec w) :
-    BitVec.toFin (x <<< n) = Fin.ofNat' (2^w) (x.toNat <<< n) := rfl
+    (x <<< n).toFin = Fin.ofNat' (2^w) (x.toNat <<< n) := rfl
 
 @[simp]
 theorem shiftLeft_zero (x : BitVec w) : x <<< 0 = x := by
@@ -2282,6 +2315,12 @@ theorem ofNat_sub_ofNat {n} (x y : Nat) : BitVec.ofNat n x - BitVec.ofNat n y =
 @[simp, bv_toNat] theorem toNat_neg (x : BitVec n) : (- x).toNat = (2^n - x.toNat) % 2^n := by
   simp [Neg.neg, BitVec.neg]
 
+theorem toNat_neg_of_pos {x : BitVec n} (h : 0#n < x) :
+    (- x).toNat = 2^n - x.toNat := by
+  change 0 < x.toNat at h
+  rw [toNat_neg, Nat.mod_eq_of_lt]
+  omega
+
 theorem toInt_neg {x : BitVec w} :
     (-x).toInt = (-x.toInt).bmod (2 ^ w) := by
   rw [← BitVec.zero_sub, toInt_sub]
@@ -2377,6 +2416,54 @@ theorem not_neg (x : BitVec w) : ~~~(-x) = x + -1#w := by
         show (_ - x.toNat) % _ = _ by rw [Nat.mod_eq_of_lt (by omega)]]
       omega
 
+/-! ### fill -/
+
+@[simp]
+theorem getLsbD_fill {w i : Nat} {v : Bool} :
+    (fill w v).getLsbD i = (v && decide (i < w)) := by
+  by_cases h : v
+  <;> simp [h, BitVec.fill, BitVec.negOne_eq_allOnes]
+
+@[simp]
+theorem getMsbD_fill {w i : Nat} {v : Bool} :
+    (fill w v).getMsbD i = (v && decide (i < w)) := by
+  by_cases h : v
+  <;> simp [h, BitVec.fill, BitVec.negOne_eq_allOnes]
+
+@[simp]
+theorem getElem_fill {w i : Nat} {v : Bool} (h : i < w) :
+    (fill w v)[i] = v := by
+  by_cases h : v
+  <;> simp [h, BitVec.fill, BitVec.negOne_eq_allOnes]
+
+@[simp]
+theorem msb_fill {w : Nat} {v : Bool} :
+    (fill w v).msb = (v && decide (0 < w)) := by
+  simp [BitVec.msb]
+
+theorem fill_eq {w : Nat} {v : Bool} : fill w v = if v = true then allOnes w else 0#w := by
+  by_cases h : v <;> (simp only [h] ; ext ; simp)
+
+@[simp]
+theorem fill_true {w : Nat} : fill w true = allOnes w := by
+  simp [fill_eq]
+
+@[simp]
+theorem fill_false {w : Nat} : fill w false = 0#w := by
+  simp [fill_eq]
+
+@[simp] theorem fill_toNat {w : Nat} {v : Bool} :
+    (fill w v).toNat = if v = true then 2^w - 1 else 0 := by
+  by_cases h : v <;> simp [h]
+
+@[simp] theorem fill_toInt {w : Nat} {v : Bool} :
+    (fill w v).toInt = if v = true && 0 < w then -1 else 0 := by
+  by_cases h : v <;> simp [h]
+
+@[simp] theorem fill_toFin {w : Nat} {v : Bool} :
+    (fill w v).toFin = if v = true then (allOnes w).toFin else Fin.ofNat' (2 ^ w) 0 := by
+  by_cases h : v <;> simp [h]
+
 /-! ### mul -/
 
 theorem mul_def {n} {x y : BitVec n} : x * y = (ofFin <| x.toFin * y.toFin) := by rfl
@@ -2520,13 +2607,13 @@ theorem udiv_def {x y : BitVec n} : x / y = BitVec.ofNat n (x.toNat / y.toNat) :
   rw [← udiv_eq]
   simp [udiv, bv_toNat, h, Nat.mod_eq_of_lt]
 
+@[simp]
+theorem toFin_udiv {x y : BitVec n} : (x / y).toFin = x.toFin / y.toFin := by
+  rfl
+
 @[simp, bv_toNat]
 theorem toNat_udiv {x y : BitVec n} : (x / y).toNat = x.toNat / y.toNat := by
-  rw [udiv_def]
-  by_cases h : y = 0
-  · simp [h]
-  · rw [toNat_ofNat, Nat.mod_eq_of_lt]
-    exact Nat.lt_of_le_of_lt (Nat.div_le_self ..) (by omega)
+  rfl
 
 @[simp]
 theorem zero_udiv {x : BitVec w} : (0#w) / x = 0#w := by
@@ -2562,6 +2649,45 @@ theorem udiv_self {x : BitVec w} :
       ↓reduceIte, toNat_udiv]
     rw [Nat.div_self (by omega), Nat.mod_eq_of_lt (by omega)]
 
+theorem msb_udiv (x y : BitVec w) :
+    (x / y).msb = (x.msb && y == 1#w) := by
+  cases msb_x : x.msb
+  · suffices x.toNat / y.toNat < 2 ^ (w - 1) by simpa [msb_eq_decide]
+    calc
+      x.toNat / y.toNat ≤ x.toNat     := by apply Nat.div_le_self
+                      _ < 2 ^ (w - 1) := by simpa [msb_eq_decide] using msb_x
+  . rcases w with _|w
+    · contradiction
+    · have : (y == 1#_) = decide (y.toNat = 1) := by
+        simp [(· == ·), toNat_eq]
+      simp only [this, Bool.true_and]
+      match hy : y.toNat with
+      | 0 =>
+        obtain rfl : y = 0#_ := eq_of_toNat_eq hy
+        simp
+      | 1 =>
+        obtain rfl : y = 1#_ := eq_of_toNat_eq (by simp [hy])
+        simpa using msb_x
+      | y + 2 =>
+        suffices x.toNat / (y + 2) < 2 ^ w by
+          simp_all [msb_eq_decide, hy]
+        calc
+          x.toNat / (y + 2)
+            ≤ x.toNat / 2 := by apply Nat.div_add_le_right (by omega)
+          _ < 2 ^ w       := by omega
+
+theorem msb_udiv_eq_false_of {x : BitVec w} (h : x.msb = false) (y : BitVec w) :
+    (x / y).msb = false := by
+  simp [msb_udiv, h]
+
+/--
+If `x` is nonnegative (i.e., does not have its msb set),
+then `x / y` is nonnegative, thus `toInt` and `toNat` coincide.
+-/
+theorem toInt_udiv_of_msb {x : BitVec w} (h : x.msb = false) (y : BitVec w) :
+    (x / y).toInt = x.toNat / y.toNat := by
+  simp [toInt_eq_msb_cond, msb_udiv_eq_false_of h]
+
 /-! ### umod -/
 
 theorem umod_def {x y : BitVec n} :
@@ -2574,6 +2700,10 @@ theorem umod_def {x y : BitVec n} :
 theorem toNat_umod {x y : BitVec n} :
     (x % y).toNat = x.toNat % y.toNat := rfl
 
+@[simp]
+theorem toFin_umod {x y : BitVec w} :
+    (x % y).toFin = x.toFin % y.toFin := rfl
+
 @[simp]
 theorem umod_zero {x : BitVec n} : x % 0#n = x := by
   simp [umod_def]
@@ -2601,6 +2731,55 @@ theorem umod_eq_and {x y : BitVec 1} : x % y = x &&& (~~~y) := by
     rcases hy with rfl | rfl <;>
       rfl
 
+theorem umod_eq_of_lt {x y : BitVec w} (h : x < y) :
+    x % y = x := by
+  apply eq_of_toNat_eq
+  simp [Nat.mod_eq_of_lt h]
+
+@[simp]
+theorem msb_umod {x y : BitVec w} :
+    (x % y).msb = (x.msb && (x < y || y == 0#w)) := by
+  rw [msb_eq_decide, toNat_umod]
+  cases msb_x : x.msb
+  · suffices x.toNat % y.toNat < 2 ^ (w - 1) by simpa
+    calc
+      x.toNat % y.toNat ≤ x.toNat     := by apply Nat.mod_le
+                      _ < 2 ^ (w - 1) := by simpa [msb_eq_decide] using msb_x
+  . by_cases hy : y = 0
+    · simp_all [msb_eq_decide]
+    · suffices 2 ^ (w - 1) ≤ x.toNat % y.toNat ↔ x < y by simp_all
+      by_cases x_lt_y : x < y
+      . simp_all [Nat.mod_eq_of_lt x_lt_y, msb_eq_decide]
+      · suffices x.toNat % y.toNat < 2 ^ (w - 1) by
+          simpa [x_lt_y]
+        have y_le_x : y.toNat ≤ x.toNat := by
+          simpa using x_lt_y
+        replace hy : y.toNat ≠ 0 :=
+          toNat_ne_iff_ne.mpr hy
+        by_cases msb_y : y.toNat < 2 ^ (w - 1)
+        · have : x.toNat % y.toNat < y.toNat := Nat.mod_lt _ (by omega)
+          omega
+        · rcases w with _|w
+          · contradiction
+          simp only [Nat.add_one_sub_one]
+          replace msb_y : 2 ^ w ≤ y.toNat := by
+            simpa using msb_y
+          have : y.toNat ≤ y.toNat * (x.toNat / y.toNat) := by
+              apply Nat.le_mul_of_pos_right
+              apply Nat.div_pos y_le_x
+              omega
+          have : x.toNat % y.toNat ≤ x.toNat - y.toNat := by
+            rw [Nat.mod_eq_sub]; omega
+          omega
+
+theorem toInt_umod {x y : BitVec w} :
+    (x % y).toInt = (x.toNat % y.toNat : Int).bmod (2 ^ w) := by
+  simp [toInt_eq_toNat_bmod]
+
+theorem toInt_umod_of_msb {x y : BitVec w} (h : x.msb = false) :
+    (x % y).toInt = x.toInt % y.toNat := by
+  simp [toInt_eq_msb_cond, h]
+
 /-! ### smtUDiv -/
 
 theorem smtUDiv_eq (x y : BitVec w) : smtUDiv x y = if y = 0#w then allOnes w else x / y := by
@@ -2757,7 +2936,12 @@ theorem smod_zero {x : BitVec n} : x.smod 0#n = x := by
 
 /-! # Rotate Left -/
 
-/-- rotateLeft is invariant under `mod` by the bitwidth. -/
+/--`rotateLeft` is defined in terms of left and right shifts. -/
+theorem rotateLeft_def {x : BitVec w} {r : Nat} :
+    x.rotateLeft r = (x <<< (r % w)) ||| (x >>> (w - r % w)) := by
+  simp only [rotateLeft, rotateLeftAux]
+
+/-- `rotateLeft` is invariant under `mod` by the bitwidth. -/
 @[simp]
 theorem rotateLeft_mod_eq_rotateLeft {x : BitVec w} {r : Nat} :
     x.rotateLeft (r % w) = x.rotateLeft r := by
@@ -2901,8 +3085,18 @@ theorem msb_rotateLeft {m w : Nat} {x : BitVec w} :
   · simp
     omega
 
+@[simp]
+theorem toNat_rotateLeft {x : BitVec w} {r : Nat} :
+    (x.rotateLeft r).toNat = (x.toNat <<< (r % w)) % (2^w) ||| x.toNat >>> (w - r % w) := by
+  simp only [rotateLeft_def, toNat_shiftLeft, toNat_ushiftRight, toNat_or]
+
 /-! ## Rotate Right -/
 
+/-- `rotateRight` is defined in terms of left and right shifts. -/
+theorem rotateRight_def {x : BitVec w} {r : Nat} :
+    x.rotateRight r = (x >>> (r % w)) ||| (x <<< (w - r % w)) := by
+  simp only [rotateRight, rotateRightAux]
+
 /--
 Accessing bits in `x.rotateRight r` the range `[0, w-r)` is equal to
 accessing bits `x` in the range `[r, w)`.
@@ -3038,6 +3232,11 @@ theorem msb_rotateRight {r w : Nat} {x : BitVec w} :
     simp [h₁]
   · simp [show w = 0 by omega]
 
+@[simp]
+theorem toNat_rotateRight {x : BitVec w} {r : Nat} :
+    (x.rotateRight r).toNat = (x.toNat >>> (r % w)) ||| x.toNat <<< (w - r % w) % (2^w) := by
+  simp only [rotateRight_def, toNat_shiftLeft, toNat_ushiftRight, toNat_or]
+
 /- ## twoPow -/
 
 theorem twoPow_eq (w : Nat) (i : Nat) : twoPow w i = 1#w <<< i := by

src/Init/Data/Int/DivModLemmas.lean

@@ -534,6 +534,13 @@ theorem mul_emod (a b n : Int) : (a * b) % n = (a % n) * (b % n) % n := by
 @[simp] theorem emod_emod (a b : Int) : (a % b) % b = a % b := by
   conv => rhs; rw [← emod_add_ediv a b, add_mul_emod_self_left]
 
+@[simp] theorem emod_sub_emod (m n k : Int) : (m % n - k) % n = (m - k) % n :=
+  Int.emod_add_emod m n (-k)
+
+@[simp] theorem sub_emod_emod (m n k : Int) : (m - n % k) % k = (m - n) % k := by
+  apply (emod_add_cancel_right (n % k)).mp
+  rw [Int.sub_add_cancel, Int.add_emod_emod, Int.sub_add_cancel]
+
 theorem sub_emod (a b n : Int) : (a - b) % n = (a % n - b % n) % n := by
   apply (emod_add_cancel_right b).mp
   rw [Int.sub_add_cancel, ← Int.add_emod_emod, Int.sub_add_cancel, emod_emod]
@@ -1098,6 +1105,32 @@ theorem bmod_def (x : Int) (m : Nat) : bmod x m =
     (x % m) - m :=
   rfl
 
+theorem bdiv_add_bmod (x : Int) (m : Nat) : m * bdiv x m + bmod x m = x := by
+  unfold bdiv bmod
+  split
+  · simp_all only [Nat.cast_ofNat_Int, Int.mul_zero, emod_zero, Int.zero_add, Int.sub_zero,
+      ite_self]
+  · dsimp only
+    split
+    · exact ediv_add_emod x m
+    · rw [Int.mul_add, Int.mul_one, Int.add_assoc, Int.add_comm m, Int.sub_add_cancel]
+      exact ediv_add_emod x m
+
+theorem bmod_add_bdiv (x : Int) (m : Nat) : bmod x m + m * bdiv x m = x := by
+  rw [Int.add_comm]; exact bdiv_add_bmod x m
+
+theorem bdiv_add_bmod' (x : Int) (m : Nat) : bdiv x m * m + bmod x m = x := by
+  rw [Int.mul_comm]; exact bdiv_add_bmod x m
+
+theorem bmod_add_bdiv' (x : Int) (m : Nat) : bmod x m + bdiv x m * m = x := by
+  rw [Int.add_comm]; exact bdiv_add_bmod' x m
+
+theorem bmod_eq_self_sub_mul_bdiv (x : Int) (m : Nat) : bmod x m = x - m * bdiv x m := by
+  rw [← Int.add_sub_cancel (bmod x m), bmod_add_bdiv]
+
+theorem bmod_eq_self_sub_bdiv_mul (x : Int) (m : Nat) : bmod x m = x - bdiv x m * m := by
+  rw [← Int.add_sub_cancel (bmod x m), bmod_add_bdiv']
+
 theorem bmod_pos (x : Int) (m : Nat) (p : x % m < (m + 1) / 2) : bmod x m = x % m := by
   simp [bmod_def, p]
 

src/Init/Data/List/Lemmas.lean

@@ -1,7 +1,8 @@
 /-
 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
+Authors: Parikshit Khanna, Jeremy Avigad, Leonardo de Moura, Floris van Doorn, Mario Carneiro,
+  Kim Morrison
 -/
 prelude
 import Init.Data.Bool
@@ -757,207 +758,6 @@ theorem length_eq_of_beq [BEq α] {l₁ l₂ : List α} (h : l₁ == l₂) : l
     | nil => simp
     | cons b l₂ => simp [isEqv, ih]
 
-/-! ### foldlM and foldrM -/
-
-@[simp] theorem foldlM_reverse [Monad m] (l : List α) (f : β → α → m β) (b) :
-    l.reverse.foldlM f b = l.foldrM (fun x y => f y x) b := rfl
-
-@[simp] theorem foldlM_append [Monad m] [LawfulMonad m] (f : β → α → m β) (b) (l l' : List α) :
-    (l ++ l').foldlM f b = l.foldlM f b >>= l'.foldlM f := by
-  induction l generalizing b <;> simp [*]
-
-@[simp] theorem foldrM_cons [Monad m] [LawfulMonad m] (a : α) (l) (f : α → β → m β) (b) :
-    (a :: l).foldrM f b = l.foldrM f b >>= f a := by
-  simp only [foldrM]
-  induction l <;> simp_all
-
-theorem foldl_eq_foldlM (f : β → α → β) (b) (l : List α) :
-    l.foldl f b = l.foldlM (m := Id) f b := by
-  induction l generalizing b <;> simp [*, foldl]
-
-theorem foldr_eq_foldrM (f : α → β → β) (b) (l : List α) :
-    l.foldr f b = l.foldrM (m := Id) f b := by
-  induction l <;> simp [*, foldr]
-
-@[simp] theorem id_run_foldlM (f : β → α → Id β) (b) (l : List α) :
-    Id.run (l.foldlM f b) = l.foldl f b := (foldl_eq_foldlM f b l).symm
-
-@[simp] theorem id_run_foldrM (f : α → β → Id β) (b) (l : List α) :
-    Id.run (l.foldrM f b) = l.foldr f b := (foldr_eq_foldrM f b l).symm
-
-/-! ### foldl and foldr -/
-
-@[simp] theorem foldr_cons_eq_append (l : List α) : l.foldr cons l' = l ++ l' := by
-  induction l <;> simp [*]
-
-@[deprecated foldr_cons_eq_append (since := "2024-08-22")] abbrev foldr_self_append := @foldr_cons_eq_append
-
-@[simp] theorem foldl_flip_cons_eq_append (l : List α) : l.foldl (fun x y => y :: x) l' = l.reverse ++ l' := by
-  induction l generalizing l' <;> simp [*]
-
-theorem foldr_cons_nil (l : List α) : l.foldr cons [] = l := by simp
-
-@[deprecated foldr_cons_nil (since := "2024-09-04")] abbrev foldr_self := @foldr_cons_nil
-
-theorem foldl_map (f : β₁ → β₂) (g : α → β₂ → α) (l : List β₁) (init : α) :
-    (l.map f).foldl g init = l.foldl (fun x y => g x (f y)) init := by
-  induction l generalizing init <;> simp [*]
-
-theorem foldr_map (f : α₁ → α₂) (g : α₂ → β → β) (l : List α₁) (init : β) :
-    (l.map f).foldr g init = l.foldr (fun x y => g (f x) y) init := by
-  induction l generalizing init <;> simp [*]
-
-theorem foldl_filterMap (f : α → Option β) (g : γ → β → γ) (l : List α) (init : γ) :
-    (l.filterMap f).foldl g init = l.foldl (fun x y => match f y with | some b => g x b | none => x) init := by
-  induction l generalizing init with
-  | nil => rfl
-  | cons a l ih =>
-    simp only [filterMap_cons, foldl_cons]
-    cases f a <;> simp [ih]
-
-theorem foldr_filterMap (f : α → Option β) (g : β → γ → γ) (l : List α) (init : γ) :
-    (l.filterMap f).foldr g init = l.foldr (fun x y => match f x with | some b => g b y | none => y) init := by
-  induction l generalizing init with
-  | nil => rfl
-  | cons a l ih =>
-    simp only [filterMap_cons, foldr_cons]
-    cases f a <;> simp [ih]
-
-theorem foldl_map' (g : α → β) (f : α → α → α) (f' : β → β → β) (a : α) (l : List α)
-    (h : ∀ x y, f' (g x) (g y) = g (f x y)) :
-    (l.map g).foldl f' (g a) = g (l.foldl f a) := by
-  induction l generalizing a
-  · simp
-  · simp [*, h]
-
-theorem foldr_map' (g : α → β) (f : α → α → α) (f' : β → β → β) (a : α) (l : List α)
-    (h : ∀ x y, f' (g x) (g y) = g (f x y)) :
-    (l.map g).foldr f' (g a) = g (l.foldr f a) := by
-  induction l generalizing a
-  · simp
-  · simp [*, h]
-
-theorem foldl_assoc {op : α → α → α} [ha : Std.Associative op] :
-    ∀ {l : List α} {a₁ a₂}, l.foldl op (op a₁ a₂) = op a₁ (l.foldl op a₂)
-  | [], a₁, a₂ => rfl
-  | a :: l, a₁, a₂ => by
-    simp only [foldl_cons, ha.assoc]
-    rw [foldl_assoc]
-
-theorem foldr_assoc {op : α → α → α} [ha : Std.Associative op] :
-    ∀ {l : List α} {a₁ a₂}, l.foldr op (op a₁ a₂) = op (l.foldr op a₁) a₂
-  | [], a₁, a₂ => rfl
-  | a :: l, a₁, a₂ => by
-    simp only [foldr_cons, ha.assoc]
-    rw [foldr_assoc]
-
-theorem foldl_hom (f : α₁ → α₂) (g₁ : α₁ → β → α₁) (g₂ : α₂ → β → α₂) (l : List β) (init : α₁)
-    (H : ∀ x y, g₂ (f x) y = f (g₁ x y)) : l.foldl g₂ (f init) = f (l.foldl g₁ init) := by
-  induction l generalizing init <;> simp [*, H]
-
-theorem foldr_hom (f : β₁ → β₂) (g₁ : α → β₁ → β₁) (g₂ : α → β₂ → β₂) (l : List α) (init : β₁)
-    (H : ∀ x y, g₂ x (f y) = f (g₁ x y)) : l.foldr g₂ (f init) = f (l.foldr g₁ init) := by
-  induction l <;> simp [*, H]
-
-/--
-Prove a proposition about the result of `List.foldl`,
-by proving it for the initial data,
-and the implication that the operation applied to any element of the list preserves the property.
-
-The motive can take values in `Sort _`, so this may be used to construct data,
-as well as to prove propositions.
--/
-def foldlRecOn {motive : β → Sort _} : ∀ (l : List α) (op : β → α → β) (b : β) (_ : motive b)
-    (_ : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ l), motive (op b a)), motive (List.foldl op b l)
-  | [], _, _, hb, _ => hb
-  | hd :: tl, op, b, hb, hl =>
-    foldlRecOn tl op (op b hd) (hl b hb hd (mem_cons_self hd tl))
-      fun y hy x hx => hl y hy x (mem_cons_of_mem hd hx)
-
-@[simp] theorem foldlRecOn_nil {motive : β → Sort _} (hb : motive b)
-    (hl : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ []), motive (op b a)) :
-    foldlRecOn [] op b hb hl = hb := rfl
-
-@[simp] theorem foldlRecOn_cons {motive : β → Sort _} (hb : motive b)
-    (hl : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ x :: l), motive (op b a)) :
-    foldlRecOn (x :: l) op b hb hl =
-      foldlRecOn l op (op b x) (hl b hb x (mem_cons_self x l))
-        (fun b c a m => hl b c a (mem_cons_of_mem x m)) :=
-  rfl
-
-/--
-Prove a proposition about the result of `List.foldr`,
-by proving it for the initial data,
-and the implication that the operation applied to any element of the list preserves the property.
-
-The motive can take values in `Sort _`, so this may be used to construct data,
-as well as to prove propositions.
--/
-def foldrRecOn {motive : β → Sort _} : ∀ (l : List α) (op : α → β → β) (b : β) (_ : motive b)
-    (_ : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ l), motive (op a b)), motive (List.foldr op b l)
-  | nil, _, _, hb, _ => hb
-  | x :: l, op, b, hb, hl =>
-    hl (foldr op b l)
-      (foldrRecOn l op b hb fun b c a m => hl b c a (mem_cons_of_mem x m)) x (mem_cons_self x l)
-
-@[simp] theorem foldrRecOn_nil {motive : β → Sort _} (hb : motive b)
-    (hl : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ []), motive (op a b)) :
-    foldrRecOn [] op b hb hl = hb := rfl
-
-@[simp] theorem foldrRecOn_cons {motive : β → Sort _} (hb : motive b)
-    (hl : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ x :: l), motive (op a b)) :
-    foldrRecOn (x :: l) op b hb hl =
-      hl _ (foldrRecOn l op b hb fun b c a m => hl b c a (mem_cons_of_mem x m))
-        x (mem_cons_self x l) :=
-  rfl
-
-/--
-We can prove that two folds over the same list are related (by some arbitrary relation)
-if we know that the initial elements are related and the folding function, for each element of the list,
-preserves the relation.
--/
-theorem foldl_rel {l : List α} {f g : β → α → β} {a b : β} (r : β → β → Prop)
-    (h : r a b) (h' : ∀ (a : α), a ∈ l → ∀ (c c' : β), r c c' → r (f c a) (g c' a)) :
-    r (l.foldl (fun acc a => f acc a) a) (l.foldl (fun acc a => g acc a) b) := by
-  induction l generalizing a b with
-  | nil => simp_all
-  | cons a l ih =>
-    simp only [foldl_cons]
-    apply ih
-    · simp_all
-    · exact fun a m c c' h => h' _ (by simp_all) _ _ h
-
-/--
-We can prove that two folds over the same list are related (by some arbitrary relation)
-if we know that the initial elements are related and the folding function, for each element of the list,
-preserves the relation.
--/
-theorem foldr_rel {l : List α} {f g : α → β → β} {a b : β} (r : β → β → Prop)
-    (h : r a b) (h' : ∀ (a : α), a ∈ l → ∀ (c c' : β), r c c' → r (f a c) (g a c')) :
-    r (l.foldr (fun a acc => f a acc) a) (l.foldr (fun a acc => g a acc) b) := by
-  induction l generalizing a b with
-  | nil => simp_all
-  | cons a l ih =>
-    simp only [foldr_cons]
-    apply h'
-    · simp
-    · exact ih h fun a m c c' h => h' _ (by simp_all) _ _ h
-
-@[simp] theorem foldl_add_const (l : List α) (a b : Nat) :
-    l.foldl (fun x _ => x + a) b = b + a * l.length := by
-  induction l generalizing b with
-  | nil => simp
-  | cons y l ih =>
-    simp only [foldl_cons, ih, length_cons, Nat.mul_add, Nat.mul_one, Nat.add_assoc,
-      Nat.add_comm a]
-
-@[simp] theorem foldr_add_const (l : List α) (a b : Nat) :
-    l.foldr (fun _ x => x + a) b = b + a * l.length := by
-  induction l generalizing b with
-  | nil => simp
-  | cons y l ih =>
-    simp only [foldr_cons, ih, length_cons, Nat.mul_add, Nat.mul_one, Nat.add_assoc]
-
 /-! ### getLast -/
 
 theorem getLast_eq_getElem : ∀ (l : List α) (h : l ≠ []),
@@ -1216,27 +1016,6 @@ theorem getLast?_tail (l : List α) : (tail l).getLast? = if l.length = 1 then n
 
 /-! ### map -/
 
-@[simp] theorem map_id_fun : map (id : α → α) = id := by
-  funext l
-  induction l <;> simp_all
-
-/-- `map_id_fun'` differs from `map_id_fun` by representing the identity function as a lambda, rather than `id`. -/
-@[simp] theorem map_id_fun' : map (fun (a : α) => a) = id := map_id_fun
-
--- This is not a `@[simp]` lemma because `map_id_fun` will apply.
-theorem map_id (l : List α) : map (id : α → α) l = l := by
-  induction l <;> simp_all
-
-/-- `map_id'` differs from `map_id` by representing the identity function as a lambda, rather than `id`. -/
--- This is not a `@[simp]` lemma because `map_id_fun'` will apply.
-theorem map_id' (l : List α) : map (fun (a : α) => a) l = l := map_id l
-
-/-- Variant of `map_id`, with a side condition that the function is pointwise the identity. -/
-theorem map_id'' {f : α → α} (h : ∀ x, f x = x) (l : List α) : map f l = l := by
-  simp [show f = id from funext h]
-
-theorem map_singleton (f : α → β) (a : α) : map f [a] = [f a] := rfl
-
 @[simp] theorem length_map (as : List α) (f : α → β) : (as.map f).length = as.length := by
   induction as with
   | nil => simp [List.map]
@@ -1262,6 +1041,27 @@ theorem get_map (f : α → β) {l i} :
     get (map f l) i = f (get l ⟨i, length_map l f ▸ i.2⟩) := by
   simp
 
+@[simp] theorem map_id_fun : map (id : α → α) = id := by
+  funext l
+  induction l <;> simp_all
+
+/-- `map_id_fun'` differs from `map_id_fun` by representing the identity function as a lambda, rather than `id`. -/
+@[simp] theorem map_id_fun' : map (fun (a : α) => a) = id := map_id_fun
+
+-- This is not a `@[simp]` lemma because `map_id_fun` will apply.
+theorem map_id (l : List α) : map (id : α → α) l = l := by
+  induction l <;> simp_all
+
+/-- `map_id'` differs from `map_id` by representing the identity function as a lambda, rather than `id`. -/
+-- This is not a `@[simp]` lemma because `map_id_fun'` will apply.
+theorem map_id' (l : List α) : map (fun (a : α) => a) l = l := map_id l
+
+/-- Variant of `map_id`, with a side condition that the function is pointwise the identity. -/
+theorem map_id'' {f : α → α} (h : ∀ x, f x = x) (l : List α) : map f l = l := by
+  simp [show f = id from funext h]
+
+theorem map_singleton (f : α → β) (a : α) : map f [a] = [f a] := rfl
+
 @[simp] theorem mem_map {f : α → β} : ∀ {l : List α}, b ∈ l.map f ↔ ∃ a, a ∈ l ∧ f a = b
   | [] => by simp
   | _ :: l => by simp [mem_map (l := l), eq_comm (a := b)]
@@ -1315,6 +1115,10 @@ theorem map_eq_cons_iff' {f : α → β} {l : List α} :
 
 @[deprecated map_eq_cons' (since := "2024-09-05")] abbrev map_eq_cons' := @map_eq_cons_iff'
 
+@[simp] theorem map_eq_singleton_iff {f : α → β} {l : List α} {b : β} :
+    map f l = [b] ↔ ∃ a, l = [a] ∧ f a = b := by
+  simp [map_eq_cons_iff]
+
 theorem map_eq_map_iff : map f l = map g l ↔ ∀ a ∈ l, f a = g a := by
   induction l <;> simp
 
@@ -1481,7 +1285,7 @@ theorem map_filter_eq_foldr (f : α → β) (p : α → Bool) (as : List α) :
 @[simp] theorem filter_append {p : α → Bool} :
     ∀ (l₁ l₂ : List α), filter p (l₁ ++ l₂) = filter p l₁ ++ filter p l₂
   | [], _ => rfl
-  | a :: l₁, l₂ => by simp [filter]; split <;> simp [filter_append l₁]
+  | a :: l₁, l₂ => by simp only [cons_append, filter]; split <;> simp [filter_append l₁]
 
 theorem filter_eq_cons_iff {l} {a} {as} :
     filter p l = a :: as ↔
@@ -1961,16 +1765,6 @@ theorem set_append {s t : List α} :
     (s ++ t).set i x = s ++ t.set (i - s.length) x := by
   rw [set_append, if_neg (by simp_all)]
 
-@[simp] theorem foldrM_append [Monad m] [LawfulMonad m] (f : α → β → m β) (b) (l l' : List α) :
-    (l ++ l').foldrM f b = l'.foldrM f b >>= l.foldrM f := by
-  induction l <;> simp [*]
-
-@[simp] theorem foldl_append {β : Type _} (f : β → α → β) (b) (l l' : List α) :
-    (l ++ l').foldl f b = l'.foldl f (l.foldl f b) := by simp [foldl_eq_foldlM]
-
-@[simp] theorem foldr_append (f : α → β → β) (b) (l l' : List α) :
-    (l ++ l').foldr f b = l.foldr f (l'.foldr f b) := by simp [foldr_eq_foldrM]
-
 theorem filterMap_eq_append_iff {f : α → Option β} :
     filterMap f l = L₁ ++ L₂ ↔ ∃ l₁ l₂, l = l₁ ++ l₂ ∧ filterMap f l₁ = L₁ ∧ filterMap f l₂ = L₂ := by
   constructor
@@ -2119,14 +1913,6 @@ theorem head?_flatten {L : List (List α)} : (flatten L).head? = L.findSome? fun
 -- `getLast?_flatten` is proved later, after the `reverse` section.
 -- `head_flatten` and `getLast_flatten` are proved in `Init.Data.List.Find`.
 
-theorem foldl_flatten (f : β → α → β) (b : β) (L : List (List α)) :
-    (flatten L).foldl f b = L.foldl (fun b l => l.foldl f b) b := by
-  induction L generalizing b <;> simp_all
-
-theorem foldr_flatten (f : α → β → β) (b : β) (L : List (List α)) :
-    (flatten L).foldr f b = L.foldr (fun l b => l.foldr f b) b := by
-  induction L <;> simp_all
-
 @[simp] theorem map_flatten (f : α → β) (L : List (List α)) : map f (flatten L) = flatten (map (map f) L) := by
   induction L <;> simp_all
 
@@ -2699,10 +2485,114 @@ theorem flatMap_reverse {β} (l : List α) (f : α → List β) : (l.reverse.fla
 @[simp] theorem reverseAux_eq (as bs : List α) : reverseAux as bs = reverse as ++ bs :=
   reverseAux_eq_append ..
 
+@[simp] theorem reverse_replicate (n) (a : α) : reverse (replicate n a) = replicate n a :=
+  eq_replicate_iff.2
+    ⟨by rw [length_reverse, length_replicate],
+     fun _ h => eq_of_mem_replicate (mem_reverse.1 h)⟩
+
+
+/-! ### foldlM and foldrM -/
+
+@[simp] theorem foldlM_append [Monad m] [LawfulMonad m] (f : β → α → m β) (b) (l l' : List α) :
+    (l ++ l').foldlM f b = l.foldlM f b >>= l'.foldlM f := by
+  induction l generalizing b <;> simp [*]
+
+@[simp] theorem foldrM_cons [Monad m] [LawfulMonad m] (a : α) (l) (f : α → β → m β) (b) :
+    (a :: l).foldrM f b = l.foldrM f b >>= f a := by
+  simp only [foldrM]
+  induction l <;> simp_all
+
+theorem foldl_eq_foldlM (f : β → α → β) (b) (l : List α) :
+    l.foldl f b = l.foldlM (m := Id) f b := by
+  induction l generalizing b <;> simp [*, foldl]
+
+theorem foldr_eq_foldrM (f : α → β → β) (b) (l : List α) :
+    l.foldr f b = l.foldrM (m := Id) f b := by
+  induction l <;> simp [*, foldr]
+
+@[simp] theorem id_run_foldlM (f : β → α → Id β) (b) (l : List α) :
+    Id.run (l.foldlM f b) = l.foldl f b := (foldl_eq_foldlM f b l).symm
+
+@[simp] theorem id_run_foldrM (f : α → β → Id β) (b) (l : List α) :
+    Id.run (l.foldrM f b) = l.foldr f b := (foldr_eq_foldrM f b l).symm
+
+@[simp] theorem foldlM_reverse [Monad m] (l : List α) (f : β → α → m β) (b) :
+    l.reverse.foldlM f b = l.foldrM (fun x y => f y x) b := rfl
+
 @[simp] theorem foldrM_reverse [Monad m] (l : List α) (f : α → β → m β) (b) :
     l.reverse.foldrM f b = l.foldlM (fun x y => f y x) b :=
   (foldlM_reverse ..).symm.trans <| by simp
 
+/-! ### foldl and foldr -/
+
+@[simp] theorem foldr_cons_eq_append (l : List α) : l.foldr cons l' = l ++ l' := by
+  induction l <;> simp [*]
+
+@[deprecated foldr_cons_eq_append (since := "2024-08-22")] abbrev foldr_self_append := @foldr_cons_eq_append
+
+@[simp] theorem foldl_flip_cons_eq_append (l : List α) : l.foldl (fun x y => y :: x) l' = l.reverse ++ l' := by
+  induction l generalizing l' <;> simp [*]
+
+theorem foldr_cons_nil (l : List α) : l.foldr cons [] = l := by simp
+
+@[deprecated foldr_cons_nil (since := "2024-09-04")] abbrev foldr_self := @foldr_cons_nil
+
+theorem foldl_map (f : β₁ → β₂) (g : α → β₂ → α) (l : List β₁) (init : α) :
+    (l.map f).foldl g init = l.foldl (fun x y => g x (f y)) init := by
+  induction l generalizing init <;> simp [*]
+
+theorem foldr_map (f : α₁ → α₂) (g : α₂ → β → β) (l : List α₁) (init : β) :
+    (l.map f).foldr g init = l.foldr (fun x y => g (f x) y) init := by
+  induction l generalizing init <;> simp [*]
+
+theorem foldl_filterMap (f : α → Option β) (g : γ → β → γ) (l : List α) (init : γ) :
+    (l.filterMap f).foldl g init = l.foldl (fun x y => match f y with | some b => g x b | none => x) init := by
+  induction l generalizing init with
+  | nil => rfl
+  | cons a l ih =>
+    simp only [filterMap_cons, foldl_cons]
+    cases f a <;> simp [ih]
+
+theorem foldr_filterMap (f : α → Option β) (g : β → γ → γ) (l : List α) (init : γ) :
+    (l.filterMap f).foldr g init = l.foldr (fun x y => match f x with | some b => g b y | none => y) init := by
+  induction l generalizing init with
+  | nil => rfl
+  | cons a l ih =>
+    simp only [filterMap_cons, foldr_cons]
+    cases f a <;> simp [ih]
+
+theorem foldl_map' (g : α → β) (f : α → α → α) (f' : β → β → β) (a : α) (l : List α)
+    (h : ∀ x y, f' (g x) (g y) = g (f x y)) :
+    (l.map g).foldl f' (g a) = g (l.foldl f a) := by
+  induction l generalizing a
+  · simp
+  · simp [*, h]
+
+theorem foldr_map' (g : α → β) (f : α → α → α) (f' : β → β → β) (a : α) (l : List α)
+    (h : ∀ x y, f' (g x) (g y) = g (f x y)) :
+    (l.map g).foldr f' (g a) = g (l.foldr f a) := by
+  induction l generalizing a
+  · simp
+  · simp [*, h]
+
+@[simp] theorem foldrM_append [Monad m] [LawfulMonad m] (f : α → β → m β) (b) (l l' : List α) :
+    (l ++ l').foldrM f b = l'.foldrM f b >>= l.foldrM f := by
+  induction l <;> simp [*]
+
+@[simp] theorem foldl_append {β : Type _} (f : β → α → β) (b) (l l' : List α) :
+    (l ++ l').foldl f b = l'.foldl f (l.foldl f b) := by simp [foldl_eq_foldlM]
+
+@[simp] theorem foldr_append (f : α → β → β) (b) (l l' : List α) :
+    (l ++ l').foldr f b = l.foldr f (l'.foldr f b) := by simp [foldr_eq_foldrM]
+
+theorem foldl_flatten (f : β → α → β) (b : β) (L : List (List α)) :
+    (flatten L).foldl f b = L.foldl (fun b l => l.foldl f b) b := by
+  induction L generalizing b <;> simp_all
+
+theorem foldr_flatten (f : α → β → β) (b : β) (L : List (List α)) :
+    (flatten L).foldr f b = L.foldr (fun l b => l.foldr f b) b := by
+  induction L <;> simp_all
+
 @[simp] theorem foldl_reverse (l : List α) (f : β → α → β) (b) :
     l.reverse.foldl f b = l.foldr (fun x y => f y x) b := by simp [foldl_eq_foldlM, foldr_eq_foldrM]
 
@@ -2716,10 +2606,127 @@ theorem foldl_eq_foldr_reverse (l : List α) (f : β → α → β) (b) :
 theorem foldr_eq_foldl_reverse (l : List α) (f : α → β → β) (b) :
     l.foldr f b = l.reverse.foldl (fun x y => f y x) b := by simp
 
-@[simp] theorem reverse_replicate (n) (a : α) : reverse (replicate n a) = replicate n a :=
-  eq_replicate_iff.2
-    ⟨by rw [length_reverse, length_replicate],
-     fun _ h => eq_of_mem_replicate (mem_reverse.1 h)⟩
+theorem foldl_assoc {op : α → α → α} [ha : Std.Associative op] :
+    ∀ {l : List α} {a₁ a₂}, l.foldl op (op a₁ a₂) = op a₁ (l.foldl op a₂)
+  | [], a₁, a₂ => rfl
+  | a :: l, a₁, a₂ => by
+    simp only [foldl_cons, ha.assoc]
+    rw [foldl_assoc]
+
+theorem foldr_assoc {op : α → α → α} [ha : Std.Associative op] :
+    ∀ {l : List α} {a₁ a₂}, l.foldr op (op a₁ a₂) = op (l.foldr op a₁) a₂
+  | [], a₁, a₂ => rfl
+  | a :: l, a₁, a₂ => by
+    simp only [foldr_cons, ha.assoc]
+    rw [foldr_assoc]
+
+theorem foldl_hom (f : α₁ → α₂) (g₁ : α₁ → β → α₁) (g₂ : α₂ → β → α₂) (l : List β) (init : α₁)
+    (H : ∀ x y, g₂ (f x) y = f (g₁ x y)) : l.foldl g₂ (f init) = f (l.foldl g₁ init) := by
+  induction l generalizing init <;> simp [*, H]
+
+theorem foldr_hom (f : β₁ → β₂) (g₁ : α → β₁ → β₁) (g₂ : α → β₂ → β₂) (l : List α) (init : β₁)
+    (H : ∀ x y, g₂ x (f y) = f (g₁ x y)) : l.foldr g₂ (f init) = f (l.foldr g₁ init) := by
+  induction l <;> simp [*, H]
+
+/--
+Prove a proposition about the result of `List.foldl`,
+by proving it for the initial data,
+and the implication that the operation applied to any element of the list preserves the property.
+
+The motive can take values in `Sort _`, so this may be used to construct data,
+as well as to prove propositions.
+-/
+def foldlRecOn {motive : β → Sort _} : ∀ (l : List α) (op : β → α → β) (b : β) (_ : motive b)
+    (_ : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ l), motive (op b a)), motive (List.foldl op b l)
+  | [], _, _, hb, _ => hb
+  | hd :: tl, op, b, hb, hl =>
+    foldlRecOn tl op (op b hd) (hl b hb hd (mem_cons_self hd tl))
+      fun y hy x hx => hl y hy x (mem_cons_of_mem hd hx)
+
+@[simp] theorem foldlRecOn_nil {motive : β → Sort _} (hb : motive b)
+    (hl : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ []), motive (op b a)) :
+    foldlRecOn [] op b hb hl = hb := rfl
+
+@[simp] theorem foldlRecOn_cons {motive : β → Sort _} (hb : motive b)
+    (hl : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ x :: l), motive (op b a)) :
+    foldlRecOn (x :: l) op b hb hl =
+      foldlRecOn l op (op b x) (hl b hb x (mem_cons_self x l))
+        (fun b c a m => hl b c a (mem_cons_of_mem x m)) :=
+  rfl
+
+/--
+Prove a proposition about the result of `List.foldr`,
+by proving it for the initial data,
+and the implication that the operation applied to any element of the list preserves the property.
+
+The motive can take values in `Sort _`, so this may be used to construct data,
+as well as to prove propositions.
+-/
+def foldrRecOn {motive : β → Sort _} : ∀ (l : List α) (op : α → β → β) (b : β) (_ : motive b)
+    (_ : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ l), motive (op a b)), motive (List.foldr op b l)
+  | nil, _, _, hb, _ => hb
+  | x :: l, op, b, hb, hl =>
+    hl (foldr op b l)
+      (foldrRecOn l op b hb fun b c a m => hl b c a (mem_cons_of_mem x m)) x (mem_cons_self x l)
+
+@[simp] theorem foldrRecOn_nil {motive : β → Sort _} (hb : motive b)
+    (hl : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ []), motive (op a b)) :
+    foldrRecOn [] op b hb hl = hb := rfl
+
+@[simp] theorem foldrRecOn_cons {motive : β → Sort _} (hb : motive b)
+    (hl : ∀ (b : β) (_ : motive b) (a : α) (_ : a ∈ x :: l), motive (op a b)) :
+    foldrRecOn (x :: l) op b hb hl =
+      hl _ (foldrRecOn l op b hb fun b c a m => hl b c a (mem_cons_of_mem x m))
+        x (mem_cons_self x l) :=
+  rfl
+
+/--
+We can prove that two folds over the same list are related (by some arbitrary relation)
+if we know that the initial elements are related and the folding function, for each element of the list,
+preserves the relation.
+-/
+theorem foldl_rel {l : List α} {f g : β → α → β} {a b : β} (r : β → β → Prop)
+    (h : r a b) (h' : ∀ (a : α), a ∈ l → ∀ (c c' : β), r c c' → r (f c a) (g c' a)) :
+    r (l.foldl (fun acc a => f acc a) a) (l.foldl (fun acc a => g acc a) b) := by
+  induction l generalizing a b with
+  | nil => simp_all
+  | cons a l ih =>
+    simp only [foldl_cons]
+    apply ih
+    · simp_all
+    · exact fun a m c c' h => h' _ (by simp_all) _ _ h
+
+/--
+We can prove that two folds over the same list are related (by some arbitrary relation)
+if we know that the initial elements are related and the folding function, for each element of the list,
+preserves the relation.
+-/
+theorem foldr_rel {l : List α} {f g : α → β → β} {a b : β} (r : β → β → Prop)
+    (h : r a b) (h' : ∀ (a : α), a ∈ l → ∀ (c c' : β), r c c' → r (f a c) (g a c')) :
+    r (l.foldr (fun a acc => f a acc) a) (l.foldr (fun a acc => g a acc) b) := by
+  induction l generalizing a b with
+  | nil => simp_all
+  | cons a l ih =>
+    simp only [foldr_cons]
+    apply h'
+    · simp
+    · exact ih h fun a m c c' h => h' _ (by simp_all) _ _ h
+
+@[simp] theorem foldl_add_const (l : List α) (a b : Nat) :
+    l.foldl (fun x _ => x + a) b = b + a * l.length := by
+  induction l generalizing b with
+  | nil => simp
+  | cons y l ih =>
+    simp only [foldl_cons, ih, length_cons, Nat.mul_add, Nat.mul_one, Nat.add_assoc,
+      Nat.add_comm a]
+
+@[simp] theorem foldr_add_const (l : List α) (a b : Nat) :
+    l.foldr (fun _ x => x + a) b = b + a * l.length := by
+  induction l generalizing b with
+  | nil => simp
+  | cons y l ih =>
+    simp only [foldr_cons, ih, length_cons, Nat.mul_add, Nat.mul_one, Nat.add_assoc]
+
 
 /-! #### Further results about `getLast` and `getLast?` -/
 

src/Init/Data/List/Lex.lean

@@ -5,6 +5,7 @@ Authors: Kim Morrison
 -/
 prelude
 import Init.Data.List.Lemmas
+import Init.Data.List.Nat.TakeDrop
 
 namespace List
 
@@ -13,8 +14,8 @@ namespace List
 @[simp] theorem lex_lt [LT α] (l₁ l₂ : List α) : Lex (· < ·) l₁ l₂ ↔ l₁ < l₂ := Iff.rfl
 @[simp] theorem not_lex_lt [LT α] (l₁ l₂ : List α) : ¬ Lex (· < ·) l₁ l₂ ↔ l₂ ≤ l₁ := Iff.rfl
 
-theorem not_lt_iff_ge [LT α] (l₁ l₂ : List α) : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
-theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] (l₁ l₂ : List α) :
+protected theorem not_lt_iff_ge [LT α] (l₁ l₂ : List α) : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
+protected theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] (l₁ l₂ : List α) :
     ¬ l₁ ≤ l₂ ↔ l₂ < l₁ :=
   Decidable.not_not
 
@@ -33,6 +34,7 @@ instance ltIrrefl [LT α] [Std.Irrefl (· < · : α → α → Prop)] : Std.Irre
 
 @[simp] theorem not_lex_nil : ¬Lex r l [] := fun h => nomatch h
 
+@[simp] theorem not_lt_nil [LT α] (l : List α) : ¬ l < [] := fun h => nomatch h
 @[simp] theorem nil_le [LT α] (l : List α) : [] ≤ l := fun h => nomatch h
 
 @[simp] theorem not_nil_lex_iff : ¬Lex r [] l ↔ l = [] := by
@@ -59,6 +61,10 @@ theorem cons_lt_cons_iff [LT α] {a b} {l₁ l₂ : List α} :
   dsimp only [instLT, List.lt]
   simp [cons_lex_cons_iff]
 
+@[simp] theorem cons_lt_cons_self [LT α] [i₀ : Std.Irrefl (· < · : α → α → Prop)] {l₁ l₂ : List α} :
+    (a :: l₁) < (a :: l₂) ↔ l₁ < l₂ := by
+  simp [cons_lt_cons_iff, i₀.irrefl]
+
 theorem not_cons_lex_cons_iff [DecidableEq α] [DecidableRel r] {a b} {l₁ l₂ : List α} :
     ¬ Lex r (a :: l₁) (b :: l₂) ↔ (¬ r a b ∧ a ≠ b) ∨ (¬ r a b ∧ ¬ Lex r l₁ l₂) := by
   rw [cons_lex_cons_iff, not_or, Decidable.not_and_iff_or_not, and_or_left]
@@ -120,7 +126,7 @@ protected theorem le_refl [LT α] [i₀ : Std.Irrefl (· < · : α → α → Pr
 instance [LT α] [Std.Irrefl (· < · : α → α → Prop)] : Std.Refl (· ≤ · : List α → List α → Prop) where
   refl := List.le_refl
 
-theorem lex_trans {r : α → α → Prop} [DecidableRel r]
+theorem lex_trans {r : α → α → Prop}
     (lt_trans : ∀ {x y z : α}, r x y → r y z → r x z)
     (h₁ : Lex r l₁ l₂) (h₂ : Lex r l₂ l₃) : Lex r l₁ l₃ := by
   induction h₁ generalizing l₃ with
@@ -137,14 +143,13 @@ theorem lex_trans {r : α → α → Prop} [DecidableRel r]
     | .cons ih =>
       exact List.Lex.cons (ih2 ih)
 
-protected theorem lt_trans [LT α] [DecidableLT α]
+protected theorem lt_trans [LT α]
     [i₁ : Trans (· < · : α → α → Prop) (· < ·) (· < ·)]
     {l₁ l₂ l₃ : List α} (h₁ : l₁ < l₂) (h₂ : l₂ < l₃) : l₁ < l₃ := by
   simp only [instLT, List.lt] at h₁ h₂ ⊢
   exact lex_trans (fun h₁ h₂ => i₁.trans h₁ h₂) h₁ h₂
 
-instance [LT α] [DecidableLT α]
-    [Trans (· < · : α → α → Prop) (· < ·) (· < ·)] :
+instance [LT α] [Trans (· < · : α → α → Prop) (· < ·) (· < ·)] :
     Trans (· < · : List α → List α → Prop) (· < ·) (· < ·) where
   trans h₁ h₂ := List.lt_trans h₁ h₂
 
@@ -197,7 +202,7 @@ instance [DecidableEq α] [LT α] [DecidableLT α]
     Trans (· ≤ · : List α → List α → Prop) (· ≤ ·) (· ≤ ·) where
   trans h₁ h₂ := List.le_trans h₁ h₂
 
-theorem lex_asymm {r : α → α → Prop} [DecidableRel r]
+theorem lex_asymm {r : α → α → Prop}
     (h : ∀ {x y : α}, r x y → ¬ r y x) : ∀ {l₁ l₂ : List α}, Lex r l₁ l₂ → ¬ Lex r l₂ l₁
   | nil, _, .nil => by simp
   | x :: l₁, y :: l₂, .rel h₁ =>
@@ -209,12 +214,11 @@ theorem lex_asymm {r : α → α → Prop} [DecidableRel r]
     | .rel h₂ => h h₂ h₂
     | .cons h₂ => lex_asymm h h₁ h₂
 
-protected theorem lt_asymm [DecidableEq α] [LT α] [DecidableLT α]
+protected theorem lt_asymm [LT α]
     [i : Std.Asymm (· < · : α → α → Prop)]
     {l₁ l₂ : List α} (h : l₁ < l₂) : ¬ l₂ < l₁ := lex_asymm (i.asymm _ _) h
 
-instance [DecidableEq α] [LT α] [DecidableLT α]
-    [Std.Asymm (· < · : α → α → Prop)] :
+instance [LT α] [Std.Asymm (· < · : α → α → Prop)] :
     Std.Asymm (· < · : List α → List α → Prop) where
   asymm _ _ := List.lt_asymm
 
@@ -234,13 +238,43 @@ theorem not_lex_total [DecidableEq α] {r : α → α → Prop} [DecidableRel r]
     obtain (_ | _) := not_lex_total h l₁ l₂ <;> contradiction
 
 protected theorem le_total [DecidableEq α] [LT α] [DecidableLT α]
-    [i : Std.Total (¬ · < · : α → α → Prop)] {l₁ l₂ : List α} : l₁ ≤ l₂ ∨ l₂ ≤ l₁ :=
+    [i : Std.Total (¬ · < · : α → α → Prop)] (l₁ l₂ : List α) : l₁ ≤ l₂ ∨ l₂ ≤ l₁ :=
   not_lex_total i.total l₂ l₁
 
 instance [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Total (¬ · < · : α → α → Prop)] :
     Std.Total (· ≤ · : List α → List α → Prop) where
-  total _ _ := List.le_total
+  total := List.le_total
+
+@[simp] protected theorem not_lt [LT α]
+    {l₁ l₂ : List α} : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
+
+@[simp] protected theorem not_le [DecidableEq α] [LT α] [DecidableLT α]
+    {l₁ l₂ : List α} : ¬ l₂ ≤ l₁ ↔ l₁ < l₂ := Decidable.not_not
+
+protected theorem le_of_lt [DecidableEq α] [LT α] [DecidableLT α]
+    [i : Std.Total (¬ · < · : α → α → Prop)]
+    {l₁ l₂ : List α} (h : l₁ < l₂) : l₁ ≤ l₂ := by
+  obtain (h' | h') := List.le_total l₁ l₂
+  · exact h'
+  · exfalso
+    exact h' h
+
+protected theorem le_iff_lt_or_eq [DecidableEq α] [LT α] [DecidableLT α]
+    [Std.Irrefl (· < · : α → α → Prop)]
+    [Std.Antisymm (¬ · < · : α → α → Prop)]
+    [Std.Total (¬ · < · : α → α → Prop)]
+    {l₁ l₂ : List α} : l₁ ≤ l₂ ↔ l₁ < l₂ ∨ l₁ = l₂ := by
+  constructor
+  · intro h
+    by_cases h' : l₂ ≤ l₁
+    · right
+      apply List.le_antisymm h h'
+    · left
+      exact Decidable.not_not.mp h'
+  · rintro (h | rfl)
+    · exact List.le_of_lt h
+    · exact List.le_refl l₁
 
 theorem lex_eq_decide_lex [DecidableEq α] (lt : α → α → Bool) :
     lex l₁ l₂ lt = decide (Lex (fun x y => lt x y) l₁ l₂) := by
@@ -299,7 +333,7 @@ theorem lex_eq_true_iff_exists [BEq α] (lt : α → α → Bool) :
     cases l₂ with
     | nil => simp [lex]
     | cons b l₂ =>
-      simp only [lex_cons_cons, Bool.or_eq_true, Bool.and_eq_true, ih, isEqv, length_cons]
+      simp [lex_cons_cons, Bool.or_eq_true, Bool.and_eq_true, ih, isEqv, length_cons]
       constructor
       · rintro (hab | ⟨hab, ⟨h₁, h₂⟩ | ⟨i, h₁, h₂, w₁, w₂⟩⟩)
         · exact .inr ⟨0, by simp [hab]⟩
@@ -363,7 +397,7 @@ theorem lex_eq_false_iff_exists [BEq α] [PartialEquivBEq α] (lt : α → α
     cases l₂ with
     | nil => simp [lex]
     | cons b l₂ =>
-      simp only [lex_cons_cons, Bool.or_eq_false_iff, Bool.and_eq_false_imp, ih, isEqv,
+      simp [lex_cons_cons, Bool.or_eq_false_iff, Bool.and_eq_false_imp, ih, isEqv,
         Bool.and_eq_true, length_cons]
       constructor
       · rintro ⟨hab, h⟩
@@ -401,7 +435,7 @@ theorem lex_eq_false_iff_exists [BEq α] [PartialEquivBEq α] (lt : α → α
               simpa using w₁ (j + 1) (by simpa)
             · simpa using w₂
 
-theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : List α} :
+protected theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : List α} :
     l₁ < l₂ ↔
       (l₁ = l₂.take l₁.length ∧ l₁.length < l₂.length) ∨
         (∃ (i : Nat) (h₁ : i < l₁.length) (h₂ : i < l₂.length),
@@ -410,7 +444,7 @@ theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Lis
   rw [← lex_eq_true_iff_lt, lex_eq_true_iff_exists]
   simp
 
-theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
+protected theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Asymm (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)] {l₁ l₂ : List α} :
@@ -427,4 +461,63 @@ theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
   · simpa using Std.Asymm.asymm
   · simpa using Std.Antisymm.antisymm
 
+theorem append_left_lt [LT α] {l₁ l₂ l₃ : List α} (h : l₂ < l₃) :
+    l₁ ++ l₂ < l₁ ++ l₃ := by
+  induction l₁ with
+  | nil => simp [h]
+  | cons a l₁ ih => simp [cons_lt_cons_iff, ih]
+
+theorem append_left_le [DecidableEq α] [LT α] [DecidableLT α]
+    [Std.Irrefl (· < · : α → α → Prop)]
+    [Std.Asymm (· < · : α → α → Prop)]
+    [Std.Antisymm (¬ · < · : α → α → Prop)]
+    {l₁ l₂ l₃ : List α} (h : l₂ ≤ l₃) :
+    l₁ ++ l₂ ≤ l₁ ++ l₃ := by
+  induction l₁ with
+  | nil => simp [h]
+  | cons a l₁ ih => simp [cons_le_cons_iff, ih]
+
+theorem le_append_left [LT α] [Std.Irrefl (· < · : α → α → Prop)]
+    {l₁ l₂ : List α} : l₁ ≤ l₁ ++ l₂ := by
+  intro h
+  match l₁, h with
+  | nil, h => simp at h
+  | cons a l₁, h => exact le_append_left (by simpa using h)
+
+theorem IsPrefix.le [LT α] [Std.Irrefl (· < · : α → α → Prop)]
+    {l₁ l₂ : List α} (h : l₁ <+: l₂) : l₁ ≤ l₂ := by
+  rcases h with ⟨_, rfl⟩
+  apply le_append_left
+
+protected theorem map_lt [LT α] [LT β]
+    {l₁ l₂ : List α} {f : α → β} (w : ∀ x y, x < y → f x < f y) (h : l₁ < l₂) :
+    map f l₁ < map f l₂ := by
+  match l₁, l₂, h with
+  | nil, nil, h => simp at h
+  | nil, cons b l₂, h => simp
+  | cons a l₁, nil, h => simp at h
+  | cons a l₁, cons _ l₂, .cons h =>
+    simp [cons_lt_cons_iff, List.map_lt w (by simpa using h)]
+  | cons a l₁, cons b l₂, .rel h =>
+    simp [cons_lt_cons_iff, w, h]
+
+protected theorem map_le [DecidableEq α] [LT α] [DecidableLT α] [DecidableEq β] [LT β] [DecidableLT β]
+    [Std.Irrefl (· < · : α → α → Prop)]
+    [Std.Asymm (· < · : α → α → Prop)]
+    [Std.Antisymm (¬ · < · : α → α → Prop)]
+    [Std.Irrefl (· < · : β → β → Prop)]
+    [Std.Asymm (· < · : β → β → Prop)]
+    [Std.Antisymm (¬ · < · : β → β → Prop)]
+    {l₁ l₂ : List α} {f : α → β} (w : ∀ x y, x < y → f x < f y) (h : l₁ ≤ l₂) :
+    map f l₁ ≤ map f l₂ := by
+  rw [List.le_iff_exists] at h ⊢
+  obtain (h | ⟨i, h₁, h₂, w₁, w₂⟩) := h
+  · left
+    rw [h]
+    simp
+  · right
+    refine ⟨i, by simpa using h₁, by simpa using h₂, ?_, ?_⟩
+    · simp +contextual [w₁]
+    · simpa using w _ _ w₂
+
 end List

src/Init/Data/List/Perm.lean

@@ -510,4 +510,18 @@ theorem Perm.eraseP (f : α → Bool) {l₁ l₂ : List α}
     refine (IH₁ H).trans (IH₂ ((p₁.pairwise_iff ?_).1 H))
     exact fun h h₁ h₂ => h h₂ h₁
 
+theorem perm_insertIdx {α} (x : α) (l : List α) {n} (h : n ≤ l.length) :
+    insertIdx n x l ~ x :: l := by
+  induction l generalizing n with
+  | nil =>
+    cases n with
+    | zero => rfl
+    | succ => cases h
+  | cons _ _ ih =>
+    cases n with
+    | zero => simp [insertIdx]
+    | succ =>
+      simp only [insertIdx, modifyTailIdx]
+      refine .trans (.cons _ (ih (Nat.le_of_succ_le_succ h))) (.swap ..)
+
 end List

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

@@ -253,6 +253,10 @@ theorem merge_perm_append : ∀ {xs ys : List α}, merge xs ys le ~ xs ++ ys
     · exact (merge_perm_append.cons y).trans
         ((Perm.swap x y _).trans (perm_middle.symm.cons x))
 
+theorem Perm.merge (s₁ s₂ : α → α → Bool) (hl : l₁ ~ l₂) (hr : r₁ ~ r₂) :
+    merge l₁ r₁ s₁ ~ merge l₂ r₂ s₂ :=
+  Perm.trans (merge_perm_append ..) <| Perm.trans (Perm.append hl hr) <| Perm.symm (merge_perm_append ..)
+
 /-! ### mergeSort -/
 
 @[simp] theorem mergeSort_nil : [].mergeSort r = [] := by rw [List.mergeSort]

src/Init/Data/List/Zip.lean

@@ -259,7 +259,7 @@ theorem zip_map (f : α → γ) (g : β → δ) :
   | [], _ => rfl
   | _, [] => by simp only [map, zip_nil_right]
   | _ :: _, _ :: _ => by
-    simp only [map, zip_cons_cons, zip_map, Prod.map]; constructor
+    simp only [map, zip_cons_cons, zip_map, Prod.map]; try constructor -- TODO: remove try constructor after update stage0
 
 theorem zip_map_left (f : α → γ) (l₁ : List α) (l₂ : List β) :
     zip (l₁.map f) l₂ = (zip l₁ l₂).map (Prod.map f id) := by rw [← zip_map, map_id]

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

@@ -26,11 +26,11 @@ theorem div_le_iff_le_mul (h : 0 < k) : x / k ≤ y ↔ x ≤ y * k + k - 1 := b
   omega
 
 -- TODO: reprove `div_eq_of_lt_le` in terms of this:
-theorem div_eq_iff (h : 0 < k) : x / k = y ↔ x ≤ y * k + k - 1 ∧ y * k ≤ x := by
+protected theorem div_eq_iff (h : 0 < k) : x / k = y ↔ x ≤ y * k + k - 1 ∧ y * k ≤ x := by
   rw [Nat.eq_iff_le_and_ge, le_div_iff_mul_le h, Nat.div_le_iff_le_mul h]
 
 theorem lt_of_div_eq_zero (h : 0 < k) (h' : x / k = 0) : x < k := by
-  rw [div_eq_iff h] at h'
+  rw [Nat.div_eq_iff h] at h'
   omega
 
 theorem div_eq_zero_iff_lt (h : 0 < k) : x / k = 0 ↔ x < k :=
@@ -49,4 +49,17 @@ theorem lt_div_mul_self (h : 0 < k) (w : k ≤ x) : x - k < x / k * k := by
   have : x % k < k := mod_lt x h
   omega
 
+theorem div_pos (hba : b ≤ a) (hb : 0 < b) : 0 < a / b := by
+  cases b
+  · contradiction
+  · simp [Nat.pos_iff_ne_zero, div_eq_zero_iff_lt, hba]
+
+theorem div_le_div_left (hcb : c ≤ b) (hc : 0 < c) : a / b ≤ a / c :=
+  (Nat.le_div_iff_mul_le hc).2 <|
+    Nat.le_trans (Nat.mul_le_mul_left _ hcb) (Nat.div_mul_le_self a b)
+
+theorem div_add_le_right {z : Nat} (h : 0 < z) (x y : Nat) :
+    x / (y + z) ≤ x / z :=
+  div_le_div_left (Nat.le_add_left z y) h
+
 end Nat

src/Init/Data/String/Lemmas.lean

@@ -23,7 +23,7 @@ attribute [local instance] Char.notLTTrans Char.notLTAntisymm Char.notLTTotal
 
 protected theorem le_trans {a b c : String} : a ≤ b → b ≤ c → a ≤ c := List.le_trans
 protected theorem lt_trans {a b c : String} : a < b → b < c → a < c := List.lt_trans
-protected theorem le_total (a b : String) : a ≤ b ∨ b ≤ a := List.le_total
+protected theorem le_total (a b : String) : a ≤ b ∨ b ≤ a := List.le_total _ _
 protected theorem le_antisymm {a b : String} : a ≤ b → b ≤ a → a = b := fun h₁ h₂ => String.ext (List.le_antisymm (as := a.data) (bs := b.data) h₁ h₂)
 protected theorem lt_asymm {a b : String} (h : a < b) : ¬ b < a := List.lt_asymm h
 protected theorem ne_of_lt {a b : String} (h : a < b) : a ≠ b := by

src/Init/Data/UInt/Basic.lean

@@ -159,6 +159,8 @@ def UInt32.xor (a b : UInt32) : UInt32 := ⟨a.toBitVec ^^^ b.toBitVec⟩
 def UInt32.shiftLeft (a b : UInt32) : UInt32 := ⟨a.toBitVec <<< (mod b 32).toBitVec⟩
 @[extern "lean_uint32_shift_right"]
 def UInt32.shiftRight (a b : UInt32) : UInt32 := ⟨a.toBitVec >>> (mod b 32).toBitVec⟩
+def UInt32.lt (a b : UInt32) : Prop := a.toBitVec < b.toBitVec
+def UInt32.le (a b : UInt32) : Prop := a.toBitVec ≤ b.toBitVec
 
 instance : Add UInt32       := ⟨UInt32.add⟩
 instance : Sub UInt32       := ⟨UInt32.sub⟩
@@ -169,6 +171,8 @@ set_option linter.deprecated false in
 instance : HMod UInt32 Nat UInt32 := ⟨UInt32.modn⟩
 
 instance : Div UInt32       := ⟨UInt32.div⟩
+instance : LT UInt32        := ⟨UInt32.lt⟩
+instance : LE UInt32        := ⟨UInt32.le⟩
 
 @[extern "lean_uint32_complement"]
 def UInt32.complement (a : UInt32) : UInt32 := ⟨~~~a.toBitVec⟩

src/Init/Data/Vector/Basic.lean

@@ -103,7 +103,7 @@ of bounds.
 @[inline] def head [NeZero n] (v : Vector α n) := v[0]'(Nat.pos_of_neZero n)
 
 /-- Push an element `x` to the end of a vector. -/
-@[inline] def push (x : α) (v : Vector α n)  : Vector α (n + 1) :=
+@[inline] def push (v : Vector α n) (x : α) : Vector α (n + 1) :=
   ⟨v.toArray.push x, by simp⟩
 
 /-- Remove the last element of a vector. -/
@@ -136,6 +136,18 @@ This will perform the update destructively provided that the vector has a refere
 @[inline] def set! (v : Vector α n) (i : Nat) (x : α) : Vector α n :=
   ⟨v.toArray.set! i x, by simp⟩
 
+@[inline] def foldlM [Monad m] (f : β → α → m β) (b : β) (v : Vector α n) : m β :=
+  v.toArray.foldlM f b
+
+@[inline] def foldrM [Monad m] (f : α → β → m β) (b : β) (v : Vector α n) : m β :=
+  v.toArray.foldrM f b
+
+@[inline] def foldl (f : β → α → β) (b : β) (v : Vector α n) : β :=
+  v.toArray.foldl f b
+
+@[inline] def foldr (f : α → β → β) (b : β) (v : Vector α n) : β :=
+  v.toArray.foldr f b
+
 /-- Append two vectors. -/
 @[inline] def append (v : Vector α n) (w : Vector α m) : Vector α (n + m) :=
   ⟨v.toArray ++ w.toArray, by simp⟩

src/Init/Data/Vector/Lemmas.lean

@@ -1,7 +1,7 @@
 /-
 Copyright (c) 2024 Shreyas Srinivas. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
-Authors: Shreyas Srinivas, Francois Dorais
+Authors: Shreyas Srinivas, Francois Dorais, Kim Morrison
 -/
 prelude
 import Init.Data.Vector.Basic
@@ -66,6 +66,18 @@ theorem toArray_mk (a : Array α) (h : a.size = n) : (Vector.mk a h).toArray = a
 @[simp] theorem back?_mk (a : Array α) (h : a.size = n) :
     (Vector.mk a h).back? = a.back? := rfl
 
+@[simp] theorem foldlM_mk [Monad m] (f : β → α → m β) (b : β) (a : Array α) (h : a.size = n) :
+    (Vector.mk a h).foldlM f b = a.foldlM f b := rfl
+
+@[simp] theorem foldrM_mk [Monad m] (f : α → β → m β) (b : β) (a : Array α) (h : a.size = n) :
+    (Vector.mk a h).foldrM f b = a.foldrM f b := rfl
+
+@[simp] theorem foldl_mk (f : β → α → β) (b : β) (a : Array α) (h : a.size = n) :
+    (Vector.mk a h).foldl f b = a.foldl f b := rfl
+
+@[simp] theorem foldr_mk (f : α → β → β) (b : β) (a : Array α) (h : a.size = n) :
+    (Vector.mk a h).foldr f b = a.foldr f b := rfl
+
 @[simp] theorem drop_mk (a : Array α) (h : a.size = n) (m) :
     (Vector.mk a h).drop m = Vector.mk (a.extract m a.size) (by simp [h]) := rfl
 
@@ -141,6 +153,14 @@ theorem toArray_mk (a : Array α) (h : a.size = n) : (Vector.mk a h).toArray = a
 @[simp] theorem all_mk (p : α → Bool) (a : Array α) (h : a.size = n) :
     (Vector.mk a h).all p = a.all p := rfl
 
+@[simp] theorem eq_mk : v = Vector.mk a h ↔ v.toArray = a := by
+  cases v
+  simp
+
+@[simp] theorem mk_eq : Vector.mk a h = v ↔ a = v.toArray := by
+  cases v
+  simp
+
 /-! ### toArray lemmas -/
 
 @[simp] theorem getElem_toArray {α n} (xs : Vector α n) (i : Nat) (h : i < xs.toArray.size) :
@@ -247,7 +267,7 @@ theorem toArray_mk (a : Array α) (h : a.size = n) : (Vector.mk a h).toArray = a
 
 @[simp] theorem toArray_mkVector : (mkVector n a).toArray = mkArray n a := rfl
 
-theorem toArray_inj {v w : Vector α n} : v.toArray = w.toArray ↔ v = w := by
+@[simp] theorem toArray_inj {v w : Vector α n} : v.toArray = w.toArray ↔ v = w := by
   cases v
   cases w
   simp
@@ -1023,11 +1043,12 @@ theorem mem_setIfInBounds (v : Vector α n) (i : Nat) (hi : i < n) (a : α) :
   cases l₂
   simp
 
-/-! Content below this point has not yet been aligned with `List` and `Array`. -/
+/-! ### map -/
 
-@[simp] theorem getElem_ofFn {α n} (f : Fin n → α) (i : Nat) (h : i < n) :
-    (Vector.ofFn f)[i] = f ⟨i, by simpa using h⟩ := by
-  simp [ofFn]
+@[simp] theorem getElem_map (f : α → β) (a : Vector α n) (i : Nat) (hi : i < n) :
+    (a.map f)[i] = f a[i] := by
+  cases a
+  simp
 
 /-- The empty vector maps to the empty vector. -/
 @[simp]
@@ -1035,6 +1056,123 @@ theorem map_empty (f : α → β) : map f #v[] = #v[] := by
   rw [map, mk.injEq]
   exact Array.map_empty f
 
+@[simp] theorem map_push {f : α → β} {as : Vector α n} {x : α} :
+    (as.push x).map f = (as.map f).push (f x) := by
+  cases as
+  simp
+
+@[simp] theorem map_id_fun : map (n := n) (id : α → α) = id := by
+  funext l
+  induction l <;> simp_all
+
+/-- `map_id_fun'` differs from `map_id_fun` by representing the identity function as a lambda, rather than `id`. -/
+@[simp] theorem map_id_fun' : map (n := n) (fun (a : α) => a) = id := map_id_fun
+
+-- This is not a `@[simp]` lemma because `map_id_fun` will apply.
+theorem map_id (l : Vector α n) : map (id : α → α) l = l := by
+  cases l <;> simp_all
+
+/-- `map_id'` differs from `map_id` by representing the identity function as a lambda, rather than `id`. -/
+-- This is not a `@[simp]` lemma because `map_id_fun'` will apply.
+theorem map_id' (l : Vector α n) : map (fun (a : α) => a) l = l := map_id l
+
+/-- Variant of `map_id`, with a side condition that the function is pointwise the identity. -/
+theorem map_id'' {f : α → α} (h : ∀ x, f x = x) (l : Vector α n) : map f l = l := by
+  simp [show f = id from funext h]
+
+theorem map_singleton (f : α → β) (a : α) : map f #v[a] = #v[f a] := rfl
+
+@[simp] theorem mem_map {f : α → β} {l : Vector α n} : b ∈ l.map f ↔ ∃ a, a ∈ l ∧ f a = b := by
+  cases l
+  simp
+
+theorem exists_of_mem_map (h : b ∈ map f l) : ∃ a, a ∈ l ∧ f a = b := mem_map.1 h
+
+theorem mem_map_of_mem (f : α → β) (h : a ∈ l) : f a ∈ map f l := mem_map.2 ⟨_, h, rfl⟩
+
+theorem forall_mem_map {f : α → β} {l : Vector α n} {P : β → Prop} :
+    (∀ (i) (_ : i ∈ l.map f), P i) ↔ ∀ (j) (_ : j ∈ l), P (f j) := by
+  simp
+
+@[simp] theorem map_inj_left {f g : α → β} : map f l = map g l ↔ ∀ a ∈ l, f a = g a := by
+  cases l <;> simp_all
+
+theorem map_congr_left (h : ∀ a ∈ l, f a = g a) : map f l = map g l :=
+  map_inj_left.2 h
+
+theorem map_inj [NeZero n] : map (n := n) f = map g ↔ f = g := by
+  constructor
+  · intro h
+    ext a
+    replace h := congrFun h (mkVector n a)
+    simp only [mkVector, map_mk, mk.injEq, Array.map_inj_left, Array.mem_mkArray,  and_imp,
+      forall_eq_apply_imp_iff] at h
+    exact h (NeZero.ne n)
+  · intro h; subst h; rfl
+
+theorem map_eq_push_iff {f : α → β} {l : Vector α (n + 1)} {l₂ : Vector β n} {b : β} :
+    map f l = l₂.push b ↔ ∃ l₁ a, l = l₁.push a ∧ map f l₁ = l₂ ∧ f a = b := by
+  rcases l with ⟨l, h⟩
+  rcases l₂ with ⟨l₂, rfl⟩
+  simp only [map_mk, push_mk, mk.injEq, Array.map_eq_push_iff]
+  constructor
+  · rintro ⟨l₁, a, rfl, rfl, rfl⟩
+    refine ⟨⟨l₁, by simp⟩, a, by simp⟩
+  · rintro ⟨l₁, a, h₁, h₂, rfl⟩
+    refine ⟨l₁.toArray, a, by simp_all⟩
+
+@[simp] theorem map_eq_singleton_iff {f : α → β} {l : Vector α 1} {b : β} :
+    map f l = #v[b] ↔ ∃ a, l = #v[a] ∧ f a = b := by
+  cases l
+  simp
+
+theorem map_eq_map_iff {f g : α → β} {l : Vector α n} :
+    map f l = map g l ↔ ∀ a ∈ l, f a = g a := by
+  cases l <;> simp_all
+
+theorem map_eq_iff {f : α → β} {l : Vector α n} {l' : Vector β n} :
+    map f l = l' ↔ ∀ i (h : i < n), l'[i] = f l[i] := by
+  rcases l with ⟨l, rfl⟩
+  rcases l' with ⟨l', h'⟩
+  simp only [map_mk, eq_mk, Array.map_eq_iff, getElem_mk]
+  constructor
+  · intro w i h
+    simpa [h, h'] using w i
+  · intro w i
+    if h : i < l.size then
+      simpa [h, h'] using w i h
+    else
+      rw [getElem?_neg, getElem?_neg, Option.map_none'] <;> omega
+
+@[simp] theorem map_set {f : α → β} {l : Vector α n} {i : Nat} {h : i < n} {a : α} :
+    (l.set i a).map f = (l.map f).set i (f a) (by simpa using h) := by
+  cases l
+  simp
+
+@[simp] theorem map_setIfInBounds {f : α → β} {l : Vector α n} {i : Nat} {a : α} :
+    (l.setIfInBounds i a).map f = (l.map f).setIfInBounds i (f a) := by
+  cases l
+  simp
+
+@[simp] theorem map_pop {f : α → β} {l : Vector α n} : l.pop.map f = (l.map f).pop := by
+  cases l
+  simp
+
+@[simp] theorem back?_map {f : α → β} {l : Vector α n} : (l.map f).back? = l.back?.map f := by
+  cases l
+  simp
+
+@[simp] theorem map_map {f : α → β} {g : β → γ} {as : Vector α n} :
+    (as.map f).map g = as.map (g ∘ f) := by
+  cases as
+  simp
+
+/-! Content below this point has not yet been aligned with `List` and `Array`. -/
+
+@[simp] theorem getElem_ofFn {α n} (f : Fin n → α) (i : Nat) (h : i < n) :
+    (Vector.ofFn f)[i] = f ⟨i, by simpa using h⟩ := by
+  simp [ofFn]
+
 @[simp] theorem getElem_push_last {v : Vector α n} {x : α} : (v.push x)[n] = x := by
   rcases v with ⟨data, rfl⟩
   simp
@@ -1088,13 +1226,6 @@ theorem getElem_append_right {a : Vector α n} {b : Vector α m} {i : Nat} (h :
   cases a
   simp
 
-/-! ### map -/
-
-@[simp] theorem getElem_map (f : α → β) (a : Vector α n) (i : Nat) (hi : i < n) :
-    (a.map f)[i] = f a[i] := by
-  cases a
-  simp
-
 /-! ### zipWith -/
 
 @[simp] theorem getElem_zipWith (f : α → β → γ) (a : Vector α n) (b : Vector β n) (i : Nat)
@@ -1103,6 +1234,37 @@ theorem getElem_append_right {a : Vector α n} {b : Vector α m} {i : Nat} (h :
   cases b
   simp
 
+/-! ### foldlM and foldrM -/
+
+@[simp] theorem foldlM_append [Monad m] [LawfulMonad m] (f : β → α → m β) (b) (l : Vector α n) (l' : Vector α n') :
+    (l ++ l').foldlM f b = l.foldlM f b >>= l'.foldlM f := by
+  cases l
+  cases l'
+  simp
+
+@[simp] theorem foldrM_push [Monad m] (f : α → β → m β) (init : β) (l : Vector α n) (a : α) :
+    (l.push a).foldrM f init = f a init >>= l.foldrM f := by
+  cases l
+  simp
+
+theorem foldl_eq_foldlM (f : β → α → β) (b) (l : Vector α n) :
+    l.foldl f b = l.foldlM (m := Id) f b := by
+  cases l
+  simp [Array.foldl_eq_foldlM]
+
+theorem foldr_eq_foldrM (f : α → β → β) (b) (l : Vector α n) :
+    l.foldr f b = l.foldrM (m := Id) f b := by
+  cases l
+  simp [Array.foldr_eq_foldrM]
+
+@[simp] theorem id_run_foldlM (f : β → α → Id β) (b) (l : Vector α n) :
+    Id.run (l.foldlM f b) = l.foldl f b := (foldl_eq_foldlM f b l).symm
+
+@[simp] theorem id_run_foldrM (f : α → β → Id β) (b) (l : Vector α n) :
+    Id.run (l.foldrM f b) = l.foldr f b := (foldr_eq_foldrM f b l).symm
+
+/-! ### foldl and foldr -/
+
 /-! ### take -/
 
 @[simp] theorem take_size (a : Vector α n) : a.take n = a.cast (by simp) := by

src/Init/Data/Vector/Lex.lean

@@ -19,6 +19,11 @@ namespace Vector
 @[simp] theorem lt_toList [LT α] (l₁ l₂ : Vector α n) : l₁.toList < l₂.toList ↔ l₁ < l₂ := Iff.rfl
 @[simp] theorem le_toList [LT α] (l₁ l₂ : Vector α n) : l₁.toList ≤ l₂.toList ↔ l₁ ≤ l₂ := Iff.rfl
 
+protected theorem not_lt_iff_ge [LT α] (l₁ l₂ : Vector α n) : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
+protected theorem not_le_iff_gt [DecidableEq α] [LT α] [DecidableLT α] (l₁ l₂ : Vector α n) :
+    ¬ l₁ ≤ l₂ ↔ l₂ < l₁ :=
+  Decidable.not_not
+
 @[simp] theorem mk_lt_mk [LT α] :
     Vector.mk (α := α) (n := n) data₁ size₁ < Vector.mk data₂ size₂ ↔ data₁ < data₂ := Iff.rfl
 
@@ -57,6 +62,7 @@ protected theorem lt_irrefl [LT α] [Std.Irrefl (· < · : α → α → Prop)]
 instance ltIrrefl [LT α] [Std.Irrefl (· < · : α → α → Prop)] : Std.Irrefl (α := Vector α n) (· < ·) where
   irrefl := Vector.lt_irrefl
 
+@[simp] theorem not_lt_empty [LT α] (l : Vector α 0) : ¬ l < #v[] := Array.not_lt_empty l.toArray
 @[simp] theorem empty_le [LT α] (l : Vector α 0) : #v[] ≤ l := Array.empty_le l.toArray
 
 @[simp] theorem le_empty [LT α] (l : Vector α 0) : l ≤ #v[] ↔ l = #v[] := by
@@ -69,12 +75,12 @@ protected theorem le_refl [LT α] [i₀ : Std.Irrefl (· < · : α → α → Pr
 instance [LT α] [Std.Irrefl (· < · : α → α → Prop)] : Std.Refl (· ≤ · : Vector α n → Vector α n → Prop) where
   refl := Vector.le_refl
 
-protected theorem lt_trans [LT α] [DecidableLT α]
+protected theorem lt_trans [LT α]
     [i₁ : Trans (· < · : α → α → Prop) (· < ·) (· < ·)]
     {l₁ l₂ l₃ : Vector α n} (h₁ : l₁ < l₂) (h₂ : l₂ < l₃) : l₁ < l₃ :=
   Array.lt_trans h₁ h₂
 
-instance [LT α] [DecidableLT α]
+instance [LT α]
     [Trans (· < · : α → α → Prop) (· < ·) (· < ·)] :
     Trans (· < · : Vector α n → Vector α n → Prop) (· < ·) (· < ·) where
   trans h₁ h₂ := Vector.lt_trans h₁ h₂
@@ -103,7 +109,7 @@ instance [DecidableEq α] [LT α] [DecidableLT α]
     Trans (· ≤ · : Vector α n → Vector α n → Prop) (· ≤ ·) (· ≤ ·) where
   trans h₁ h₂ := Vector.le_trans h₁ h₂
 
-protected theorem lt_asymm [DecidableEq α] [LT α] [DecidableLT α]
+protected theorem lt_asymm [LT α]
     [i : Std.Asymm (· < · : α → α → Prop)]
     {l₁ l₂ : Vector α n} (h : l₁ < l₂) : ¬ l₂ < l₁ := Array.lt_asymm h
 
@@ -113,13 +119,31 @@ instance [DecidableEq α] [LT α] [DecidableLT α]
   asymm _ _ := Vector.lt_asymm
 
 protected theorem le_total [DecidableEq α] [LT α] [DecidableLT α]
-    [i : Std.Total (¬ · < · : α → α → Prop)] {l₁ l₂ : Vector α n} : l₁ ≤ l₂ ∨ l₂ ≤ l₁ :=
-  Array.le_total
+    [i : Std.Total (¬ · < · : α → α → Prop)] (l₁ l₂ : Vector α n) : l₁ ≤ l₂ ∨ l₂ ≤ l₁ :=
+  Array.le_total _ _
 
 instance [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Total (¬ · < · : α → α → Prop)] :
     Std.Total (· ≤ · : Vector α n → Vector α n → Prop) where
-  total _ _ := Vector.le_total
+  total := Vector.le_total
+
+@[simp] protected theorem not_lt [LT α]
+    {l₁ l₂ : Vector α n} : ¬ l₁ < l₂ ↔ l₂ ≤ l₁ := Iff.rfl
+
+@[simp] protected theorem not_le [DecidableEq α] [LT α] [DecidableLT α]
+    {l₁ l₂ : Vector α n} : ¬ l₂ ≤ l₁ ↔ l₁ < l₂ := Decidable.not_not
+
+protected theorem le_of_lt [DecidableEq α] [LT α] [DecidableLT α]
+    [i : Std.Total (¬ · < · : α → α → Prop)]
+    {l₁ l₂ : Vector α n} (h : l₁ < l₂) : l₁ ≤ l₂ :=
+  Array.le_of_lt h
+
+protected theorem le_iff_lt_or_eq [DecidableEq α] [LT α] [DecidableLT α]
+    [Std.Irrefl (· < · : α → α → Prop)]
+    [Std.Antisymm (¬ · < · : α → α → Prop)]
+    [Std.Total (¬ · < · : α → α → Prop)]
+    {l₁ l₂ : Vector α n} : l₁ ≤ l₂ ↔ l₁ < l₂ ∨ l₁ = l₂ := by
+  simpa using Array.le_iff_lt_or_eq (l₁ := l₁.toArray) (l₂ := l₂.toArray)
 
 @[simp] theorem lex_eq_true_iff_lt [DecidableEq α] [LT α] [DecidableLT α]
     {l₁ l₂ : Vector α n} : lex l₁ l₂ = true ↔ l₁ < l₂ := by
@@ -181,14 +205,14 @@ theorem lex_eq_false_iff_exists [BEq α] [PartialEquivBEq α] (lt : α → α
   rcases l₂ with ⟨l₂, n₂⟩
   simp_all [Array.lex_eq_false_iff_exists, n₂]
 
-theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Vector α n} :
+protected theorem lt_iff_exists [DecidableEq α] [LT α] [DecidableLT α] {l₁ l₂ : Vector α n} :
     l₁ < l₂ ↔
       (∃ (i : Nat) (h : i < n), (∀ j, (hj : j < i) → l₁[j] = l₂[j]) ∧ l₁[i] < l₂[i]) := by
   cases l₁
   cases l₂
   simp_all [Array.lt_iff_exists]
 
-theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
+protected theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
     [Std.Irrefl (· < · : α → α → Prop)]
     [Std.Asymm (· < · : α → α → Prop)]
     [Std.Antisymm (¬ · < · : α → α → Prop)] {l₁ l₂ : Vector α n} :
@@ -199,4 +223,32 @@ theorem le_iff_exists [DecidableEq α] [LT α] [DecidableLT α]
   rcases l₂ with ⟨l₂, n₂⟩
   simp [Array.le_iff_exists, ← n₂]
 
+theorem append_left_lt [LT α] {l₁ : Vector α n} {l₂ l₃ : Vector α m} (h : l₂ < l₃) :
+    l₁ ++ l₂ < l₁ ++ l₃ := by
+  simpa using Array.append_left_lt h
+
+theorem append_left_le [DecidableEq α] [LT α] [DecidableLT α]
+    [Std.Irrefl (· < · : α → α → Prop)]
+    [Std.Asymm (· < · : α → α → Prop)]
+    [Std.Antisymm (¬ · < · : α → α → Prop)]
+    {l₁ : Vector α n} {l₂ l₃ : Vector α m} (h : l₂ ≤ l₃) :
+    l₁ ++ l₂ ≤ l₁ ++ l₃ := by
+  simpa using Array.append_left_le h
+
+protected theorem map_lt [LT α] [LT β]
+    {l₁ l₂ : Vector α n} {f : α → β} (w : ∀ x y, x < y → f x < f y) (h : l₁ < l₂) :
+    map f l₁ < map f l₂ := by
+  simpa using Array.map_lt w h
+
+protected theorem map_le [DecidableEq α] [LT α] [DecidableLT α] [DecidableEq β] [LT β] [DecidableLT β]
+    [Std.Irrefl (· < · : α → α → Prop)]
+    [Std.Asymm (· < · : α → α → Prop)]
+    [Std.Antisymm (¬ · < · : α → α → Prop)]
+    [Std.Irrefl (· < · : β → β → Prop)]
+    [Std.Asymm (· < · : β → β → Prop)]
+    [Std.Antisymm (¬ · < · : β → β → Prop)]
+    {l₁ l₂ : Vector α n} {f : α → β} (w : ∀ x y, x < y → f x < f y) (h : l₁ ≤ l₂) :
+    map f l₁ ≤ map f l₂ := by
+  simpa using Array.map_le w h
+
 end Vector

src/Init/Grind.lean

@@ -8,3 +8,6 @@ import Init.Grind.Norm
 import Init.Grind.Tactics
 import Init.Grind.Lemmas
 import Init.Grind.Cases
+import Init.Grind.Propagator
+import Init.Grind.Util
+import Init.Grind.Offset

src/Init/Grind/Lemmas.lean

@@ -5,10 +5,96 @@ Authors: Leonardo de Moura
 -/
 prelude
 import Init.Core
+import Init.SimpLemmas
+import Init.Classical
+import Init.ByCases
+import Init.Grind.Util
 
 namespace Lean.Grind
 
 theorem intro_with_eq (p p' q : Prop) (he : p = p') (h : p' → q) : p → q :=
   fun hp => h (he.mp hp)
 
+/-! And -/
+
+theorem and_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a ∧ b) = b := by simp [h]
+theorem and_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a ∧ b) = a := by simp [h]
+theorem and_eq_of_eq_false_left {a b : Prop} (h : a = False) : (a ∧ b) = False := by simp [h]
+theorem and_eq_of_eq_false_right {a b : Prop} (h : b = False) : (a ∧ b) = False := by simp [h]
+
+theorem eq_true_of_and_eq_true_left {a b : Prop} (h : (a ∧ b) = True) : a = True := by simp_all
+theorem eq_true_of_and_eq_true_right {a b : Prop} (h : (a ∧ b) = True) : b = True := by simp_all
+
+theorem or_of_and_eq_false {a b : Prop} (h : (a ∧ b) = False) : (¬a ∨ ¬b) := by
+  by_cases a <;> by_cases b <;> simp_all
+
+/-! Or -/
+
+theorem or_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a ∨ b) = True := by simp [h]
+theorem or_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a ∨ b) = True := by simp [h]
+theorem or_eq_of_eq_false_left {a b : Prop} (h : a = False) : (a ∨ b) = b := by simp [h]
+theorem or_eq_of_eq_false_right {a b : Prop} (h : b = False) : (a ∨ b) = a := by simp [h]
+
+theorem eq_false_of_or_eq_false_left {a b : Prop} (h : (a ∨ b) = False) : a = False := by simp_all
+theorem eq_false_of_or_eq_false_right {a b : Prop} (h : (a ∨ b) = False) : b = False := by simp_all
+
+/-! Implies -/
+
+theorem imp_eq_of_eq_false_left {a b : Prop} (h : a = False) : (a → b) = True := by simp [h]
+theorem imp_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a → b) = True := by simp [h]
+theorem imp_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a → b) = b := by simp [h]
+
+theorem eq_true_of_imp_eq_false {a b : Prop} (h : (a → b) = False) : a = True := by simp_all
+theorem eq_false_of_imp_eq_false {a b : Prop} (h : (a → b) = False) : b = False := by simp_all
+
+/-! Not -/
+
+theorem not_eq_of_eq_true {a : Prop} (h : a = True) : (Not a) = False := by simp [h]
+theorem not_eq_of_eq_false {a : Prop} (h : a = False) : (Not a) = True := by simp [h]
+
+theorem eq_false_of_not_eq_true {a : Prop} (h : (Not a) = True) : a = False := by simp_all
+theorem eq_true_of_not_eq_false {a : Prop} (h : (Not a) = False) : a = True := by simp_all
+
+theorem false_of_not_eq_self {a : Prop} (h : (Not a) = a) : False := by
+  by_cases a <;> simp_all
+
+/-! Eq -/
+
+theorem eq_eq_of_eq_true_left {a b : Prop} (h : a = True) : (a = b) = b := by simp [h]
+theorem eq_eq_of_eq_true_right {a b : Prop} (h : b = True) : (a = b) = a := by simp [h]
+
+theorem eq_congr  {α : Sort u} {a₁ b₁ a₂ b₂ : α} (h₁ : a₁ = a₂) (h₂ : b₁ = b₂) : (a₁ = b₁) = (a₂ = b₂) := by simp [*]
+theorem eq_congr' {α : Sort u} {a₁ b₁ a₂ b₂ : α} (h₁ : a₁ = b₂) (h₂ : b₁ = a₂) : (a₁ = b₁) = (a₂ = b₂) := by rw [h₁, h₂, Eq.comm (a := a₂)]
+
+/-! Forall -/
+
+theorem forall_propagator (p : Prop) (q : p → Prop) (q' : Prop) (h₁ : p = True) (h₂ : q (of_eq_true h₁) = q') : (∀ hp : p, q hp) = q' := by
+  apply propext; apply Iff.intro
+  · intro h'; exact Eq.mp h₂ (h' (of_eq_true h₁))
+  · intro h'; intros; exact Eq.mpr h₂ h'
+
+theorem of_forall_eq_false (α : Sort u) (p : α → Prop) (h : (∀ x : α, p x) = False) : ∃ x : α, ¬ p x := by simp_all
+
+/-! dite -/
+
+theorem dite_cond_eq_true' {α : Sort u} {c : Prop} {_ : Decidable c} {a : c → α} {b : ¬ c → α} {r : α} (h₁ : c = True) (h₂ : a (of_eq_true h₁) = r) : (dite c a b) = r := by simp [h₁, h₂]
+theorem dite_cond_eq_false' {α : Sort u} {c : Prop} {_ : Decidable c} {a : c → α} {b : ¬ c → α} {r : α} (h₁ : c = False) (h₂ : b (of_eq_false h₁) = r) : (dite c a b) = r := by simp [h₁, h₂]
+
+/-! Casts -/
+
+theorem eqRec_heq.{u_1, u_2} {α : Sort u_2} {a : α}
+        {motive : (x : α) → a = x → Sort u_1} (v : motive a (Eq.refl a)) {b : α} (h : a = b)
+        : HEq (@Eq.rec α a motive v b h) v := by
+ subst h; rfl
+
+theorem eqRecOn_heq.{u_1, u_2} {α : Sort u_2} {a : α}
+        {motive : (x : α) → a = x → Sort u_1} {b : α} (h : a = b) (v : motive a (Eq.refl a))
+        : HEq (@Eq.recOn α a motive b h v) v := by
+ subst h; rfl
+
+theorem eqNDRec_heq.{u_1, u_2} {α : Sort u_2} {a : α}
+        {motive : α → Sort u_1} (v : motive a) {b : α} (h : a = b)
+        : HEq (@Eq.ndrec α a motive v b h) v := by
+ subst h; rfl
+
 end Lean.Grind

src/Init/Grind/Norm.lean

@@ -5,6 +5,7 @@ Authors: Leonardo de Moura
 -/
 prelude
 import Init.SimpLemmas
+import Init.PropLemmas
 import Init.Classical
 import Init.ByCases
 
@@ -40,9 +41,10 @@ attribute [grind_norm] not_true
 -- False
 attribute [grind_norm] not_false_eq_true
 
+-- Remark: we disabled the following normalization rule because we want this information when implementing splitting heuristics
 -- Implication as a clause
-@[grind_norm] theorem imp_eq (p q : Prop) : (p → q) = (¬ p ∨ q) := by
-  by_cases p <;> by_cases q <;> simp [*]
+-- @[grind_norm↓] theorem imp_eq (p q : Prop) : (p → q) = (¬ p ∨ q) := by
+--  by_cases p <;> by_cases q <;> simp [*]
 
 -- And
 @[grind_norm↓] theorem not_and (p q : Prop) : (¬(p ∧ q)) = (¬p ∨ ¬q) := by
@@ -58,13 +60,19 @@ attribute [grind_norm] ite_true ite_false
 @[grind_norm↓] theorem not_ite {_ : Decidable p} (q r : Prop) : (¬ite p q r) = ite p (¬q) (¬r) := by
   by_cases p <;> simp [*]
 
+@[grind_norm] theorem ite_true_false {_ : Decidable p} : (ite p True False) = p := by
+  by_cases p <;> simp
+
+@[grind_norm] theorem ite_false_true {_ : Decidable p} : (ite p False True) = ¬p := by
+  by_cases p <;> simp
+
 -- Forall
 @[grind_norm↓] theorem not_forall (p : α → Prop) : (¬∀ x, p x) = ∃ x, ¬p x := by simp
 attribute [grind_norm] forall_and
 
 -- Exists
 @[grind_norm↓] theorem not_exists (p : α → Prop) : (¬∃ x, p x) = ∀ x, ¬p x := by simp
-attribute [grind_norm] exists_const exists_or
+attribute [grind_norm] exists_const exists_or exists_prop exists_and_left exists_and_right
 
 -- Bool cond
 @[grind_norm] theorem cond_eq_ite (c : Bool) (a b : α) : cond c a b = ite c a b := by
@@ -107,4 +115,7 @@ attribute [grind_norm] Nat.le_zero_eq
 -- GT GE
 attribute [grind_norm] GT.gt GE.ge
 
+-- Succ
+attribute [grind_norm] Nat.succ_eq_add_one
+
 end Lean.Grind

src/Init/Grind/Offset.lean

@@ -0,0 +1,165 @@
+/-
+Copyright (c) 2025 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Init.Core
+import Init.Omega
+
+namespace Lean.Grind.Offset
+
+abbrev Var := Nat
+abbrev Context := Lean.RArray Nat
+
+def fixedVar := 100000000 -- Any big number should work here
+
+def Var.denote (ctx : Context) (v : Var) : Nat :=
+  bif v == fixedVar then 1 else ctx.get v
+
+structure Cnstr where
+  x : Var
+  y : Var
+  k : Nat  := 0
+  l : Bool := true
+  deriving Repr, DecidableEq, Inhabited
+
+def Cnstr.denote (c : Cnstr) (ctx : Context) : Prop :=
+  if c.l then
+    c.x.denote ctx + c.k ≤ c.y.denote ctx
+  else
+    c.x.denote ctx ≤ c.y.denote ctx + c.k
+
+def trivialCnstr : Cnstr := { x := 0, y := 0, k := 0, l := true }
+
+@[simp] theorem denote_trivial (ctx : Context) : trivialCnstr.denote ctx := by
+  simp [Cnstr.denote, trivialCnstr]
+
+def Cnstr.trans (c₁ c₂ : Cnstr) : Cnstr :=
+  if c₁.y = c₂.x then
+    let { x, k := k₁, l := l₁, .. } := c₁
+    let { y, k := k₂, l := l₂, .. } := c₂
+    match l₁, l₂ with
+    | false, false =>
+      { x, y, k := k₁ + k₂, l := false }
+    | false, true =>
+      if k₁ < k₂ then
+        { x, y, k := k₂ - k₁, l := true }
+      else
+        { x, y, k := k₁ - k₂, l := false }
+    | true, false =>
+      if k₁ < k₂ then
+        { x, y, k := k₂ - k₁, l := false }
+      else
+        { x, y, k := k₁ - k₂, l := true }
+    | true, true =>
+      { x, y, k := k₁ + k₂, l := true }
+  else
+    trivialCnstr
+
+@[simp] theorem Cnstr.denote_trans_easy (ctx : Context) (c₁ c₂ : Cnstr) (h : c₁.y ≠ c₂.x) : (c₁.trans c₂).denote ctx := by
+  simp [*, Cnstr.trans]
+
+@[simp] theorem Cnstr.denote_trans (ctx : Context) (c₁ c₂ : Cnstr) : c₁.denote ctx → c₂.denote ctx → (c₁.trans c₂).denote ctx := by
+  by_cases c₁.y = c₂.x
+  case neg => simp [*]
+  simp [trans, *]
+  let { x, k := k₁, l := l₁, .. } := c₁
+  let { y, k := k₂, l := l₂, .. } := c₂
+  simp_all; split
+  · simp [denote]; omega
+  · split <;> simp [denote] <;> omega
+  · split <;> simp [denote] <;> omega
+  · simp [denote]; omega
+
+def Cnstr.isTrivial (c : Cnstr) : Bool := c.x == c.y && c.k == 0
+
+theorem Cnstr.of_isTrivial (ctx : Context) (c : Cnstr) : c.isTrivial = true → c.denote ctx := by
+  cases c; simp [isTrivial]; intros; simp [*, denote]
+
+def Cnstr.isFalse (c : Cnstr) : Bool := c.x == c.y && c.k != 0 && c.l == true
+
+theorem Cnstr.of_isFalse (ctx : Context) {c : Cnstr} : c.isFalse = true → ¬c.denote ctx := by
+  cases c; simp [isFalse]; intros; simp [*, denote]; omega
+
+def Cnstrs := List Cnstr
+
+def Cnstrs.denoteAnd' (ctx : Context) (c₁ : Cnstr) (c₂ : Cnstrs) : Prop :=
+  match c₂ with
+  | [] => c₁.denote ctx
+  | c::cs => c₁.denote ctx ∧ Cnstrs.denoteAnd' ctx c cs
+
+theorem Cnstrs.denote'_trans (ctx : Context) (c₁ c : Cnstr) (cs : Cnstrs) : c₁.denote ctx → denoteAnd' ctx c cs → denoteAnd' ctx (c₁.trans c) cs := by
+  induction cs
+  next => simp [denoteAnd', *]; apply Cnstr.denote_trans
+  next c cs ih => simp [denoteAnd']; intros; simp [*]
+
+def Cnstrs.trans' (c₁ : Cnstr) (c₂ : Cnstrs) : Cnstr :=
+  match c₂ with
+  | [] => c₁
+  | c::c₂ => trans' (c₁.trans c) c₂
+
+@[simp] theorem Cnstrs.denote'_trans' (ctx : Context) (c₁ : Cnstr) (c₂ : Cnstrs) : denoteAnd' ctx c₁ c₂ → (trans' c₁ c₂).denote ctx := by
+  induction c₂ generalizing c₁
+  next => intros; simp_all [trans', denoteAnd']
+  next c cs ih => simp [denoteAnd']; intros; simp [trans']; apply ih; apply denote'_trans <;> assumption
+
+def Cnstrs.denoteAnd (ctx : Context) (c : Cnstrs) : Prop :=
+  match c with
+  | [] => True
+  | c::cs => denoteAnd' ctx c cs
+
+def Cnstrs.trans (c : Cnstrs) : Cnstr :=
+  match c with
+  | []    => trivialCnstr
+  | c::cs => trans' c cs
+
+theorem Cnstrs.of_denoteAnd_trans {ctx : Context} {c : Cnstrs} : c.denoteAnd ctx → c.trans.denote ctx := by
+  cases c <;> simp [*, trans, denoteAnd] <;> intros <;> simp [*]
+
+def Cnstrs.isFalse (c : Cnstrs) : Bool :=
+  c.trans.isFalse
+
+theorem Cnstrs.unsat' (ctx : Context) (c : Cnstrs) : c.isFalse = true → ¬ c.denoteAnd ctx := by
+  simp [isFalse]; intro h₁ h₂
+  have := of_denoteAnd_trans h₂
+  have := Cnstr.of_isFalse ctx h₁
+  contradiction
+
+/-- `denote ctx [c_1, ..., c_n] C` is `c_1.denote ctx → ... → c_n.denote ctx → C` -/
+def Cnstrs.denote (ctx : Context) (cs : Cnstrs) (C : Prop) : Prop :=
+  match cs with
+  | [] => C
+  | c::cs => c.denote ctx → denote ctx cs C
+
+theorem Cnstrs.not_denoteAnd'_eq (ctx : Context) (c : Cnstr) (cs : Cnstrs) (C : Prop) : (denoteAnd' ctx c cs → C) = denote ctx (c::cs) C := by
+  simp [denote]
+  induction cs generalizing c
+  next => simp [denoteAnd', denote]
+  next c' cs ih =>
+    simp [denoteAnd', denote, *]
+
+theorem Cnstrs.not_denoteAnd_eq (ctx : Context) (cs : Cnstrs) (C : Prop) : (denoteAnd ctx cs → C) = denote ctx cs C := by
+  cases cs
+  next => simp [denoteAnd, denote]
+  next c cs => apply not_denoteAnd'_eq
+
+def Cnstr.isImpliedBy (cs : Cnstrs) (c : Cnstr) : Bool :=
+  cs.trans == c
+
+/-! Main theorems used by `grind`. -/
+
+/-- Auxiliary theorem used by `grind` to prove that a system of offset inequalities is unsatisfiable. -/
+theorem Cnstrs.unsat (ctx : Context) (cs : Cnstrs) : cs.isFalse = true → cs.denote ctx False := by
+  intro h
+  rw [← not_denoteAnd_eq]
+  apply unsat'
+  assumption
+
+/-- Auxiliary theorem used by `grind` to prove an implied offset inequality. -/
+theorem Cnstrs.imp (ctx : Context) (cs : Cnstrs) (c : Cnstr) (h : c.isImpliedBy cs = true)  : cs.denote ctx (c.denote ctx) := by
+  rw [← eq_of_beq h]
+  rw [← not_denoteAnd_eq]
+  apply of_denoteAnd_trans
+
+end Lean.Grind.Offset

src/Init/Grind/Propagator.lean

@@ -0,0 +1,27 @@
+/-
+Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Init.NotationExtra
+
+namespace Lean.Parser
+
+/-- A user-defined propagator for the `grind` tactic. -/
+-- TODO: not implemented yet
+syntax (docComment)? "grind_propagator " (Tactic.simpPre <|> Tactic.simpPost) ident " (" ident ")" " := " term : command
+
+/-- A builtin propagator for the `grind` tactic. -/
+syntax (docComment)? "builtin_grind_propagator " ident (Tactic.simpPre <|> Tactic.simpPost) ident " := " term : command
+
+/-- Auxiliary attribute for builtin `grind` propagators. -/
+syntax (name := grindPropagatorBuiltinAttr) "builtin_grind_propagator" (Tactic.simpPre <|> Tactic.simpPost) ident : attr
+
+macro_rules
+  | `($[$doc?:docComment]? builtin_grind_propagator $propagatorName:ident $direction $op:ident := $body) => do
+    let propagatorType := `Lean.Meta.Grind.Propagator
+    `($[$doc?:docComment]? def $propagatorName:ident : $(mkIdent propagatorType) := $body
+      attribute [builtin_grind_propagator $direction $op] $propagatorName)
+
+end Lean.Parser

src/Init/Grind/Tactics.lean

@@ -6,20 +6,56 @@ Authors: Leonardo de Moura
 prelude
 import Init.Tactics
 
+namespace Lean.Parser.Attr
+
+syntax grindEq     := "="
+syntax grindEqBoth := atomic("_" "=" "_")
+syntax grindEqRhs  := atomic("=" "_")
+syntax grindBwd    := "←"
+syntax grindFwd    := "→"
+
+syntax (name := grind) "grind" (grindEqBoth <|> grindEqRhs <|> grindEq <|> grindBwd <|> grindFwd)? : attr
+
+end Lean.Parser.Attr
+
 namespace Lean.Grind
 /--
 The configuration for `grind`.
-Passed to `grind` using, for example, the `grind (config := { eager := true })` syntax.
+Passed to `grind` using, for example, the `grind (config := { matchEqs := true })` syntax.
 -/
 structure Config where
+  /-- Maximum number of case-splits in a proof search branch. It does not include splits performed during normalization. -/
+  splits : Nat := 5
+  /-- Maximum number of E-matching (aka heuristic theorem instantiation) rounds before each case split. -/
+  ematch : Nat := 5
   /--
-  When `eager` is true (default: `false`), `grind` eagerly splits `if-then-else` and `match`
-  expressions.
-  -/
-  eager : Bool := false
+  Maximum term generation.
+  The input goal terms have generation 0. When we instantiate a theorem using a term from generation `n`,
+  the new terms have generation `n+1`. Thus, this parameter limits the length of an instantiation chain. -/
+  gen : Nat := 5
+  /-- Maximum number of theorem instances generated using E-matching in a proof search tree branch. -/
+  instances : Nat := 1000
+  /-- If `matchEqs` is `true`, `grind` uses `match`-equations as E-matching theorems. -/
+  matchEqs : Bool := true
+  /-- If `splitMatch` is `true`, `grind` performs case-splitting on `match`-expressions during the search. -/
+  splitMatch : Bool := true
+  /-- If `splitIte` is `true`, `grind` performs case-splitting on `if-then-else` expressions during the search. -/
+  splitIte : Bool := true
+  /--
+  If `splitIndPred` is `true`, `grind` performs case-splitting on inductive predicates.
+  Otherwise, it performs case-splitting only on types marked with `[grind_split]` attribute. -/
+  splitIndPred : Bool := true
   deriving Inhabited, BEq
 
+end Lean.Grind
+
+namespace Lean.Parser.Tactic
+
 /-!
 `grind` tactic and related tactics.
 -/
-end Lean.Grind
+
+-- TODO: parameters
+syntax (name := grind) "grind" optConfig ("on_failure " term)? : tactic
+
+end Lean.Parser.Tactic

src/Init/Grind/Util.lean

@@ -0,0 +1,34 @@
+/-
+Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Leonardo de Moura
+-/
+prelude
+import Init.Core
+
+namespace Lean.Grind
+
+/-- A helper gadget for annotating nested proofs in goals. -/
+def nestedProof (p : Prop) (h : p) : p := h
+
+/--
+Gadget for marking terms that should not be normalized by `grind`s simplifier.
+`grind` uses a simproc to implement this feature.
+We use it when adding instances of `match`-equations to prevent them from being simplified to true.
+-/
+def doNotSimp {α : Sort u} (a : α) : α := a
+
+/-- Gadget for representing offsets `t+k` in patterns. -/
+def offset (a b : Nat) : Nat := a + b
+
+/--
+Gadget for annotating the equalities in `match`-equations conclusions.
+`_origin` is the term used to instantiate the `match`-equation using E-matching.
+When `EqMatch a b origin` is `True`, we mark `origin` as a resolved case-split.
+-/
+def EqMatch (a b : α) {_origin : α} : Prop := a = b
+
+theorem nestedProof_congr (p q : Prop) (h : p = q) (hp : p) (hq : q) : HEq (nestedProof p hp) (nestedProof q hq) := by
+  subst h; apply HEq.refl
+
+end Lean.Grind

src/Init/Internal.lean

@@ -0,0 +1,13 @@
+/-
+Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joachim Breitner
+-/
+prelude
+import Init.Internal.Order
+
+/-!
+This directory is used for components of the standard library that are either considered
+implementation details or not yet ready for public consumption, and that should be available
+without explicit import (in contrast to `Std.Internal`)
+-/

src/Init/Internal/Order.lean

@@ -0,0 +1,8 @@
+/-
+Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joachim Breitner
+-/
+prelude
+import Init.Internal.Order.Basic
+import Init.Internal.Order.Tactic

src/Init/Internal/Order/Basic.lean

@@ -0,0 +1,693 @@
+/-
+Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joachim Breitner
+-/
+prelude
+
+import Init.ByCases
+import Init.RCases
+
+/-!
+This module contains some basic definitions and results from domain theory, intended to be used as
+the underlying construction of the `partial_fixpoint` feature. It is not meant to be used as a
+general purpose library for domain theory, but can be of interest to users who want to extend
+the `partial_fixpoint` machinery (e.g. mark more functions as monotone or register more monads).
+
+This follows the corresponding
+[Isabelle development](https://isabelle.in.tum.de/library/HOL/HOL/Partial_Function.html), as also
+described in [Alexander Krauss: Recursive Definitions of Monadic Functions](https://www21.in.tum.de/~krauss/papers/mrec.pdf).
+-/
+
+universe u v w
+
+namespace Lean.Order
+
+/--
+A partial order is a reflexive, transitive and antisymmetric relation.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+class PartialOrder (α : Sort u) where
+  /--
+  A “less-or-equal-to” or “approximates” relation.
+
+  This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+  -/
+  rel : α → α → Prop
+  rel_refl : ∀ {x}, rel x x
+  rel_trans : ∀ {x y z}, rel x y → rel y z → rel x z
+  rel_antisymm : ∀ {x y}, rel x y → rel y x → x = y
+
+@[inherit_doc] scoped infix:50 " ⊑ " => PartialOrder.rel
+
+section PartialOrder
+
+variable {α  : Sort u} [PartialOrder α]
+
+theorem PartialOrder.rel_of_eq {x y : α} (h : x = y) : x ⊑ y := by cases h; apply rel_refl
+
+/--
+A chain is a totally ordered set (representing a set as a predicate).
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+def chain (c : α → Prop) : Prop := ∀ x y , c x → c y → x ⊑ y ∨ y ⊑ x
+
+end PartialOrder
+
+section CCPO
+
+/--
+A chain-complete partial order (CCPO) is a partial order where every chain a least upper bound.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+class CCPO (α : Sort u) extends PartialOrder α where
+  /--
+  The least upper bound of a chain.
+
+  This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+  -/
+  csup : (α → Prop) → α
+  csup_spec {c : α → Prop} (hc : chain c) : csup c ⊑ x ↔ (∀ y, c y → y ⊑ x)
+
+open PartialOrder CCPO
+
+variable {α  : Sort u} [CCPO α]
+
+theorem csup_le {c : α → Prop} (hchain : chain c) : (∀ y, c y → y ⊑ x) → csup c ⊑ x :=
+  (csup_spec hchain).mpr
+
+theorem le_csup {c : α → Prop} (hchain : chain c) {y : α} (hy : c y) : y ⊑ csup c :=
+  (csup_spec hchain).mp rel_refl y hy
+
+/--
+The bottom element is the least upper bound of the empty chain.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+def bot : α := csup (fun _ => False)
+
+scoped notation "⊥" => bot
+
+theorem bot_le (x : α) : ⊥ ⊑ x := by
+  apply csup_le
+  · intro x y hx hy; contradiction
+  · intro x hx; contradiction
+
+end CCPO
+
+section monotone
+
+variable {α : Sort u} [PartialOrder α]
+variable {β : Sort v} [PartialOrder β]
+
+/--
+A function is monotone if if it maps related elements to releated elements.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+def monotone (f : α → β) : Prop := ∀ x y, x ⊑ y → f x ⊑ f y
+
+theorem monotone_const (c : β) : monotone (fun (_ : α) => c) :=
+  fun _ _ _ => PartialOrder.rel_refl
+
+theorem monotone_id : monotone (fun (x : α) => x) :=
+  fun _ _ hxy => hxy
+
+theorem monotone_compose
+    {γ : Sort w} [PartialOrder γ]
+    {f : α → β} {g : β → γ}
+    (hf : monotone f) (hg : monotone g) :
+   monotone (fun x => g (f x)) := fun _ _ hxy => hg _ _ (hf _ _ hxy)
+
+end monotone
+
+section admissibility
+
+variable {α : Sort u} [CCPO α]
+
+open PartialOrder CCPO
+
+/--
+A predicate is admissable if it can be transferred from the elements of a chain to the chains least
+upper bound. Such predicates can be used in fixpoint induction.
+
+This definition implies `P ⊥`. Sometimes (e.g. in Isabelle) the empty chain is excluded
+from this definition, and `P ⊥` is a separate condition of the induction predicate.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+def admissible (P : α → Prop) :=
+  ∀ (c : α → Prop), chain c → (∀ x, c x → P x) → P (csup c)
+
+theorem admissible_const_true : admissible (fun (_ : α) => True) :=
+  fun _ _ _ => trivial
+
+theorem admissible_and (P Q : α → Prop)
+  (hadm₁ : admissible P) (hadm₂ : admissible Q) : admissible (fun x => P x ∧ Q x) :=
+    fun c hchain h =>
+    ⟨ hadm₁ c hchain fun x hx => (h x hx).1,
+      hadm₂ c hchain fun x hx => (h x hx).2⟩
+
+theorem chain_conj (c P : α → Prop) (hchain : chain c) : chain (fun x => c x ∧ P x) := by
+  intro x y ⟨hcx, _⟩ ⟨hcy, _⟩
+  exact hchain x y hcx hcy
+
+theorem csup_conj (c P : α → Prop) (hchain : chain c) (h : ∀ x, c x → ∃ y, c y ∧ x ⊑ y ∧ P y) :
+    csup c = csup (fun x => c x ∧ P x) := by
+  apply rel_antisymm
+  · apply csup_le hchain
+    intro x hcx
+    obtain ⟨y, hcy, hxy, hPy⟩ := h x hcx
+    apply rel_trans hxy; clear x hcx hxy
+    apply le_csup (chain_conj _ _ hchain) ⟨hcy, hPy⟩
+  · apply csup_le (chain_conj _ _ hchain)
+    intro x ⟨hcx, hPx⟩
+    apply le_csup hchain hcx
+
+theorem admissible_or (P Q : α → Prop)
+  (hadm₁ : admissible P) (hadm₂ : admissible Q) : admissible (fun x => P x ∨ Q x) := by
+  intro c hchain h
+  have : (∀ x, c x → ∃ y, c y ∧ x ⊑ y ∧ P y) ∨ (∀ x, c x → ∃ y, c y ∧ x ⊑ y ∧ Q y) := by
+    open Classical in
+    apply Decidable.or_iff_not_imp_left.mpr
+    intro h'
+    simp only [not_forall, not_imp, not_exists, not_and] at h'
+    obtain ⟨x, hcx, hx⟩ := h'
+    intro y hcy
+    cases hchain x y hcx hcy  with
+    | inl hxy =>
+      refine ⟨y, hcy, rel_refl, ?_⟩
+      cases h y hcy with
+      | inl hPy => exfalso; apply hx y hcy hxy hPy
+      | inr hQy => assumption
+    | inr hyx =>
+      refine ⟨x, hcx, hyx , ?_⟩
+      cases h x hcx with
+      | inl hPx => exfalso; apply hx x hcx rel_refl hPx
+      | inr hQx => assumption
+  cases this with
+  | inl hP =>
+    left
+    rw [csup_conj (h := hP) (hchain := hchain)]
+    apply hadm₁ _ (chain_conj _ _ hchain)
+    intro x ⟨hcx, hPx⟩
+    exact hPx
+  | inr hQ =>
+    right
+    rw [csup_conj (h := hQ) (hchain := hchain)]
+    apply hadm₂ _ (chain_conj _ _ hchain)
+    intro x ⟨hcx, hQx⟩
+    exact hQx
+
+def admissible_pi (P : α → β → Prop)
+  (hadm₁ : ∀ y, admissible (fun x => P x y)) : admissible (fun x => ∀ y, P x y) :=
+    fun c hchain h y => hadm₁ y c hchain fun x hx => h x hx y
+
+end admissibility
+
+section fix
+
+open PartialOrder CCPO
+
+variable {α  : Sort u} [CCPO α]
+
+variable {c : α → Prop} (hchain : chain c)
+
+/--
+The transfinite iteration of a function `f` is a set that is `⊥ ` and is closed under application
+of `f` and `csup`.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+inductive iterates (f : α → α) : α → Prop where
+  | step : iterates f x → iterates f (f x)
+  | sup {c : α → Prop} (hc : chain c) (hi : ∀ x, c x → iterates f x) : iterates f (csup c)
+
+theorem chain_iterates {f : α → α} (hf : monotone f) : chain (iterates f) := by
+  intros x y hx hy
+  induction hx generalizing y
+  case step x hx ih =>
+    induction hy
+    case step y hy _ =>
+      cases ih y hy
+      · left; apply hf; assumption
+      · right; apply hf; assumption
+    case sup c hchain hi ih2 =>
+      show f x ⊑ csup c ∨ csup c ⊑ f x
+      by_cases h : ∃ z, c z ∧ f x ⊑ z
+      · left
+        obtain ⟨z, hz, hfz⟩ := h
+        apply rel_trans hfz
+        apply le_csup hchain hz
+      · right
+        apply csup_le hchain _
+        intro z hz
+        rw [not_exists] at h
+        specialize h z
+        rw [not_and] at h
+        specialize h hz
+        cases ih2 z hz
+        next => contradiction
+        next => assumption
+  case sup c hchain hi ih =>
+    show rel (csup c) y ∨ rel y (csup c)
+    by_cases h : ∃ z, c z ∧ rel y z
+    · right
+      obtain ⟨z, hz, hfz⟩ := h
+      apply rel_trans hfz
+      apply le_csup hchain hz
+    · left
+      apply csup_le hchain _
+      intro z hz
+      rw [not_exists] at h
+      specialize h z
+      rw [not_and] at h
+      specialize h hz
+      cases ih z hz y hy
+      next => assumption
+      next => contradiction
+
+theorem rel_f_of_iterates {f : α → α} (hf : monotone f) {x : α} (hx : iterates f x) : x ⊑ f x := by
+  induction hx
+  case step ih =>
+    apply hf
+    assumption
+  case sup c hchain hi ih =>
+    apply csup_le hchain
+    intro y hy
+    apply rel_trans (ih y hy)
+    apply hf
+    apply le_csup hchain hy
+
+set_option linter.unusedVariables false in
+/--
+The least fixpoint of a monotone function is the least upper bound of its transfinite iteration.
+
+The `monotone f` assumption is not strictly necessarily for the definition, but without this the
+definition is not very meaningful and it simplifies applying theorems like `fix_eq` if every use of
+`fix` already has the monotonicty requirement.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+def fix (f : α → α) (hmono : monotone f) := csup (iterates f)
+
+/--
+The main fixpoint theorem for fixedpoints of monotone functions in chain-complete partial orders.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+theorem fix_eq {f : α → α} (hf : monotone f) : fix f hf = f (fix f hf) := by
+  apply rel_antisymm
+  · apply rel_f_of_iterates hf
+    apply iterates.sup (chain_iterates hf)
+    exact fun _ h => h
+  · apply le_csup (chain_iterates hf)
+    apply iterates.step
+    apply iterates.sup (chain_iterates hf)
+    intro y hy
+    exact hy
+
+/--
+The fixpoint induction theme: An admissible predicate holds for a least fixpoint if it is preserved
+by the fixpoint's function.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+theorem fix_induct {f : α → α} (hf : monotone f)
+    (motive : α → Prop) (hadm: admissible motive)
+    (h : ∀ x, motive x → motive (f x)) : motive (fix f hf) := by
+  apply hadm _ (chain_iterates hf)
+  intro x hiterates
+  induction hiterates with
+  | @step x hiter ih => apply h x ih
+  | @sup c hchain hiter ih => apply hadm c hchain ih
+
+end fix
+
+section fun_order
+
+open PartialOrder
+
+variable {α : Sort u}
+variable {β : α → Sort v}
+variable {γ : Sort w}
+
+instance instOrderPi [∀ x, PartialOrder (β x)] : PartialOrder (∀ x, β x) where
+  rel f g := ∀ x, f x ⊑ g x
+  rel_refl _ := rel_refl
+  rel_trans hf hg x := rel_trans (hf x) (hg x)
+  rel_antisymm hf hg := funext (fun x => rel_antisymm (hf x) (hg x))
+
+theorem monotone_of_monotone_apply [PartialOrder γ] [∀ x, PartialOrder (β x)] (f : γ → (∀ x, β x))
+  (h : ∀ y, monotone (fun x => f x y)) : monotone f :=
+  fun x y hxy z => h z x y hxy
+
+theorem monotone_apply [PartialOrder γ] [∀ x, PartialOrder (β x)] (a : α) (f : γ → ∀ x, β x)
+    (h : monotone f) :
+    monotone (fun x => f x a) := fun _ _ hfg => h _ _ hfg a
+
+theorem chain_apply [∀ x, PartialOrder (β x)] {c : (∀ x, β x) → Prop} (hc : chain c) (x : α) :
+    chain (fun y => ∃ f, c f ∧ f x = y) := by
+  intro _ _ ⟨f, hf, hfeq⟩ ⟨g, hg, hgeq⟩
+  subst hfeq; subst hgeq
+  cases hc f g hf hg
+  next h => left; apply h x
+  next h => right; apply h x
+
+def fun_csup [∀ x, CCPO (β x)] (c : (∀ x, β x) → Prop) (x : α) :=
+  CCPO.csup (fun y => ∃ f, c f ∧ f x = y)
+
+instance instCCPOPi [∀ x, CCPO (β x)] : CCPO (∀ x, β x) where
+  csup := fun_csup
+  csup_spec := by
+    intro f c hc
+    constructor
+    next =>
+      intro hf g hg x
+      apply rel_trans _ (hf x); clear hf
+      apply le_csup (chain_apply hc x)
+      exact ⟨g, hg, rfl⟩
+    next =>
+      intro h x
+      apply csup_le (chain_apply hc x)
+      intro y ⟨z, hz, hyz⟩
+      subst y
+      apply h z hz
+
+def admissible_apply [∀ x, CCPO (β x)] (P : ∀ x, β x → Prop) (x : α)
+  (hadm : admissible (P x)) : admissible (fun (f : ∀ x, β x) => P x (f x)) := by
+  intro c hchain h
+  apply hadm _ (chain_apply hchain x)
+  rintro _ ⟨f, hcf, rfl⟩
+  apply h _ hcf
+
+def admissible_pi_apply [∀ x, CCPO (β x)] (P : ∀ x, β x → Prop) (hadm : ∀ x, admissible (P x)) :
+    admissible (fun (f : ∀ x, β x) => ∀ x, P x (f x)) := by
+  apply admissible_pi
+  intro
+  apply admissible_apply
+  apply hadm
+
+end fun_order
+
+section monotone_lemmas
+
+theorem monotone_letFun
+    {α : Sort u} {β : Sort v} {γ : Sort w} [PartialOrder α] [PartialOrder β]
+    (v : γ) (k : α → γ → β)
+    (hmono : ∀ y, monotone (fun x => k x y)) :
+  monotone fun (x : α) => letFun v (k x) := hmono v
+
+theorem monotone_ite
+    {α : Sort u} {β : Sort v} [PartialOrder α] [PartialOrder β]
+    (c : Prop) [Decidable c]
+    (k₁ : α → β) (k₂ : α → β)
+    (hmono₁ : monotone k₁) (hmono₂ : monotone k₂) :
+  monotone fun x => if c then k₁ x else k₂ x := by
+    split
+    · apply hmono₁
+    · apply hmono₂
+
+theorem monotone_dite
+    {α : Sort u} {β : Sort v} [PartialOrder α] [PartialOrder β]
+    (c : Prop) [Decidable c]
+    (k₁ : α → c → β) (k₂ : α → ¬ c → β)
+    (hmono₁ : monotone k₁) (hmono₂ : monotone k₂) :
+  monotone fun x => dite c (k₁ x) (k₂ x) := by
+    split
+    · apply monotone_apply _ _ hmono₁
+    · apply monotone_apply _ _ hmono₂
+
+end monotone_lemmas
+
+section pprod_order
+
+open PartialOrder
+
+variable {α : Sort u}
+variable {β : Sort v}
+variable {γ : Sort w}
+
+instance [PartialOrder α] [PartialOrder β] : PartialOrder (α ×' β) where
+  rel a b := a.1 ⊑ b.1 ∧ a.2 ⊑ b.2
+  rel_refl := ⟨rel_refl, rel_refl⟩
+  rel_trans ha hb := ⟨rel_trans ha.1 hb.1, rel_trans ha.2 hb.2⟩
+  rel_antisymm := fun {a} {b} ha hb => by
+    cases a; cases b;
+    dsimp at *
+    rw [rel_antisymm ha.1 hb.1, rel_antisymm ha.2 hb.2]
+
+theorem monotone_pprod [PartialOrder α] [PartialOrder β] [PartialOrder γ]
+    {f : γ → α} {g : γ → β} (hf : monotone f) (hg : monotone g) :
+    monotone (fun x => PProd.mk (f x) (g x)) :=
+  fun _ _ h12 => ⟨hf _ _ h12, hg _ _ h12⟩
+
+theorem monotone_pprod_fst [PartialOrder α] [PartialOrder β] [PartialOrder γ]
+    {f : γ → α ×' β} (hf : monotone f) : monotone (fun x => (f x).1) :=
+  fun _ _ h12 => (hf _ _ h12).1
+
+theorem monotone_pprod_snd [PartialOrder α] [PartialOrder β] [PartialOrder γ]
+    {f : γ → α ×' β} (hf : monotone f) : monotone (fun x => (f x).2) :=
+  fun _ _ h12 => (hf _ _ h12).2
+
+def chain_pprod_fst [CCPO α] [CCPO β] (c : α ×' β → Prop) : α → Prop := fun a => ∃ b, c ⟨a, b⟩
+def chain_pprod_snd [CCPO α] [CCPO β] (c : α ×' β → Prop) : β → Prop := fun b => ∃ a, c ⟨a, b⟩
+
+theorem chain.pprod_fst [CCPO α] [CCPO β] (c : α ×' β → Prop) (hchain : chain c) :
+    chain (chain_pprod_fst c) := by
+  intro a₁ a₂ ⟨b₁, h₁⟩ ⟨b₂, h₂⟩
+  cases hchain ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ h₁ h₂
+  case inl h => left; exact h.1
+  case inr h => right; exact h.1
+
+theorem chain.pprod_snd [CCPO α] [CCPO β] (c : α ×' β → Prop) (hchain : chain c) :
+    chain (chain_pprod_snd c) := by
+  intro b₁ b₂ ⟨a₁, h₁⟩ ⟨a₂, h₂⟩
+  cases hchain ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ h₁ h₂
+  case inl h => left; exact h.2
+  case inr h => right; exact h.2
+
+instance [CCPO α] [CCPO β] : CCPO (α ×' β) where
+  csup c := ⟨CCPO.csup (chain_pprod_fst c), CCPO.csup (chain_pprod_snd c)⟩
+  csup_spec := by
+    intro ⟨a, b⟩ c hchain
+    dsimp
+    constructor
+    next =>
+      intro ⟨h₁, h₂⟩ ⟨a', b'⟩ cab
+      constructor <;> dsimp at *
+      · apply rel_trans ?_ h₁
+        apply le_csup hchain.pprod_fst
+        exact ⟨b', cab⟩
+      · apply rel_trans ?_ h₂
+        apply le_csup hchain.pprod_snd
+        exact ⟨a', cab⟩
+    next =>
+      intro h
+      constructor <;> dsimp
+      · apply csup_le hchain.pprod_fst
+        intro a' ⟨b', hcab⟩
+        apply (h _ hcab).1
+      · apply csup_le hchain.pprod_snd
+        intro b' ⟨a', hcab⟩
+        apply (h _ hcab).2
+
+theorem admissible_pprod_fst {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] (P : α → Prop)
+    (hadm : admissible P) : admissible (fun (x : α ×' β) => P x.1) := by
+  intro c hchain h
+  apply hadm _ hchain.pprod_fst
+  intro x ⟨y, hxy⟩
+  apply h ⟨x,y⟩ hxy
+
+theorem admissible_pprod_snd {α : Sort u} {β : Sort v} [CCPO α] [CCPO β] (P : β → Prop)
+    (hadm : admissible P) : admissible (fun (x : α ×' β) => P x.2) := by
+  intro c hchain h
+  apply hadm _ hchain.pprod_snd
+  intro y ⟨x, hxy⟩
+  apply h ⟨x,y⟩ hxy
+
+end pprod_order
+
+section flat_order
+
+variable {α : Sort u}
+
+set_option linter.unusedVariables false in
+/--
+`FlatOrder b` wraps the type `α` with the flat partial order generated by `∀ x, b ⊑ x`.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+def FlatOrder {α : Sort u} (b : α) := α
+
+variable {b : α}
+
+/--
+The flat partial order generated by `∀ x, b ⊑ x`.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+inductive FlatOrder.rel : (x y : FlatOrder b) → Prop where
+  | bot : rel b x
+  | refl : rel x x
+
+instance FlatOrder.instOrder : PartialOrder (FlatOrder b) where
+  rel := rel
+  rel_refl := .refl
+  rel_trans {x y z : α} (hxy : rel x y) (hyz : rel y z) := by
+    cases hxy <;> cases hyz <;> constructor
+  rel_antisymm {x y : α} (hxy : rel x y) (hyz : rel y x) : x = y := by
+    cases hxy <;> cases hyz <;> constructor
+
+open Classical in
+private theorem Classical.some_spec₂ {α : Sort _} {p : α → Prop} {h : ∃ a, p a} (q : α → Prop)
+    (hpq : ∀ a, p a → q a) : q (choose h) := hpq _ <| choose_spec _
+
+noncomputable def flat_csup (c : FlatOrder b → Prop) : FlatOrder b := by
+  by_cases h : ∃ (x : FlatOrder b), c x ∧ x ≠ b
+  · exact Classical.choose h
+  · exact b
+
+noncomputable instance FlatOrder.instCCPO : CCPO (FlatOrder b) where
+  csup := flat_csup
+  csup_spec := by
+    intro x c hc
+    unfold flat_csup
+    split
+    next hex =>
+      apply Classical.some_spec₂ (q := (· ⊑ x ↔ (∀ y, c y → y ⊑ x)))
+      clear hex
+      intro z ⟨hz, hnb⟩
+      constructor
+      · intro h y hy
+        apply PartialOrder.rel_trans _ h; clear h
+        cases hc y z hy hz
+        next => assumption
+        next h =>
+          cases h
+          · contradiction
+          · constructor
+      · intro h
+        cases h z hz
+        · contradiction
+        · constructor
+    next hnotex =>
+      constructor
+      · intro h y hy; clear h
+        suffices y = b by rw [this]; exact rel.bot
+        rw [not_exists] at hnotex
+        specialize hnotex y
+        rw [not_and] at hnotex
+        specialize hnotex hy
+        rw [@Classical.not_not] at hnotex
+        assumption
+      · intro; exact rel.bot
+
+theorem admissible_flatOrder (P : FlatOrder b → Prop) (hnot : P b) : admissible P := by
+  intro c hchain h
+  by_cases h' : ∃ (x : FlatOrder b), c x ∧ x ≠ b
+  · simp [CCPO.csup, flat_csup, h']
+    apply Classical.some_spec₂ (q := (P ·))
+    intro x ⟨hcx, hneb⟩
+    apply h x hcx
+  · simp [CCPO.csup, flat_csup, h', hnot]
+
+end flat_order
+
+section mono_bind
+
+/--
+The class `MonoBind m` indicates that every `m α` has a `PartialOrder`, and that the bind operation
+on `m` is monotone in both arguments with regard to that order.
+
+This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
+-/
+class MonoBind (m : Type u → Type v) [Bind m] [∀ α, PartialOrder (m α)] where
+  bind_mono_left {a₁ a₂ : m α} {f : α → m b} (h : a₁ ⊑ a₂) : a₁ >>= f ⊑ a₂ >>= f
+  bind_mono_right {a : m α} {f₁ f₂ : α → m b} (h : ∀ x, f₁ x ⊑ f₂ x) : a >>= f₁ ⊑ a >>= f₂
+
+theorem monotone_bind
+    (m : Type u → Type v) [Bind m] [∀ α, PartialOrder (m α)] [MonoBind m]
+    {α β : Type u}
+    {γ : Type w} [PartialOrder γ]
+    (f : γ → m α) (g : γ → α → m β)
+    (hmono₁ : monotone f)
+    (hmono₂ : monotone g) :
+    monotone (fun (x : γ) => f x >>= g x) := by
+  intro x₁ x₂ hx₁₂
+  apply PartialOrder.rel_trans
+  · apply MonoBind.bind_mono_left (hmono₁ _ _ hx₁₂)
+  · apply MonoBind.bind_mono_right (fun y => monotone_apply y _ hmono₂ _ _ hx₁₂)
+
+instance : PartialOrder (Option α) := inferInstanceAs (PartialOrder (FlatOrder none))
+noncomputable instance : CCPO (Option α) := inferInstanceAs (CCPO (FlatOrder none))
+noncomputable instance : MonoBind Option where
+  bind_mono_left h := by
+    cases h
+    · exact FlatOrder.rel.bot
+    · exact FlatOrder.rel.refl
+  bind_mono_right h := by
+    cases ‹Option _›
+    · exact FlatOrder.rel.refl
+    · exact h _
+
+theorem admissible_eq_some (P : Prop) (y : α) :
+    admissible (fun (x : Option α) => x = some y → P) := by
+  apply admissible_flatOrder; simp
+
+instance [Monad m] [inst : ∀ α, PartialOrder (m α)] : PartialOrder (ExceptT ε m α) := inst _
+instance [Monad m] [∀ α, PartialOrder (m α)] [inst : ∀ α, CCPO (m α)] : CCPO (ExceptT ε m α) := inst _
+instance [Monad m] [∀ α, PartialOrder (m α)] [∀ α, CCPO (m α)] [MonoBind m] : MonoBind (ExceptT ε m) where
+  bind_mono_left h₁₂ := by
+    apply MonoBind.bind_mono_left (m := m)
+    exact h₁₂
+  bind_mono_right h₁₂ := by
+    apply MonoBind.bind_mono_right (m := m)
+    intro x
+    cases x
+    · apply PartialOrder.rel_refl
+    · apply h₁₂
+
+end mono_bind
+
+namespace Example
+
+def findF (P : Nat → Bool) (rec : Nat → Option Nat) (x : Nat) : Option Nat :=
+  if P x then
+    some x
+  else
+    rec (x + 1)
+
+noncomputable def find (P : Nat → Bool) : Nat → Option Nat := fix (findF P) <| by
+  unfold findF
+  apply monotone_of_monotone_apply
+  intro n
+  split
+  · apply monotone_const
+  · apply monotone_apply
+    apply monotone_id
+
+theorem find_eq : find P = findF P (find P) := fix_eq ..
+
+theorem find_spec : ∀ n m, find P n = some m → n ≤ m ∧ P m := by
+  unfold find
+  refine fix_induct (motive := fun (f : Nat → Option Nat) => ∀ n m, f n = some m → n ≤ m ∧ P m) _ ?hadm ?hstep
+  case hadm =>
+    -- apply admissible_pi_apply does not work well, hard to infer everything
+    exact admissible_pi_apply _ (fun n => admissible_pi _ (fun m => admissible_eq_some _ m))
+  case hstep =>
+    intro f ih n m heq
+    simp only [findF] at heq
+    split at heq
+    · simp_all
+    · obtain ⟨ih1, ih2⟩ := ih _ _ heq
+      constructor
+      · exact Nat.le_trans (Nat.le_add_right _ _ ) ih1
+      · exact ih2
+
+end Example
+
+end Lean.Order

src/Init/Internal/Order/Tactic.lean

@@ -0,0 +1,20 @@
+/-
+Copyright (c) 2024 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Joachim Breitner
+-/
+
+prelude
+import Init.Notation
+
+namespace Lean.Order
+/--
+`monotonicity` performs one compositional step solving `monotone` goals,
+using lemma tagged with `@[partial_fixpoint_monotone]`.
+
+This tactic is mostly used internally by lean in `partial_fixpoint` definitions, but
+can be useful on its own for debugging or when proving new `@[partial_fixpoint_monotone]` lemmas.
+-/
+scoped syntax (name := monotonicity) "monotonicity" : tactic
+
+end Lean.Order

src/Init/Prelude.lean

@@ -4170,6 +4170,16 @@ def withRef [Monad m] [MonadRef m] {α} (ref : Syntax) (x : m α) : m α :=
   let ref := replaceRef ref oldRef
   MonadRef.withRef ref x
 
+/--
+If `ref? = some ref`, run `x : m α` with a modified value for the `ref` by calling `withRef`.
+Otherwise, run `x` directly.
+-/
+@[always_inline, inline]
+def withRef? [Monad m] [MonadRef m] {α} (ref? : Option Syntax) (x : m α) : m α :=
+  match ref? with
+  | some ref => withRef ref x
+  | _        => x
+
 /-- A monad that supports syntax quotations. Syntax quotations (in term
     position) are monadic values that when executed retrieve the current "macro
     scope" from the monad and apply it to every identifier they introduce

src/Init/Tactics.lean

@@ -818,7 +818,7 @@ syntax inductionAlt  := ppDedent(ppLine) inductionAltLHS+ " => " (hole <|> synth
 After `with`, there is an optional tactic that runs on all branches, and
 then a list of alternatives.
 -/
-syntax inductionAlts := " with" (ppSpace colGt tactic)? withPosition((colGe inductionAlt)+)
+syntax inductionAlts := " with" (ppSpace colGt tactic)? withPosition((colGe inductionAlt)*)
 
 /--
 Assuming `x` is a variable in the local context with an inductive type,

src/Lean/Compiler/ExternAttr.lean

@@ -18,6 +18,7 @@ inductive ExternEntry where
   | inline   (backend : Name) (pattern : String)
   | standard (backend : Name) (fn : String)
   | foreign  (backend : Name) (fn : String)
+  deriving BEq, Hashable
 
 /--
 - `@[extern]`
@@ -36,7 +37,7 @@ inductive ExternEntry where
 structure ExternAttrData where
   arity?   : Option Nat := none
   entries  : List ExternEntry
-  deriving Inhabited
+  deriving Inhabited, BEq, Hashable
 
 -- def externEntry := leading_parser optional ident >> optional (nonReservedSymbol "inline ") >> strLit
 -- @[builtin_attr_parser] def extern     := leading_parser nonReservedSymbol "extern " >> optional numLit >> many externEntry

src/Lean/Compiler/LCNF/Basic.lean

@@ -7,6 +7,7 @@ prelude
 import Init.Data.List.BasicAux
 import Lean.Expr
 import Lean.Meta.Instances
+import Lean.Compiler.ExternAttr
 import Lean.Compiler.InlineAttrs
 import Lean.Compiler.Specialize
 import Lean.Compiler.LCNF.Types
@@ -429,6 +430,80 @@ where
     | .cases c => c.alts.forM fun alt => go alt.getCode
     | .unreach .. | .return .. | .jmp .. => return ()
 
+partial def Code.instantiateValueLevelParams (code : Code) (levelParams : List Name) (us : List Level) : Code :=
+  instCode code
+where
+  instLevel (u : Level) :=
+    u.instantiateParams levelParams us
+
+  instExpr (e : Expr) :=
+    e.instantiateLevelParamsNoCache levelParams us
+
+  instParams (ps : Array Param) :=
+    ps.mapMono fun p => p.updateCore (instExpr p.type)
+
+  instAlt (alt : Alt) :=
+    match alt with
+    | .default k => alt.updateCode (instCode k)
+    | .alt _ ps k => alt.updateAlt! (instParams ps) (instCode k)
+
+  instArg (arg : Arg) : Arg :=
+    match arg with
+    | .type e => arg.updateType! (instExpr e)
+    | .fvar .. | .erased => arg
+
+  instLetValue (e : LetValue) : LetValue :=
+    match e with
+    | .const declName vs args => e.updateConst! declName (vs.mapMono instLevel) (args.mapMono instArg)
+    | .fvar fvarId args => e.updateFVar! fvarId (args.mapMono instArg)
+    | .proj .. | .value .. | .erased => e
+
+  instLetDecl (decl : LetDecl) :=
+    decl.updateCore (instExpr decl.type) (instLetValue decl.value)
+
+  instFunDecl (decl : FunDecl) :=
+    decl.updateCore (instExpr decl.type) (instParams decl.params) (instCode decl.value)
+
+  instCode (code : Code) :=
+    match code with
+    | .let decl k => code.updateLet! (instLetDecl decl) (instCode k)
+    | .jp decl k | .fun decl k => code.updateFun! (instFunDecl decl) (instCode k)
+    | .cases c => code.updateCases! (instExpr c.resultType) c.discr (c.alts.mapMono instAlt)
+    | .jmp fvarId args => code.updateJmp! fvarId (args.mapMono instArg)
+    | .return .. => code
+    | .unreach type => code.updateUnreach! (instExpr type)
+
+inductive DeclValue where
+  | code (code : Code)
+  | extern (externAttrData : ExternAttrData)
+  deriving Inhabited, BEq
+
+partial def DeclValue.size : DeclValue → Nat
+  | .code c => c.size
+  | .extern .. => 0
+
+def DeclValue.mapCode (f : Code → Code) : DeclValue → DeclValue :=
+  fun
+    | .code c => .code (f c)
+    | .extern e => .extern e
+
+def DeclValue.mapCodeM [Monad m] (f : Code → m Code) : DeclValue → m DeclValue :=
+  fun v => do
+    match v with
+    | .code c => return .code (← f c)
+    | .extern .. => return v
+
+def DeclValue.forCodeM [Monad m] (f : Code → m Unit) : DeclValue → m Unit :=
+  fun v => do
+    match v with
+    | .code c => f c
+    | .extern .. => return ()
+
+def DeclValue.isCodeAndM [Monad m] (v : DeclValue) (f : Code → m Bool) : m Bool :=
+  match v with
+  | .code c => f c
+  | .extern .. => pure false
+
 /--
 Declaration being processed by the Lean to Lean compiler passes.
 -/
@@ -455,7 +530,7 @@ structure Decl where
   The body of the declaration, usually changes as it progresses
   through compiler passes.
   -/
-  value : Code
+  value : DeclValue
   /--
   We set this flag to true during LCNF conversion. When we receive
   a block of functions to be compiled, we set this flag to `true`
@@ -536,7 +611,9 @@ We use this function to decide whether we should inline a declaration tagged wit
 `[inline_if_reduce]` or not.
 -/
 def Decl.isCasesOnParam? (decl : Decl) : Option Nat :=
-  go decl.value
+  match decl.value with
+  | .code c => go c
+  | .extern .. => none
 where
   go (code : Code) : Option Nat :=
     match code with
@@ -550,49 +627,6 @@ def Decl.instantiateTypeLevelParams (decl : Decl) (us : List Level) : Expr :=
 def Decl.instantiateParamsLevelParams (decl : Decl) (us : List Level) : Array Param :=
   decl.params.mapMono fun param => param.updateCore (param.type.instantiateLevelParamsNoCache decl.levelParams us)
 
-partial def Decl.instantiateValueLevelParams (decl : Decl) (us : List Level) : Code :=
-  instCode decl.value
-where
-  instLevel (u : Level) :=
-    u.instantiateParams decl.levelParams us
-
-  instExpr (e : Expr) :=
-    e.instantiateLevelParamsNoCache decl.levelParams us
-
-  instParams (ps : Array Param) :=
-    ps.mapMono fun p => p.updateCore (instExpr p.type)
-
-  instAlt (alt : Alt) :=
-    match alt with
-    | .default k => alt.updateCode (instCode k)
-    | .alt _ ps k => alt.updateAlt! (instParams ps) (instCode k)
-
-  instArg (arg : Arg) : Arg :=
-    match arg with
-    | .type e => arg.updateType! (instExpr e)
-    | .fvar .. | .erased => arg
-
-  instLetValue (e : LetValue) : LetValue :=
-    match e with
-    | .const declName vs args => e.updateConst! declName (vs.mapMono instLevel) (args.mapMono instArg)
-    | .fvar fvarId args => e.updateFVar! fvarId (args.mapMono instArg)
-    | .proj .. | .value .. | .erased => e
-
-  instLetDecl (decl : LetDecl) :=
-    decl.updateCore (instExpr decl.type) (instLetValue decl.value)
-
-  instFunDecl (decl : FunDecl) :=
-    decl.updateCore (instExpr decl.type) (instParams decl.params) (instCode decl.value)
-
-  instCode (code : Code) :=
-    match code with
-    | .let decl k => code.updateLet! (instLetDecl decl) (instCode k)
-    | .jp decl k | .fun decl k => code.updateFun! (instFunDecl decl) (instCode k)
-    | .cases c => code.updateCases! (instExpr c.resultType) c.discr (c.alts.mapMono instAlt)
-    | .jmp fvarId args => code.updateJmp! fvarId (args.mapMono instArg)
-    | .return .. => code
-    | .unreach type => code.updateUnreach! (instExpr type)
-
 /--
 Return `true` if the arrow type contains an instance implicit argument.
 -/
@@ -693,7 +727,7 @@ where
       visit k
 
   go : StateM NameSet Unit :=
-    decls.forM fun decl => visit decl.value
+    decls.forM (·.value.forCodeM visit)
 
 def instantiateRangeArgs (e : Expr) (beginIdx endIdx : Nat) (args : Array Arg) : Expr :=
   if !e.hasLooseBVars then

src/Lean/Compiler/LCNF/Bind.lean

@@ -123,7 +123,10 @@ def FunDeclCore.etaExpand (decl : FunDecl) : CompilerM FunDecl := do
   decl.update decl.type params value
 
 def Decl.etaExpand (decl : Decl) : CompilerM Decl := do
-  let some (params, value) ← etaExpandCore? decl.type decl.params decl.value | return decl
-  return { decl with params, value }
+  match decl.value with
+  | .code code =>
+    let some (params, newCode) ← etaExpandCore? decl.type decl.params code | return decl
+    return { decl with params, value := .code newCode}
+  | .extern .. => return decl
 
 end Lean.Compiler.LCNF

src/Lean/Compiler/LCNF/CSE.lean

@@ -102,7 +102,7 @@ end CSE
 Common sub-expression elimination
 -/
 def Decl.cse (decl : Decl) : CompilerM Decl := do
-  let value ← decl.value.cse
+  let value ← decl.value.mapCodeM (·.cse)
   return { decl with value }
 
 def cse (phase : Phase := .base) (occurrence := 0) : Pass :=

src/Lean/Compiler/LCNF/Check.lean

@@ -261,7 +261,7 @@ def run (x : CheckM α) : CompilerM α :=
 end Check
 
 def Decl.check (decl : Decl) : CompilerM Unit := do
-  Check.run do Check.checkFunDeclCore decl.name decl.params decl.type decl.value
+  Check.run do decl.value.forCodeM (Check.checkFunDeclCore decl.name decl.params decl.type)
 
 /--
 Check whether every local declaration in the local context is used in one of given `decls`.
@@ -299,7 +299,7 @@ where
 
   visitDecl (decl : Decl) : StateM FVarIdHashSet Unit := do
     visitParams decl.params
-    visitCode decl.value
+    decl.value.forCodeM visitCode
 
   visitDecls (decls : Array Decl) : StateM FVarIdHashSet Unit :=
     decls.forM visitDecl

src/Lean/Compiler/LCNF/CompilerM.lean

@@ -148,7 +148,7 @@ def eraseCodeDecls (decls : Array CodeDecl) : CompilerM Unit := do
 
 def eraseDecl (decl : Decl) : CompilerM Unit := do
   eraseParams decl.params
-  eraseCode decl.value
+  decl.value.forCodeM eraseCode
 
 abbrev Decl.erase (decl : Decl) : CompilerM Unit :=
   eraseDecl decl

src/Lean/Compiler/LCNF/DeclHash.lean

@@ -38,6 +38,7 @@ end
 instance : Hashable Code where
   hash c := hashCode c
 
+deriving instance Hashable for DeclValue
 deriving instance Hashable for Decl
 
-end Lean.Compiler.LCNF
+end Lean.Compiler.LCNF

src/Lean/Compiler/LCNF/ElimDead.lean

@@ -95,6 +95,6 @@ def Code.elimDead (code : Code) : CompilerM Code :=
   ElimDead.elimDead code |>.run' {}
 
 def Decl.elimDead (decl : Decl) : CompilerM Decl := do
-  return { decl with value := (← decl.value.elimDead) }
+  return { decl with value := (← decl.value.mapCodeM Code.elimDead) }
 
 end Lean.Compiler.LCNF

src/Lean/Compiler/LCNF/ElimDeadBranches.lean

@@ -513,7 +513,7 @@ def inferStep : InterpM Bool := do
     let currentVal ← getFunVal idx
     withReader (fun ctx => { ctx with currFnIdx := idx }) do
       decl.params.forM fun p => updateVarAssignment p.fvarId .top
-      interpCode decl.value
+      decl.value.forCodeM interpCode
     let newVal ← getFunVal idx
     if currentVal != newVal then
       return true
@@ -538,7 +538,7 @@ Use the information produced by the abstract interpreter to:
 -/
 partial def elimDead (assignment : Assignment) (decl : Decl) : CompilerM Decl := do
   trace[Compiler.elimDeadBranches] s!"Eliminating {decl.name} with {repr (← assignment.toArray |>.mapM (fun (name, val) => do return (toString (← getBinderName name), val)))}"
-  return { decl with value := (← go decl.value) }
+  return { decl with value := (← decl.value.mapCodeM go) }
 where
   go (code : Code) : CompilerM Code := do
     match code with

src/Lean/Compiler/LCNF/FixedParams.lean

@@ -141,8 +141,9 @@ partial def evalApp (declName : Name) (args : Array Arg) : FixParamM Unit := do
       let key := (declName, values)
       unless (← get).visited.contains key do
         modify fun s => { s with visited := s.visited.insert key }
-        let assignment := mkAssignment decl values
-        withReader (fun ctx => { ctx with assignment }) <| evalCode decl.value
+        decl.value.forCodeM fun c =>
+          let assignment := mkAssignment decl values
+          withReader (fun ctx => { ctx with assignment }) <| evalCode c
 
 end
 
@@ -169,8 +170,12 @@ def mkFixedParamsMap (decls : Array Decl) : NameMap (Array Bool) := Id.run do
     let values := mkInitialValues decl.params.size
     let assignment := mkAssignment decl values
     let fixed := Array.mkArray decl.params.size true
-    match evalCode decl.value |>.run { main := decl, decls, assignment } |>.run { fixed } with
-    | .ok _ s | .error _ s => result := result.insert decl.name s.fixed
+    match decl.value with
+    | .code c =>
+      match evalCode c |>.run { main := decl, decls, assignment } |>.run { fixed } with
+      | .ok _ s | .error _ s => result := result.insert decl.name s.fixed
+    | .extern .. =>
+      result := result.insert decl.name fixed
   return result
 
 end Lean.Compiler.LCNF

src/Lean/Compiler/LCNF/FloatLetIn.lean

@@ -239,7 +239,7 @@ Iterate through `decl`, pushing local declarations that are only used in one
 control flow arm into said arm in order to avoid useless computations.
 -/
 partial def floatLetIn (decl : Decl) : CompilerM Decl := do
-  let newValue ← go decl.value |>.run {}
+  let newValue ← decl.value.mapCodeM go |>.run {}
   return { decl with value := newValue }
 where
   /--