---
title: 'LeanSSR: Lean 4 Small Scale Reflection'
url: https://www.emergentmind.com/topics/leanssr
type: topic
---

# LeanSSR: Lean 4 Small Scale Reflection

LeanSSR is the implementation of the Small Scale Reflection (SSR) proof methodology and tactic language for the Lean 4 proof assistant, directly inspired by Coq’s SSReflect system. LeanSSR delivers concise proof scripting, powerful rewriting/simplification, and effective hypothesis management while leveraging Lean 4’s metaprogramming infrastructure. Its design emphasizes seamless integration between logical (Prop-valued) statements and their Boolean counterparts, yielding shorter, clearer, and more maintainable proof scripts without requiring explicit representation switching. Proof engineers benefit from maintainability, interoperability with Lean’s mathlib4 and ported Mathematical Components libraries, and the ability to extend tactic behaviors in Lean 4’s native language [2403.12733].

## 1. Principles and Language Architecture

LeanSSR adheres to three core principles:

- **Chained Tactic Language:** LeanSSR scripts operate with a concise, tactic-chaining language where each proof step can manipulate both the goal’s quantifier stack and the local hypothesis context. The principal entry point is the `move=>` construct, which combines the effects of `revert`, `intro`, and `simp`, with support for flexible intro patterns (`?`, `*`, `/[swap]`, `/[dup]`, and alternations such as `![ … | … ]`).
- **Unified Rewriting and Simplification:** The `srw` (ssreflect-rw) tactic interleaves rewriting (`rw`), direction toggling, focused occurrence selection (e.g., `-[2]` for right-to-left rewrite at the 2nd occurrence), and calls to simplification tactics (`simp`, `dsimp`), supporting rewriting both in goals and in hypotheses specified via `at H`.
- **Implicit Reflection:** The reflection discipline enables implicit conversion between Prop-valued predicates and Boolean-valued functions. Unlike SSReflect in Coq, no explicit tactics are needed to switch between logical and symbolic representations (e.g., no manual `apply ↔P2b`).

Under the hood, LeanSSR is implemented entirely within Lean 4, utilizing its metaprogramming API. Key mechanisms include:

| Aspect                 | Role in LeanSSR                                | Notable Implementation   |
|------------------------|------------------------------------------------|--------------------------|
| Syntax Categories      | Structure tactic language grammar              | `declare_syntax_cat`     |
| Macro Rules            | Expand composite tactic patterns               | `macro_rules`            |
| Elaboration Rules      | Specify tactic execution semantics             | `elab_rules`             |
| Custom Env Extensions  | Propagate rewrite locations (e.g., `at H`)     | `EnvExtension`           |
| `evalTactic`           | Single-point script evaluation and tracing     | -                        |

Everything is open to user extension via new rules, with no core recompilation required [2403.12733].

## 2. Formal Definitions and Key Lemmas

Central to LeanSSR is the `Reflect` class:

```lean
class inductive Reflect (P : Prop) : Bool → Type
| T (h : P)     : Reflect P true
| F (h : ¬P)    : Reflect P false
```
This asserts that a logical proposition $P$ is "reflected" by a Boolean $b$:
$$
P \;\longleftrightarrow\; (b = \mathrm{true})
$$

The `#reflect` command automates the generation of canonical lemmas linking Boolean functions with their logical specifications. For example, `#reflect even evenb` produces:
- $\mathrm{evenb}\;0 = \mathsf{true}$
- $\mathrm{evenb}\;1 = \mathsf{false}$
- $\forall n.\;\mathrm{evenb}(n+2) = \mathrm{evenb}\;n$
- `toPropEq`: $\mathrm{even}\;n = \mathrm{evenb}\;n \implies \mathrm{even}\;n = \mathrm{True}$

Hypotheses manipulation and targeted rewriting are enabled by tactics such as:
```lean
by move=> ?; srw -[2] (IH m') //
```
where `-[2]` targets the second occurrence in right-to-left rewriting using an inductive hypothesis.

## 3. Metaprogramming Infrastructure

LeanSSR exploits three Lean 4 metaprogramming features:

- **Syntax Categories, Macro and Elaboration Rules:** Tactic languages are defined via custom syntax categories (e.g., `ssrTriv`). Macros expand complex patterns, and elaboration rules execute Lean tactics. For example, composite scripts like `//==` are expanded to `/== //` via macros, and tokens such as `//=`, `/==` are interpreted into Lean’s standard tactics. `evalTactic` manages parsing, expansion, and execution, providing before/after state tracking for editor tooling and diagnostics.
- **Custom Environment Extensions:** When tactics must operate at specific locations (hypothesis, goal), custom environment entries (`locExt`) are employed to track locations across macro expansions and tactic executions.
- **Type-Class–Driven Reflection:** Reflect instances, tagged with `@[reflect]`, enable Lean’s type-class inference to supply reflection proofs automatically. This unifies decidability and rewriting—whenever $\mathrm{Reflect}\;P\;b$ can be inferred, `Decidable P` is also available, and symbolic and logical forms can be rewritten interchangeably.

Since these features are implemented with Lean’s user-level APIs, proof engineers can extend the tactic suite, add intro patterns, or insert new rewrite rules without modifying Lean’s kernel or externalizing plugins.

## 4. Applications: Case Studies

### 4.1 Porting Mathematical Components Sequence Lemmas

Approximately 10% of the Coq Mathematical Components `seq.v` file (including 31 definitions and 72 theorems) was ported nearly mechanically with LeanSSR. For example, subsequence transitivity (`subseq_trans`) shrank from a 12-line, rewrite-heavy SSReflect/Coq proof requiring explicit predicate switches, to a 9-line LeanSSR proof with no explicit application of reflect predicates or rewrite calls. The `//=` tactic absorbs all rewrite and simplification steps, removing boilerplate.

### 4.2 Finite Set Lemma Refactoring in mathlib4

In mathlib4, proofs concerning cardinalities of images under bijections typically required explicit pattern matching, constructors, and manual manipulation. The LeanSSR adaptation reduced a 6-line subgoal proof (involving `fun`, `rintro`, explicit instance use) to a 4-line script with a single `move=>`, alternation via `![ … | … ]`, and four view patterns, bringing the script closer to standard mathematical argumentation and reducing line count by approximately one third.

## 5. Comparison with SSReflect and Practical Impact

LeanSSR’s main advantages over SSReflect for Coq include:

- **Implicit Prop/Bool Reflection:** Tactics and simplification steps automatically handle transitions between logical and Boolean predicates (no need for explicit `apply/ReflectP`), streamlining proof scripts.
- **Editor Usability:** Hooks in `evalTactic` allow for precise proof state visualization and token-centric error highlighting in advanced Lean 4 editors.
- **Direct Extensibility:** Tactic categories and behaviors (e.g., new patterns for `ssrIntro` or specialized rewrites) can be user-extended by adding new macro or elaboration rules in Lean, without recompilation or OCaml plugins.
- **Integrated Backward and Forward Reasoning:** Through “views” and the `sby` (“solve by …”) tactical, LeanSSR supports both backward chaining (apply-style) and forward reasoning within a single proof mode.

However, LeanSSR does not currently support every SSReflect feature (e.g., unusual intro patterns, large tactics like `move: … /negP`). Tactic execution relies on `evalTactic`, and deep macro stacks can impact proof elaboration performance; future Lean versions may address this with improved incremental elaboration. Planned enhancements include integration with Lean 4’s hygienic macro system and `tabled typeclass` machinery, potentially permitting parameterized SSR patterns.

## 6. Significance and Prospective Developments

LeanSSR embeds SSReflect’s fine-grained, stepwise reflection methodology within Lean 4 in a purely extensible form, prioritizing unified reasoning, concise proof representation, and high customizability for proof engineers. Case studies show measurable reduction in proof size and increased script clarity in both legacy Mathematical Components imports and native mathlib4 developments. Current limitations center on partial feature parity with Coq’s SSReflect and performance scaling of complex scripts. Planned integration of new Lean 4 metaprogramming infrastructure suggests further expansion of SSR-based methodologies and deeper synergy with core Lean libraries [2403.12733].

Source: https://www.emergentmind.com/topics/leanssr