feat: `LambdaCalculus.LocallyNameless.Coc` by matthunz · Pull Request #392 · leanprover/cslib

matthunz · 2026-03-03T05:50:16Z

Summary

Adds basic syntax and typing judgments for the Calculus of Constructions following Coquand's algorithm. I tried to keep everything as close to other lambda calculi in this project as well as general code style. Some of the lemmas from that paper are noticeably missing but I'm hoping this can be an OK first cut 😃

`LambdaCalculus.LocallyNameless.Coc`

Term syntax

inductive Term (Var : Type u) : Type u
  /-- Bound term variables using a de-Bruijn index. -/
  | bvar : ℕ → Term Var
  /-- Free term variables. -/
  | fvar : Var → Term Var
  /-- Function application. -/
  | app : Term Var → Term Var → Term Var
  /-- Lambda abstraction. -/
  | abs : Term Var → Term Var → Term Var
  /-- Pi type. -/
  | pi : Term Var → Term Var → Term Var
  /-- Type universe. -/
  | type : ℕ → Term Var

Typing judgements

inductive Typing : Env Var → Term Var → Term Var → Prop
  /-- Variable lookup in Γ -/
  | var : Γ.Wf → ⟨x, A⟩ ∈ Γ → Typing Γ (.fvar x) A
  /-- Function application -/
  | app : Typing Γ M (.pi A B) → Typing Γ N A → Typing Γ (.app M N) (B ^ᵗ N)
  /-- Lambda abstraction -/
  | abs (ρ : Finset Var) :
      Typing Γ A K →
      (∀ x ∉ ρ, Typing ({⟨x, A⟩} ∪ Γ) (N ^ᵗ .fvar x) (B ^ᵗ .fvar x)) →
      Typing Γ (.abs A N) (.pi A B)
  /-- Pi type -/
  | pi (ρ : Finset Var) :
      Typing Γ A (.type k) →
      (∀ x ∉ ρ, Typing ({⟨x, A⟩} ∪ Γ) (B ^ᵗ .fvar x) (.type i)) →
      (i = k ∨ i = 0) →
      Typing Γ (.pi A B) (.type i)
  /-- Type universe -/
  | type : Typing Γ (.type s) (.type (s + 1))
  /-- β-conversion -/
  | conv : Typing Γ M A → A =β B → Typing Γ B (.type i) → Typing Γ M B

`Cslib.Foundations.Syntax.HasBetaEquiv`

HasBetaEquiv (similar to HasAlphaEquiv) for the notation A =β B

class HasBetaEquiv (t : Type u) where
  /-- β-equivalence relation for type t. -/
  BetaEquiv : t → t → Prop

chenson2018 · 2026-03-03T21:27:13Z

Hi, thanks for your interest in contributing!

Can I ask why the jump to CoC for this named representation of binding? It is a little uncommon to do this style at all, so there's not much else to build off yet. I was hoping that STLC and System F would get filled out first to work out any kinks before more complex type systems.

We are planning to add well scoped indices as an alternative in the next few months or so, but if your interest is formalizing CoC right now would you be interested in doing so in the locally nameless style? This would be much easier to review in comparison to what we already have and prior work in Rocq.

…nto new files

matthunz · 2026-03-04T05:51:16Z

Hey 👋 thanks so much for the feedback!

I wanted to go the named representation route at first because it felt more natural to me coming from functional programming but I'm definitely unsure of how to prove things like well-formedness with that approach.

I'd be thrilled if we can fit this in here somehow given the current plans, here's what I did for now:

Changed to locally-nameless AST b3c0b23
Added the requisite locally-closed and well-formed proofs 8a20752 13ec089

I think the biggest remaining features would now be reduction and the related proofs to tie everything together, which might be a somewhat significant undertaking 😅 happy to defer to your judgement on what the scope of this PR should be

chenson2018

Some of this looks good, in particular thank you for mostly following conventions from the System F formalization. There are a few important places however where I'm not sure about the definitions. Because these are tricky to get right I suggest closely following prior work like the formalization from Charguéraud I link below.

chenson2018 · 2026-03-04T13:56:34Z

Cslib/Languages/LambdaCalculus/LocallyNameless/Coc/Basic.lean

+  /-- Pi type. -/
+  | pi : Term Var → Term Var → Term Var
+  /-- Type universe. -/
+  | type : Term Var


We probably want this to be ℕ → Term Var as well.

Makes sense 👍 I was just going with the simple universal type at first
Changed in 12c85b0

chenson2018 · 2026-03-04T13:59:47Z

Cslib/Languages/LambdaCalculus/LocallyNameless/Coc/Basic.lean

+abbrev Env (Var : Type u) := Finset (Var × Term Var)
+
+def Env.dom [DecidableEq Var] : Env Var → Finset Var := Finset.image Prod.fst


I would expect we reuse LocallyNameless.Context instead of this abbrev.

Ahh I didn't notice that, changed in 0d6e3b9

chenson2018 · 2026-03-04T14:01:21Z

Cslib/Languages/LambdaCalculus/LocallyNameless/Coc/Opening.lean

+
+/-- Variable opening of the ith bound variable. -/
+@[scoped grind =]
+def openingRec (i : ℕ) (s : Term Var) : Term Var → Term Var


We should name this consistently as openRec and open' with the other typesystems.

Oh agreed, changed in 52d3606

chenson2018 · 2026-03-04T14:10:02Z

Cslib/Languages/LambdaCalculus/LocallyNameless/Coc/Opening.lean

+  | abs (L : Finset Var) : σ.LC → (∀ x ∉ L, LC (t₁ ^ᵗ fvar x)) → LC (abs σ t₁)
+  | pi (L : Finset Var) : σ.LC → (∀ x ∉ L, LC (t₁ ^ᵗ fvar x)) → LC (pi σ t₁)


For CoC, the variable σ is a term, as opposed to System F where it was a type. I'd update the variable names accordingly to use t₁ and t₂.

Makes sense I think my copy-paste is showing there lol, changed in 58caddf

chenson2018 · 2026-03-04T14:10:50Z

Cslib/Languages/LambdaCalculus/LocallyNameless/Coc/Opening.lean

+
+/-- A locally closed term is unchanged by opening. -/
+lemma openingRec_lc [HasFresh Var] {σ τ : Term Var} (lc : σ.LC) : σ = σ⟦X ↝ τ⟧ := by
+  classical


This is for decidable equality? I'd rather make this explicit as a typeclass parameter.

Yeah exactly I was just following what the linter said there, adjusted to match the conventions in 827087b

Ah I see, you mean the linter.unusedDecidableInType linter? This will trigger because it is unaware of the typeclass requirements that happen within the proof for free_union. I have unset this in several places for lambda calculi.

chenson2018 · 2026-03-04T14:15:34Z

Cslib/Languages/LambdaCalculus/LocallyNameless/Coc/Typing.lean

+open Term
+
+/-- β-equivalence. -/
+inductive BetaEquiv : Term Var → Term Var → Prop


This definition looks very different from what I expected. See for instance the definition in the Rocq formalization I closely followed for other type systems.

Ah I see BetaEquiv was a little lacking 😅 this should now match Chargueraud's representation d6afe92

chenson2018 · 2026-03-04T14:29:18Z

Cslib/Languages/LambdaCalculus/LocallyNameless/Coc/Typing.lean

+  BetaEquiv := BetaEquiv
+
+/-- Typing judgement -/
+inductive Typing [DecidableEq Var] : Env Var → Term Var → Term Var → Prop


I was expecting to see a mutual block also defining well-formed contexts.

Appreciate the hint! Your idea about having these be mutually-recursive and Chargueraud's repo finally got me to see how to do this e69ac78

chenson2018 · 2026-03-04T14:30:12Z

Cslib/Languages/LambdaCalculus/LocallyNameless/Coc/WellFormed.lean

+/-- An environment is well-formed if it binds each variable exactly once to a well-formed type. -/
+inductive Env.Wf : Env Var → Prop
+  | nil : Wf {}
+  | cons : Wf Γ → Term.Wf Γ τ → x ∉ Γ.dom → Wf ({⟨x, τ⟩} ∪ Γ)


I don't think this is right. Because of the dependent types aspect, we need a typing derivation before adding to the context, right?

Ah yeah the context of dependent types was the part I struggled with quite a bit. I had a version of Coquand's algorithm for type checking using this simple context but for this actual formalization I guess that feels pretty weak.

Changed to Chargueraud's representation in e69ac78

…fit current conventions

chenson2018 · 2026-03-04T19:06:58Z

Cslib/Languages/LambdaCalculus/LocallyNameless/Coc/Typing.lean

+open Term
+
+/-- β-reduction. -/
+inductive BetaEquiv : Term Var → Term Var → Prop


I should have mentioned previously. This should use the reduction_sys attribute to get notation, because this is still reduction and not the equivalence (reflexive symmetric transitive closure), right? I would remove the HasBetaEquiv class and use this.

Oh that's super interesting 🤔 I'm not sure I fully understand how this works but it looks like if I have @[reduction_sys "β"] attribute on BetaEquiv, then using A ↠β B in the conversion Typing judgement would work like multi-step reduction? It seems to be working in 4f202b4

Yes, this looks correct. It is a custom attribute that we use in CSLib, with some docs at here.

…i-step beta reduction

chenson2018 · 2026-03-05T00:27:54Z

At first glance your changes about the feedback I gave look good. I will give it a closer review hopefully later this week.

It seems there is some new material about reduction now? You had asked about scope, and while there's no hard limit I think at ~450 LoC this is a nice upper bound for what is preferable to review at once.

matthunz · 2026-03-05T00:53:59Z

Thank you for the mentoring here!

Now that β-reduction is in this port would just need β*-reduction, the Church-Rosser theorem, and conversion to be fully complete (as long as what's here is correct so far...).

I'll hold off for now, please let me know if you have any more notes 😄

chenson2018 · 2026-03-05T01:10:00Z

Thank you for the mentoring here!

No problem, happy to help!

Now that β-reduction is in this port would just need β*-reduction, the Church-Rosser theorem, and conversion to be fully complete (as long as what's here is correct so far...).

By β*-reduction, you mean the reflexive transitive closure, right? When you did @[reduction_sys "β"] this actually registers both a notation ⭢β for the single step reduction you tagged, but also ↠β for this multiple reduction. This second arrow notation is for Relation.ReflTransGen, which is able to work with general relations. So you have this defined already, but let's hold off on adding any additional proofs about it to keep this PR size manageable.

And in general yes, we'll want all these other things you mention, but in small chunks! 😁

I'll hold off for now, please let me know if you have any more notes 😄

I think there will be one or two definitions we might what to generalize, but I can help out with this when I do my second round of reviewing.

matthunz added 5 commits March 2, 2026 23:58

feat: Term

0ddd4a8

feat: Term.rename

448207e

feat: Term.subst

745a7c6

feat: Term.BetaEquiv and HasBetaEquiv

1d265e4

feat: Typing

7979775

matthunz requested review from chenson2018 and fmontesi as code owners March 3, 2026 05:50

matthunz added 2 commits March 3, 2026 11:42

refactor: rename lam to abs to fit styling of other AST

e8cef24

fix: BetaEq relationship order in eq

29c2bd9

matthunz added 3 commits March 3, 2026 19:46

feat: switch to locally-nameless representation

b3c0b23

feat: add opening lemmas for locally-closed terms and split up code i…

8a20752

…nto new files

feat: WellFormed

13ec089

matthunz changed the title ~~feat: LambdaCalculus.Named.Coc~~ feat: LambdaCalculus.LocallyNameless.Coc Mar 4, 2026

chenson2018 requested changes Mar 4, 2026

View reviewed changes

matthunz added 7 commits March 4, 2026 12:24

refactor: re-use existing Context for Env

0d6e3b9

refactor: rename opening to open' to match current conventions

52d3606

refactor: rename LC-related variables for clarity

58caddf

refactor: replace use of classical with constraint on DecidableEq to …

827087b

…fit current conventions

fix: extend BetaEquiv to match the definition by Chargueraud

d6afe92

feat: add sort level to Term.type AST

12c85b0

fix: stronger typing relations in Env.Wf and Typing

e69ac78

chenson2018 reviewed Mar 4, 2026

View reviewed changes

matthunz added 2 commits March 4, 2026 14:26

fix: replace HasBetaEquiv class with reduction_sys attribute for mult…

4f202b4

…i-step beta reduction

feat: β-reduction

37451c6

		abbrev Env (Var : Type u) := Finset (Var × Term Var)

		def Env.dom [DecidableEq Var] : Env Var → Finset Var := Finset.image Prod.fst

		\| abs (L : Finset Var) : σ.LC → (∀ x ∉ L, LC (t₁ ^ᵗ fvar x)) → LC (abs σ t₁)
		\| pi (L : Finset Var) : σ.LC → (∀ x ∉ L, LC (t₁ ^ᵗ fvar x)) → LC (pi σ t₁)

Conversation

matthunz commented Mar 3, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Summary

LambdaCalculus.LocallyNameless.Coc

Cslib.Foundations.Syntax.HasBetaEquiv

Uh oh!

chenson2018 commented Mar 3, 2026

Uh oh!

matthunz commented Mar 4, 2026

Uh oh!

chenson2018 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

matthunz Mar 5, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

matthunz Mar 5, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

chenson2018 commented Mar 5, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

matthunz commented Mar 5, 2026

Uh oh!

chenson2018 commented Mar 5, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

matthunz commented Mar 3, 2026 •

edited

Loading

`LambdaCalculus.LocallyNameless.Coc`

`Cslib.Foundations.Syntax.HasBetaEquiv`

matthunz Mar 5, 2026 •

edited

Loading

matthunz Mar 5, 2026 •

edited

Loading

chenson2018 commented Mar 5, 2026 •

edited

Loading