Kernel diagnostics appear if diagnostics is enabled, even if it is the only section (#4611).


Adds missing profileitM functions (#4753).


Adds Lean.Expr.numObjs for counting allocated sub-expressions (#4754).


Adds missing withTraceNodes for trace.profiler (#4769).


Makes 'use set_option diagnostics true' message conditional on the setting (#4781, #4882).


Adds ShareCommon.shareCommon' (and other related improvements) for common subterm sharing. In large expressions, up to 20x speedup (#4767, #4775, #4887).


Ensures Expr.replaceExpr preserves DAG structure (#4779).


Documents performance issues in Expr.replaceExpr (#4783).


Makes for_each use a precise cache (#4794, #4797, #4798).


Makes Expr.find?/findExt? use kernel implementations for better caching (#4795).


Makes Expr.replace use kernel implementation (#4799).


Makes Expr.foldConsts use a precise cache (#4871).


Makes expr_eq_fn use a precise cache (#4890).


Upstreams ToExpr FilePath and compile_time_search_path% (#4453).


Fixes handling of const2ModIdx in finalizeImport, preferring the original module for a re-declared declaration (#4652).


Kernel: prevents large Nat exponentiations from evaluating, gate-limited by exponentiation.threshold (#4637).


Updates comments in kernel/declaration.h (#4683).


Improves performance by using precise replace for sub-expressions (#4796).


Fixes expression copying overhead (10% runtime) by proper move constructor usage (#4700).


Speeds up replace_rec_fn::apply by avoiding expression copies (#4702).


Fixes a typo in constants and trace.profiler.useHeartbeats (#4590).


Adds 'since' dates to deprecated attributes (#4617).


Improves constructor-as-variable test (#4625).


Extends a test with example from Zulip (#4740).


Moves Syntax.hasIdent earlier, shakes dependencies (#4766).


Splits out Lean.Language.Lean.Types (#4881).


Adds LEAN_EXPORT for sharecommon functions (#4893).


Fixes typos (#4635, #4719, #af40e6).


Docs: Command.Scope (#4748).


Moves Std from libleanshared to libInit_shared, fixing Windows build (#4661).


Fixes initialization by explicitly calling lean_initialize for Std (#4668).


Adjusts shouldExport to exclude more symbols to get below Windows symbol limit (#4746). Adds partial reversions (#4884, #4956) for Verso support.


Adjusts shouldExport exceptions for Verso (#4884).


Adds lean_is_exclusive_obj (Lean.isExclusiveUnsafe) and lean_set_external_data (#4778).


Fixes calling programs with spaces on Windows (#4515).


Improves Git checkouts and cloud releases. On error, Lake prints all top-level logs. Forcibly fetches tags. Better error messages. The builtin package facets release, optRelease, extraDep are now consistent. Also supports optional jobs that do not fail the build. afterReleaseSync/afterReleaseAsync now fetch optRelease. See PR (#4735).


Adds draft CI workflow on new projects (#4608).


Adds CLI options --log-level and --fail-level to control log printing and build failure triggers (#4847).


Lake docs (#4853).


Release triggers update of release.lean-lang.org (#4531).


Adjusts pr-release for new lakefile.lean (#4598).


Makes pr-release use correct tag name (#4632).


Allows manual triggering of nightly release (#4638).


Adds debug output for restart-on-label (#4640). Bumps wait from 10s to 30s (#4663). Updates actions version (#4664, #582d6e).


Bumps download-artifact to 582d6e. Adds back check-stage3 (6d9718). Adds Jira sync for FRO (0768ad).


Adds support for reporting CI errors on FRO Zulip (#4830).


Adds nightly_bump_toolchain trigger on mathlib4 (#4838).


Fixes msys2 (#abf420).


Deprecates Nix-based builds, removing interactive components (#4895).


Updates release checklist (#4693, #4458, #4876).


Fixes 'max dynamic symbols' metric per static library (#4669).


Improves tests/list_simp for retesting normal forms with Mathlib (#4691).


Updates the quickstart guide (#4806).


Documents triage team in the contribution guide (c02aa9).


For @[ext]-generated ext/ext_iff lemmas, the x and y arguments are now implicit, and these lemmas are protected. (#4543).


trace.profiler.useHearbeats is now trace.profiler.useHeartbeats (#4590).


A bugfix in structural recursion may break existing code if a parameter is behind indices in the recursive argument. Reordering parameters can fix it (#4672).


List.filterMapM now sequences monadic actions left-to-right (#4820).


The effect of the variable command on theorem bodies changed. Section variables are no longer included based on usage inside proofs; only the theorem signature, includes, or instance implicits referencing included variables cause them to be included. This ensures theorem statements do not change if the proof changes. For porting, set_option deprecated.oldSectionVars true can revert to old behavior (#4883 etc.).


Language features, tactics, and metaprograms

Improves the strategy split uses to generalize discriminants of matches and adds trace.split.failure trace class for diagnosing issues.


Prevents the tactic from claiming pre-existing goals are new subgoals.


Adds dsimprocs for if expressions (ite and dite).


Improves heuristics for unfolding, where equational lemmas have priorities so more-specific lemmas are tried first before a catch-all.


Fixes an issue where function-valued OfNat numeric literals would become denormalized.


Fixes an issue where dsimp theorems might not apply to literals.


Fixes the source position for the warning for deprecated simp arguments.


Adds docstrings for dsimp configuration.


Improves the accuracy of used simp lemmas reported by simp?.


Makes the omega tactic generate error messages lazily, improving performance when used in tactic combinators.


Works around changes to the definition of Fin.sub in bv_omega tactic.


Sets up groundwork for a tactic index in generated documentation, as there was in Lean 3. See PR description for details.


Makes the variable command fully elaborate binders during validation, fixing an issue where some errors would be reported only at the next declaration.


Fixes a discrepancy in universe parameter order between theorem and def declarations.


Fixes a discrepancy in the elaborators for theorem, def, and example, making Prop-valued examples and other definition commands elaborate like theorems.


Fixes an elaboration bug in #check_tactic.


Adds support for open _root_.<namespace>.


Adds the debug.byAsSorry option, which elaborates all 'by ...' terms as 'sorry'.


Adds a linter to flag local variables whose names coincide with argumentless constructors of their type. The linter can be disabled with set_option linter.constructorNameAsVariable false. Also improves error messages suggesting similar valid constructor names.


Adds public Name.isInternalDetail function for filtering declarations using naming conventions for internal names.


Sorts the output of #print axioms for determinism.


Fixes error message range for the cdot focusing tactic.


Language server, widgets, and IDE extensions

Makes the watchdog be more resilient against badly behaving clients.


Restores fallback pretty printers when context is not available, and documents addMessageContext.


Introduces pp.maxSteps option and sets the default value of pp.deepTerms to false, to keep excessively large or deep terms from overwhelming the Infoview.


Splits GetElem class into GetElem and GetElem? to remove Decidable instance arguments from getElem? and getElem!, improving rewritability.


Makes Array.toArrayAux_eq be a simp lemma.


Improves robustness of the proof for Array.reverse_data.


Improves the organization of the List API.


Further improves the organization of the List API.


Improves the List.set and List.concat API.


Upstreams lemmas about List.filter from Batteries.


Adjusts @[simp] attributes for List.


Makes List.getElem?_eq_getElem be a simp lemma.


Adds missing List.replicate API.


Adds lemmas about List.map.


Changes List.length_cons to use as.length + 1 instead of as.length.succ.


Fixes the statement of List.filter_congr.


Changes binder explicitness in List.bind_map.


Adds maximum?_eq_some_iff' and minimum?_eq_some_iff?.


Switches the normal forms for indexing List and Array to xs[n] and xs[n]? rather than using List.get or Array.get.


Fixes linearity in HashMap.insert and HashMap.erase, leading to a 40% speedup in a replace-heavy workload.


Generalizes type of Option.forM from Unit to PUnit.


Removes simp attribute from Option.elim and adds it to individual reduction lemmas, making unfolding less aggressive.


Adds missing theorems for n + 1 and n - 1 normal forms.


Makes Nat.min_assoc be a simp lemma.


Moves @[simp] from Nat.pred_le to Nat.sub_one_le.


Changes various Nat.succ n to n + 1.


Adds complete div/mod simprocs for Int.


Makes the byte-size interface be Nat-valued with Char.utf8Size and String.utf8ByteSize, replacing Char.csize.


Upstreams Char.ext from Batteries and adds some Char documentation to the manual.


Adjusts Fin.sub to be more performant in definitional equality checks.


Adds missing Prod.map lemmas.


Fixes binder explicitness in Prod lemmas.


Adds missing simproc for BitVec equality.


Adds BitVec.twoPow and lemmas, toward bitblasting multiplication for LeanSAT.


Introduces Std, a library situated between Init and Lean, providing functionality not in the prelude both to Lean's implementation and to external users.


Standardizes on using (· == a) over (a == ·).


Fixes errors found by running the library through the Batteries linters.


Makes getBitVecValue? recognize BitVec.ofNatLt.


Adjusts instantiateMVars algorithm to zeta-reduce let expressions while beta reducing instantiated metavariables.


Fixes occurs check for metavariable assignments to also take metavariable types into account.


Fixes forEachModuleInDir to iterate over each Lean file exactly once.


Adds support to build Lean core oleans using Lake.


Improves performance of isDefEq by eta reducing lambda-abstracted terms during metavariable assignments, since they're beta reduced anyway at instantiation.


Removes redundant code in isDefEqQuickOther.


Fixes handling of metavariables when caching results at synthInstance?.


Makes 'don't know how to synthesize implicit argument' errors more reliably report the argument name.


Fixes a name resolution bug for generalized field notation (dot notation).


Blocks the implicit lambda feature for (e :) notation.


Makes it an error for there to be two functions with the same name in a where/let rec block.


Refactors findRecArg, extracting withRecArgInfo. Errors are now reported in parameter order rather than the order tried, and for each argument it reports why it wasn't suitable.


Refactors constructions toward a future port to Lean.


Ports mk_definition_inferring_unsafe to Lean.


Ports recOn construction to Lean.


Ports below and brecOn construction to Lean.


Adds a more-detailed docstring for PersistentEnvExtension.


Removes @[inline] from NameMap.find?, which caused repeated respecialization at call sites.


Removes the 'you might need to open '{dir}' in your editor' message, now handled by Lake and the VS Code extension.


Improves the performance of CollectMVars and FindMVar.


Adds missing DecidableEq and Repr instances for intermediate structures used by the BitVec and Fin simprocs.


Adds tests for a previous isDefEq issue.


Fixes @[implemented_by] for functions defined by well-founded recursion.


Adds additional tests for apply? tactic.


Adds a workaround for a bug in IndPredBelow.mkBelowMatcher.


Minor cleanup.


Adds validation of UTF-8 at the C++-to-Lean boundary in the runtime.


Fixes missing unboxing in interpreter when loading initialized value.


Exposes the compiler flags for the bundled C compiler (clang).


Deprecates inputFile and replaces it with inputBinFile and inputTextFile. inputTextFile normalizes line endings, ensuring platform-independent traces.


Simplifies dependency resolution code.


Touches up the Lake configuration DSL, allowing string literals instead of identifiers for names, avoids French quotes in lake new/init templates, changes the exe template to use Main, improves the math template error if lean-toolchain fails to download, and downgrades unknown config fields from error to warning for cross-version compatibility.


Tweaks require syntax and updates docs. Now require in TOML for a package like doc-gen4 does not need French quotes.


Fixes a bug where package versions in indirect dependencies would take precedence over direct dependencies.


Fixes a bug where Lake incorrectly included the module dynamic library in a platform-independent trace.


Fixes issues with bad import errors, so a bad import in an executable no longer prevents building its root module. Also shows transitive bad import locations. The root module now respects nativeFacets.


Fixes a bug where non-identifier script names could not be entered on the CLI without French quotes.


Addresses issues with precompiled libraries, ensuring Lake no longer always precompiles the package of a module. If a module is precompiled, it now also precompiles its imports.


Adds a new type of require that fetches package metadata from a registry API endpoint (like Reservoir) and then clones a Git package. This helps Lake pick the correct default branch if it's not 'master'.


Adds new type of registry-based require, improving how Lake fetches metadata from endpoints like Reservoir for packages with non-'master' default branches.


Further improves the new registry require feature, letting Lake handle the RESERVIOR_API_URL environment variable for alternative registry endpoints.


Uses Namespace runners for CI for leanprover/lean4.


Fixes speedcenter tests in CI.


Fixes that a workflow change would break CI for unrebased PRs.


Fixes Wasm release-ci.


Causes releases to be marked as prerelease on GitHub.


Switches Lake to using src/lake/lakefile.toml to avoid needing to load a version of Lake to build Lake.


Adds gdb to the Nix shell.


Adds a platform-dependent flag to the lib target in Nix builds.


Links -lStd back into Nix build flags on Darwin, fixing a build issue.


Adds the seal and unseal commands, which make definitions locally irreducible or semireducible.


Marks functions defined by well-founded recursion with @[irreducible] by default, preventing expensive unfolding.


Extends incremental elaboration into definition headers, bodies, and tactics.


Improves resilience by ensuring incremental commands and tactics are only reached in supported ways.


Adds special handling for := by so that stray tokens in tactic blocks do not inhibit incrementality.


Adds incremental have tactic.


Fixes incorrect info tree reuse with incremental elaboration.


Adds incrementality for careful command macros such as set_option in theorem, theorem foo.bar, and lemma.


Adds a conservative fix for whitespace handling to avoid incremental reuse showing goals in front of the cursor.


Fixes non-incremental commands in macros blocking further incremental reporting.


Fixes incremental reporting when there are nested tactics in terms.


Adds incrementality support for next and if tactics.


Disables incrementality for tactics-in-terms-in-tactics.


Ensures that the names used for functional induction are reserved.


Adds support for structural recursion on reflexive types (example: Many α).


Normalizes all line endings to LF before processing, making Lean insensitive to CRLF vs LF.


Makes the tactic framework able to recover from runtime errors like deterministic timeouts or max recursion depth.


Fixes split at h when h has forward dependencies.


Allows split for if-expressions to work on non-propositional goals.


Improves error messages by displaying implicit arguments in unification errors as needed (MessageData changes).


Adds support for unifying large offsets like x + 20000 = 20001.


Lets omega fall back to classical Decidable instances for contradiction proofs.


Fixes a bug in omega tactic.


Fixes another bug in omega tactic.


Improves the error message if no facts are found in the local context.


Improves expression matching by using match_expr.


Makes names of erased lemmas clickable.


Adds a pretty printer for discrimination tree keys.


Adds Simp.Config.index option to control discrimination tree usage, with diagnostics for 'bad keys'.


Prevents internal match equational theorems from appearing in simp trace.


Continues the simp process even if a lemma fails to elaborate, in recovery mode.


Fixes panic when applying @[simp] to malformed theorem syntax.


Prevents simp from using the forward version of user-specified backward theorems.


Adds missing dsimp simplifications for fixed parameters in generated congruence theorems.


Improves trace messages for simp so constants are hoverable.


Makes subst notation (he ▸ h) try rewriting in both directions even with no expected type.


Adds support for identifiers in autoparams, e.g. (h : x = y := by exact rfl).


Changes how the type in let/have is elaborated, requiring tactics in the type to be fully evaluated first.


Ensures expression tree elaborator commits to the computed "max type" for arithmetic expressions.


Shows signature elaboration errors even if parse errors exist in the body.


Improves error messages when numeric literals fail to synthesize OfNat, including warnings about proposition types.


Fixes nested error messages/infotrees vanishing (snapshot subtrees not restored).


Calculates error suppression per snapshot, letting elaboration errors appear even if there are later parse errors.


Adds Lean.MVarId.revertAll to revert all free variables.


Adds Lean.MVarId.ensureNoMVar to ensure the goal's target has no expression metavariables.


Adds cleanupAnnotations parameter to forallTelescope methods.


Adds support for parser aliases in syntax quotations.


Adds grind_norm and grind_norm_proc attributes and @[grind_norm] theorems.


Creates grind preprocessor and core module.


Adds special cases tactic to grind along with @[grind_cases].


Adds special injection? tactic to grind.


Fixes a bug in Nat.reduceLeDiff simproc.


Makes deprecation warnings activate even for generalized field notation.


Fixes sorry so that it does not activate the implicit lambda feature.


Fixes the case tactic so it can be used in macros, erasing macro scopes from the tag.


Fixes bugs in partial calc tactic when there is mdata or metavariables.


Makes termination_by? report each unused parameter as _.


Fixes 'Find References' when browsing core Lean sources.


Allows embedding user widgets in structured messages (companion PR in vscode-lean4#449).


Makes watchdog more resilient against badly behaving clients.


Upstreams many List and Array operations and theorems from Batteries.


Removes the unused Inhabited instance for Subtype.


Adds dates in existing @[deprecated] attributes.


Adds boilerplate Char, UInt, and Fin theorems.


Fixes the MonadStore type classes to use semiOutParam.


Renames IsLawfulSingleton to LawfulSingleton.


Swaps Nat.zero_or and Nat.or_zero.


Changes definition of Nat.mod so n % (m + n) reduces when n is a literal without well-founded recursion.


Changes definition of Nat.mod to avoid well-founded recursion becoming irreducible by default.


Redefines Nat.testBit to be more performant.


Adds theorems for Nat.


Improves functional induction principle Array.feraseIdx.induct.


Removes @[simp] from List.length_pos.


Adds theorems to simplify Option-valued dependent if-then-else.


Removes @[simp] from Option.bind_eq_some.


Adds theorems for BitVec.


Adds simprocs for reducing x >>> i and x <<< i when i is a bitvector literal.


Adds simprocs for reducing repeated shifts (x <<< i) <<< j and (x >>> i) >>> j.


Redefines rotateLeft/rotateRight to use modulo reduction of the shift offset.


Makes <num>#<term> bitvector literal notation global, removing <term>#<term> form.


Fixes implicitness of typeclass arguments in HashMap.ofList.


Adds IO.Process.getCurrentDir and IO.Process.setCurrentDir for adjusting current working directory.


Minor cleanup.


Removes unnecessary checkpointDefEq.


Fixes isReadOnlyOrSyntheticOpaque to respect metavariable depth.


Fixes missing occurs check for delayed assignments.


Lean internals (Definition transparency)

Adds validation for @[reducible]/@[semireducible]/@[irreducible] attributes, with local/scoped modifiers.


Fixes a bug where indices could be incorrectly promoted to parameters.


Fixes a bug in the injectivity theorem generator.


Fixes elaboration of mutual inductives with instance parameters.


Lean internals (Diagnostics and profiling)

Adds option trace.profiler.useHeartbeats to measure profiler.threshold in heartbeats rather than ms.


Makes set_option diagnostics true report kernel diagnostic info.


Fixes multiple issues with TC caching interacting with synthPendingDepth, adds maxSynthPendingDepth = 1.


Ensures local instance cache does not contain duplicates.


Fixes handling of metavariables so that backward.synthInstance.canonInstances need not be false.


Fixes propagation of state for liftCoreM/liftTermElabM in Lean.Elab.Command.


Makes the Repr deriving handler consistent for structure vs inductive (erasing types/proofs).


Propagates maxHeartbeats to the kernel, controlling (kernel) deterministic timeout errors.


Reverts #3970 (monadic generalization of FindExpr).


Catches stack overflow in auto-bound implicits feature.


Adds tryCatchRuntimeEx combinator to replace catchRuntimeEx reader state.


Simplifies the expression canonicalizer.


Adds many missing trace classes (Elab, Tactic, etc.).


Adds more missing trace classes.


Makes congruence theorem generators clean up type annotations of argument types.


Fixes restoration of infotrees with auto-bound implicits, improving hovers and variable linter accuracy.


Fixes an issue where the interrupt exception was swallowed by some tryCatchRuntimeEx uses (merge conflict).


Adapts kernel interruption to the new cancellation system.


Minor cleanup.


Improves reset/reuse algorithm, relaxing constraints in a second pass for memory reuse.


Fixes segfault in old compiler from mishandling noConfusion applications.


Fixes bug in constant folding in the compiler.


Documents the runtime memory layout for inductive types.


Makes trace reading more robust, rebuilding if trace files are invalid/unreadable. Backwards-compatible with numeric traces.


Adds support for docstrings on require commands.


Improves hovers for family_def and library_data commands.


Adds default README.md to package templates.


Extends lake test help page, adds lake lint, supports specifying test/lint drivers, library test drivers, etc.


Adds lake pack and lake unpack for archiving build artifacts.


Switches manifest format to semantic versioning, e.g. major.minor.patch with backward compatibility for older numeric versions.


Adds a lift from JobM to FetchM for backwards compatibility.


Fixes performance issues when lifting LogIO to CliM.


Makes Lake store the dependency trace in the cached build and verify it before replaying logs.


Moves the cached log into the trace file, ensuring out-of-date logs aren't associated with up-to-date traces.


Cleans up tests.


Fixes noRelease test when Lean repo is tagged.


Improves tests/serve script.


Adds build log path to the warning for missing or invalid build log.


Adds a script (script/rebase-stage0.sh) for git rebase -i that updates each stage0 automatically.


Finishes renamings from transition to Std to Batteries.


Adjusts the GitHub bug template to mention testing on live.lean-lang.org.


Makes CI rerun only when full-ci label is added or removed.


Switches to #guard_msgs in tests wherever possible.


Explains the Lean4 pygments lexer.


Sets up a procedure for preparing release notes.


Modernizes build instructions and workflows.


Moves some expensive checks from merge queue to releases.


Adds aarch64 macOS as a native compilation target in CI.


Updates build instructions for macOS.


Adjusts workflow to update Batteries in the manifest for lean-pr-testing-NNNN branches.


Simplifies lean4checker step of the release checklist.


Adds installing elan to pr-release CI step.


Fixes the Windows build which was missing an exported symbol.


Now well-founded recursive functions have @[irreducible], which can break definitional-equality-based proofs.


Swaps Nat.zero_or and Nat.or_zero.


Renames IsLawfulSingleton to LawfulSingleton.


BitVec literal notation is now <num>#<term>, global, and rotateLeft/rotateRight take shift modulo bitwidth.


No longer simp lemmas: List.length_pos and Option.bind_eq_some.


Due to #3929, MessageData.ofPPFormat is removed; use MessageData.lazy or .ofFormatWithInfos.


Types in let/have can fail to elaborate due to new restrictions on embedded tactics (#4096).


Language features, tactics, and metaprograms (Functional induction)

Introduces a functional induction principle for recursive functions.


Expands or modifies the functional induction mechanism.


Refines generation of functional induction theorems for certain definitions.


Improves elaboration or usage of functional induction principles.


Optimizes aspects of functional induction for specific patterns.


Extends functional induction with additional features or fixes.


Updates functional induction principle edge cases.


Language features, tactics, and metaprograms (Termination checker)

Makes termination_by? avoid sizeOf when unnecessary.


Improves the termination_by syntax.


Changes how termination arguments are elaborated.


Refactors GuessLex to allow more complex inferred termination arguments.


Infers termination arguments like xs.size - i automatically.


Language features, tactics, and metaprograms (Custom eliminators)

Introduces @[induction_eliminator] for custom induction tactics.


Introduces @[cases_eliminator] for custom cases tactics.


Provides custom Nat eliminators so 'induction' uses n+1, not Nat.succ n.


Language features, tactics, and metaprograms (Shorter instance names)

Reduces generated anonymous instance name length using a new algorithm.


Refines cross-project uniqueness by adding a module-based suffix.


Language features, tactics, and metaprograms (simp/dsimp)

Enables kernel projection reduction in dsimp.


Makes dsimp normalize raw Nat literals as OfNat.ofNat.


Ensures simp handles OfScientific literals properly.


Makes dsimp? report used simprocs.


Improves performance when simp encounters a loop.


Fixes discharger/cache interaction in simp.


Prevents simp from breaking Char literals.


Allows more lenient matching for Nat instances in simp.


Documents simp configuration options.


Fixes simp caching issues.


Improves cache behavior for well-behaved dischargers in simp.


Language features, tactics, and metaprograms (omega)

Introduces a term canonicalizer for omega.


Improves the positivity handling for Int modulo operator.


Lets omega function as a simp discharger.


Adds helpful error messages for omega usage.


Refines internal usage or correctness in omega tactic.


Further fixes or improvements for omega logic.


Enhances fallback error handling in omega tactic.


Language features, tactics, and metaprograms (rfl)

Upstreams @[refl] attribute and the rfl tactic.


Continues upstreaming rfl features or patches.


Makes apply_rfl not operate on Eq itself.


Improves rfl error message when no goals remain.


Language features, tactics, and metaprograms (rw?)

Upstreams the rw? tactic for rewriting suggestions.


Fixes or improves the rw? tactic usage details.


Additional enhancements for lemma selection in rw?.


Further refinements or fixes for rw? rewriting approach.


Language features, tactics, and metaprograms (conv)

Adds a conv version of the calc tactic.


Uses try with_reducible rfl to clean up conv states.


Language features, tactics, and metaprograms (#guard_msgs)

Introduces whitespace protection with the ⏎ char in #guard_msgs.


Adds options for whitespace normalization and message ordering in #guard_msgs.


Adds an unused variables ignore function for #guard_msgs checks.


Introduces diff output comparing expected vs. actual messages (#guard_msgs.diff).


Language features, tactics, and metaprograms (do notation)

Makes it an error to lift (<- ...) out of a pure if ... then ... else.


Language features, tactics, and metaprograms (LazyDiscrTree)

Fixes a name collision for LazyDiscrTree that caused cache poisoning.


Simplifies exact?/apply? usage in LazyDiscrTree.


Moves general exact?/apply? logic into LazyDiscrTree internals.


Improves lemma selection for rw? using LazyDiscrTree.


Improves ordering of matches in LazyDiscrTree lookups.


Adds inductive.autoPromoteIndices option to disable index auto-promotion.


Language features, tactics, and metaprograms (Misc fixes)

Preserves simp cache/dischargeDepth fields in Lean.Meta.Simp.Result.mkEqSymm.


Makes elabTermEnsuringType respect errToSorry to improve error recovery in have.


Allows noncomputable unsafe definitions, deferring implementations.


Adjusts namespaces of certain tactics for consistency.


Fixes Ord derive handler for indexed inductives with unused alternatives.


Improves performance of derived Ord instances.


Changes error reporting for failing tactic macros, e.g. rfl no-goal error.


Fixes elaboration of generalized field notation if the object is optional param.


Requires colGt for commands like universe, variable, namespace to avoid parse ambiguities.


Lets split tactic be used in code contexts, not just proofs.


Adds missing info for induction with with-clauses (| cstr a b => ?_).


Fixes withSetOptionIn combinator usage.


Removes unused trace.Elab.syntax option.


Improves hover/go-to-def for attribute command usage.


Makes linter options more discoverable.


Fixes go-to-def for syntax from @[builtin_term_parser].


Makes solveByElim handle symm lemmas correctly, re-enabling exact?/apply?.


Improves the @[deprecated] attribute to accept (since := "<date>").


Makes #print show structure fields.


Makes exact?% behave like by exact? rather than by apply?.


Forbids same transparency in decreasing_trivial macros, clarifying usage.


Adjusts transparency for he ▸ h notation elaboration.


Speeds up binop%/binrel% expression tree elaborators.


Documentation improvements and clarifications for various Lean 4 features.


Adds or refines doc examples in the Lean codebase.


More usage examples and reference docs for Lean 4 tactics.


Documents further config and internal details of Lean 4.


Adds clarifications and usage notes for advanced Lean concepts.


Expands documentation on certain language constructs or modules.


Improves doc references for library code or syntax usage.


Refines doc strings for macros or commands.


Explains minor details in the reference about Lean code structure.


Adds a few clarifications to specialized doc topics.


Enables auto-completions for import statements in the server.


Fixes off-by-one errors in diagnostic ranges (#392 in vscode-lean4).


Introduces snapshot trees for incremental tactics/parallelism foundation.


Adds a basic incrementality API for snapshot-based elaboration.


Allows server-to-client requests for advanced IDE features.


Fixes jump to definition with conflicting names from different files (#1170).


Keeps semantic tokens in sync, improving performance of semantic highlighting.


Further optimizes or stabilizes semantic tokens usage in the LSP server.


Enhances synchronization or correctness in semantic tokens logic.


Shows diagnostics suggesting 'Restart File' when a file dependency is saved.


Adds more diagnostics for 'Restart File' usage in the server.


Uses correct module names in references or highlight output.


Makes errors in the file header appear reliably, sets 'Import out of date' warning severity as hint.


Simplifies text of 'Import out of date' warning message.


Fixes info nodes from before the cursor being used for completions (#3462).


Displays trace timings in Infoview for deeper performance insight.


Fixes hovers over binders so that they show types properly.


Adds attribute @[pp_using_anonymous_constructor] for structures to print as ⟨x,y,z⟩.


Expands usage of @[pp_using_anonymous_constructor] on structures like Sigma/PSigma.


Inlines parent-structure fields for structure instance printing by default.


Renames pp.structureProjections to pp.fieldNotation, adding suboption generalized.


Allows disabling or restricting field notation on a function-by-function basis.


Ensures no field notation is used on theorems, only definitions or functions.


Fixes interaction between app unexpanders and pp.fieldNotation.generalized.


Makes delabConstWithSignature put arguments after the colon when needed.


Adds option pp.mvars (default true) and pp.mvars.withType (default false).


Shows expression metavariables with type info if pp.mvars.withType is true.


Hides or shortens metavariable names if pp.mvars is false.


Makes binders hoverable in code with docstrings displayed.


Shows correct term in hovers for RHS of match expressions in Infoview.


Improves simp confluence for mixing Bool and Prop terms.


Adds more theorems or simplification rules for Bool/Prop usage.


Makes Nat.succ_eq_add_one a simp lemma, aligning with n+1 usage.


Replaces Nat.succ rules with simprocs for simpler rewriting.


Adds faster Nat.repr implementation in C.


Adds or refines Int theorems for integer operations.


Improves performance of UInt upcasting operations.


Removes Array.eraseIdxAux, eraseIdxSzAux, eraseIdx'.


Simplifies Array.findIdx? implementation.


Renames Subarray fields from as/h₁/h₂ to array/start_le_stop/stop_le_array_size.


Upstreams tail-recursive List operations and @[csimp] lemmas.


Adds or refines BitVec theorems for shifting/rotation, rewriting, etc.


Further updates BitVec theorems for various operations.


Extends BitVec rewriting rules or proofs.


Adds additional BitVec lemmas or theorems (like rotation).


Refines BitVec usage with advanced rewriting or equivalences.


Provides more BitVec facts for numeric reasoning.


Adds further expansions or corrections to BitVec theorems.


Protects Std.BitVec to avoid undesired overshadowing or redefinition.


Fixes String.splitOn function behavior.


Adds String.Pos.isValid and UTF-8 string validation logic.


Implements a reference model for UTF-8 encoding/decoding in String.


Adds IO.getTaskState to check a task's runtime state (finished/running/waiting).


Reduces imports for Init.Data.Nat and Init.Data.Int.


Reduces imports for Init.Omega.Int, making it leaner.


Upstreams Std.Data.Nat into core Lean library.


Upstreams Std.Data.Int into core Lean library.


Further import reductions for omega-related modules.


Extends GetElem interface with getElem! and getElem? for containers.


Renames Option.toMonad to Option.getM, removing unneeded Monad argument.


Merges lexOrd with compareLex for consistent lexicographic ordering.


Makes Quotient.sound a theorem instead of a definition.


Fixes System.FilePath.parent for absolute paths on certain platforms.


Corrects ByteArray.toUInt64LE!/toUInt64BE! being swapped.


Fixes linearity in HashMap.insertIfNew, HashSet.erase, HashMap.erase.


Further linearity fix for certain HashSet or HashMap operations.


Ensures linearity in Parsec.many*Core loops.


Adds FS.Stream.isTty field for checking TTY state in streams.


Deprecates Option.toBool in favor of Option.isSome.


Upstreams Data.List.Init and Data.Array.Init from Std.


Adds instances so ac_rfl can work without Mathlib.


Changes Fin.induction to use structural induction for clarity.


Various doc updates for library modules or user guides.


Additional clarifications or expansions in doc comments.


Edits to doc pages for clarity or completeness.


Refines docstrings or user-facing doc references in the codebase.


Minor doc improvements or reorganizations of existing references.


Edits or extends documentation for advanced features or modules.


Fixes or updates certain doc references in Lean code.


Further doc updates for specialized areas or linter references.


Expands doc coverage in some lesser-known library parts.


Syncs doc changes for tactics or macros with the code updates.


Updates docs to reflect changed or deprecated features in Lean 4.


Revises doc references in sections related to config or options.


Cleanups in doc references for library usage or style.


Minor enhancements for code examples in doc strings.


Doc improvements for certain library modules or theorems.


Expands user documentation and references for advanced usage.


Adds better support for reducing Nat.rec expressions.


Adds tracing for non-easy WHNF cases.


Fixes isDefEq performance by trying structure eta after lazy delta.


Prevents transparency level bump when reducing projections (yesWithDeltaI fix).


Improves heuristics in isDefEq for certain matching scenarios.


Enhances isDefEq to handle constraints like t.i =?= s.i more efficiently.


Improves isDefEqProj logic for projections.


Adds universe constraint approximations (u=?=max u ?v => ?v = u).


Improves isDefEqProj in typeclass resolution contexts.


Adds backward.isDefEq.lazyProjDelta and lazyWhnfCore for compat.


Removes dead code in the kernel.


Fixes mismatch for TheoremVal between Lean and C++ implementations.


Lean internals (Typeclass instance synthesis)

Eta-reduces synthesized instances to avoid unnecessary lambdas.


Adds backward.synthInstance.canonInstances and restricts subgoals lacking metavars.


Renames automatically generated equational theorems to .eq_<idx> instead of ._eq_<idx>.


Refines equational theorem naming from ._unfold to .eq_def.


Adds a mechanism to reserve names for certain definitions or theorems.


Fixes name resolution for reserved names in namespaces and matchers.


Treats nested non-proof definitions inside theorems as def instead of theorem.


Makes proposition fields of structures automatically theorems.


Issues an error if a theorem is marked extern.


Improves performance for well-founded recursive definition equation generation.


Avoids unfolding in Lean.Meta.evalNat for simpler evaluation steps.


Centralizes Fix/GuessLex/FunInd logic in ArgsPacker module.


Rewrites the UnusedVariable linter for better performance.


Removes the coercion from String to Name, requiring manual mkSimple.


Removes lines field from FileMap, simplifying file mapping logic.


Makes the msg parameter to throwTacticEx optional for convenience.


Adds set_option diagnostics true to track unfolded declarations, etc.


Adds counters for used instances, reducible decls, isDefEq heuristics in diagnostics.


Expands diagnostic counters to recursor reductions and more details.


Displays exceptional hints for deterministic timeout with diagnostics true.


Shows max recursion info in diagnostics at certain failing points.


Adds set_option diagnostics for congruence theorem generation stats.


Adds environment extension marking which defs use structural or well-founded recursion.


Allows trace.profiler output to be exported to Firefox Profiler format.


Introduces @[builtin_doc] attribute to store docs/location as builtin metadata.


Extends builtin_doc usage or storage to more declarations.


Adds lean --json CLI to print messages as JSON for external tooling.


Improves test_extern command for verifying external definitions.


Provides a monadic generalization of FindExpr, rewriting prior approach.


Additional documentation clarifying internal Lean modules or flows.


Expands doc references for elaboration or kernel internals.


Documents new or refactored internal definitions in the Lean codebase.


Addresses certain edge cases in internal elaboration (#3622).


Fixes issues with a parse or macro usage (#3726).


Resolves partial flaws in auto-bound implicits (#3823).


Improves logic in certain kernel or meta checks (#3897).


Corrects a bug in isDefEq or transparency usage (#3964).


Fixes mismatch in environment handling (#3946).


Resolves an issue in a certain elaboration step (#4007).


Adjusts or cleans up code for tactic usage (#4026).


Allocates/frees thread-local runtime resources for threads not started by Lean.


Improves error message about compacting closures for clarity.


Fixes a deadlock in IO.Promise.resolve calls.


Catches MoveFileEx errors on Windows for better diagnostics.


Fixes double reset bug in ResetReuse transformation for memory reuse.


Adds support for lakefile.toml as alternative to lakefile.lean with partial feature set.


Introduces lake translate-config for migrating .lean to .toml or vice versa.


Overhauls build flow with a top-level Lake build monitor for standardized logs.


Improves job isolation so stray I/O or import errors don't abort entire build.


Adds color and in-place progress lines with --ansi or --no-ansi.


Implements --wfail and --iofail to fail on warnings or log messages.


Refines build job output formatting for consistent progress reporting.


Localizes module import errors to their respective build jobs.


Adds a built-in lake test command to run a test_runner-labeled script/exe.


New command lake lean <file> builds the imports before running lean on it.


Adds LEAN_GITHASH env var to override Git hash used in trace computation.


Improves relative package directory path normalization in pre-rename checks.


Fixes handling of packages repeated in a dependency tree.


Makes it an error if package name mismatches the require name, warns about std->batteries rename.


Fixes quiet mode so it suppresses build output properly.


Adds or updates Lake documentation for usage and advanced config options.


Adds a release process checklist for maintainers to follow.


Extends the release checklist or merges improvements to it.


Runs nix-ci more uniformly across different build/test steps.


Avoids argument limit issues on Windows builds by adjusting build scripts.


Builds Lean's .o files in parallel with other core components.


Changes how Lean is built on Windows, requiring dynamic linking for supportInterpreter.


Marks 'Build matrix complete' as canceled if the entire build is canceled.


Fixes or updates CI steps for certain steps like #3700 usage.


Refines workflow steps to handle #3702 improvements in CI scripts.


Additional fix or improvement in #3701 for std/mathlib CI integration.


Tweaks or merges #3834 improvements for standard library CI.


Applies #3923 changes for mathlib CI or general project CI improvements.


Fixes nix build . on macOS (#3712).


Replaces shell.nix with flake.nix in devShell (#3717).


Adds test result summaries after certain runs (#3715).


Prevents stage0 changes from merging without proper checks (#3971).


Adds handling for changes-stage0 label in the merge queue (#3979).


Adds a script to summarize GitHub issues (#3952).


Large Lake build refactor changes output format and certain Lake APIs.


Executables with supportInterpreter on Windows must run via lake exe to find DLLs.


Equational theorems renamed from ._eq_<idx> to .eq_<idx>, and ._unfold to .eq_def.


Simp and rw skip instance resynthesis by default; revert with `set_option tactic.skipAssignedInstances false`.


When `pp.proofs = false`, omitted proofs now display as `⋯` instead of `_`.


pp.proofs.withType is now false by default.


App delaborator handles over-application so extra-arg cases in app_unexpanders are unnecessary.


Adds `zetaDelta` option (false by default); see #2682 for details on zeta vs zetaDelta.


Local theorems for simp assume function arguments are `no_index`, restoring Lean 3 behavior.


Improved error messages for `decide` tactic.


Improved auto-completion performance.


Faster initial language server startup.


Sort entries and remove private header from displayed names in call hierarchy.


Added a low-level error recovery combinator for DSLs.


`termination_by?` reveals inferred argument and can convert to `termination_by` via code action.


`/` and `%` on `Int` now use `Int.ediv` and `Int.emod`, with kernel support. (Change for non-Std users.)


Now in core; supplemented by `bv_omega` for BitVec linear arithmetic.


Supports `Fin` type.


Supports `<<<` operator.


No longer identifies atoms up to definitional equality; can't prove `id x ≤ x` automatically.


Used in Lean's automation for termination proofs.


Used in array indexing proofs.


`exact?`/`apply?`/`solve_by_elim` from Std are now in core Lean.


New `#check_tactic` and `#check_simp` for verifying tactic behavior.


Delaborator tries unexpanders on every prefix, registering TermInfo properly for subexpressions.


Stronger `MonadAlwaysExcept` requirement for `Lean.withTraceNode` and variants.


`match ... with.` replaced by `nomatch` syntax from Std.


`fun.` replaced by `nofun` syntax from Std.


Avoid crash when `simp` loops indefinitely.


`simp` no longer gets stuck on autoParam premises.


`simp` doesn't fail when a custom discharger makes no progress.


`simp` can now discharge autoParam premises reduced to True.


`simp?` suggests generated equation lemma names (part 1).


`simp?` suggests generated equation lemma names (part 2).


Fix regression with builtin literals in match.


Accept match over BitVec finite types.


Fix matching on Int literals.


Allow patterns containing int values/constructors in match.


Improved error messages for `termination_by` usage.


Fix rename_i in macros (part 1).


Fix rename_i in macros (part 2).


Fix excessive resource usage in `generalize` (part 1).


Fix excessive resource usage in `generalize` (part 2).


AutoParam arguments fail to rewrite (part 1).


AutoParam arguments fail to rewrite (part 2).


`add_decl_doc` now checks that declarations are local.


Instantiate types of inductives with correct parameters (part 1).


Instantiate types of inductives with correct parameters (part 2).


New simprocs for many basic types.


Warn on cloud release fetch failures.


Handle trace & `lake build :release` errors better.


Backport of #3552 fixing a performance regression in server startup.


Added custom simplification procedures (simprocs) to `simp`, controllable via `set_option simprocs false` or by specifying them in `simp` commands.


Overhauled `termination_by` and `decreasing_by` syntax and placement, removing function names and placing them next to their respective definitions.


Changed semantics of `decreasing_by` so the tactic is applied to all termination proof goals together.


Modified to allow partial contexts during command elaboration, breaking some manual InfoTree traversals.


Added call hierarchy support; requires a full rebuild for new .ilean format.


Multiple sources are filled strictly left-to-right, avoiding unnecessary eta expansion and reducing CPU usage.


RFC discussion for the new structure instance elaborator approach.


Added `pp.deepTerms` and `pp.deepTerms.threshold` to omit printing deeply nested terms.


Added `pp.numeralTypes` and `pp.natLit` options to show type ascriptions on number literals or print them as `nat_lit`.


Further discussion about numeral printing conventions.


Improved platform information and control.


Allowed `lake update` from unsupported manifest versions.


`intro` now aware of `let_fun`.


Produce simpler proof terms in `rw` tactic.


Fuse nested `mkCongrArg` calls in `simp` proofs.


`induction using` now supports a general term.


Allow generalization in `let`; fixes #3065.


Out-of-bounds `swap!` returns `a`, not `default`; fixes #3196.


Derive `BEq` on structures with `Prop` fields; fixes #3140.


Refine through more `casesOnApp`/`matcherApp`; fixes #3175.


Do not strip dotted components from module names; fixes #2999.


Fix `deriving` only applying to the first declaration; fixes #3057.


Prevent metavariable instantiation for disallowed occurrences in kabstract/rw; fixes #2538.


Hover info for `cases h : ...` constructs.


Modify lexical syntax of string literals to have string gaps, allowing multi-line strings without extra whitespace.


Discussion of string-gap design and motivation in RFC #2838.


Add raw string literal syntax: `r"..."` with optional `#` for quoting double quotes inside.


Issue tracking raw string literal request and design details.


Removed `termination_by'`; use `termination_by` or `WellFounded.wrap` as alternatives.


Support snippet edits in `TextEdit`s (see `Lean.Lsp.SnippetString`) for advanced code actions.


UserWidgetDefinition→Widget.Module; see `@[widget_module]`. Also adds `show_panel_widgets` and `RpcEncodable` props in infotree.


If no lexicographic measure is found, an explanation is given to help with debugging.


`set_option showInferredTerminationBy true` prints auto-generated `termination_by` clauses.


More detailed errors for invalid mutual recursion blocks.


Improvements to the output of `simp?` and `simp_all?` (first set).


Further improvements to `simp?` and `simp_all?` (second set).


Tactics using `withLocation *` no longer fail if they close the main goal.


New `test_extern` command for testing `@[extern]` or `@[implemented_by]` functions.


Fixes for issues #2853, #2953, #2966, #2971, #2990, #3094.


Fixed eager evaluation in `Option.getD` (#3043), prevented panic in `leanPosToLspPos` (#3071), improved short-circuit for `List.all/any` (#2972).


Addressed issues #3036, #3064, #3069 in Lake.


Per-package server options (`leanOptions`/`moreServerOptions`); `moreServerArgs`→`moreGlobalServerArgs` deprecated.


Implemented rename request handler (LSP).


Import auto-completion feature.


Added `pp.beta` to apply beta reduction in pretty printing.


Embed and check githash in .olean for build verification.


Guess lexicographic order for well-founded recursion automatically.


Allow trailing commas in tuples, lists, and tactics.


Fixes #2628, #2883, #2810, #2925, #2914 in core or server code.


Update package creation: `lake init .` uses current dir name, disallows invalid pkg names, no uppercase conversion for `lean_lib`, supports non-ident libs, filters irrelevant env extensions, re-unpacks cloud releases, simpler math template, parse build targets in `lake exe`, shadowing for later packages, excludes exe roots from importable modules.


Disallow invalid package names (#2637).


No uppercase conversion for `lean_lib` (#2567).


Support non-identifier library names (#2865).


Filter irrelevant env extensions (#2632).


Re-unpack cloud releases if build dir is removed (#2928).


Simplified math template (#2930).


Parse build target in `lake exe` (#2932).


Shadow later packages over earlier ones (#2937).


`simp [f]` no longer unfolds partial applications of `f` by default (#2042). Use `unfold f` or `simp (config := { unfoldPartialApp := true }) [f]`.


Does not use `Decidable` rewriting unless `decide := true` is set in config. (`simp` won't close all decidable goals).


Addresses #2778, #2790, #2552, #1926, #2669, #2281, #2711, #2685, #2514, #2729, #2361, #2178. Also cancels tasks on doc edit (#2648), removes extra `%` from `Fin.mod` (#2688), avoids DecidableEq in `Array.mem` (#2774), unifies `USize.size` (#1926), better emacs eglot (#2721).


Sensible defaults for `lake new MyProject math` (#2770), replaced `postUpdate?` with `post_update` (#185), auto-create manifest (#2680), deprecated `:=` syntax in config, `LAKE_PKG_URL_MAP` for overriding URLs (#2709), moved outputs to `.lake` (#2713), updated manifest to v7 (#2801), stricter `lakefile.olean` checks (#2842).


Replace `postUpdate?` with `post_update` (#185).


Auto-create manifest if missing (#2680).


Override package URLs with `LAKE_PKG_URL_MAP` (#2709).


Move outputs to `.lake` (#2713).


Updated manifest format to version 7 (#2801).


Stricter checks on `lakefile.olean` (#2842).


Cache for terms not containing metavariables (#2644).


Made `Environment.mk`/`Environment.add` private; safer `replay` method (#2604).


Follow-up environment changes for add (#2642) and replay (#2617).


Also reference #2617 (replay) for safe environment modifications.


`IO.Process.output` no longer inherits stdin of the caller.


Do not inhibit caching of default-level match reduction (#2612).


List valid case tags on invalid input (#2629).


Support `DecidableEq` on mutual inductives (#2591).


Show path of failed import (#2616), fix macOS linker warnings (#2598), add `postUpdate?` config, improve startup (#2572, #2573).


Fix macOS linker warnings (#2598).


Improved startup time (#2572).


Further improvement to startup (#2573).


`refine e` only yields newly-created metavars, preventing duplicated or closed goals (#2502).


Improve positioning on missing tokens in incomplete tactic proofs (#2393).


Lake caches `lakefile.lean` in `lakefile.olean`; use `-R/--reconfigure` if config changed.


Signature changed: args→weakArgs/traceArgs separation.


Use `Array Import` in `importModules`, `headerToImports`, `parseImports` (#2480).


`occs` field in `Rewrite.Config` for controlling pattern occurrences (#2470).


Renamed `Lean.Meta.getConst?` to `getUnfoldableConst?` and `getConstNoEx?` to `getUnfoldableConstNoEx?`. Use `Lean.getConstInfo` instead for public API.


`dsimp / simp / simp_all` now fail by default if they make no progress. Use `(config := { failIfUnchanged := false })` to override.


`simp_all` now preserves hypothesis order more consistently. This may affect tactics that rely on ordering (rename_i, case, next).


`this` is now a regular identifier introduced by `have :=` in the current tactic block. Previously it was a keyword visible in all scopes.


Show typeclass and tactic names in profiler output.


`calc` requires consistent indentation for relation/proof pairs. Also supports underscores `_` in the first relation.


Update Lake to latest prerelease version.


Go-to-definition on typeclass projection applications goes to the instance(s).


Include timings in trace messages when `profiler = true`.


Pretty-print signatures in hover and `#check <ident>` results.


Introduce parser memoization to avoid exponential behavior in ambiguous grammars.


Allow `doSeq` in `let x <- e | seq` pattern (partial/do-block scenario).


Hover/go-to-def/refs for options (e.g. set_option).


Add empty type ascription `(e :)` to indicate expression type is not yet known.


Make tokens in `<|>` relevant to syntax match (fix parse ambiguities).


Add `linter.deprecated` option to silence deprecation warnings.


Improve fuzzy-matching heuristics for completions.


Support hidden/implementation-only hypotheses that appear in tactic proofs for internal usage.


Hover info for `cases` or `induction` case names, referencing pattern variables.


Prefer longer parse branch even if unsuccessful, for better error messages in ambiguous contexts.


Show the declaration module name in hover text.


New `conv` structuring tactics for advanced rewriting.


`simp` can track steps and print an equivalent `simp only` set. Useful for debugging. (Simp steps recorded.)


Uniform indentation required in tactic blocks/do blocks. (Issue #1606 references.)


Moved these data structures into Lean package. Standard library (std4) will evolve them independently.


Std library moved to separate std4 repository on GitHub.


`InteractiveGoals` now includes info about changed parts of a goal after applying a tactic.


Add `[inheritDoc]` attribute for reusing docstrings across declarations.


Expose that `panic = default` in more contexts (lower-level improvements).


New code generator project in `src/Lean/Compiler/LCNF` has started.


Remove optional description parameter from `register_simp_attr` command.


Additional concurrency primitives (futures, channels, etc.).


Support collapsible traces with messages for improved debugging views.


Hygienic resolution of namespaces in macros and expansions.


New `Float` functions for arithmetic or conversions.


Added many new docstrings to declarations in `Init`.


Update Lake to v4.0.0. See Lake's v4.0.0 release notes for changes.


Support mutual declarations in different namespaces. The compiler auto-creates a common prefix namespace.


Allow user-defined deriving handlers for existing typeclasses. See `tests/pkg/deriving/UserDeriving` for example.


Add `congr (num)?`. This tactic helps prove equality by structural decomposition of function arguments.


Missing doc linter for declarations lacking docstrings (#1390).


Check for unused alternatives in `match`. (#1371).


Auto-completion for structure instance fields and dotted identifier notation (#123?).


No longer needed for `OfNat` instances. E.g., `instance : OfNat Bit 0` is valid.


Add `[elabAsElim]` to mimic Lean 3's `elab_as_eliminator` for custom induction usage.


`Trans` now accepts relations in `Type u`, enabling more flexible rewriting in calc expressions.


Allow unescaped keywords as inductive constructor names, using dot notation to avoid conflicts.


Error if parametric local instances are not forward-dependent, can disable via `set_option checkBinderAnnotations false`.


New option to hide let-binders' RHS in goals. Defaults to `true` in tactic-mode, `false` otherwise.


Option `warningAsError` treats warnings as errors at elaboration time.


Support dotted notation and named arguments in match/pattern syntax, e.g. `.forallE (binderType := type) .. => type`.


Go-to-definition for references in attributes like `@[implementedBy func]`, `@[tactic parserName]`, etc.


Add easier-to-find MVarId methods, deprecate older ones. (#1346 references further improvements).


Mark declarations with `[deprecated]`. Warnings suggest the recommended replacement if given.


New type `LevelMVarId` (aka `LMVarId`) for universe metavars, preventing confusion with expr metavars.


Improvements to the `calc` syntax and tactics (issue #1342 references).


Relaxed parsing further reduces need for explicit `$x:p` in macros.


Inductives can define `[computedField]` for constant-time field access (values stored in constructor).


`a[i]` is now `getElem a i (by get_elem_tactic)`. Also introduced `a[i]!` and `a[i]?` for panic/Option indexing.


Better support for qualified names in recursive declarations, e.g. `Nat.fact` inside a `namespace Nat` block.


`#eval` supports `CommandElabM` monad for on-the-fly commands in user code.


Try elaborating do-blocks even if the expected type is unknown, allowing `#eval do IO.println ...` forms.


Panics on Linux print a backtrace by default. Disable via `LEAN_BACKTRACE=0`.


Auto-insert `group(·)` where needed in `(...)+` combinators to avoid grammar conflicts.


Syntax antiquotations track syntax kinds, reducing ill-formed expansions. (#1251 references)


Alias of a protected definition is also protected. E.g. `Nat.double` → `Ex.double` is protected.


`IO.rand` seeds from `IO.getRandomBytes`, more secure random initialization (#2 references?).


Improve dot-notation with namespace exports/aliases. E.g. `FinSet.union` as alias of `Set.union`.


`ext` and `enter` conv tactics can go inside let-declarations in `conv at h => ...` blocks.


New `zeta` conv tactic expands local let-declarations in the goal.


Improve how `open Tactic` can open both `Lean.Parser.Tactic` and `Lean.Elab.Tactic` (#1224 references).


Rename `constant` command to `opaque` for truly opaque definitions. Zulip discussion linked for details.


Support multiple left-hand-sides in a single alternative. Example: `cases v with | mk1 x | mk2 x => ...`


`let/if` indentation in do-blocks is supported (#1120 references).


New `$_` antiquotation for syntax patterns without naming a placeholder.


Warn about unused variables in tactics. (#1159 references).


Error if a decl body references a universe param not in its type or not explicit. E.g. hidden `PUnit.{u}` usage.


New `subst_vars` tactic to systematically substitute variable equalities.


Fix for lost `autoParam` in multiple inherited structure fields (#1158).


Allows specifying a default recursor for `induction`/`cases`. Alternative to `using <recursor>` syntax.


Add support for `casesOn` in structural & well-founded recursion modules. E.g. writing definitions with tactics.


`Option` is once again a monad (removed `OptionM`). (#279761084 references).


Improved: can handle `match h : e with` even if `e` not a free variable. No more failing generalization step.


Preserve `h : e` discriminants so tools like `split` can benefit from them. E.g. `match h : foo x with...`


`exists term1, term2, ...` supports comma-separated values in one statement.


Add tactics `dsimp` & `dsimp!` applying only rfl-theorems, preserving definitional equality in the result.


Fix binder info for patterns using `[matchPattern]`-tagged defs like `Nat.add` in match expressions.


Now can depend on structure parameters. E.g. `n2 : Nat := 1 + i` is allowed.


`dsimp` method in `simp` can apply `rfl`-theorems. Allows inlined expansions for better rewriting.


Auto-bound no longer captures the declaration's own name for an unbound variable. (#f → (#f is a var)??).


No longer highlights some recursive calls as variables in inductive or function definitions.


`simp!`, `simp_arith!`, `simp_all!`, and `simp_all_arith!` auto-unfold recursive or match-based definitions.


`save` is a shorter alias for `checkpoint ...` in tactic scripts.


Removed support for `{}` annotation in inductive & structure commands. Use new parameter/indices promotion.


Several fixes for go-to-definition in mutually rec defs, match patterns, pattern variables, etc.


`macro ... xs:p* ...` has `xs : Array Syntax`. This ensures correct type for repeated parser combinators.


Syntax patterns ignore macro scopes in identifiers, improving pattern matching reliability.


Improve auto implicit param naming for constructor arguments in mutual inductives (ex: `α` instead of `x`).


Better error if constructor parameter's universe is too large. More consistent with other checks.


Support iteration with index proof in `[start:stop]`. Eases termination proofs in loops over arrays, etc.


`case'` is a variant of `case` that fails outright if the case doesn't exist, skipping fallback admission.


Add `macro stop s:tacticSeq => repeat sorry`. Debug/placeholder tactic macro on discussion at Zulip.


Don't display inaccessible proposition names if no forward dependencies. Only their types are shown.


Hypothesis name is optional in `by_cases p`, e.g. `by_cases p => ...` just references it as `this` or `_`.


Rename node kinds: `numLit`→`num`, `charLit`→`char`, `nameLit`→`name`, `strLit`→`str`, `scientificLit`→`scientific` (#1090).


Experimental `checkpoint <tactic-seq>` for partial proof steps in large scripts.


Renamed tactic `nativeDecide` to `native_decide` for naming consistency.


Now accepted in any syntax context. Removed `incQuotDepth` parser. Simplifies macro dev.


Remove `_discr := ...` or `h✝` from match patterns/branches, simplifying the local context.


Expansion ensures the goal references the new bindings, e.g. `let (a,b) := x` yields `f (a,b)` not `f x`.


Add cross-compiled aarch64 Linux and macOS builds. (#1066, #1076 references)


Added tutorial-like examples using LeanInk+Alectryon for documentation.


`simp` now supports user-defined simp-attributes. E.g. `register_simp_attr my_simp` for a custom set.


Multiple LHS in single alternative, e.g. `| 0 | 1 => 1`. (#371 references).


`#eval` tries to reduce the type further if no `Lean.MetaEval` is found initially. E.g. `def Foo := List Nat` now works.


`rw` can apply auto-generated equation lemmas for a definition. E.g. `rw [List.length]` to step through eqns.


Fuzzy matching for auto-completion (#1023).


`f.comp g` notation for function composition if `f : α→β`; done via `Function.field` arrow-type lookups.


Supports `.map .succ xs` etc. when a function type is expected (Zulip #944 references).


Added code folding support to language server (#1014).


Allow `let <pattern> := e | alt` in do-blocks for simple branching. Removes older partial expansions.


No more 'auto' pure resolution. Must specify the monad or use type ascription if needed.


No longer require all function args to be free vars on LHS. Partial argument usage is allowed.


Allow partially applied congruence theorems for more general rewriting (#988 references).


Reduce expected type if it's a metavariable before elaboration, to avoid incorrect postponement.


Deprecated `leanpkg` replaced by Lake as the package manager (#985).


Improve find-all-refs for newly introduced definitions. Also fix coverage for partial expansions.


Auto generated congr lemmas can cast proofs/`Decidable` instances (#988 references).


Renamed the option controlling auto-bound implicits to `autoImplicit`.


`contradiction` closes the goal if `False.elim` is in the target or a local hypothesis.


Renamed tactic `byCases` to `by_cases` for naming convention consistency.


Typeclass resolution can use local instances from patterns, e.g. `(⟨_, inst⟩ :: as).


Now `(motive := (args) → ...)` syntax instead of whitespace-based. E.g. `match (motive := ...) x, rfl with ...`


`match` defaults to `(generalizing := true)` even if the result type is not a Prop. E.g. no extra annotation needed.


Mutually recursive definitions use `PSum` instead of `Sum` for well-founded rec. (#??) no PR # here.


Better support for parametric well-founded relations (#1017).


Add macros `while <cond>` / `repeat <do>` / `repeat <do> until <cond>` for partial/do usage only.


New `arith` option in `Simp.Config`. `simp_arith` includes Nat linear arithmetic rewriting.


`fail <message>` tactic that always fails with a user-provided error text.


Check acyclicity in dependent elimination, addressing #1022 potentially.


Add `trace <string>` tactic for debugging messages within proofs.


Add nontrivial `SizeOf` for function types `Unit→α` and in user-defined inductives with delayed fields.


Try simple well-founded relations automatically for recursion. E.g. no extra `termination_by` needed for array loops.


Add `for h : x in xs do ...` meaning `h : x ∈ xs`. Useful for termination of iteration-based definitions.


Unassigned metavariables in auto-implicit types become fresh auto-implicit locals. E.g. `HasType` example with `n`.


Fixed prefix of inductive family indices is promoted to parameters if they do not vary. E.g. `Sublist`, `Lst` examples.


Chaining unassigned meta in index types now fosters correct type injection for families (#??).


Eliminate autoParam/optParam in recursors

Recursor minor premises & structure projections no longer carry autoParam/optParam overhead.


Allowed if each alternative has the same pattern variable set. E.g. `::` for List/Vector in different contexts.


Introducing `.<ident>` notation. Infers namespace from expected type. E.g. `.ok x`, `.error "..."`