verse-lab / lean-ssr

LeanSSR: an SSReflect-Like Tactic Language for Lean

LeanSSR: an SSReflect-Like Tactic Language for Lean

This repository provides LeanSSR: a SSReflect tactic DSL for Lean4. LeanSSR extends Coq/SSReflect's tactic DSL with various new DSL constructions and enhanced mechanism for computational reflection.

Building

With elan installed, lake build should suffice.

Adding LeanSSR to your project

To use the latest version of LeanSSR in a Lean 4 project, first add this package as a dependency. In your lakefile.lean, add

require ssreflect from git "https://github.com/verse-lab/lean-ssr" @ "master"

Then run

lake update ssreflect

You also need to make sure that your lean-toolchain file contains the same version of Lean 4 as LeanSSR's, and that your versions of LeanSSR's dependencies (currently only Batteries4) match. THe project does not support version ranges at the moment.

You may also consider using a stable release of the framework by adding the following to your lakefile.lean instead:

require ssreflect from git "https://github.com/verse-lab/lean-ssr" @ "v1.0"

Once LeanSSR is downloaded and compiler, the following test file should compile:

import Ssreflect.Lang

example {α : Type} : α → α := by
  -- The following is equivalent to 
  -- intro x; trivial
  move=> x//

Documentation

• The paper Small Scale Reflection for the Working Lean User provides a brief tutorial on LeanSSR and documents its main features
• LeanSSR Wiki containts detailed technical documentation on LeanSSR tactics

Examples

You can find LeanSSR use case examples at Examples folder

Contributors

• Vladimir Gladshtein
• George Pîrlea
• Ilya Sergey

lean-ssr's Issues

Error message when `->` fails has the top of the stack as a hypothesis in the context

/-- error:
tactic 'rewrite' failed, did not find instance of the pattern in the target expression
  x
x y z : Nat
H : x = y
⊢ z = z
---
error: unsolved goals
x y z : Nat
⊢ x = y → z = z
-/
theorem rrw_intro_fail : ∀ (x y z : Nat), x = y → z = z := by
  move=>x y z ->

I would expect the H to not be there in the error message (it isn't there after the tactic fails), but this is not very important.

Intro pattern equivalent of `constructor`

Using `apply` tactic makes Lean panic

Minimal example reproducing the bug from VSCode:

import Ssreflect.Lang

example {α : Type} : α → α := by
  apply 

Using ssr-lean version d2000f5

Add support for custom induction principles

Bug: `->` intro pattern introduces the hypothesis even if the rewrite fails

Expected behaviour: a failed rewrite should leave the goal unchanged.

Goals forgotten: `(kernel) declaration has metavariables`

-- FAILING test case: what is going on here??
/-- error:
(kernel) declaration has metavariables 'subnDA'
-/
theorem subnDA (m n p : Nat) : n - (m + p) = (n - m) - p := by
  elim: m;
  move=>//;

I've added a test case – making an issue so we don't lose track of this.

Error when using rewrite that solves the goal

@[simp] theorem size_nseq n (x : α) : size (nseq x n) = n := by
  elim: n=>[ // | n /= ->]

There is an error highlighted at -> ("no goals to be solved") and by ("unsolved goals").

However, #print size_nseq then actually prints a term without sorry, so this might be an issue just with how the errors are attributed.

I've slightly modified the code in IntroPats.lean to try to figure out what's going on:

    | `(ssrIntro| ->) => do
      let name ← fresh "H"
      run `(tactic| intros $name)
      let nGoals := (← getUnsolvedGoals).length
      dbg_trace s!"goals before rw: {nGoals}"
      run `(tactic| rw [$name:ident])
      let nGoals := (← getUnsolvedGoals).length
      dbg_trace s!"goals left after rw: {nGoals}"
      if (← getUnsolvedGoals).length != 0 then
        dbg_trace "clear"
        run `(tactic| try clear $name)

The issue doesn't seem to be related to try clear – the error shows up even if that doesn't run as in the above code.

`srw` should rewrite everywhere in goal by default, not just first occurrence

Maybe also print a helper message of how to rewrite a single occurrence if multiple are rewritten?

Look behind definitions (such that explicit unfolds are not needed) when performing rewrites

This is the behaviour Coq rewrite seems to have.

Currently in Lean, we either:

1. Add a @[simp] attribute to the definition, which means it's always unfolded when simplification is called – which is annoying when a goal has multiple functions, only some of which we want to unfold, or
2. Manually unfold before calling the rewrite, which is verbose

Unexpected end of input

-- Left rewrite
theorem lrw_intro_1 : ∀ (x y z : Nat), x = y → y = z → z = x := by
  move=>x y z <-
  trace_state
  move=>->

This gives an unexpected end of input on the last line. It's not related to it being ->; other intro patterns result in the same error. Moving the move=>-> line above trace_state, the error disappears, so it seems inherently related to this being the last tactic in a proof.

Show correct proof state at end of line without requiring `;`

Eliminate/generalize terms, not just hypotheses

In the proof of last_ind in Seq.v, one needs to generalize a term []. This is done by elim: s [] Hnil, but this is currently not supported in Ssrlean.

Lemma last_ind P :
  P [::] -> (forall s x, P s -> P (rcons s x)) -> forall s, P s.
Proof.
move=> Hnil Hlast s; rewrite -(cat0s s).
elim: s [::] Hnil => [|x s2 IHs] s1 Hs1; first by rewrite cats0.
by rewrite -cat_rcons; apply/IHs/Hlast.
Qed.

Here's the equivalent Lean proof:

theorem last_ind (P : Seq α → Prop) :
  P [] → (∀ s x, P s → P (rcons s x)) → ∀ s, P s := by
  move=> Hnil Hlast s <;> srw -(cat0s s);
  revert Hnil; generalize [] = s1; revert s1
  elim: s=>[|x s2 IHs] s1 Hs1
  { sby srw cats0 }
  { sby srw -cat_rcons; apply IHs; apply Hlast }

Intro top-of-stack does not support multiple arguments

-- FAILING: Intro top of stack with multiple arguments
/--
info: α : Type
x y : α
xs : List α
⊢ List.length (y :: xs) ≤ List.length (x :: y :: xs) → List.length (y :: xs) ≤ List.length (x :: y :: xs)
-/
#guard_msgs(info) in
theorem length_cons_3 {α : Type} (x : α) (y : α) (xs : List α) :
  List.length (y :: xs) ≤ List.length (x :: y :: xs) := by
  have H: ∀ (x : α) (xs : List α), List.length xs ≤ List.length (x :: xs)
    := by induction xs with | nil => move=>//= | cons x xs ih => move=>//=
  revert H;
  move=> /(_ x (y :: xs));
  trace_state
  move=>//=;

Some issues

• #f examples
• revert proof view
• apply/

Add option to print standard Lean tactic script for SSR-Lean script

In aesop, this seems to be handled by traceScript

Related files:

• Script.lean
• Tree/ExtractScript.lean

Sequence with case split

In Coq, I can write something like:

Lemma lastP s : last_spec s.
Proof. case: s => [|x s]; [left | rewrite lastI; right]. Qed.

Is there something similar in Ssrlean?

Currently I do the following, which is a bit verbose:

theorem lastP (s : Seq α) : last_spec s := by
  scase: s => [|x s]
  { left }
  { srw lastI; right }

Code smell: `Revert.lean` and `Elim.lean` have duplicate `private def kpattern`

Code smell: `kpattern` and `kpatternType` are almost identical