v4.11.0-rc1

What's Changed

• feat: upstream List.attach and Array.attach from Batteries by @llllvvuu in #4586
• fix: typo hearbeats -> heartbeats by @kmill in #4590
• feat: total ByteArray.toList/findIdx? by @Vtec234 in #4582
• chore: release triggers update of release.lean-lang.org by @nomeata in #4531
• chore: begin development cycle for v4.11.0 by @semorrison in #4594
• chore: pr-release: adjust to new lakefile.lean syntax by @nomeata in #4598
• fix: adapt kernel interruption to new cancellation system by @Kha in #4584
• feat: omega error message: normalize constraint order by @nomeata in #4612
• fix: diagnostics: show kernel diags even if it is the only section by @nomeata in #4611
• feat: termination_by structural by @nomeata in #4542
• feat: mul recurrence theorems for LeanSAT by @bollu in #4568
• fix: unresolve name avoiding locals by @digama0 in #4593
• feat: Nat.and_le_(left|right) by @TwoFX in #4597
• feat: additional lemmas for Option by @TwoFX in #4599
• feat: additional lemmas for lists by @TwoFX in #4602
• feat: getElem_congr by @TwoFX in #4603
• feat: additional lemmas for cond by @TwoFX in #4604
• feat: additional lemmas for bounded integers by @TwoFX in #4605
• chore: defs that should be theorems by @semorrison in #4619
• chore: delete deprecations from 2022 by @semorrison in #4618
• chore: satisfy duplicate namespace linter by @semorrison in #4616
• chore: follow simpNF linter's advice by @semorrison in #4620
• chore: add 'since' dates to deprecated by @semorrison in #4617
• chore: make constructor-as-variable test more robust by @TwoFX in #4625
• fix: enforce isDefEqStuckEx at unstuckMVar procedure by @leodemoura in #4596
• fix: Windows build by @Kha in #4628
• chore: pr-release: use right tag name by @nomeata in #4632
• fix: set default value of pp.instantiateMVars to true and make the option be effective by @kmill in #4558
• feat: USize.and_toNat by @TwoFX in #4629
• feat: Option.or by @TwoFX in #4600
• chore: typo by @alok in #4635
• feat: safe exponentiation by @leodemoura in #4637
• fix: make sure syntax nodes always run their formatters by @kmill in #4631
• chore: manual nightly trigger by @Kha in #4638
• chore: CI: restart-on-label: view run more often by @nomeata in #4640
• refactor: include declNames in Structural.EqnInfo by @nomeata in #4639
• fix: snapshot subtree was not restored on reuse by @Kha in #4643
• refactor: lambdaBoundedTelescope by @nomeata in #4642
• fix: improve synthAppInstances by @leodemoura in #4646
• feat: EquivBEq and LawfulHashable classes by @TwoFX in #4607
• feat: additional lemmas for arrays by @TwoFX in #4627
• fix: universe level in .below and .brecOn construction by @nomeata in #4651
• refactor: Split Constructions module by @nomeata in #4656
• feat: Std.HashMap by @TwoFX in #4583
• chore: restart-on-label: wait for 30s by @nomeata in #4663
• fix: don't set pp.tagAppFns when pretty printing signatures by @kmill in #4665
• fix: move Std from libleanshared to much smaller libInit_shared by @Kha in #4661
• fix: explicitly initialize Std in lean_initialize by @Kha in #4668
• chore: make Antisymm a Prop by @semorrison in #4666
• fix: hasBadParamDep? to look at term, not type by @nomeata in #4672
• chore: bump actions/checkout and actions/upload-artifacts by @nomeata in #4664
• chore: cleanup unused arguments (from linter) by @semorrison in #4621
• fix: unorphan modules in Init by @TwoFX in #4680
• fix: unorphan modules in Std.Data by @TwoFX in #4679
• chore: update codeowners by @TwoFX in #4681
• chore: Inhabited instances for Std.HashMap by @TwoFX in #4682
• chore: fix "max dynamic symbols" metric by @Kha in #4669
• fix: calculate error suppression per snapshot by @Kha in #4657
• chore: update comments in kernel/declaration.h by @nomeata in #4683
• feat: structural mutual recursion by @nomeata in #4575
• feat: Process.tryWait by @hargoniX in #4660
• chore: adjust List.replicate simp lemmas by @semorrison in #4687
• chore: upstream ToExpr FilePath and compile_time_search_path% by @semorrison in #4453
• chore: forward and backward directions of not_exists by @semorrison in #4688
• chore: upstream SMap.foldM by @semorrison in #4690
• chore: improve compatibility of tests/list_simp with Mathlib by @semorrison in #4691
• chore: add step to release checklist by @semorrison in #4693
• refactor: InductiveVal.numNested instead of .isNested by @nomeata in #4684
• feat: make @[ext] derive ext_iff theorems from user ext theorems by @kmill in #4543
• chore: upstream eq_iff_true_of_subsingleton by @semorrison in #4689
• chore: make use of ext_iff realization now that stage0 is updated by @kmill in #4694
• feat: lake: require @ git by @tydeu in #4692
• feat: omega doesn't push coercion over multiplication unnecessarily by @semorrison in #4695
• feat: chore upstream List.Sublist and API from Batteries by @semorrison in #4697
• fix: prefer original module in const2ModIdx by @digama0 in #4652
• feat: characterisations of List.Sublist by @semorrison in #4704
• feat: basic material on List.Pairwise and Nodup by @semorrison in #4706
• doc: update release checklist for new release notes workflow by @kmill in #4458
• feat: lemmas for List.head and List.getLast by @semorrison in #4678
• feat: simp normal form tests for Pairwise and Nodup by @semorrison in #4707
• chore: reorganise lemmas on list getters by @semorrison in #4708
• fix: Repr instances for Int and Float by @leodemoura in #4709
• fix: decide tactic transparency by @leodemoura in #4711
• fix: make iff theorem generated by @[ext] preserve inst implicits by @kmill in #4710
• fix: deprecated warnings for overloaded symbols by @leodemoura in #4713
• fix: mutual structural recursion: check that datatype parameters agree by @nomeata in #4715
• feat: upstream more erase API by @semorrison in #4720
• chore: fix typo in doc-string by @grunweg in #4719
• feat: further theorems for List.erase by @semorrison in #4723
• fix: make matcher pretty printer sensitive to pp.explicit by @kmill in #4724
• fix: nested structural recursion over reflexive data type by @nomeata in #4728
• feat: detailed feedback on decide tactic failure by @kmill in #4674
• feat: Meta.withErasedFVars by @no...

v4.10.0

Language features, tactics, and metaprograms

• split tactic:

  • #4401 improves the strategy split uses to generalize discriminants of matches and adds trace.split.failure trace class for diagnosing issues.

• rw tactic:

  • #4385 prevents the tactic from claiming pre-existing goals are new subgoals.
  • dac1da adds configuration for ordering new goals, like for apply.

• simp tactic:

  • #4430 adds dsimprocs for if expressions (ite and dite).
  • #4434 improves heuristics for unfolding. Equational lemmas now have priorities where more-specific equationals lemmas are tried first before a possible catch-all.
  • #4481 fixes an issue where function-valued OfNat numeric literals would become denormalized.
  • #4467 fixes an issue where dsimp theorems might not apply to literals.
  • #4484 fixes the source position for the warning for deprecated simp arguments.
  • #4258 adds docstrings for dsimp configuration.
  • #4567 improves the accuracy of used simp lemmas reported by simp?.
  • fb9727 adds (but does not implement) the simp configuration option implicitDefEqProofs, which will enable including rfl-theorems in proof terms.

• omega tactic:

  • #4360 makes the tactic generate error messages lazily, improving its performance when used in tactic combinators.

• bv_omega tactic:

  • #4579 works around changes to the definition of Fin.sub in this release.

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

• Commands

  • #4370 makes the variable command fully elaborate binders during validation, fixing an issue where some errors would be reported only at the next declaration.
  • #4408 fixes a discrepency in universe parameter order between theorem and def declarations.
  • #4493 and #4482 fix a discrepancy in the elaborators for theorem, def, and example,
    making Prop-valued examples and other definition commands elaborate like theorems.
  • 8f023b, 3c4d6b and 0783d0 change the #reduce command to be able to control what gets reduced.
    For example, #reduce (proofs := true) (types := false) e reduces both proofs and types in the expression e.
    By default, neither proofs or types are reduced.
  • #4489 fixes an elaboration bug in #check_tactic.
  • #4505 adds support for open _root_.<namespace>.

• Options

  • #4576 adds the debug.byAsSorry option. Setting set_option debug.byAsSorry true causes all by ... terms to elaborate as sorry.
  • 7b56eb and d8e719 add the debug.skipKernelTC option. Setting set_option debug.skipKernelTC true turns off kernel typechecking. This is meant for temporarily working around kernel performance issues, and it compromises soundness since buggy tactics may produce invalid proofs, which will not be caught if this option is set to true.

• #4301 adds a linter to flag situations where a local variable's name is one of
  the argumentless constructors of its type. This can arise when a user either
  doesn't open a namespace or doesn't add a dot or leading qualifier, as
  in the following:

  inductive Tree (α : Type) where
    | leaf
    | branch (left : Tree α) (val : α) (right : Tree α)
  
  def depth : Tree α → Nat
    | leaf => 0

  With this linter, the leaf pattern is highlighted as a local
  variable whose name overlaps with the constructor Tree.leaf.

  The linter can be disabled with set_option linter.constructorNameAsVariable false.

  Additionally, the error message that occurs when a name in a pattern that takes arguments isn't valid now suggests similar names that would be valid. This means that the following definition:

  def length (list : List α) : Nat :=
    match list with
    | nil => 0
    | cons x xs => length xs + 1

  now results in the following warning:

  warning: Local variable 'nil' resembles constructor 'List.nil' - write '.nil' (with a dot) or 'List.nil' to use the constructor.
  note: this linter can be disabled with `set_option linter.constructorNameAsVariable false`
  

  and error:

  invalid pattern, constructor or constant marked with '[match_pattern]' expected
  
  Suggestion: 'List.cons' is similar
  

• Metaprogramming

  • #4454 adds public Name.isInternalDetail function for filtering declarations using naming conventions for internal names.

• Other fixes or improvements

  • #4416 sorts the ouput of #print axioms for determinism.
  • #4528 fixes error message range for the cdot focusing tactic.

Language server, widgets, and IDE extensions

• #4443 makes the watchdog be more resilient against badly behaving clients.

Pretty printing

• #4433 restores fallback pretty printers when context is not available, and documents addMessageContext.
• #4556 introduces pp.maxSteps option and sets the default value of pp.deepTerms to false. Together, these keep excessively large or deep terms from overwhelming the Infoview.

Library

• #4560 splits GetElem class into GetElem and GetElem?.
  This enables removing Decidable instance arguments from GetElem.getElem? and GetElem.getElem!, improving their rewritability.
  See the docstrings for these classes for more information.
• Array
  • #4389 makes Array.toArrayAux_eq be a simp lemma.
  • #4399 improves robustness of the proof for Array.reverse_data.
• List
  • #4469 and #4475 improve the organization of the List API.
  • #4470 improves the List.set and List.concat API.
  • #4472 upstreams lemmas about List.filter from Batteries.
  • #4473 adjusts @[simp] attributes.
  • #4488 makes List.getElem?_eq_getElem be a simp lemma.
  • #4487 adds missing List.replicate API.
  • #4521 adds lemmas about List.map.
  • #4500 changes List.length_cons to use as.length + 1 instead of as.length.succ.
  • #4524 fixes the statement of List.filter_congr.
  • #4525 changes binder explicitness in List.bind_map.
  • #4550 adds maximum?_eq_some_iff' and minimum?_eq_some_iff?.
• #4400 switches the normal forms for indexing List and Array to xs[n] and xs[n]?.
• HashMap
  • #4372 fixes linearity in HashMap.insert and HashMap.erase, leading to a 40% speedup in a replace-heavy workload.
• Option
  • #4403 generalizes type of Option.forM from Unit to PUnit.
  • #4504 remove simp attribute from Option.elim and instead adds it to individal reduction lemmas, making unfolding less aggressive.
• Nat
  • #4242 adds missing theorems for n + 1 and n - 1 normal forms.
  • #4486 makes Nat.min_assoc be a simp lemma.
  • #4522 moves @[simp] from Nat.pred_le to Nat.sub_one_le.
  • #4532 changes various Nat.succ n to n + 1.
• Int
  • #3850 adds complete div/mod simprocs for Int.
    *...

v4.10.0-rc2

fix: calculate error suppression per snapshot (#4657)

Generalizes #3556 to not suppressing errors in tactic steps either when
the parse error is in a later step, as otherwise changes to the end of a
proof would affect (correctness or effectiveness of) incrementality of
preceding steps.

Fixes #4623, in combination with #4643

v4.9.1

Bugfixes for incremental compilation. Otherwise identical to v4.9.0.

v4.10.0-rc1

update RELEASES.md and CMakeLists.txt for release branch

v4.9.0

Language features, tactics, and metaprograms

• Definition transparency
  • #4053 adds the seal and unseal commands, which make definitions locally be irreducible or semireducible.
  • #4061 marks functions defined by well-founded recursion with @[irreducible] by default,
    which should prevent the expensive and often unfruitful unfolding of such definitions (see breaking changes below).
• Incrementality
  • #3940 extends incremental elaboration into various steps inside of declarations:
    definition headers, bodies, and tactics.
    .
  • 250994 and 67338b add @[incremental] attribute to mark an elaborator as supporting incremental elaboration.
  • #4259 improves resilience by ensuring incremental commands and tactics are reached only in supported ways.
  • #4268 adds special handling for := by so that stray tokens in tactic blocks do not inhibit incrementality.
  • #4308 adds incremental have tactic.
  • #4340 fixes incorrect info tree reuse.
  • #4364 adds incrementality for careful command macros such as set_option in theorem, theorem foo.bar, and lemma.
  • #4395 adds conservative fix for whitespace handling to avoid incremental reuse leading to goals in front of the text cursor being shown.
  • #4407 fixes non-incremental commands in macros blocking further incremental reporting.
  • #4436 fixes incremental reporting when there are nested tactics in terms.
• Functional induction
  • #4135 ensures that the names used for functional induction are reserved.
  • #4327 adds support for structural recursion on reflexive types.
    For example,

    inductive Many (α : Type u) where
      | none : Many α
      | more : α → (Unit → Many α) → Many α
    
    def Many.map {α β : Type u} (f : α → β) : Many α → Many β
      | .none => .none
      | .more x xs => .more (f x) (fun _ => (xs ()).map f)
    
    #check Many.map.induct
    /-
    Many.map.induct {α β : Type u} (f : α → β) (motive : Many α → Prop)
      (case1 : motive Many.none)
      (case2 : ∀ (x : α) (xs : Unit → Many α), motive (xs ()) → motive (Many.more x xs)) :
      ∀ (a : Many α), motive a
    -/
    

• #3903 makes the Lean frontend normalize all line endings to LF before processing.
  This lets Lean be insensitive to CRLF vs LF line endings, improving the cross-platform experience and making Lake hashes be faithful to what Lean processes.
• #4130 makes the tactic framework be able to recover from runtime errors (for example, deterministic timeouts or maximum recursion depth errors).
• split tactic
  • #4211 fixes split at h when h has forward dependencies.
  • #4349 allows split for if-expressions to work on non-propositional goals.
• apply tactic
  • #3929 makes error message for apply show implicit arguments in unification errors as needed.
    Modifies MessageData type (see breaking changes below).
• cases tactic
  • #4224 adds support for unification of offsets such as x + 20000 = 20001 in cases tactic.
• omega tactic
  • #4073 lets omega fall back to using classical Decidable instances when setting up contradiction proofs.
  • #4141 and #4184 fix bugs.
  • #4264 improves omega error message if no facts found in local context.
  • #4358 improves expression matching in omega by using match_expr.
• simp tactic

  • #4176 makes names of erased lemmas clickable.

  • #4208 adds a pretty printer for discrimination tree keys.

  • #4202 adds Simp.Config.index configuration option,
    which controls whether to use the full discrimination tree when selecting candidate simp lemmas.
    When index := false, only the head function is taken into account, like in Lean 3.
    This feature can help users diagnose tricky simp failures or issues in code from libraries
    developed using Lean 3 and then ported to Lean 4.

    In the following example, it will report that foo is a problematic theorem.

    opaque f : Nat → Nat → Nat
    
    @[simp] theorem foo : f x (x, y).2 = y := by sorry
    
    example : f a b ≤ b := by
      set_option diagnostics true in
      simp (config := { index := false })
    /-
    [simp] theorems with bad keys
      foo, key: f _ (@Prod.mk ℕ ℕ _ _).2
    -/

    With the information above, users can annotate theorems such as foo using no_index for problematic subterms. Example:

    opaque f : Nat → Nat → Nat
    
    @[simp] theorem foo : f x (no_index (x, y).2) = y := by sorry
    
    example : f a b ≤ b := by
      simp -- `foo` is still applied with `index := true`

  • #4274 prevents internal match equational theorems from appearing in simp trace.

  • #4177 and #4359 make simp continue even if a simp lemma does not elaborate, if the tactic state is in recovery mode.

  • #4341 fixes panic when applying @[simp] to malformed theorem syntax.

  • #4345 fixes simp so that it does not use the forward version of a user-specified backward theorem.

  • #4352 adds missing dsimp simplifications for fixed parameters of generated congruence theorems.

  • #4362 improves trace messages for simp so that constants are hoverable.

• Elaboration
  • #4046 makes subst notation (he ▸ h) try rewriting in both directions even when there is no expected type available.
  • #3328 adds support for identifiers in autoparams (for example, rfl in (h : x = y := by exact rfl)).
  • #4096 changes how the type in let and have is elaborated, requiring that any tactics in the type be evaluated before proceeding, improving performance.
  • #4215 ensures the expression tree elaborator commits to the computed "max type" for the entire arithmetic expression.
  • #4267 cases signature elaboration errors to show even if there are parse errors in the body.
  • #4368 improves error messages when numeric literals fail to synthesize an OfNat instance,
    including special messages warning when the expected type of the numeral can be a proposition.
• Metaprogramming
  • #4167 adds Lean.MVarId.revertAll to revert all free variables.
  • #4169 adds Lean.MVarId.ensureNoMVar to ensure the goal's target contains no expression metavariables.
  • #4180 adds cleanupAnnotations parameter to forallTelescope methods.
  • #4307 adds support for parser aliases in syntax quotations.
• Work toward implementing grind tactic
  • 0a515e and #4164 add grind_norm and grind_norm_proc attributes and @[grind_norm] theorems.
  • #4170, #4221, and #4249 create grind preprocessor and core module.
  • #4235 and d6709e add special cases tactic to grind along with @[grind_cases] attribute to mark types that this cases tactic should automatically apply to.
  • #4243 adds special injection? tactic to grind.
• Other fixes or improvements
  • #4065 fixes a bug in the Nat.reduceLeDiff simproc.
  • #3969 makes deprecation warnings activate even for general...

v4.9.0-rc3

chore: mark releases as prerelease

v4.9.0-rc2

feat: lake: reliably cache logs and hashes (#4402)

Moves the cached log into the trace file (no more `.log.json`). This
means logs are no longer cached on fatal errors and this ensures that an
out-of-date log is not associated with an up-to-date trace. Separately,
`.hash` file generation was changed to be more reliable as well. `.hash`
files are deleted as part of the build and always regenerate with
`--rehash`.

Closes #2751.

(cherry picked from commit db74ee9e83c631dd4bab9b7b6a10d0793cb0cbef)

v4.9.0-rc1

chore: set LEAN_VERSION_IS_RELEASE to 1

v4.8.0

Language features, tactics, and metaprograms

• Functional induction principles.
  #3432, #3620, #3754, #3762, #3738, #3776, #3898.

  Derived from the definition of a (possibly mutually) recursive function,
  a functional induction principle is created that is tailored to proofs about that function.

  For example from:

  def ackermann : Nat → Nat → Nat
    | 0, m => m + 1
    | n+1, 0 => ackermann n 1
    | n+1, m+1 => ackermann n (ackermann (n + 1) m)
  

  we get

  ackermann.induct (motive : Nat → Nat → Prop) (case1 : ∀ (m : Nat), motive 0 m)
    (case2 : ∀ (n : Nat), motive n 1 → motive (Nat.succ n) 0)
    (case3 : ∀ (n m : Nat), motive (n + 1) m → motive n (ackermann (n + 1) m) → motive (Nat.succ n) (Nat.succ m))
    (x x : Nat) : motive x x
  

  It can be used in the induction tactic using the using syntax:

  induction n, m using ackermann.induct
  

• The termination checker now recognizes more recursion patterns without an
  explicit termination_by. In particular the idiom of counting up to an upper
  bound, as in

  def Array.sum (arr : Array Nat) (i acc : Nat) : Nat :=
    if _ : i < arr.size then
      Array.sum arr (i+1) (acc + arr[i])
    else
      acc
  

  is recognized without having to say termination_by arr.size - i.

  • #3630 makes termination_by? not use sizeOf when not needed
  • #3652 improves the termination_by syntax.
  • #3658 changes how termination arguments are elaborated.
  • #3665 refactors GuessLex to allow inferring more complex termination arguments
  • #3666 infers termination arguments such as xs.size - i

• #3629, #3655, #3747:
  Adds @[induction_eliminator] and @[cases_eliminator] attributes to be able to define custom eliminators
  for the induction and cases tactics, replacing the @[eliminator] attribute.
  Gives custom eliminators for Nat so that induction and cases put goal states into terms of 0 and n + 1
  rather than Nat.zero and Nat.succ n.
  Added option tactic.customEliminators to control whether to use custom eliminators.
  Added a hack for rcases/rintro/obtain to use the custom eliminator for Nat.

• Shorter instances names. There is a new algorithm for generating names for anonymous instances.
  Across Std and Mathlib, the median ratio between lengths of new names and of old names is about 72%.
  With the old algorithm, the longest name was 1660 characters, and now the longest name is 202 characters.
  The new algorithm's 95th percentile name length is 67 characters, versus 278 for the old algorithm.
  While the new algorithm produces names that are 1.2% less unique,
  it avoids cross-project collisions by adding a module-based suffix
  when it does not refer to declarations from the same "project" (modules that share the same root). #3089 and #3934.

• 8d2adf Importing two different files containing proofs of the same theorem is no longer considered an error.
  This feature is particularly useful for theorems that are automatically generated on demand (e.g., equational theorems).

• 84b091 Lean now generates an error if the type of a theorem is not a proposition.

• Definition transparency. 47a343. @[reducible], @[semireducible], and @[irreducible] are now scoped and able to be set for imported declarations.

• simp/dsimp

  • #3607 enables kernel projection reduction in dsimp
  • b24fbf and acdb00: dsimproc command to define defeq-preserving simplification procedures.
  • #3624 makes dsimp normalize raw nat literals as OfNat.ofNat applications.
  • #3628 makes simp correctly handle OfScientific.ofScientific literals.
  • #3654 makes dsimp? report used simprocs.
  • dee074 fixes equation theorem handling in simp for non-recursive definitions.
  • #3819 improved performance when simp encounters a loop.
  • #3821 fixes discharger/cache interaction.
  • #3824 keeps simp from breaking Char literals.
  • #3838 allows Nat instances matching to be more lenient.
  • #3870 documentation for simp configuration options.
  • #3972 fixes simp caching.
  • #4044 improves cache behavior for "well-behaved" dischargers.

• omega

  • #3639, #3766, #3853, #3875: introduces a term canonicalizer.
  • #3736 improves handling of positivity for the modulo operator for Int.
  • #3828 makes it work as a simp discharger.
  • #3847 adds helpful error messages.

• rfl

  • #3671, #3708: upstreams the @[refl] attribute and the rfl tactic.
  • #3751 makes apply_rfl not operate on Eq itself.
  • #4067 improves error message when there are no goals.

• #3719 upstreams the rw? tactic, with fixes and improvements in #3783, #3794, #3911.

• conv

  • #3659 adds a conv version of the calc tactic.
  • #3763 makes conv clean up using try with_reducible rfl instead of try rfl.

• #guard_msgs

  • #3617 introduces whitespace protection using the ⏎ character.
  • #3883: The #guard_msgs command now has options to change whitespace normalization and sensitivity to message ordering.
    For example, #guard_msgs (whitespace := lax) in cmd collapses whitespace before checking messages,
    and #guard_msgs (ordering := sorted) in cmd sorts the messages in lexicographic order before checking.
  • #3931 adds an unused variables ignore function for #guard_msgs.
  • #3912 adds a diff between the expected and actual outputs. This feature is currently
    disabled by default, but can be enabled with set_option guard_msgs.diff true.
    Depending on user feedback, this option may default to true in a future version of Lean.

• do notation

  • #3820 makes it an error to lift (<- ...) out of a pure if ... then ... else ...

• Lazy discrimination trees

  • #3610 fixes a name collision for LazyDiscrTree that could lead to cache poisoning.
  • #3677 simplifies and fixes LazyDiscrTree handling for exact?/apply?.
  • #3685 moves general exact?/apply? functionality into LazyDiscrTree.
  • #3769 has lemma selection improvements for rw? and LazyDiscrTree.
  • #3818 improves ordering of matches.

• #3590 adds inductive.autoPromoteIndices option to be able to disable auto promotion of indices in the inductive command.

• Miscellaneous bug fixes and improvements

  • #3606 preserves cache and dischargeDepth fields in Lean.Meta.Simp.Result.mkEqSymm.
  • #3633 makes elabTermEnsuringType respect errToSorry, improving error recovery of the have tactic.
  • [#3647](https://github.com/leanprover/lean4/pull/...