michael/oplss2024
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
oplss2024/pfenning/notes.typ
Michael Zhang d2afe9399c ye
2024-06-05 15:26:46 -04:00

482 lines
No EOL
13 KiB
Text
Raw Blame History

#import "@preview/fletcher:0.4.5" as fletcher: diagram, node, edge
#import "../common.typ": *
#import "@preview/prooftrees:0.1.0": *
#import "@preview/algo:0.3.3": algo, i, d, comment, code
#show: doc => conf("Adjoint Functional Programming", doc)
#let n(t) = text(fill: rgb("#aa3333"))[#t]
#let evalto = $arrow.r.hook$
#let with = $op(\&)$
== Lecture 1
- Origins of linearity is from linear logic
- from 1987 or before
#let isValue(x) = $#x "value"$
Language to be studied is called "snax"
- Features
- Substructural programming
- Inference
- Overloading? writing the same function that works both linearly and non-linearly
- "Proof-theoretic compiler"
- Everything up til the target C is either natural deduction, sequent calculus, etc.
- Types
- "if there's something you don't need in the language, don't put it in the language"
- no empty type
- unit type
- 1
- #tree(axi[], uni[$() : 1$])
- #tree(axi[], uni[$isValue(())$])
- +
- #tree(axi[$e : A$], uni[$"inl" e : A + B$])
- #tree(axi[$e : B$], uni[$"inr" e : A + B$])
- #tree(axi[$isValue("v")$], uni[$isValue("inl" v)$])
- #tree(axi[$isValue("v")$], uni[$isValue("inr" v)$])
- $A + B :equiv +\{"inl":A, "inr": B\}$
- label set $L eq.not emptyset$ , finite
- finiteness is important
- nat = $+\{ "zero" : 1 , "succ" : "nat" \}$
- recursion is required to define an infinite amount of things
- "equirecursive" types
- nat is "equal" to the recursive definition in some sense
- k
- $\{(k \in l) e : A_e}{k(e) : +\{l : A_l\}_{l : L}}$
- $ceil(0) = "zero" ()$
- Computational rules
Define negation of booleans
$"not" (x : "bool") : "bool" \
"not" x = "match" x "with" \
| "true" u arrow.r "false" u\
| "false" u arrow.r "true" u \
$
Function definitiosn like these operate at the meta level.
Avoid introducing function types today.
Linear functional programming means *every variable must be used exactly once.*
*NOTE:* Above cannot be defined $"true" u arrow.r "false" ()$, since $u$ is not used.
DOn't need a garbage collector for linear functional programming language
#tree(
axi[$e : +{l : A_l}_(l in L)$],
axi[$x : A_l$],
axi[$tack.r e_l : C(l in L)$],
nary(3)[$"match" e "with" (l(x) arrow.r.double e_l)_(l in L) : C$],
)
Cannot write a function $"duplicate"(x) = (x , x)$ because of linear programming
#tree(
axi[$Delta tack.r e_1: A$],
axi[$Gamma tack.r e_2 : B$],
bin[$Delta,Gamma tack.r (e_1, e_2) : A times B$],
)
so introducing contexts
$Gamma :equiv (dot) | Gamma , x : A$
where the variable $x$ must be unique.
#tree(axi[], uni[$x : A tack.r x : A$])
*NOTE:* Left side is $x : A$, not $Gamma , x : A$ because those others would be unused, violating the single use rule.
#tree(
axi[$Delta , e : A times B$],
axi[$Gamma , x : A, y : B tack.r e' : C$],
nary(2)[$Delta , Gamma tack.r "match" e "with" (x , y) => e' : C$],
)
Have to split your variables to check $e$ and $e'$. This is not the way to implement it.
To implement it, check $"FV"(e)$ and $"FV"(e')$. These correspond to $Delta$ and $Gamma$ respectively. This is expensive.
- An easier way is to have each judgement give back another context containing the variables not use. Called a "subtractive" approach.
- Additive approach returns the variables used, and then check to make sure variables don't exist on the output.
GOing backk
#tree(
axi[],
uni[$dot tack.r () : 1$],
)
// #tree(
// axi[$Delta tack.r e : +{l : A_l}_(l in L)$],
// axi[$Gamma $]
// )
Defining plus:
-
$"plus" (x : "nat") (y : "nat") : "nat" \
"plus" x " " y = "match" x "with" \
| "zero" () arrow.r.double #text(fill: red)[$"zero" ()$] \
| "succ" x' arrow.r.double "succ" ("plus" x' y)
$
This is problematic because it doesn't use up $y$ in the first branch.
-
$"plus" (x : "nat") (y : "nat") : "nat" \
"plus" x " " y = "match" x "with" \
| "zero" () arrow.r.double y \
| "succ" x' arrow.r.double "succ" ("plus" x' y)
$
This uses up all inputs exactly.
#tree(
axi[$Gamma tack.r e : A_k (k in L)$],
uni[$Gamma tack.r k(e) : +{l : A_l}_(l in L)$],
)
#pagebreak()
=== Lecture 2
Type system
- Proving something different than type soundness; we want to demonstrate that no garbage is created.
- Set up a close correspondence between the static rules for inference and dynamic rules for evaluation.
- This should be _very_ close ideally.
At runtime, if you have $Gamma tack.r e : A$
- $e$ is what you're executing
- you don't want to carry $A$ around during runtime
- $Gamma$ corresponds to a set of variables (you need this) $eta : Gamma$
#rect[$eta : Gamma$]
#tree(axi[], uni[$(dot) : (dot)$])
#tree(axi[$eta : Gamma$], axi[$dot tack.r v : A$], bin[$eta , x mapsto v : Gamma , x : A$])
("environment" refers to $eta$, while context refers to $Gamma$)
Runtime values are _always_ closed.
*Theorem.*
Under the conditions $Gamma tack.r e : A$ and $eta : Gamma$, then $eta tack.r e arrow.r.hook v$ and $dot tack.r v : A$.
However, this rule is problematic:
#tree(
axi[$Delta tack.r e_1 : A$],
axi[$Gamma tack.r e_2 : B$],
bin[$Delta,Gamma tack.r (e_1, e_2) : A times B$]
)
This evaluates to:
#tree(
axi[$e_1 arrow.r.hook v_1$],
axi[$e_2 arrow.r.hook v_2$],
bin[$eta tack.r (e_1, e_2) arrow.r.hook (v_1, v_2)$],
)
How to split the environment in this case?
It's not feasible to split the free variables.
One idea is we can just pass the whole environment into both sides:
#tree(
axi[$eta tack.r e_1 arrow.r.hook v_1$],
axi[$eta tack.r e_2 arrow.r.hook v_2$],
bin[$eta tack.r (e_1, e_2) arrow.r.hook (v_1, v_2)$],
)
The typechecker tells us that everything is used up correctly, so at runtime we can use this assumption.
Using subtractive approach, this looks like:
#tree(
axi[$eta tack.r e_1 arrow.r.hook v_1 #n[$tack.l eta_1$]$],
axi[$#n[$eta_1$] tack.r e_2 arrow.r.hook v_2 #n[$tack.l eta_2$]$],
bin[$#n[$eta_2$] tack.r (e_1, e_2) arrow.r.hook (v_1, v_2)$],
)
The subtractive approach has problems:
- When you execute your program, you are forced to go left-to-right. You can't run in parallel.
Additive approach:
#rect[$Gamma tack.r e: A tack.l Omega$]
where $Omega$ are the variables that are _actually_ used
For example, rules for pairs:
#tree(
axi[$Gamma tack.r e_1 : A tack.l Omega_1$],
axi[$Gamma tack.r e_2 : B tack.l Omega_2$],
bin[$Gamma tack.r (e_1,e_2) : A times B tack.l Omega_1, Omega_2$],
)
The $Omega_1 , Omega_2$ disjoint union, and is undefined if they share a variable.
The runtime rule corresponds to:
#tree(
axi[$eta tack.r e_1 arrow.r.hook v_1 tack.l omega_1$],
axi[$eta tack.r e_2 arrow.r.hook v_2 tack.l omega_2$],
bin[$eta tack.r (e_1, e_2) arrow.r.hook (v_1, v_2) tack.l omega_1, omega_2$]
)
If we typechecked correctly, $omega_1$ and $omega_2$ would be disjoint as well.
*Soundness.* If $Gamma tack.r e : A tack.l Omega$ then $Omega tack.r e : A$ ($Omega subset Gamma$)
*Completeness.* If $Omega tack.r e : A$ and $Gamma supset Omega$ then $Gamma tack.r e : A tack.l Omega$
The $Omega tack.r e : A$ is a _precise_ judgement: $Omega$ _only_ contains the variables used in $e$.
You would need two different sets of typing rules, one that has the $Omega$ rules and one that doesn't.
Prove this by rule induction.
Change the original theorem:
*New Theorem.*
Under the conditions $Gamma tack.r e : A tack.l Omega$ and $eta : Gamma$ and $omega : Omega$,
then $eta tack.r e arrow.r.hook v tack.l omega$ and $dot tack.r v : A$.
This can now be proven with the new dynamics.
How to prove that there's no garbage?
For all top level computations, $eta tack.r e arrow.r.hook v tack.l eta$.
This means that everything is used.
This can be proven using rule induction.
Updated theorem, to point out that $e arrow.r.hook v$ may not necessarily be true because termination is not proven by rule induction.
*New Theorem.*
Under the conditions $Gamma tack.r e : A tack.l Omega$ and $eta : Gamma$ and $omega : Omega$,
#n[and $eta tack.r e arrow.r.hook v tack.l omega$] then $dot tack.r v : A$.
(under affine logic, the top-level judgment $Gamma tack.r e : A tack.l Omega$ requires only that $Omega subset Gamma$, not that $Omega = Gamma$)
Example of evaluation rule that matches the typing rule:
#tree(
axi[$eta tack.r e arrow.r.hook (v_1, v_2) tack.l omega$],
axi[$eta, x mapsto v_1 , y mapsto v_2 tack.r e' arrow.r.hook v' tack.l (omega', x mapsto v_1, y mapsto v_2)$],
bin[$eta tack.r "match" e "with" (x, y) arrow.r.double e' arrow.r.hook v' tack.l (omega, omega')$]
)
==== Looking at typing rules as logic
#rect[Natural Deduction]
$Gamma ::= (dot) | Gamma , A$
#tree(
axi[],
uni[$A tack.r A$]
)
#tree(
axi[$Delta tack.r A$],
axi[$Gamma tack.r B$],
bin[$Delta, Gamma, tack.r A times B$]
)
#tree(
axi[$Delta tack.r A times B$],
axi[$Gamma, A, B tack.r C$],
bin[$Delta, Gamma tack.r C$]
)
These are like a rule of logic. For plus:
#tree(
axi[$Delta tack.r A$],
uni[$Delta tack.r A + B$],
)
#tree(
axi[$Delta tack.r B$],
uni[$Delta tack.r A + B$],
)
Proof by cases:
#tree(
axi[$Delta tack.r A + B$],
axi[$Gamma , A tack.r C$],
axi[$Gamma , B tack.r C$],
tri[$Delta , Gamma tack.r C$],
)
Every assumption has to be used _exactly_ once. This is called *linear logic*.
(notation uses $times.circle$ and $plus.circle$ instead of $times$ and $plus$)
Linear logic is weak by itself, just as linear type system is weak without global definitions.
Summary of operators:
#image("lec1.jpg")
$!A$ is read "of course A", lets you re-use assumptions. We don't have this except by top-level definitions.
In the judgement $Sigma ; Gamma tack.r e : A$, $Sigma$ contains definitions that you can use however many times you want, and $Gamma$ contains the definitions that are created linearly.
Distinction between positive and negative types:
- Lambdas cannot be pattern-matched against, you have to apply it.
- However, for $times.circle$ and $plus.circle$ you can directly observe their structure.
In this case, $A with B$, read "A with B":
#tree(
axi[$Gamma tack.r A$],
axi[$Gamma tack.r B$],
bin[$Gamma tack.r A with B$],
)
This is sound because only one of them can be extracted:
#tree(
axi[$Gamma tack.r e_1:A$],
axi[$Gamma tack.r e_2:B$],
bin[$Gamma tack.r angle.l e_1,e_2 angle.r : A with B$],
)
#tree(
axi[$Gamma tack.r e : A with B$],
uni[$Gamma tack.r e.pi_1 : A$]
)
#tree(
axi[$Gamma tack.r e : A with B$],
uni[$Gamma tack.r e.pi_2 : B$]
)
"Lazy pair" you can only extract one side at a time. There are also "lazy records":
$with { l : A_l}_(l in L)$
#tree(
axi[$Gamma tack.r e_l : A_l (forall l in L)$],
uni[$Gamma tack.r {l = e_l}_(l in L) : with {l : A_l}_(l in L)$]
)
#tree(
axi[$Gamma tack.r e : with { l : A_l}_(l in L) (forall l in L)$],
uni[$Gamma tack.r e.k : A_k (k in L)$]
)
#pagebreak()
=== Lecture 3
- negation
- Mixing linear & non-linear programs
- Mode checking & inference
#diagram((
node((0, -0.8), "Unrestricted"),
edge("-|>"),
node((0.8, 0), "Strict (at least once)"),
node((-0.8, 0), "Affine (at most once)"),
edge("-|>"),
node((0, 0.8), "Linear"),
edge((0, -0.8), (-0.8, 0), "-|>"),
edge((0.8, 0), (0, 0.8), "-|>"),
))
Cannot write map:
```
fail decl map (f : nat -> nat) (xs : list) : list
defn map f xs = match xs with
| 'nil () => 'nil ()
| 'cons (x, xs) => 'cons (f x, map f xs)
```
This is because $f$ isn't used in the first line but used twice in the second line.
We could write some iterator:
```
type iterator = &{'next : nat -> nat * iterator, 'done : 1}
decl iterate (iter : iterator) (xs : list) : list
defn iterate iter xs = match xs with
| 'nil () => (match iter.'done with | () => 'nil ())
| 'cons (x, xs) => (match iter.'next x with | (y, iter) => 'cons ('succ y, iterate iter xs))
```
This is a linear implementation of a function that adds 1 to everything in the list.
=== Modes
Take the entire language and parameterize by modes:
$A, B_m ::= 1_m &| A_m times B_m | +{l : A^l_m}_(l in L) | arrow.b^k_m A_k (k >= m) \
&| A_m arrow B_m | \&{l:A^l_m}_(l in L) | arrow.t^i_m A_i (i <= m)
$
These are implemented in the code:
```
type nat[k] = +{'zero : 1, 'succ : nat[k]}
```
Modes need to be _guarded_. For example:
```
type nat[k] = +{'zero : 1, 'succ : down[k] nat[k]}
type list[m k] = +{
'nil : 1,
'cons : down[k] nat[k] * down[m] list[m k],
}
```
The `m` is used because it comes first.
$ (!A_L)_L eq.delta arrow.b^U_L arrow.t^U_L A_L$
needs a partial ordering on U and L. Need to copy when it's in the U and then move it back into the L when you're done.
```
decl map (f : [mf] up[k] (nat[k] -> nat[k])) (xs : list[m k]) : list[r k]
defn map f xs = match xs with
| 'nil () => 'nil ()
| 'cons (<x>, <xs>) => 'cons(<f.force x>, <map f xs>)
```
$Gamma$ can be multi-modal. This is how top-level declarations can be re-used.
https://www.cs.cmu.edu/~fp/papers/tocl07.pdf
Need to enforce independence, that $Gamma tack.r e : A_m$ means $Gamma >= m$
Pointer:
#let wrap(e) = $angle.l #e angle.r $
#tree(
axi[$Gamma >= k$],
axi[$Gamma tack.r e : A_k$],
bin[$Gamma tack.r wrap(e) : arrow.b^k_m A_k$]
)
*NOTE:* The bottom would not be valid if $Gamma cancel(>=) k$
#tree(
axi[$Delta >= m >= r$],
axi[$Delta tack.r e : arrow.b^k_m A_k$],
axi[$Gamma , x : A_k tack.r e' : C_r$],
nary(3)[$Delta Gamma tack.r "match" e with wrap(x) => e' : C_r$],
)
Reference in a new issue View git blame Copy permalink