Normalization by Evaluation Dependent Types and ...
Transcript of Normalization by Evaluation Dependent Types and ...
![Page 1: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/1.jpg)
Normalization by EvaluationDependent Types and Impredicativity
Andreas Abel
Department of Computer ScienceLudwig-Maximilians-University Munich
Habilitation TalkLudwig-Maximilians-University Munich
31 May 2013
Andreas Abel (LMU) NbE Habil 1 / 39
![Page 2: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/2.jpg)
Introduction
Context of This Work
Dependently-typed (programming) languages allow
to express functional specifications in types,to prove (correctness) properties in the language,formalize and prove mathematical propositions.
Prominent proof assistent: Coq (INRIA 1984–)
CompCert: Certifed compiler for C– (Leroy)Formalized proof of Four Color Theorem (Gonthier, 2005)Odd-Order Theorem (Gonthier, 2012)
Theorem Feit_Thompson
(gT : finGroupType) (G : {group gT}) :
odd #|G| -> solvable G.
Experimental languages: Agda, Epigram, Idris, . . .
Andreas Abel (LMU) NbE Habil 2 / 39
![Page 3: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/3.jpg)
Introduction
Behind the Veil
What made Coq ready for huge developments?
Benjamin Gregoire, Xavier Leroy:A compiled implementation of strong reduction. ICFP 2002
Efficient normalization!
Gregoire, Leroy: Efficient checking of β-equality.
This thesis: Framework for βη-equality.
Andreas Abel (LMU) NbE Habil 3 / 39
![Page 4: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/4.jpg)
Introduction
A Taste of Programming with Dependent Types
Descending lists: [x , y , . . . , z ] ∈ List↓ n iff n ≥ x ≥ y ≥ · · · ≥ z
Constructor carries proof p for descent.
nil : List↓ 0
x : N p : x ≥ y xs : List↓ y
cons x p xs : List↓ x
Singleton list carries a trivial proof.
singleton : (x : N)→ List↓ x
singleton x = cons x nil where : x ≥ 0
Andreas Abel (LMU) NbE Habil 4 / 39
![Page 5: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/5.jpg)
Introduction
Correct Insert
Case: Insert into empty list.
insert : (x : N)→ List↓ n→ List↓ (max x n)
insert x nil = singleton x
Inferred type singleton x : List↓ x .
Expected type singleton x : List↓ (max x 0).
Type-checker needs to ensure List↓ x = List↓ (max x 0).
Sufficient: x = max x 0.
Compare expressions with free variables!
Solution: normalize max x 0 to x .
Andreas Abel (LMU) NbE Habil 5 / 39
![Page 6: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/6.jpg)
Introduction
Normalization
Bring an expression with unkowns into a canonical form.
Unknowns = free variables.
Checking equality by comparing canonical forms.
Examples:
Expression Normalizer
arithmetical expression symbolic evaluator (MathLAB)
functional programming language term rewriting, partial evaluation
stack maching code JIT compiler
SQL query query compiler
Andreas Abel (LMU) NbE Habil 6 / 39
![Page 7: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/7.jpg)
Introduction
Evaluation
Compute the value of an expression relative to an environment.
Environment assigns values to free variables of expressions.
Examples:
Expression Environment Evaluator
arithmetical expression valuation calculator
functional programming language stack & heap interpreter
stack machine code stack stack machine
SQL-query database SQL processor
Andreas Abel (LMU) NbE Habil 7 / 39
![Page 8: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/8.jpg)
Introduction
Normalization by Evaluation (NbE)
Adapt an interpreter to simplify expressions with unknowns.
MLTT Martin-Lof 1975: NbE for Type Theory (weak conversion)
STL Berger Schwichtenberg 1991: NbE for simply-typed λ-calculus
T Danvy 1996: Type-directed partial evaluation
F Altenkirch Hofmann Streicher 1996: NbE for λ-free System F
λ Aehlig Joachimski 2004: Untyped NbE, operationally
λ Filinski Rohde 2004: Untyped NbE, denotationally
LF Danielsson 2006: strongly typed NbE for LF
T Altenkirch Chapman 2007: Tait in one big step
Andreas Abel (LMU) NbE Habil 8 / 39
![Page 9: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/9.jpg)
Introduction
This Thesis
A correct normalization-by-evaluation procedurefor functional languages with dependent types
and impredicative polymorphism.
Start from untyped NbE.
Semantics/model based on NbE.
Model proves decidability of equality and typing.
Model uses generic partial applicative structures.
Covers many different implementations (e.g., Coq’s compiledreduction).
Andreas Abel (LMU) NbE Habil 9 / 39
![Page 10: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/10.jpg)
Introduction
Publications Underlying This Thesis
Dependent types:
MLTT Abel Aehlig Dybjer (MFPS 2007): untyped equality.
MLTT Abel Coquand Dybjer (LICS 2007):Decidability of typed equality with η on types.
MLTT Abel Coquand Pagano (LMCS 2011): Singleton types.
Impredicativity:
F Abel (LPAR 2008)
Fω Abel (CSL 2009)
CoC+N Abel (FLOPS 2010)
Andreas Abel (LMU) NbE Habil 10 / 39
![Page 11: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/11.jpg)
Introduction
Barendregt’s λ-Cube
Fω CoC
erasure
yy
F
higher-order
??
OO
polymorphism
•
• •
STL dependence // LF
erasure
cc
NbE:known (STL, LF,F)this thesis (Fω)reducible (CoC)
Andreas Abel (LMU) NbE Habil 11 / 39
![Page 12: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/12.jpg)
Introduction
Dependency Erasure
Restrictive dependencies can be erased safely.
|List↓ n| = List
We can forget that we deal with descending lists.
Recursive (computational) dependencies cannot be erased.
NAry : N→ Type
NAry 0 = NNAry (n + 1) = N→ NAry n
|NAry n| = ?
No simple type corresponds to NAry n.
Andreas Abel (LMU) NbE Habil 12 / 39
![Page 13: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/13.jpg)
Introduction
The Cube with N and Recursion
Fω + N CoC + N
erasure
yy
F + N
??
OO •
• MLTT+
T // MLTT
erasure
cc
NbE:known (T)th. (MLTT(+),CoC + N)subsumed (F(ω) + N)
Andreas Abel (LMU) NbE Habil 13 / 39
![Page 14: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/14.jpg)
Untyped Lambda Calculus
Untyped Lambda Calculus
Grammar:
Exp 3 r , s, t ::= x variable
| λx . t abstracting variable x in body t
| r s applying r to s
Equational theory (β):
` (λx . t) s = t[s/x ]
β-normal forms.
Nf 3 v ::= λx . v | u normal form
Ne 3 u ::= x | u v neutral term
Andreas Abel (LMU) NbE Habil 14 / 39
![Page 15: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/15.jpg)
Untyped Lambda Calculus
Evaluation of Lambda-Expressions
Values a, b, f ∈ D with (partial) application · : D× D→ D.
Evaluation (specification):
Lx Mρ = ρ(x)
Lr s Mρ.
= Lr Mρ · Ls MρLλx . t Mρ · a
.= Lt M(ρ,a/x)
Instance: compiled execution.
f · a Call f with argument a
Lλx . t Mρ Code for function λx . t with predefined variables ρ
Andreas Abel (LMU) NbE Habil 15 / 39
![Page 16: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/16.jpg)
Untyped Lambda Calculus
Implementation via Closures
Instance: do nothing.
Lλx . t Mρ = (λxt)ρ
Initial applicative structure: closures.
D 3 a, b, f ::= (λxt)ρ waiting for value of x
Application and evaluation are mutually defined.
(λxt)ρ · a = Lt M(ρ,a/x)
Lr s Mρ = Lr Mρ · Ls Mρ
Andreas Abel (LMU) NbE Habil 16 / 39
![Page 17: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/17.jpg)
Untyped Lambda Calculus
Residual Model: Adding Unknowns
For normalization, we need free variables in D.
Application x · a of a free variable stores argument a.
Need neutrals/accumulators x ~a in D.
D 3 a, b, f ::= (λxt)ρ | eDne 3 e ::= x | e a
Application extended:
(λxt)ρ · a = Lt M(ρ,a/x)
x ~a · a = x (~a, a)
Andreas Abel (LMU) NbE Habil 17 / 39
![Page 18: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/18.jpg)
Untyped Lambda Calculus
Reading Back Expressions from Values
Reading back values:
Rnf : D→ Nf
Rnf((λxt)ρ) = λy .Rnf(Lt M(ρ,y/x)) where y“fresh”
Rnf(e) = Rne(e)
Reading back neutrals:
Rne : Dne → Ne
Rne(x) = x
Rne(e a) = Rne(e) Rnf(a)
Andreas Abel (LMU) NbE Habil 18 / 39
![Page 19: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/19.jpg)
Untyped Lambda Calculus
Fresh Name Generation
Freshness problem: ≥ 9 approaches.
Simple solution: Rnfξ reads fresh names from supply ξ.
E.g., ξ is an infinite stream of distinct identifiers.
Rnf(y ,ξ)((λxt)ρ) = λy .Rnf
ξ (Lt M(ρ,y/x))
Rnfξ (e) = Rne
ξ (e)
Rneξ (x ~a) = x Rnf
ξ (~a)
Normalization:
nfξ(t) = Rnfξ (Lt Mρid
)
Andreas Abel (LMU) NbE Habil 19 / 39
![Page 20: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/20.jpg)
Untyped Lambda Calculus
Summ it ary
Semantics D
Rnf
��
Dne
Rne
��
⊇
aa
Syntax Exp
[[ ]]
@@
Nf⊇oo Ne
⊇oo Var⊇oo
⊇
aa
Andreas Abel (LMU) NbE Habil 20 / 39
![Page 21: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/21.jpg)
Typed Lambda Calculus
Simply-Typed Lambda Calculus
Types S ,T ::= N | S → T .
Typing contexts Γ ::= x1 :S1, . . . , xn :Sn.
Typing Γ ` t : T .
(x :T ) ∈ Γ
Γ ` x : T
Γ, x :S ` t : T
Γ ` λx . t : S → T
Γ ` r : S → T Γ ` s : S
Γ ` r s : T
Equational theory (βη).
(β)Γ, x :S ` t : T Γ ` s : S
Γ ` (λxt) s = t[s/x ] : T
(η)Γ ` t : S → T
Γ ` t = λx . t x : S → T
Andreas Abel (LMU) NbE Habil 21 / 39
![Page 22: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/22.jpg)
Typed Lambda Calculus
Bidirectional η-Expansion
↑T “reflection”: η-expansion inside-out
↓T “reification”: η-expansion outside-in
Example (terms):
↓(N→N)→(N→N)f = λy . ↓N→N(f (↑N→Ny))
= λy . λx . ↓N(f (↑N→Ny) (↑Nx))
= λy . λx . ↓N(f (λz . ↓N(y (↑Nz))) (↑Nx))
= λy . λx . f (λz . y z) x
Andreas Abel (LMU) NbE Habil 22 / 39
![Page 23: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/23.jpg)
Typed Lambda Calculus
Adding η-Expansion
Semantics (β) D
↓T
��Semantics (βη) Dnf
Rnf
��
Dne
Rne
��
↑T
``
Syntax Exp
[[ ]]
@@
Nf⊇oo Ne
⊇oo Var⊇oo
⊇
``
Andreas Abel (LMU) NbE Habil 23 / 39
![Page 24: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/24.jpg)
Typed Lambda Calculus
Eta-expansion: reflection and reification
Values now include delayed η-expansions.
D 3 a, b, f ::= (λxt)ρ | ↑T e
Dne 3 e ::= x | e dDnf 3 d ::= ↓Ta
Application and readback trigger these expansions.
(λxt)ρ · a = Lt M(ρ,a/x)
↑S→T e · a = ↑T (e ↓Sa)
Rnf(y ,ξ) (↓S→T f ) = λy . Rnf
ξ (↓T (f · ↑Sy))
Rnfξ (↓N ↑Ne) = Rne
ξ (e)
Andreas Abel (LMU) NbE Habil 24 / 39
![Page 25: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/25.jpg)
Typed Lambda Calculus
Normalization for STL
Canonical environment:
ρΓ(x) = ↑T x where (x : T ) ∈ Γ
Variable supply:ξΓ = Var \ Γ
Normalization of Γ ` t : T :
nfTΓ (t) = RnfξΓ
(↓T Lt MρΓ)
Andreas Abel (LMU) NbE Habil 25 / 39
![Page 26: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/26.jpg)
Dependent Types
Dependent Types
Recall singleton : (x : N)→ List↓ x .Dependent function space (x : S)→ T .
Γ ` S : Type Γ, x :S ` T : Type
Γ ` (x :S)→ T : Type
Γ, x :S ` t : T
Γ ` λx . t : (x :S)→ T
Γ ` r : (x :S)→ T Γ ` s : S
Γ ` r s : T [s/x ]
η-expansion directed by type values.
↓NAry(2)(f ) = ↓N→NAry(1)(f )
= λx . ↓NAry(1)(f (↑Nx))
= λx . ↓N→NAry(0)(f (↑Nx))
= λx . λy . ↓NAry(0)(f (↑Nx) (↑Ny)) = . . .
Andreas Abel (LMU) NbE Habil 26 / 39
![Page 27: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/27.jpg)
Dependent Types
Type Values
Values include types.
D 3 a, b, f ,A,F ::= (λxt)ρ | FunAF | Type | ↑Ae
Dne 3 e ::= x | e dDnf 3 d ::= ↓Aa
Read-back evaluates types further.
Rnf(y ,ξ)(↓FunAF f ) = λy . Rnf
ξ (↓F ·a(f · a))
Rnf(y ,ξ)(↓Type(FunAF )) = (y :↓TypeA)→ ↓Type(F · a)
where a = ↑Ay .
Andreas Abel (LMU) NbE Habil 27 / 39
![Page 28: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/28.jpg)
Dependent Types
Normalization for Dependent Types
Canonical environment:
ρΓ(x) = ↑LT MρΓ (x) where (x : T ) ∈ Γ
Normalization of Γ ` t : T :
nfTΓ (t) = RnfξΓ
(↓LT MρΓ Lt MρΓ)
Andreas Abel (LMU) NbE Habil 28 / 39
![Page 29: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/29.jpg)
Dependent Types
Correctness of Normalization
Normalization is sound if for all expressions Γ ` t : T ,
Γ ` t = nfTΓ (t) : T .
Normalization is complete if for all Γ ` t, t ′ : T ,
Γ ` t = t ′ : T =⇒ nfTΓ (t) =α nfTΓ (t ′)
Implies idempotence nfTΓ (t) =α nfTΓ (nfTΓ (t)).
Andreas Abel (LMU) NbE Habil 29 / 39
![Page 30: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/30.jpg)
Dependent Types
Partial Equivalence Relations
Relation A = A′ ∈ Type shall mean that A,A′ are extensionally equaltype values.
Relation a = a′ ∈ A shall mean that a, a′ are extensionally equalvalues of type A.
Defined simultaneously by induction-recursion:
A = A′ ∈ Type F · a = F ′ · a′ ∈ Type for all a = a′ ∈ A
FunAF = FunA′ F ′ ∈ Type
f · a = f ′ · a′ ∈ F · a for all a = a′ ∈ A
f = f ′ ∈ FunAF
Models βη-equality.
Andreas Abel (LMU) NbE Habil 30 / 39
![Page 31: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/31.jpg)
Dependent Types
Typed Candidate Spaces
Greatest and least PERs:
d = d ′ ∈ >> ⇐⇒ Rnfξ (d) =α Rnf
ξ (d ′) for all ξ
e = e ′ ∈ ⊥⊥ ⇐⇒ Rneξ (e) =α Rne
ξ (e ′) for all ξ
Greatest and least type candidate:
a = a′ ∈ A ⇐⇒ ↓Aa = ↓Aa′ ∈ >>a = a′ ∈ A ⇐⇒ a = ↑Ae and a′ = ↑Ae ′ and e = e ′ ∈ ⊥⊥
Sandwich property:
a = a′ ∈ A =⇒ a = a′ ∈ A =⇒ a = a′ ∈ A
Andreas Abel (LMU) NbE Habil 31 / 39
![Page 32: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/32.jpg)
Dependent Types
Completeness of Normalization
Well-typed βη-equal terms have the same normal form.
Γ ` t = t ′ : T =⇒a︷ ︸︸ ︷
Lt MρΓ=
a′︷ ︸︸ ︷Lt ′ MρΓ
∈A︷ ︸︸ ︷
LT MρΓ
=⇒ a = a′ ∈ A
=⇒ ↓Aa = ↓Aa′ ∈ >>
=⇒ RnfξΓ↓Aa =α Rnf
ξΓ↓Aa′
Andreas Abel (LMU) NbE Habil 32 / 39
![Page 33: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/33.jpg)
Dependent Types
Soundness of Normalization
A well-typed term is βη-equal to its normal form.
Γ ` t : T =⇒ Γ ` t : T R©a︷ ︸︸ ︷
Lt MρΓ∈
A︷ ︸︸ ︷LT MρΓ
=⇒ Γ ` t = RnfξΓ↓Aa : T
⇐⇒ Γ ` t = nfTΓ (t) : T
Andreas Abel (LMU) NbE Habil 33 / 39
![Page 34: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/34.jpg)
Impredicativity
Impredicative Polymorphism
Impredicativity: Quantification over all types gives a type.
Γ,X :Type ` T : Type
Γ ` (∀X :Type.T ) : Type
Applications:
(Functional) programming: System F, Haskell, . . .Second-order logic.
Semantic difficulty: Valid types cannot be defined from below.
F · A = F ′ · A′ ∈ Type for all A = A′ ∈ Type
∀F = ∀F ′ ∈ Type
Circularity!
Andreas Abel (LMU) NbE Habil 34 / 39
![Page 35: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/35.jpg)
Impredicativity
NbE for System F
Semantic type candidate A for S
S ⊆ A ⊆ S
Interpret ∀ by quantifying over all candidates (Girard):
[[∀XT ]]ρ =⋂
S⊆A⊆S
[[T ]](ρ,A/X )
Andreas Abel (LMU) NbE Habil 35 / 39
![Page 36: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/36.jpg)
Conclusions
Results
NbE for dependent types and impredicativity: CoC + N.(Close to Coq’s logical basis).
Decidability of type checking with η on type level.
Singleton types and universes.
Theoretical basis for “compiled reduction” with η.
Andreas Abel (LMU) NbE Habil 36 / 39
![Page 37: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/37.jpg)
Conclusions
Future Work
Agda: compiled equality checking based on NbE.
Full Calculus of Inductive Constructions (Coq).
Use NbE-semantics as tool to develop sound extensions of dependenttype systems.
Andreas Abel (LMU) NbE Habil 37 / 39
![Page 38: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/38.jpg)
Conclusions
Acknowledgements
To the mentorate: Martin Hofmann, Helmut Schwichtenberg, PeterDybjer.
To my coauthors: Klaus Aehlig, Peter Dybjer, Thierry Coquand,Michael Pagano.
To my boss: Martin Hofmann.
To my colleagues, family and friends.
Andreas Abel (LMU) NbE Habil 38 / 39
![Page 39: Normalization by Evaluation Dependent Types and ...](https://reader031.fdocuments.us/reader031/viewer/2022012506/6181ba3922c3dc58c24ff9a7/html5/thumbnails/39.jpg)
Conclusions
A Munich Topic
Helmut Schwichtenberg, Ulrich Berger
Thorsten Altenkirch, Martin Hofmann, Thomas Streicher
Mattias Eberl (PhD)
Klaus Aehlig, Felix Joachimski
Freiric Barral (PhD)
Florian Haftmann, Tobias Nipkow
Andreas Abel (LMU) NbE Habil 39 / 39