ladder-calculus/paper/main.tex

\documentclass[10pt, sigplan, nonacm]{acmart}

\usepackage[utf8]{inputenc}
\usepackage{formal-grammar}
\usepackage[dvipsnames]{xcolor}
\usepackage{mathpartir}
\usepackage{hyperref}
\usepackage{url}
\usepackage{stmaryrd}
\usepackage{minted}
\usemintedstyle{tango}

\DeclareUnicodeCharacter{2200}{$\forall$}
\DeclareUnicodeCharacter{03C3}{$\sigma$}
\DeclareUnicodeCharacter{03C4}{$\tau$}
\DeclareUnicodeCharacter{03BB}{$\lambda$}
\DeclareUnicodeCharacter{21A6}{$\mapsto$}
\DeclareUnicodeCharacter{039B}{$\Lambda$}
\DeclareUnicodeCharacter{03B1}{$\alpha$}
\DeclareUnicodeCharacter{03B2}{$\beta$}
\DeclareUnicodeCharacter{03B3}{$\gamma$}
\DeclareUnicodeCharacter{03B4}{$\delta$}
\DeclareUnicodeCharacter{0393}{$\Gamma$}
\DeclareUnicodeCharacter{211D}{$\mathbb{R}$}

\newcommand{\metavariable}[1]{\textcolor{teal}{#1}}
\newcommand{\typeterminal}[1]{\textcolor{brown}{#1}}
\newcommand{\exprterminal}[1]{\textcolor{Sepia}{#1}}

\newcommand{\seltype}[0]{ {\textsc{\footnotesize{Typ}}} }
\newcommand{\selexpr}[0]{ {\textsc{\footnotesize{Exp}}} }
\newcommand{\selval}[0]{ {\textsc{\footnotesize{Val}}} }

\newcommand{\exprvars}[0]{ V }
\newcommand{\typevars}[0]{ \Upsilon }
\newcommand{\typenames}[0]{ \Sigma }

\newcommand{\typenonterm}[1]{ \nonterm{ T_\seltype \footnotesize{\textsf{$(\typenames, #1)$}}}}
\newcommand{\exprnonterm}[2]{ \nonterm{ T_\selexpr \footnotesize{\textsf{$(\typenames, #1, #2)$}}}}
\newcommand{\valnonterm}[2]{ \nonterm{ T_\selval \footnotesize{\textsf{$(\typenames, #1, #2)$}}}}


\newcommand{\todo}[1]{ {\textcolor{red}{\textbf{TODO:} #1}} }

\title{A functional core calculus with ladder-types}
\author{Michael Sippel}
\email{michael.sippel@mailbox.tu-dresden.de}

\makeatletter
\let\@authorsaddresses\@empty
\makeatother
\begin{document}


\begin{abstract}
 This work introduces \emph{representational polymorphism} as a form of
 coercive subtyping, which differentiates between various concrete
 representations w.r.t. an abstract concept using an explicit type
 structure. This structure captures the 'represented-as' relation of
 multi-level data embeddings.  Motivated by the need to manage data
 transformations —whether for hardware interfacing, IPC/RPC
 communication, or performance optimizations— our type system aims to
 reduce bugs and enhance code clarity by enabling implicit coercions
 between semantically equivalent representations, while retaining
 coherence and soundness.

 We extend the polymorphic λ-calculus (System F) with a new type
 constructor, termed \emph{ladder-type} to encode a subtype relation based on
 syntactical embedding, which inversely also helps to disambiguate
 multiple interpretations of the same presentation type. To facilitate
 implicit coercions between semantically equivalent yet presentationally
 different types, we introduce morphisms —functions that transform one
 representation to another of the same abstract type. Morphisms can be
 inductively combined to form complex morphism-paths allowing
 transitivity, list-mappings and lifting of presentation subtypes
 without loss of coherence.  This enables programmers to treat various
 representational forms interchangeably as abstract objects, with
 required transformations managed by the compiler during a separate
 translation step based on expression typing, while still being able to
 locally control specific representations.

 We formalize our extended calculus in Coq and demonstrate that our
 translation function preserves typing, with progress and preservation
 theorems remaining valid.
\end{abstract}

\maketitle
\tableofcontents


%\newpage
\section{Introduction}
The issue of transformation between varying data encodings is all-pervasive in software development.
Altough programming languages in principle try provide a 'realm of consistent abstraction',
many parts of the code that interface with the outside world are still riddled with data transformation routines.

While certain representational forms might be fixed already at the boundaries of an application,
internally, some other representations might be desired for reasons of simplicity, efficiency or
for the sake of interfacing with hardware, other libraries / processes, the user.
Further, differing complexity-profiles of certain representations might even have the potential to complement
each other and coexist in a single application.
Often however, such specialized implementations become heavily dependent on concrete data formats
and require technical knowledge of the low-level data structures.
Making use of multiple such representations, additionally requires careful transformation of data.

\paragraph{Interfacing}
\todo{serilization / marshalling}

\paragraph{How to get fast code ?}
 -> algorithmic optimization
   -> see which methods are used most frequently
   -> switch structures to reduce complexity there
   -> identify special cases
   -> remove indirection

 -> optimize implementation detail:
 -- bottleneck? memory!
 ---- plenty of Main memory,
	  but FAST memory is scarce
	--> improve cache efficiency: make compact representations
	   * Balance De-/Encode Overhead
	         vs. Load-Overhead

       * Synchronize locality in access order and memory layout.
       -> elements accessed in succession shall be close in memory.
	        (e.g. AoS vs SoA)

     ..while..
     - accounting for machine specific cache-sizes
     - accounting for SIMD instructions
     - interfacing with kernels running on accelerator devices

\paragraph{Elegant Abstractions}
\todo{difference to traditional coercions (static cast)}
\todo{relation with inheritance based subtyping:  bottom-up vs top-down inheritance vs ladder-types}
\todo{relation to traits/type-classes}
\todo{relation to coercive subtyping}

\paragraph{Related Work}
\todo{type specific languages}

In order to facilitate programming at "high-level", we introduce a type-system that is able to disambiguate
this multiplicity of representations and facilitate implicit coercions between them.
We claim this to aid in (1) forgetting details about representational details during program composition
and (2) keeping the system flexible enough to introduce representational optimizations at a later stage without
compromising semantic correctness.

\section{Core Calculus}
\subsection{Syntax}

The calculus is made up of a \emph{type-level} language, and an \emph{expression-level} language. The formal grammar for both is given in \ref{gr:core}.
In addition to \emph{function types} \(\tau_1 \rightarrow \tau_2\), \emph{universal types} \(\forall\alpha.\tau\) and type specialization \(<\tau_1 \tau_2>\),
which are already known from SystemF,
types can be of the form \(\tau_1 \sim \tau_2\) to denote a \emph{ladder type} to formalizes the notion of a type \(\tau_1\) being represented in terms of type \(\tau_2\).
Similar to SystemF, expressions can be \emph{variables}, \emph{type-abstractions}, \emph{}

Coq definitions of the abstract syntax can be found in \hyperref[coq:terms]{\texttt{terms.v}}.

\begin{figure}[h]
\label{gr:core}

\begin{grammar}

\firstcase{ T }{
	\metavariable{\sigma}
}{Base Type}

\otherform{
	\metavariable{\alpha}
}{Type Variable}

\otherform{
	\typeterminal{\forall} \metavariable{\alpha} \typeterminal{.} \nonterm{T}
}{Universal Type}

\otherform{
	\typeterminal{<} \nonterm{T} \quad \nonterm{T} \typeterminal{>}
}{Specialized Type}

\otherform{
	\nonterm{T} \quad \typeterminal{\rightarrow} \quad \nonterm{T}
}{Function Type}

\otherform{
	\nonterm{T} \quad \typeterminal{\rightarrow_\text{morph}} \quad \nonterm{T}
}{Morphism Type}

\otherform{
	\nonterm{T} \quad \typeterminal{\sim} \quad \nonterm{T}
}{Ladder Type}

$$\\$$

\firstcase{ E
% T_\selexpr
}
	{ \metavariable{x}
} {Variable}

\otherform{
	\exprterminal{let} \quad \metavariable{x} \quad \exprterminal{=} \quad 
	\nonterm{ E }
	\quad \exprterminal{in} \quad
	\nonterm{ E }
}{Variable Binding}

\otherform{
	$$ \exprterminal{\Lambda} \metavariable{\alpha}
	\quad \exprterminal{\mapsto} \quad $$
	\nonterm{ E }
}{Type Abstraction}

\otherform{
	$$ \exprterminal{\lambda} \metavariable{x} $$
	\exprterminal{:} \nonterm{ T }
    \quad $$\exprterminal{\mapsto}$$ \quad
	\nonterm{ E }
}{Value Abstraction}

\otherform{
	$$ \exprterminal{\lambda} \metavariable{x} $$
	\exprterminal{:} \nonterm{ T }
    \quad $$\exprterminal{\mapsto_\text{morph}}$$ \quad
	\nonterm{ E }
}{Value Morphism}

\otherform{
	\nonterm{ E }
	\quad
	\nonterm{ T }
}{Type Application}

\otherform{
	\nonterm{ E }
	\quad
    \nonterm{ E }
}{Value Application}

\otherform{
    \nonterm{ E }
	\quad
	\exprterminal{as}
	\quad
    \nonterm{ T }
}{Ascription}

%\otherform{
%    \nonterm{ E }
%	\quad
%	\exprterminal{to}
%	\quad
%    \nonterm{ T }
%}{Transformation}
%\otherform{\exprterminal{(} \quad \nonterm{E} \quad \exprterminal{)}}{Parenthesis}


$$\\$$

\firstcase{V}{
	\nonterm{ V } \quad
	\exprterminal{as} \quad
	\nonterm{ T }
}{Ascribed Value}

\otherform{
	\exprterminal{\Lambda} \metavariable{\alpha} \quad
	\exprterminal{\mapsto} \quad
	\nonterm{ V }
}{Type-Abstraction Value}

\otherform{
	\exprterminal{\lambda} \metavariable{x}
	\exprterminal{:}
	\nonterm{ T } \quad
	\exprterminal{\mapsto} \quad
	\nonterm{ E }
}{Abstraction Value}

\end{grammar}



\caption{Syntax of the core calculus with colors for \metavariable{metavariables}, \typeterminal{type-level terminal symbols}, \exprterminal{expression-level terminal symbols}
where $\typenames, \typevars, \exprvars$ are mutually disjoint, countable sets of symbols to denote atomic type identifiers (\(\typenames\)), typevariables (\(\typevars\)), and expression variables (\(\exprvars\)).
By default, assume \(\metavariable{\sigma} \in \typenames\), \(\metavariable{\alpha} \in \typevars\) and \(\metavariable{x} \in \exprvars\).
For simplicity, we write \(\metavariable{e} \in \nonterm{E}\) to say that the term \metavariable{e} is contained in the language generated by the nonterminal \(\nonterm{E}\).
$$\\$$}

\end{figure}

\begin{example}
\label{ex:terms}
Let \(\Sigma = \{ \text{Digit}, \text{Char}, \text{Seq}, \text{UTF-8}, \mathbb{N}, PosInt \} \cup \{ 0, 1, 2, ... \}\).
The following terms are valid types over \(\Sigma\):

\begin{enumerate}
\item \typeterminal{<Seq Char>}\\ %\( \in \typenonterm{\emptyset}\)\\
"sequence of characters"
\item \typeterminal{<Seq <Digit 10> \(\sim\) Char>}\\ %\( \in \typenonterm{\emptyset}\)\\
"sequence of decimal digits, where each digit is represented as character"
\item \typeterminal{<Seq Item> \(\rightarrow \mathbb{N} \rightarrow\) Item}\\ %\( \in \typenonterm{\{Item\}}\)\\
"function that maps a sequence of items and a natural number to an item"\\
%Note: this type contains the free variable \typeterminal{Item}
\item \typeterminal{<Seq Char> \(\sim\) UTF-8 \(\rightarrow \mathbb{N} \rightarrow\) Char }\\ %\( \in \typenonterm{\emptyset}\)\\
"function that takes a sequence of chars, represented as UTF-8 string, and a natural number to return a character"
\item \typeterminal{\(\forall\) Radix . <Seq <Digit Radix> \(\sim\) Char>}\\ %\(\in \typenonterm{\emptyset} \)\\
"given the parameter \typeterminal{Radix}, a sequence of digits where each digit is represented as character"
%Note: this type-term is \emph{ground} (i.e. \(\typevars = \emptyset\)), since \typeterminal{Radix} is bound by \(\typeterminal{\forall}\)
\item \typeterminal{
	\(\forall\) SrcRadix.\\
	\(\forall\) DstRadix.\\
	\(\mathbb{N} \sim\) <PosInt SrcRadix> \(\sim\) <Seq <Digit SrcRadix> \(\sim\) Char>\\
	\(\rightarrow_{morph}\)\\
	\(\mathbb{N} \sim\) <PosInt DstRadix> \(\sim\) <Seq <Digit DstRadix> \(\sim\) Char>\\
}\\ %\(\in \typenonterm{\emptyset} \)\\
"morphism function that maps the \typeterminal{PosInt} representation of \(\typeterminal{\mathbb{N}}\) with radix \typeterminal{SrcRadix} to the \typeterminal{PosInt} representation of radix \typeterminal{DstRadix}"
\end{enumerate}
\end{example}


\begin{definition}[Substitution in Types]
Given a type-variable assignment \(\psi_t = \{ \metavariable{\alpha_1} \mapsto \metavariable{\tau_1}, \quad \metavariable{\alpha_2} \mapsto \metavariable{\tau_2}, \quad \dots \}\),
the thereby induced substitution \(\overline{\psi_t}\) replaces all \emph{free} occurences of the variables \(\metavariable{\alpha_i}\) in a type-term \(\metavariable{\xi} \in \nonterm{T}\) recursively with the type-term given by \(\psi_t(\metavariable{\alpha_i})\)
, while occurences of bound variables are left untouched.
Further, we assume that for all \(\tau_i\), all variable names are disjunct with the free variables of the term to which the substitution is applied.
Coq definition is at \hyperref[coq:subst-type]{subst.v:\ref{coq:subst-type}}.

\[\overline{\psi_t} \metavariable{\xi} = \begin{cases}
\metavariable{\xi} \quad \text{if } \metavariable{\xi} \in \typenames\\
\metavariable{\xi} \quad \text{if }  \metavariable{\xi} \in \{\metavariable{\alpha_1}, \metavariable{\alpha_2}, \dots\} \text{ and } \metavariable{\xi} \notin \text{Dom}(\psi_t)\\
\metavariable{\tau} \quad \text{if }  \metavariable{\xi} \in \{\metavariable{\alpha_1}, \metavariable{\alpha_2}, \dots\} \text{ and } (\metavariable{\xi} \mapsto \metavariable{\tau}) \in \psi_t\\
\typeterminal{\forall} \metavariable{\alpha} \typeterminal{.} \overline{\psi_t}\metavariable{\xi'} \quad \text{if } \metavariable{\xi} \text{ is of the form } \typeterminal{\forall}  \metavariable{\alpha} \typeterminal{.} \metavariable{\xi'} \text{ and } \metavariable{\alpha} \notin \text{Dom}(\psi_t)\\
\typeterminal{\forall} \metavariable{\alpha} \typeterminal{.} \overline{\psi_t \setminus \{\metavariable{\alpha} \mapsto \metavariable{\tau}\}}\metavariable{\xi'} \quad \text{if } \metavariable{\xi} \text{ is of the form } \typeterminal{\forall}  \metavariable{\alpha} \typeterminal{.} \metavariable{\xi'} \text{ and } \{\metavariable{\alpha} \mapsto \metavariable{\tau}\} \in \psi_t\\
\typeterminal{<} (\overline{\psi_t} \metavariable{\xi_1}) \quad (\overline{\psi_t} \metavariable{\xi_2}) \typeterminal{>} \quad \text{if } \metavariable{\xi} \text{ is of the form } \typeterminal{<} \metavariable{\xi_1} \quad \metavariable{\xi_2} \typeterminal{>}\\
(\overline{\psi_t} \metavariable{\xi_1}) \typeterminal{\rightarrow} (\overline{\psi_t} \metavariable{\xi_2}) \quad \text{if } \metavariable{\xi} \text{ is of the form } \metavariable{\xi_1} \typeterminal{\rightarrow} \metavariable{\xi_2}\\
(\overline{\psi_t} \metavariable{\xi_1}) \typeterminal{\rightarrow_{morph}} (\overline{\psi_t} \metavariable{\xi_2}) \quad \text{if } \metavariable{\xi} \text{ is of the form } \metavariable{\xi_1} \typeterminal{\rightarrow_{morph}} \metavariable{\xi_2}\\
(\overline{\psi_t} \metavariable{\xi_1}) \typeterminal{\sim} (\overline{\psi_t} \metavariable{\xi_2}) \quad \text{if } \metavariable{\xi} \text{ is of the form } \metavariable{\xi_1} \typeterminal{\sim} \metavariable{\xi_2}\\
\end{cases}\]

\[\overline{\psi_t} \metavariable{e} = \begin{cases}
\metavariable{e} \quad \text{ if } \metavariable{e} \text{ is a variable}
\\

\exprterminal{\text{let } \metavariable{x} = }\overline{\psi_t}\metavariable{a} \exprterminal{\text{ in }} \overline{\psi_t}\metavariable{e'}
\quad \text{ if \metavariable{e} is of the form }
\exprterminal{\text{let } \metavariable{x} = \metavariable{a} \text{ in } \metavariable{e'}}
\\

\exprterminal{\Lambda \metavariable{\alpha} \mapsto} \overline{\psi_t}\metavariable{e'} 
\quad \text{ if \metavariable{e} is of the form } \exprterminal{\Lambda \metavariable{\alpha} \mapsto \metavariable{e'}}
\\

\exprterminal{\lambda \metavariable{x} : }\overline{\psi_t}\metavariable{\tau} \exprterminal{\mapsto} \overline{\psi_t}\metavariable{e'} 
\quad \text{ if \metavariable{e} is of the form } \exprterminal{\lambda \metavariable{x} : \metavariable{\tau} \mapsto \metavariable{e'}}
\\

\exprterminal{\lambda \metavariable{x} : }\overline{\psi_t}\metavariable{\tau} \exprterminal{\mapsto_\text{morph}} \overline{\psi_t}\metavariable{e'} 
\quad \text{ if \metavariable{e} is of the form } \exprterminal{\lambda \metavariable{x} : \metavariable{\tau} \mapsto_\text{morph} \metavariable{e'}}
\\

\overline{\psi_t} \metavariable{e'} \overline{\psi_t}\metavariable{\tau}
\quad \text{ if \metavariable{e} is of the form }
\exprterminal{( \metavariable{e'} \metavariable{\tau} )}
\\

\overline{\psi_t} \metavariable{e_1} \overline{\psi_t} \metavariable{e_2}
\quad \text{ if \metavariable{e} is of the form }
\exprterminal{(\metavariable{e_1} \metavariable{e_2})}
\\

\overline{\psi_t} \metavariable{e'} \exprterminal{\text{ as }} \overline{\psi_t}\metavariable{\tau}
\quad \text{ if \metavariable{e} is of the form }
\exprterminal{ \metavariable{e'} \text{ as } \metavariable{\tau} }

\end{cases}\]


\end{definition}





\begin{definition}[Substitution in Expressions]
\todo{complete}
Given an expression-variable assignment \(\psi_e = \{ \metavariable{x_1} \mapsto \metavariable{t_1}, \quad \metavariable{x_2} \mapsto \metavariable{t_2}, \quad \dots \}\),
the thereby induced substitution \(\overline{\psi_e}\) replaces all \emph{free} occurences of the expression variables \(\metavariable{x_i}\)
in an expression \(e \in \nonterm{E} \) with the \(\psi_e(\metavariable{x_i})\)

\[\overline{\psi_e} \metavariable{e} = \begin{cases}

\metavariable{e} \quad \text{if } \metavariable{e} \in \exprvars \text{ and } \metavariable{e} \notin \text{Dom}(\psi_e)\\
\metavariable{t} \quad \text{if } \metavariable{e} \in \exprvars \text{ and } (\metavariable{e}\mapsto\metavariable{t}) \in \psi_e\\

\exprterminal{\text{let } \metavariable{x} \text{ = }} \overline{\psi_e}\metavariable{a} \exprterminal{\text{ in }} \overline{\psi_e}\metavariable{e'}
\quad \text{if }
\\

\exprterminal{\lambda\metavariable{x}:\metavariable{\tau} \mapsto }  \overline{\psi_e} \metavariable{e'}
\quad \text{if \metavariable{e} is of the form }
\exprterminal{\lambda\metavariable{x}:\metavariable{\tau} \mapsto \metavariable{e'}}
\text{ and } \metavariable{x} \notin \text{Dom}(\psi_e)
\\

\exprterminal{\lambda\metavariable{x}:\metavariable{\tau} \mapsto }  \overline{\psi_e \setminus \{\metavariable{x} \mapsto \metavariable{t}\}} \metavariable{e'}
\quad \text{if \metavariable{e} is of the form }
\exprterminal{\lambda\metavariable{x}:\metavariable{\tau} \mapsto \metavariable{e'}}
\text{ and } (\metavariable{x}\mapsto\metavariable{t}) \in \psi_e
\\


\end{cases}\]

\end{definition}

\subsection{Typing}

\subsubsection{Equivalence of Type Terms}

%We want distributivity of ladders over type-specialization as well as over function/morphism types.
\begin{definition}[Distributivity in Types]

\begin{mathpar}
\typeterminal{< \metavariable{\sigma}\sim\metavariable{\sigma'} \quad \metavariable{\tau} >}
\rightarrow_\text{distribute}
\typeterminal{< \metavariable{\sigma} \quad \metavariable{\tau} > \sim < \metavariable{\sigma'} \quad \metavariable{\tau} > }

\typeterminal{< \metavariable{\sigma} \quad \metavariable{\tau}\sim\metavariable{\tau'} >}
\rightarrow_\text{distribute}
\typeterminal{< \metavariable{\sigma} \quad \metavariable{\tau} > \sim < \metavariable{\sigma} \quad \metavariable{\tau'} > }

\typeterminal{ \metavariable{\sigma}\sim\metavariable{\sigma'} \rightarrow \metavariable{\tau} }
\rightarrow_\text{distribute}
\typeterminal{ (\metavariable{\sigma} \rightarrow \metavariable{\tau} ) \sim ( \metavariable{\sigma'} \rightarrow \metavariable{\tau} ) }

\typeterminal{ \metavariable{\sigma} \rightarrow \metavariable{\tau}\sim\metavariable{\tau'} }
\rightarrow_\text{distribute}
\typeterminal{ (\metavariable{\sigma} \rightarrow \metavariable{\tau} ) \sim ( \metavariable{\sigma} \rightarrow \metavariable{\tau'} ) }

\typeterminal{ \metavariable{\sigma}\sim\metavariable{\sigma'} \rightarrow_\text{morph} \metavariable{\tau} }
\rightarrow_\text{distribute}
\typeterminal{ (\metavariable{\sigma} \rightarrow_\text{morph} \metavariable{\tau} ) \sim ( \metavariable{\sigma'} \rightarrow_\text{morph} \metavariable{\tau} ) }

\typeterminal{ \metavariable{\sigma} \rightarrow_\text{morph} \metavariable{\tau}\sim\metavariable{\tau'} }
\rightarrow_\text{distribute}
\typeterminal{ (\metavariable{\sigma} \rightarrow_\text{morph} \metavariable{\tau} ) \sim ( \metavariable{\sigma} \rightarrow_\text{morph} \metavariable{\tau'} ) }

\end{mathpar}


Let \(\rightarrow_\text{condense}\) be the inverse to \(\rightarrow_\text{distribute}\).

See \hyperref[coq:type-dist]{equiv.v:\ref{coq:type-dist}}.
\end{definition}

\begin{definition}[Alpha Conversion in Types]
\begin{mathpar}
\typeterminal{\forall \metavariable{\alpha} . \metavariable{\tau}}
\rightarrow_{\alpha}
\typeterminal{\forall \metavariable{\alpha'} . } \{ \metavariable{\alpha} \mapsto \metavariable{\alpha'} \} \metavariable{\tau}

\end{mathpar}
\end{definition}

\begin{definition}[Equivalence Relation]
Transitive closure over \(\rightarrow_\text{distribute}\), \(\rightarrow_\text{condense}\) and \(\rightarrow_\alpha\).


\begin{mathpar}

\inferrule[T-Eq-Refl]{
	\metavariable{\tau} \in \nonterm{T}
}{
	\metavariable{\tau} \equiv \metavariable{\tau}
}\and
\inferrule[T-Eq-Trans]{
	\metavariable{\tau_1} \equiv \metavariable{\tau_2}\\
	\metavariable{\tau_2} \equiv \metavariable{\tau_3}
}{
	\metavariable{\tau_1} \equiv \metavariable{\tau_3}
}

\inferrule[T-Eq-Alpha]{
	\metavariable{\tau_1} \rightarrow_\alpha \metavariable{\tau_2}
}{
	\metavariable{\tau_1} \equiv \metavariable{\tau_2}
}

\inferrule[T-Eq-Distribute]{
	\metavariable{\tau_1} \rightarrow_\text{distribute} \metavariable{\tau_2}
}{
	\metavariable{\tau_1} \equiv \metavariable{\tau_2}
}\and
\inferrule[T-Eq-Condense]{
	\metavariable{\tau_1} \rightarrow_\text{condense} \metavariable{\tau_2}
}{
	\metavariable{\tau_1} \equiv \metavariable{\tau_2}
}

\end{mathpar}

See \hyperref[coq:type-equiv]{equiv.v:\ref{coq:type-equiv}}.
\end{definition}


\begin{lemma}[Symmetry of \(\equiv\)]

\begin{mathpar}
\inferrule[T-Eq-Symm]{
	\metavariable{\tau_1} \equiv \metavariable{\tau_2}
}{
	\metavariable{\tau_2} \equiv \metavariable{\tau_1}
}
\end{mathpar}

\begin{proof}
\(\rightarrow_{distribute}\) is the inverse of \(\rightarrow_{condense}\) and \(\rightarrow_{\alpha}\) is symmetric by itself.
\end{proof}

\end{lemma}

\subsubsection{Normal Forms}

\begin{definition}[Ladder Normal Form]
LNF is reached by exhaustive application of \(\rightarrow_\text{distribute}\).
\end{definition}

\begin{definition}[Parameter Normal Form]
PNF reached by exhaustive application of \(\rightarrow_\text{condense}\).
\end{definition}

\subsubsection{Subtype Relations}

We define two relations: first the representation subtype relation \(\leq\) and second the transformation subtype relation \(\precsim\).

\begin{definition}[Representation Subtype (\(\tau_1\leq\tau_2\))]
\begin{mathpar}
\inferrule[TSubRepr-Refl]{	
	\metavariable{\tau} \equiv \metavariable{\tau'}
}{
	\metavariable{\tau} \leq \metavariable{\tau'}
}

\inferrule[TSubRepr-Trans]{	
	\metavariable{\sigma} \leq \metavariable{\tau}\\
	\metavariable{\tau} \leq \metavariable{\nu}
}{
	\metavariable{\sigma} \leq \metavariable{\nu}
}

\inferrule[TSubRepr-Ladder]{
	\metavariable{\sigma} \leq \metavariable{\tau}
}{
	\metavariable{\sigma'} \typeterminal{\sim} \metavariable{\sigma} \leq \metavariable{\tau}
}
\end{mathpar}
\end{definition}

\begin{definition}[Transformation Subtype (\(\tau_1\precsim\tau_2\))]
\begin{mathpar}
\inferrule[TSub-Refl]{	
	\metavariable{\tau} \equiv \metavariable{\tau'}
}{
	\metavariable{\tau} \precsim \metavariable{\tau'}
}\and
\inferrule[TSub-Trans]{	
	\metavariable{\sigma} \precsim \metavariable{\tau}\\
	\metavariable{\tau} \precsim \metavariable{\nu}
}{
	\metavariable{\sigma} \precsim \metavariable{\nu}
}

\\

\inferrule[TSub-Ladder]{
	\metavariable{\sigma} \precsim \metavariable{\tau}
}{
	\metavariable{\sigma'} \typeterminal{\sim} \metavariable{\sigma} \precsim \metavariable{\tau}
}\and
\inferrule[TSub-Morph]{
	\metavariable{\sigma} \equiv \metavariable{\tau}
}{
	\metavariable{\sigma} \typeterminal{\sim} \metavariable{\sigma'} \precsim \metavariable{\tau} \typeterminal{\sim} \metavariable{\tau'}
}
\end{mathpar}
\end{definition}


\begin{example}[Representation \& Transformation Subtypes]$\\$

\begin{enumerate}
\item \typeterminal{ <Digit 10> \(\sim\) Char \( \quad \leq \quad \) Char }\\
.. is a \emph{representation subtype}, because the representation of \typeterminal{<Digit 10>} is \emph{embedded} into \typeterminal{Char}.\\

\item \typeterminal{ <Digit 10> \(\sim\) Char \( \quad \precsim \quad \) <Digit 10> \(\sim\) machine.UInt64}\\
.. is a \emph{transformation subtype}, because the \typeterminal{Char} based representation can be transformed into a representation based on \typeterminal{machine.UInt64},
while preserving its semantics.
\end{enumerate}
\end{example}

\subsubsection{Typing Context}

As usual, the typing-context \(\Gamma = \{ \metavariable{x_1} : \metavariable{\tau_1} , \quad \metavariable{x_2} : \metavariable{\tau_2} , \quad \ldots \}\)
is a finite mapping which assigns variables \(\metavariable{x_i} \in \exprvars\) to types \(\metavariable{\tau_i} \in \nonterm{T}\).

%Using the inference rules given in \ref{def:pathrules} \ref{def:typerules}, further typing-judgements
%of the form \(\Gamma \vdash \metavariable{e} : \metavariable{\tau} \quad\) read as "expression \(\metavariable{e}\) is of type \(\metavariable{\tau}\)"
%can be derived from the context \(\Gamma\) where \(\metavariable{e} \in \nonterm{E}\) and \(\metavariable{\tau} \in \nonterm{T}\).

\subsubsection{Morphism Graph}
Every typing context \(\Gamma\) implies a \emph{Morphism Graph}, a directed graph whose vertices are types
and the edges represent a type-transformations, as defined by morphisms.
A type \(\metavariable{\tau}\) can be implicitly coerced into a type \(\metavariable{\tau'}\),
provided there is a path from \(\metavariable{\tau}\) to \(\metavariable{\tau'}\) in the \emph{Morphism-Graph} of \(\Gamma\),
written as \(\Gamma  \vdash \metavariable{\tau} \leadsto \metavariable{\tau'}\).

\begin{definition}[Morphism Paths]
\label{def:pathrules}
\begin{mathpar}

	\inferrule[M-Sub]{
		\metavariable{\tau} \leq \metavariable{\tau'}
	}{
		\Gamma \vdash \metavariable{\tau} \leadsto \metavariable{\tau'}
	}

	\inferrule[M-Single]{
		(\metavariable{h} : \metavariable{\tau} \typeterminal{\rightarrow_\text{morph}} \metavariable{\tau'}) \in \Gamma
	}{
		\Gamma \vdash \metavariable{\tau} \leadsto \metavariable{\tau'}
	}

	\inferrule[M-Chain]{
		\Gamma \vdash \metavariable{\tau} \leadsto \metavariable{\tau'}\\
		\Gamma \vdash \metavariable{\tau'} \leadsto \metavariable{\tau''}
	}{
		\Gamma \vdash \metavariable{\tau} \leadsto \metavariable{\tau''}
	}
	
	\inferrule[M-MapSeq]{
		\Gamma \vdash \metavariable{\tau} \leadsto \metavariable{\tau'}
	}{
		\Gamma \vdash
		\typeterminal{\langle\text{Seq } \metavariable{\tau}\rangle} \leadsto
		\typeterminal{\langle\text{Seq } \metavariable{\tau'}\rangle}
	}
\end{mathpar}

\end{definition}

\begin{example}[Morphism Graph]
Assume \(\Gamma := \{\\
	\exprterminal{\text{degrees-to-turns}} : \typeterminal{\text{Angle}\sim\text{Degrees}\sim\mathbb{R} \rightarrow_\text{morph} \text{Angle}\sim\text{Turns}\sim\mathbb{R}},\\
	\exprterminal{\text{turns-to-radians}} : \typeterminal{\text{Angle}\sim\text{Turns}\sim\mathbb{R} \rightarrow_\text{morph} \text{Angle}\sim\text{Radians}\sim\mathbb{R}},\\
\}\).
Then
\begin{itemize}
\item \(\Gamma \vdash \typeterminal{\text{Angle}\sim\text{Degrees}\sim\mathbb{R}} \leadsto \typeterminal{\mathbb{R}}\) (by \textsc{M-Sub})
\item \(\Gamma \vdash \typeterminal{\text{Angle}\sim\text{Degrees}\sim\mathbb{R}} \leadsto \typeterminal{\text{Angle}\sim\text{Radians}\sim\mathbb{R}}\) (by \textsc{M-Chain})
\item \(\Gamma \vdash \typeterminal{\langle\text{Seq }\text{Angle}\sim\text{Degrees}\sim\mathbb{R}\rangle} \leadsto \typeterminal{\langle\text{Seq }\text{Angle}\sim\text{Radians}\sim\mathbb{R}\rangle}\) (by \textsc{M-MapSeq})
\end{itemize}

\end{example}


\begin{definition}[Typing Relation]

\label{def:typerules}
\begin{mathpar}

	\inferrule[T-Variable]{
		\metavariable{x}:\metavariable{\tau} \in \Gamma\\
	}{
		\Gamma \vdash \metavariable{x}:\metavariable{\tau}
	}\and

	\inferrule[T-LetBinding]{
		\Gamma \vdash \metavariable{e} : \metavariable{\sigma} \\
		\Gamma , \metavariable{x}:\metavariable{\sigma} \vdash \metavariable{t} : \metavariable{\tau}
	}{
		\Gamma \vdash (\exprterminal{\text{let }}\metavariable{x}\exprterminal{\text{ = }}\metavariable{e}\exprterminal{\text{ in }} \metavariable{t}) : \metavariable{\tau}
	}

	\inferrule[T-TypeAbs]{
		\Gamma \vdash \metavariable{e} : \metavariable{\tau} \\
	}{
        \Gamma \vdash (\exprterminal{\Lambda} \metavariable{\alpha} \exprterminal{\mapsto} \metavariable{e}) : \typeterminal{\forall}\metavariable{\alpha}\typeterminal{.}\metavariable{\tau}
	}

	\inferrule[T-TypeApp]{
		\Gamma \vdash \metavariable{e} : \typeterminal{\forall} \metavariable{\alpha} \typeterminal{.} \metavariable{\tau} \\
		\metavariable{\sigma} \in \nonterm{T}
	}{
		\Gamma \vdash ( \metavariable{e} \quad \metavariable{\sigma} ) : \{\metavariable{\alpha} \mapsto \metavariable{\sigma}\} \metavariable{\tau}
	}

	\inferrule[T-Abs]{
		\Gamma,\metavariable{x}:\metavariable{\sigma} \vdash \metavariable{e} : \metavariable{\tau} \\
	}{
        \Gamma \vdash (\exprterminal{\lambda} \metavariable{x} \exprterminal{:} \metavariable{\sigma} \exprterminal{\mapsto} \metavariable{e}) : \metavariable{\sigma}\typeterminal{\rightarrow}\metavariable{\tau}
	}

	\inferrule[T-MorphAbs]{
		\Gamma,\metavariable{x}:\metavariable{\tau} \vdash \metavariable{e} : \metavariable{\tau'} \\
		\metavariable{\tau} \precsim \metavariable{\tau'}
	}{
        \Gamma \vdash (\exprterminal{\lambda} \metavariable{x} \exprterminal{:} \metavariable{\tau} \exprterminal{\mapsto_{morph}} \metavariable{e}) : \metavariable{\tau}\typeterminal{\rightarrow_{morph}}\metavariable{\tau'}
	}\and

	\inferrule[T-App]{
		\Gamma \vdash \metavariable{f} : \metavariable{\sigma} \typeterminal{\rightarrow} \metavariable{\tau}\\
		\Gamma \vdash \metavariable{a} : \metavariable{\sigma'}\\
		\Gamma \vdash \metavariable{\sigma'} \leadsto \metavariable{\sigma}
	}{
		\Gamma \vdash (\metavariable{f} \quad \metavariable{a}) : \metavariable{\tau}
	}\and

	\inferrule[T-MorphFun]{
        \Gamma \vdash \metavariable{f} : \metavariable{\sigma}\typeterminal{\rightarrow_{morph}}\metavariable{\tau}
	}{
        \Gamma \vdash \metavariable{f} : \metavariable{\sigma}\typeterminal{\rightarrow}\metavariable{\tau}
	}\and

	\inferrule[T-Ascension]{
		\Gamma \vdash \metavariable{e} : \metavariable{\tau} \\
		\metavariable{\tau'} \leq \metavariable{\tau}
	}{
		\Gamma \vdash (\metavariable{e} \exprterminal{\text{ as }} \metavariable{\tau'}) : \metavariable{\tau'}
	}\and

	\inferrule[T-Descension]{
		\Gamma \vdash \metavariable{e} : \metavariable{\tau}\\
		\metavariable{\tau} \leq \metavariable{\tau'}
	}{
		\Gamma \vdash \metavariable{e} : \metavariable{\tau'}
	}

\end{mathpar}
\end{definition}


\begin{definition}[Well-Typedness]
An expression \(\metavariable{e} \in \nonterm{E}\) is \textbf{well-typed} if there exist \(\Gamma\) and \(\metavariable{\tau}\)
such that \( \Gamma \vdash \metavariable{e} : \metavariable{\tau} \) by \ref{def:typerules}.
\end{definition}

\subsection{Coercion Semantics}
%We define the translation function \(\llbracket . \rrbracket\) which translates morphism-paths into
%expressions that define a transformation function, and also translates type-derivations into expressions with expanded type coercions.


%which completes a \emph{semantically well-typed} expression
%by inserting all required coercions based on the typing derivation of the expression.
%The result shall be a \emph{syntactically well-typed} expression.

We write \(C :: \tau \leadsto \tau'\) to mean "C is a morphism-path derivation tree whose conclusion is \(\tau \leadsto \tau'\)".
Similarly, we write \(D :: \Gamma \vdash e : \tau\) to mean "D is a typing derivation whose conclusion is \(\Gamma \vdash e : \tau\)"

\begin{definition}[Morphism Translation]
%Translates a morphism-path derivation into an expression that defines a coercion function

\begin{mathpar}

\Big{\llbracket}
	\inferrule[M-Sub]{
		\metavariable{\tau} \leq \metavariable{\tau'}
	}{
		\Gamma \vdash \metavariable{\tau} \leadsto \metavariable{\tau'}
	}
\Big{\rrbracket} = \exprterminal{\lambda x:\metavariable{\tau} \mapsto x}
\and

\Big{\llbracket}
	\inferrule[M-Single]{
		(\metavariable{h} : \metavariable{\tau} \typeterminal{\rightarrow_\text{morph}} \metavariable{\tau'}) \in \Gamma
	}{
		\Gamma \vdash \metavariable{\tau} \leadsto \metavariable{\tau'}
	}
\Big{\rrbracket} = \metavariable{h}
\and


\Big{\llbracket}
	\inferrule[M-Chain]{
		C_1 :: \Gamma \vdash \metavariable{\tau} \leadsto \metavariable{\tau'}\\
		C_2 :: \Gamma \vdash \metavariable{\tau'} \leadsto \metavariable{\tau''}
	}{
		\Gamma \vdash \metavariable{\tau} \leadsto \metavariable{\tau''}
	}
\Big{\rrbracket} = \exprterminal{\lambda \text{x}:\metavariable{\tau} \mapsto}
		\Big{\llbracket} C_2 \Big{\rrbracket}
		\exprterminal{(}\Big{\llbracket} C_1 \Big{\rrbracket} \exprterminal{\text{x})}
\and


\Big{\llbracket}
	\inferrule[M-MapSeq]{
		C_1 :: \Gamma \vdash \metavariable{\tau} \leadsto \metavariable{\tau'}
	}{
		\Gamma \vdash
		\typeterminal{\langle\text{Seq } \metavariable{\tau}\rangle} \leadsto
		\typeterminal{\langle\text{Seq } \metavariable{\tau'}\rangle}
	}
\Big{\rrbracket} = \exprterminal{\lambda \text{xs}:\typeterminal{\langle\text{Seq }\metavariable{\tau}\rangle} \mapsto}
		\exprterminal{( \text{map}} \Big{\llbracket} C_1 \Big{\rrbracket} \exprterminal{\text{xs})}

\end{mathpar}
\end{definition}

\begin{definition}[Expression Translation]
%Translates a type-derivation tree into a fully expanded expression

\begin{mathpar}
\Big{\llbracket} \inferrule[T-Variable]{
	\metavariable{x}:\metavariable{\tau} \in \Gamma
}{
	\Gamma \vdash \metavariable{x}:\metavariable{\tau}
}\Big{\rrbracket} = \metavariable{x}
\and

\Big{\llbracket} \inferrule[T-LetBinding]{
	D_1 ::\Gamma \vdash \metavariable{e} : \metavariable{\sigma} \\
	D_2 :: \Gamma , \metavariable{x}:\metavariable{\sigma} \vdash \metavariable{t} : \metavariable{\tau}
}{
	\Gamma \vdash (\exprterminal{\text{let }}\metavariable{x}\exprterminal{\text{ = }}\metavariable{e}\exprterminal{\text{ in }} \metavariable{t}) : \metavariable{\tau}
}\Big{\rrbracket} = \exprterminal{\text{let }\metavariable{x} = }
\Big{\llbracket} D_1 \Big{\rrbracket}
\exprterminal{\text{ in }}
\Big{\llbracket} D_2 \Big{\rrbracket}
\and


\Big{\llbracket} 
	\inferrule[T-TypeAbs]{
		D_1 :: \Gamma \vdash \metavariable{e} : \metavariable{\tau} \\
	}{
        \Gamma \vdash (\exprterminal{\Lambda} \metavariable{\alpha} \exprterminal{\mapsto} \metavariable{e}) : \typeterminal{\forall}\metavariable{\alpha}\typeterminal{.}\metavariable{\tau}
	}
\Big{\rrbracket} = \exprterminal{\Lambda \metavariable{\alpha} \mapsto} \Big{\llbracket} D_1 \Big{\rrbracket}
\and


\Big{\llbracket}
	\inferrule[T-TypeApp]{
		D_1 :: \Gamma \vdash \metavariable{e} : \typeterminal{\forall} \metavariable{\alpha} \typeterminal{.} \metavariable{\tau} \\
		\metavariable{\sigma} \in \nonterm{T}
	}{
		\Gamma \vdash ( \metavariable{e} \quad \metavariable{\sigma} ) : \{\metavariable{\alpha} \mapsto \metavariable{\sigma}\} \metavariable{\tau}
	}
\Big{\rrbracket} =
\exprterminal{(}
\Big{\llbracket}
D_1
\Big{\rrbracket}
\metavariable{\sigma}
\exprterminal{)}
\and


\Big{\llbracket}
	\inferrule[T-Abs]{
		D_1 :: \Gamma,\metavariable{x}:\metavariable{\sigma} \vdash \metavariable{e} : \metavariable{\tau} \\
	}{
        \Gamma \vdash (\exprterminal{\lambda} \metavariable{x} \exprterminal{:} \metavariable{\sigma} \exprterminal{\mapsto} \metavariable{e}) : \metavariable{\sigma}\typeterminal{\rightarrow}\metavariable{\tau}
	}
\Big{\rrbracket} = 
\exprterminal{\lambda} \metavariable{x} \exprterminal{:} \metavariable{\sigma}
\exprterminal{\mapsto} \Big{\llbracket}D_1\Big{\rrbracket}
\and


\Big{\llbracket}
	\inferrule[T-MorphAbs]{
		D_1 :: \Gamma,\metavariable{x}:\metavariable{\tau} \vdash \metavariable{e} : \metavariable{\tau'} \\
		\metavariable{\tau} \precsim \metavariable{\tau'}
	}{
        \Gamma \vdash (\exprterminal{\lambda} \metavariable{x} \exprterminal{:} \metavariable{\tau} \exprterminal{\mapsto_{morph}} \metavariable{e}) : \metavariable{\tau}\typeterminal{\rightarrow_\text{morph}}\metavariable{\tau'}
	}
\Big{\rrbracket} = 
\exprterminal{\lambda} \metavariable{x} \exprterminal{:} \metavariable{\tau}
\exprterminal{\mapsto_\text{morph}} \Big{\llbracket}D_1\Big{\rrbracket}
\and



\Big{\llbracket}
	\inferrule[T-App]{
		D_1 :: \Gamma \vdash \metavariable{f} : \metavariable{\sigma} \typeterminal{\rightarrow} \metavariable{\tau}\\
		D_2 :: \Gamma \vdash \metavariable{a} : \metavariable{\sigma'}\\\\
		C :: \Gamma \vdash \metavariable{\sigma'} \leadsto \metavariable{\sigma}
	}{
		\Gamma \vdash (\metavariable{f} \quad \metavariable{a}) : \metavariable{\tau}
	}
\Big{\rrbracket} =
	\Big{\llbracket}D_1\Big{\rrbracket}
	\exprterminal{(}
	\Big{\llbracket}C\Big{\rrbracket}
	\Big{\llbracket}D_2\Big{\rrbracket}
	\exprterminal{)}
\and

\Big{\llbracket}
	\inferrule[T-MorphFun]{
        D_1 :: \Gamma \vdash \metavariable{f} : \metavariable{\sigma}\typeterminal{\rightarrow_{morph}}\metavariable{\tau}
	}{
        \Gamma \vdash \metavariable{f} : \metavariable{\sigma}\typeterminal{\rightarrow}\metavariable{\tau}
	}
\Big{\rrbracket} = \Big{\llbracket} D_1 \Big{\rrbracket}
\and

\Big{\llbracket}
	\inferrule[T-Ascension]{
		D_1 :: \Gamma \vdash \metavariable{e} : \metavariable{\tau} \\
		\metavariable{\tau'} \leq \metavariable{\tau}
	}{
		\Gamma \vdash (\metavariable{e} \exprterminal{\text{ as }} \metavariable{\tau'}) : \metavariable{\tau'}
	}
\Big{\rrbracket} =
	\Big{\llbracket}D_1\Big{\rrbracket} \exprterminal{\text{ as }} \metavariable{\tau'}
\and


\Big{\llbracket}
	\inferrule[T-Descension]{
		D_1 :: \Gamma \vdash \metavariable{e} : \metavariable{\tau}\\
		\metavariable{\tau} \leq \metavariable{\tau'}
	}{
		\Gamma \vdash \metavariable{e} : \metavariable{\tau'}
	}
\Big{\rrbracket} =
	\Big{\llbracket}
		D_1
	\Big{\rrbracket}


\end{mathpar}
\end{definition}




\subsection{Evaluation}

Evaluation of an expression \(\metavariable{e} \in \nonterm{E}\) is defined by exhaustive application of the rewrite rule \(\rightarrow_\beta\) as in \ref{def:evalrules}.

\begin{definition}[Inference Rules for Evaluation]
\label{def:evalrules}

\begin{mathpar}

	\inferrule[E-App1]{
		\metavariable{e_1} \rightarrow_\beta \metavariable{e_1'}
	}{
		\metavariable{e_1} \metavariable{e_2}
		\rightarrow_\beta
		\metavariable{e_1'} \metavariable{e_2}
	}\and

	\inferrule[E-App2]{
		\metavariable{e_2} \rightarrow_\beta \metavariable{e_2'}
	}{
		\metavariable{v_1} \metavariable{e_2}
		\rightarrow_\beta
		\metavariable{v_1} \metavariable{e_2'}
	}\and

	\inferrule[E-TypApp]{
%		\metavariable{\tau} \in \typenonterm{\emptyset}\\
		\metavariable{e} \rightarrow_\beta \metavariable{e'}
	}{
		\metavariable{e}
		\metavariable{\tau}
		\rightarrow_\beta
		\metavariable{e'}
		\metavariable{\tau}
	}

	\newline

	\inferrule[E-TypAppLam]{
	}{
		\exprterminal{(\Lambda} \metavariable{\alpha}
		\exprterminal{\mapsto} \metavariable{e}
		\exprterminal{)}
		\metavariable{\tau}
		\rightarrow_\beta
		\{ \metavariable{\alpha} \mapsto \metavariable{\tau} \} \metavariable{e}
	}\and
	\inferrule[E-AppLam]{
	}{
		\exprterminal{(\lambda} \metavariable{x}
		\exprterminal{:} \metavariable{\sigma}
		\exprterminal{\mapsto} \metavariable{e}
		\exprterminal{)}
		\metavariable{a}
		\rightarrow_\beta
		\{ \metavariable{x} \mapsto \metavariable{a} \} \metavariable{e}
	}\and

	\inferrule[E-AppLet]{
	}{
		\exprterminal{\text{let }}\metavariable{x}
		\exprterminal{\text{ = }}\metavariable{a}
		\exprterminal{\text{ in }}\metavariable{e}
		\rightarrow_\beta
		\{ \metavariable{x} \mapsto \metavariable{a} \} \metavariable{e}
	}

	\inferrule[E-AppLamAscribe]{
	}{
		\exprterminal{(( \lambda \metavariable{x}:\metavariable{\sigma} \mapsto \metavariable{e} )}
		\exprterminal{\text{ as }}
		\typeterminal{\metavariable{\tau}}
		\exprterminal{)}
		\metavariable{a}
		\rightarrow_\beta
		\exprterminal{( \lambda \metavariable{x}:\metavariable{\sigma} \mapsto \metavariable{e} )}
		\metavariable{a}
	}
\end{mathpar}
\end{definition}


\subsection{Soundness}

\begin{lemma}[Preservation]
\label{lemma:preservation}
Assume the expression \(\metavariable{e}\) is well typed,
i.e. there is a type-derivation tree
\(D :: \Gamma \vdash \metavariable{e} : \metavariable{\tau}\)
for some type \(\metavariable{\tau}\) and context \(\Gamma\).

Then forall \(\metavariable{e'}\) with \(\llbracket D \rrbracket \rightarrow_{\beta} \metavariable{e'}\)
it holds that \(\Gamma \vdash \metavariable{e'} : \metavariable{\tau}\) as well.

\begin{proof}
\todo{}
\end{proof}
\end{lemma}

\begin{lemma}[Progress]
\label{lemma:progress}
Assume the expression \(\metavariable{e}\) is well typed,
i.e. there is a type-derivation tree
\(D :: \Gamma \vdash \metavariable{e} : \metavariable{\tau}\)
for some type \(\metavariable{\tau}\) and context \(\Gamma\).

Then either \(\metavariable{e}\) is a value
or there exists some \(\metavariable{e'}\) such that \(\llbracket D \rrbracket \rightarrow_{\beta} \metavariable{e'}\)

\begin{proof}
\todo{}
\end{proof}
\end{lemma}

\begin{theorem}[Soundness]
\label{theorem:semantic-soundness}
No well-typed expression is stuck.

Assume the typing derivation \(D :: \Gamma \vdash \metavariable{e}:\metavariable{\tau}\).
Then it never occurs that \(\llbracket D \rrbracket \rightarrow_{\beta}^{*} \metavariable{e'}\) where \metavariable{e'} is in normal form but not a value.

\begin{proof}
\todo{}
%Assume the typing derivation \(D :: \Gamma \vdash \metavariable{e}:\approx\metavariable{\tau}\).
%By \ref{lemma:translation}, \(\Gamma \vdash \llbracket D \rrbracket : \metavariable{\tau}\)
%and thus it follows by \ref{theorem:syntactic-soundness} that \metavariable{e} is not stuck.
\end{proof}
\end{theorem}



\newpage
\section{Boehm-Berarducci Encoding}


\newcommand{\typvar}[1]{\textcolor{Emerald}{#1}}
\newcommand{\expvar}[1]{\textcolor{MidnightBlue}{#1}}


\subsection{Booleans}

\begin{definition}
Let \(\Sigma = \{ \text{Bool}, \text{BB-Bool} \}\).

\begin{itemize}
\item let {\textcolor{magenta}{bb-true}} = \exprterminal{\((\Lambda\typvar{\alpha}\mapsto\lambda\expvar{t}:\typvar{\alpha}\mapsto\lambda\expvar{f}:\typvar{\alpha}\mapsto\expvar{t})\) as} \typeterminal{Bool \(\sim\) BB-Bool}
\item let {\textcolor{magenta}{bb-false}} = \exprterminal{\((\Lambda\typvar{\alpha}\mapsto\lambda\expvar{t}:\typvar{\alpha}\mapsto\lambda\expvar{f}:\typvar{\alpha}\mapsto\expvar{f})\) as} \typeterminal{Bool \(\sim\) BB-Bool}
\end{itemize}

\end{definition}

\begin{lemma}
{\textcolor{magenta}{bb-true}} and {\textcolor{magenta}{bb-false}} are \emph{values}.

\begin{proof}
\todo{}
\end{proof}
\end{lemma}

\subsection{Conditionals}

\begin{itemize}
\item let {\textcolor{magenta}{bb-if}} = \exprterminal{
	\(\Lambda\typvar{\alpha}\)\\
	\(\mapsto\lambda\) \expvar{cond} : \typeterminal{ Bool \(\sim\) BB-Bool \(\sim \forall\typvar{\beta}.(\typvar{\beta}\rightarrow\typvar{\beta}\rightarrow\typvar{\beta})\)}\\
	\(\mapsto\lambda\) \expvar{then} : \(\typvar{\alpha}\)\\
	\(\mapsto\lambda\) \expvar{else} : \(\typvar{\alpha}\)\\
	\(\mapsto\) \expvar{cond} \typvar{\(\alpha\)} \expvar{then} \expvar{else}
}
\end{itemize}

\subsection{Natural Numbers}
\begin{definition}

Let \(\Sigma = \{ \mathbb{N}, \text{BB-Nat}\}\).

\begin{itemize}
\item let {\textcolor{magenta}{bb-zero}} = \(\exprterminal{( \Lambda \typvar{\alpha} \mapsto \lambda \expvar{s} : \typeterminal{\typvar{\alpha} \rightarrow \typvar{\alpha}} \mapsto \lambda \expvar{z} : \typvar{\alpha} \mapsto \expvar{z} ) \text{ as } }\)
\typeterminal{\(\mathbb{N} \sim \text{BB-Nat} \sim \forall \typvar{\alpha} . (\typvar{\alpha} \rightarrow \typvar{\alpha}) \rightarrow \typvar{\alpha} \rightarrow \typvar{\alpha} \)}


\item let {\textcolor{magenta}{bb-one}} = \(\exprterminal{(\Lambda \typvar{\alpha} \mapsto \lambda \expvar{s} : \typeterminal{\typvar{\alpha} \rightarrow \typvar{\alpha}} \mapsto \lambda \expvar{z} : \typvar{\alpha} \mapsto \expvar{s} \expvar{z} ) \text{ as }}\)
\typeterminal{\(\mathbb{N} \sim \text{BB-Nat} \sim \forall \typvar{\alpha} . (\typvar{\alpha} \rightarrow \typvar{\alpha}) \rightarrow \typvar{\alpha} \rightarrow \typvar{\alpha} \)}


\item let {\textcolor{magenta}{bb-two}} = \(\exprterminal{(\Lambda \typvar{\alpha} \mapsto \lambda \expvar{s} : \typeterminal{\typvar{\alpha} \rightarrow \typvar{\alpha}} \mapsto \lambda \expvar{z} : \typvar{\alpha} \mapsto \expvar{s} (\expvar{s} \expvar{z}) ) \text{ as }}\)
\typeterminal{\(\mathbb{N} \sim \text{BB-Nat} \sim \forall \typvar{\alpha} . (\typvar{\alpha} \rightarrow \typvar{\alpha}) \rightarrow \typvar{\alpha} \rightarrow \typvar{\alpha} \)}

\end{itemize}

\end{definition}


\begin{definition}
The successor function is given by:

let {\textcolor{magenta}{bb-succ}} =
\newline\(\exprterminal{\quad \lambda \expvar{n} :
\typeterminal{ \mathbb{N}
\sim \text{BB-Nat}
\sim \forall \typvar{\alpha} . ((\typvar{\alpha} \rightarrow \typvar{\alpha}) \rightarrow \typvar{\alpha} \rightarrow \typvar{\alpha})}\\
}\)
\newline
\( \exprterminal{\quad \quad \mapsto ( \Lambda \typvar{\alpha} \mapsto \lambda \expvar{s} : \typeterminal{(\typvar{\alpha} \rightarrow \typvar{\alpha})} \mapsto \lambda \expvar{z} : \typvar{\alpha} }\)
\( \exprterminal{\mapsto \expvar{s} ( \expvar{n} \typvar{\alpha} \expvar{s} \expvar{z} )) \text{ as } }\)
\typeterminal{
\(\mathbb{N} \sim \text{BB-Nat} \sim \forall \typvar{\alpha} . (\typvar{\alpha} \rightarrow \typvar{\alpha}) \rightarrow \typvar{\alpha} \rightarrow \typvar{\alpha}\)
}
\end{definition}

\begin{example}
\(\emptyset \vdash ( \textcolor{magenta}{\text{bb-succ} \quad \text{bb-one}} ) : \typeterminal{ \mathbb{N} \sim \text{BB-Nat} \sim \forall \typvar{\alpha} . (\typvar{\alpha} \rightarrow \typvar{\alpha}) \rightarrow \typvar{\alpha} \rightarrow \typvar{\alpha}) } \)
\end{example}

\begin{example}
\textcolor{magenta}{bb-succ bb-one} \(\rightarrow_\beta^{*}\) \textcolor{magenta}{bb-two}.
\end{example}

\begin{example}
\exprterminal{(}\textcolor{magenta}{bb-succ bb-false}\exprterminal{)} is stuck. \(\nexists\metavariable{v} . \) \exprterminal{(}\textcolor{magenta}{bb-succ bb-false}\exprterminal{)} \( \rightarrow_\text{eval} \metavariable{v}\) where \(\metavariable{v}\) is a \emph{value}.
\end{example}

\begin{example}
\exprterminal{(}\textcolor{magenta}{bb-succ bb-false}\exprterminal{)} is \emph{not} well-typed. \(\nexists\metavariable{\tau} . \emptyset \vdash \) \textcolor{magenta}{bb-succ bb-false} : \(\metavariable{\tau}\).
\end{example}

\subsection{Pairs}

\begin{definition}
pairs

\begin{itemize}
\item let {\textcolor{magenta}{bb-pair}} = \(\exprterminal{\Lambda \typvar{\alpha} \mapsto \Lambda \typvar{\beta} \mapsto \lambda \expvar{a}:\typvar{\alpha} \mapsto \lambda \expvar{b} : \typvar{\beta}}\)\\
\(\exprterminal{
	\mapsto (\Lambda\typvar{\gamma} \mapsto \lambda \expvar{s} : \typeterminal{\typvar{\alpha} \rightarrow \typvar{\beta} \rightarrow \typvar{\gamma}} \mapsto \expvar{s} \expvar{a} \expvar{b})}\)
	\exprterminal{ as } \typeterminal{\((\typvar{\alpha}\times\typvar{\beta})\) \(\sim\) <BB-Pair \(\typvar{\alpha}\text{ }\typvar{\beta}\)> \(\sim\) \(\forall \typvar{\gamma} . ((\typvar{\alpha} \rightarrow \typvar{\beta} \rightarrow \typvar{\gamma}) \rightarrow \typvar{\gamma})\) }\\

\item let {\textcolor{magenta}{bb-pair-first}} = \(\exprterminal{
	\Lambda \typvar{\alpha} \mapsto \Lambda \typvar{\beta}\\
	\mapsto \lambda \expvar{p} : \typeterminal{
		(\typvar{\alpha}\times\typvar{\beta}) \sim\text{ <BB-Pair \(\typvar{\alpha}\text{ }\typvar{\beta}\)> }\sim \forall \typvar{\gamma} . ((\typvar{\alpha} \rightarrow \typvar{\beta} \rightarrow \typvar{\gamma}) \rightarrow \typvar{\gamma} )
	}}\)\\
	\(\exprterminal{
	\mapsto \expvar{p} \typvar{\alpha} (\lambda \expvar{a}:\typvar{\alpha} \mapsto \lambda \expvar{b}:\typvar{\beta} \mapsto \expvar{a})
}\)\\

\item let {\textcolor{magenta}{bb-pair-second}} = \(\exprterminal{
	\Lambda \typvar{\alpha} \mapsto \Lambda \typvar{\beta}
	\mapsto \lambda \expvar{p} : \typeterminal{
		(\typvar{\alpha}\times\typvar{\beta}) \sim\text{<BB-Pair \(\typvar{\alpha}\text{ }\typvar{\beta}\)> }\sim \forall \typvar{\gamma} . ((\typvar{\alpha} \rightarrow \typvar{\beta} \rightarrow \typvar{\gamma}) \rightarrow \typvar{\gamma} )
	}}\)\\
	\(\exprterminal{
	\mapsto \expvar{p} \typvar{\beta} (\lambda \expvar{a}:\typvar{\alpha} \mapsto \lambda \expvar{b}:\typvar{\beta} \mapsto \expvar{b})
}\)\\

\end{itemize}
\end{definition}

\subsection{Lists}


\subsection{Algebraic Datatypes}
\todo{}

\input{appendix}

\end{document}