Lecture 10: Abstract Machines

Reminder:

cf. pictures

Notations:

$⟶$ : rewriting for code ( $λ$ -calculus)
$⇝$ : rewriting for abstract machines
$⇝_{S E A}$ : search
$⇝_{S U B}$ : substitute
${\overset{―}{u}}^{α}$ : $u$ well-formed and correctly $α$ -renamed

Code	Stack		Code	Stack
$t u$	$π$	$⟶_{S E A}$	$t$	$u :: π$
$λ x . t$	$u :: π$	$⟶_{β}$	$t {x \leftarrow u}$	$π$

\begin{matrix} \underset{―}{(t, ε)} ≝ t \\ \underset{―}{(t, u :: π)} ≝ \underset{―}{(t u, π)} \end{matrix}

$s ⇝_{β} s^{'} ⟹ \underset{―}{s} ⟶_{β} \underset{―}{s^{'}}$
$s ⟶_{S E A} s^{'} ⟹ \underset{―}{s} = \underset{―}{s^{'}}$
$s ⇝_{S E A} s^{'}$ terminates
$⟶, ⇝_{S E A}$ deterministic
$s$ is final state then $\underset{―}{s}$ is normal

Micro Abstract Machine

Code	Environment		Code	Environment
$(λ x . t) u r_{1} \dots r_{n}$	$E$	$⇝_{β}$	$t r_{1} \dots r_{n}$	$[x \leftarrow u] :: E$
$\underset{―}{x} r_{1} \dots r_{n}$	$E_{1} :: [x \leftarrow u] :: E_{2}$	$⇝_{S U B}$	$u^{α} r_{1} \dots r_{n}$	$E_{1} :: [x \leftarrow u] :: E_{2}$

\begin{matrix} \underset{―}{(t, ε)} ≝ t \\ \underset{―}{(t, [x \leftarrow u] :: E)} ≝ \underset{―}{(t {x \leftarrow u}, E)} \end{matrix}

\begin{matrix} t ↓_{ε} = t \\ t ↓_{[x \leftarrow e] :: E} ≝ t {x \leftarrow u} ↓_{E} \end{matrix}

Ex: You may need two $⇝_{β}$ in a row:

\begin{matrix} (λ y . (λ x . x) y) I, ε \\ ⇝_{β} (λ x . x) y, [y \leftarrow I] \\ ⇝_{β} x, [x \leftarrow y] [y \leftarrow I] \end{matrix}

Number of $⇝_{β}$ : bounded by the “size” of the environment, provided it is not “weird”. We must ensure that we have:

Lemma: Let $s = (t, E)$ be a Micro-AM reachable state.

Abs: if $λ x . \overset{―}{u}$ is a subterm of $\overset{―}{t}$ or $E$ , then $x$ occurs only in $\overset{―}{u}$

Env scope: $E = E^{'} :: [x \leftarrow u] :: E^{″}$ then $x$ is fresh wrt $u$ and $E^{″}$

s ⇝_{β}^{k} s^{'} ⟹ k \leq | E |

Ex: Pay attention to renaming. Example of a mistake (we don’t rename in the second step):

\begin{matrix} (λ z . z z I δ) λ x y . x y \\ ⇝_{β} z z I δ, [z \leftarrow λ x y . x y] \\ ⇝_{S U B} (λ x y . x y) z I δ, [z \leftarrow λ x y . x y] \\ ⇝_{β} (λ y . x y) I δ, [x \leftarrow z] [z \leftarrow λ x y . x y] \\ ⇝_{β} x y δ, [y \leftarrow I] [x \leftarrow z] [z \leftarrow λ x y . x y] \\ ⇝_{S U B}^{2} (λ y . x y) y δ, [y \leftarrow I] [x \leftarrow z] [z \leftarrow λ x y . x y] \\ ⇝_{β} (λ y . x y) δ, [x \leftarrow y] [y \leftarrow I] [x \leftarrow z] [z \leftarrow λ x y . x y] Property already violated \\ ⇝_{β} x y, [y \leftarrow δ] [x \leftarrow y] [y \leftarrow I] [x \leftarrow z] [z \leftarrow λ x y . x y] \\ ⇝_{S U B} y y, [y \leftarrow δ] [x \leftarrow y] [y \leftarrow I] [x \leftarrow z] [z \leftarrow λ x y . x y] \end{matrix}

So it reduces to $δ δ$ , which diverges, but it should in fact reduce to $δ$ (in $(λ y . (λ x y . x y) y I δ)$ , not both $y$ ’s are bound by $δ$ ), which converges!

Milner Abstract Machines (MAM)

Simplified version of Krivine AM.

Code	Stack	Environment		Code	Stack	Environment
$\overset{―}{t} \overset{―}{u}$	$π$	$E$	$⇝_{S E A}$	$\overset{―}{t}$	$\overset{―}{u} :: π$	$E$
$λ x . \overset{―}{t}$	$\overset{―}{u} :: π$	$E$	$⇝_{β}$	$\overset{―}{t}$	$π$	$[x \leftarrow \overset{―}{u}] :: E$
$x$	$π$	$E_{1} :: [x \leftarrow u] :: E_{2}$	$⇝_{S U B}$	${\overset{―}{u}}^{α}$	$π$	$E_{1} :: [x \leftarrow u] :: E_{2}$

\begin{matrix} \underset{―}{(t, u :: π, E)} ≝ \underset{―}{(t u, π, E)} \\ \underset{―}{(t, ε, [x \leftarrow u] :: E)} ≝ \underset{―}{(t {x \leftarrow u}, ε, E)} \\ \underset{―}{(t, ε, ε)} ≝ t \end{matrix}

\begin{matrix} \underset{―}{ε} ≝ ⟨ ⟩ \\ \underset{―}{u :: π} ≝ π (⟨ ⟩ u) \end{matrix}

TODO: write $↓$

Complexity analysis

λ_{C B M} ⟶_{P O L} M A M ⟶_{P O L} R A M

Let $d : t_{0} ⟶_{β_{c b n}}^{k} s$ be a derivation

Input: the size $| t_{0} |$ of the initial term
Length: $| d | = k$

Number of machine transitions
Cost of a single transition
Combine the two

Code	Environment		Code	Environment
$(λ x . t) u r_{1} \dots r_{k}$	$E$	$⇝_{β}$	$t r_{1} \dots r_{k}$	$[x \leftarrow u] :: E$
$\underset{―}{x} r_{1} \dots r_{k}$	$E_{1} :: [x \leftarrow u] :: E_{2}$	$⇝_{S U B}$	$u^{α} r_{1} \dots r_{k}$	$E_{1} :: [x \leftarrow u] :: E_{2}$

Let $ρ : s ⇝^{*} s^{'}$

How do $| ρ |_{S U B}$ and $| ρ |_{β}$ compare?

The size of the environment is the number of $β$ transitions. But if

s_{0} ⇝_{β}^{n} ⇝_{S U B}^{k} s_{1}

then, the $k \leq n + size of the environment at s_{0}$ .

Therefore, if

(t_{0}, ε) ⇝_{β}^{a_{1}} ⇝_{S U B}^{b_{1}} \dots ⇝_{β}^{a_{k}} ⇝_{S U B}^{b_{k}} s^{'}

then

| ρ |_{S U B} = \sum_{i = 1}^{k} b_{i} = \sum_{i = 1}^{k} \underset{\leq | ρ |_{k}}{\underset{⏟}{\sum_{j = 1}^{i} a_{j}}} \leq \sum_{i = 1}^{k} | ρ |_{β} \leq | ρ |_{β}^{2}

where

\begin{matrix} k \leq | ρ |_{β} \\ b_{i} \leq \sum_{j = 1}^{i} a_{j} \end{matrix}

So $| ρ |_{S U B} = O (| ρ |_{β}^{2})$

Is this bound reached? Yes:

\begin{matrix} (λ x_{0} . x_{0} x_{0}) δ \\ ⇝_{β} x_{0} x_{0}, [x_{0} \leftarrow δ] \\ ⇝_{S U B} (λ x_{1} . x_{1} x_{1}) x_{0}, [x_{0} \leftarrow δ] \\ ⇝_{β} x_{1} x_{1}, [x_{1} \leftarrow x_{0}] [x_{0} \leftarrow δ] \\ ⇝_{S U B} x_{0} x_{1}, [x_{1} \leftarrow x_{0}] [x_{0} \leftarrow δ] \\ ⇝_{S U B} (λ x_{2} . x_{2} x_{2}) x_{1}, [x_{1} \leftarrow x_{0}] [x_{0} \leftarrow δ] \\ ⇝_{β} x_{2} x_{2}, [x_{2} \leftarrow x_{1}] [x_{1} \leftarrow x_{0}] [x_{0} \leftarrow δ] \\ ⇝_{S U B} x_{1} x_{2}, [x_{2} \leftarrow x_{1}] [x_{1} \leftarrow x_{0}] [x_{0} \leftarrow δ] \\ ⇝_{S U B} x_{0} x_{2}, [x_{2} \leftarrow x_{1}] [x_{1} \leftarrow x_{0}] [x_{0} \leftarrow δ] \\ ⇝_{S U B} (λ x_{3} . x_{3} x_{3}) x_{2}, [x_{2} \leftarrow x_{1}] [x_{1} \leftarrow x_{0}] [x_{0} \leftarrow δ] \\ ⇝_{β} x_{3} x_{3}, [x_{3} \leftarrow x_{2}] [x_{2} \leftarrow x_{1}] [x_{1} \leftarrow x_{0}] [x_{0} \leftarrow δ] \\ \dots \end{matrix}

Subterm Invariant

The “equivalent” of the Hauptsatz in sequent calculus, or the subformula property.

Lemma (Subterm Invariant): Let $ρ : (\overset{―}{t_{0}}, ε, ε) ⇝^{*} (\overset{―}{u}, π, E)$ be an execution. Then $u$ and any code in $E$ and $π$ are subterms of the $t_{0}$ (up to $α$ )

Proof: The only subtle proof step: $⇝_{S U B}$ (the only step where the machine duplicates): $u$ is duplicated.

This gives us a bound on the size of duplicated terms.

Recall

\begin{matrix} t_{n} ⟶_{β}^{n} r_{n} \\ where | r_{n} | = Ω (2^{n}) \end{matrix}

This lemma tells us: whenever

s ⇝^{n} s^{'}

as in each step you can only duplicate subterms, then the size of $s^{'}$ is bounded by

| s^{'} | \leq (n + 1) | t_{0} |

⟹ there’s no size explosion wrt the number of steps.

Warning: it could happen that the number of steps is itself exponential ⟹ we have to make sure that the number of transitions is reasonable (from $λ$ to $M$ , before even going from $M$ to $R A M$ )

(u, E) ⇝_{S E A, β}^{k} s ⟹ k \leq | u | \leq | t_{0} |

by the subterm invariant.

But $⇝_{S U B}$ increases the size of the term: replaces a variable (size $1$ ) by a term (size $\geq 1$ ). But by the subterm invariant, this term is a subterm of $t_{0}$ , so:

| ρ |_{S E A} \leq | t_{0} | + | ρ |_{S U B} | t_{0} | = (| t_{0} | + 1) | ρ |_{S U B} \leq (| t_{0} | + 1) | ρ |_{β}^{2}

Recall that that AM take care of SEA(rch), SUB(stitution), and NAMES. But SEA is quadratic wrt to SUB ⟹ we can afford not to take it into account, it doesn’t impact much the complexity. NAMES impact even less the complexity.

	Number of transitions
SEA	$(\| t_{0} \| + 1) \| ρ \|_{β}^{2}$
$β$	$\| ρ \|_{β}$
SUB	$\| ρ \|_{β}^{2}$

With pointers, the SEA and the $β$ transitions take constant time.

As for SUB: if we implement the environments as lists, you don’t have constant time access. But if variables are pointers, we can access the substituted term for $x$ in the environment in constant time ⟹ so SUB is bounded by $| t_{0} |$ (as $u$ is a subterm thereof).

Therefore:

	Number of transitions	Cost of single transition	Global cost
SEA	$(\| t_{0} \| + 1) \| ρ \|_{β}^{2}$	$O (1)$	$O ((\| t_{0} \| + 1) \| ρ \|_{β}^{2})$
$β$	$\| ρ \|_{β}$	$O (1)$	$O (\| ρ \|_{β})$
SUB	$\| ρ \|_{β}^{2}$	$O (\| t_{0} \|)$	$O ((\| t_{0} \| + 1) \| ρ \|_{β}^{2})$

Call-by-Value evaluation

We saw that there’s an efficient abstract machine to implement call-by-name evaluation. But reasonable cost models are not about finding such efficient machines.

T M \overset{linear}{⟶} λ_{d e t}

But $λ$ -calculus is bigger, and there are terms where the evaluation strategy matters.

Ex: Duplicator:

\begin{matrix} CBV: δ (I x) ⟶ δ x ⟶ x x \\ CBN: δ (I x) ⟶ (I x) (I x) ⟶ x (I x) ⟶ x x \end{matrix}

⟹ CBN seems to be silly (we duplicate work), but we just showed that it is reasonable.

Ex: Erasor:

\begin{matrix} CBV: (λ z . y) (δ δ) ⟶ (λ z . y) (δ δ) ⟶ \dots \\ CBN: (λ z . y) (δ δ) ⟶ y \end{matrix}

⟹ CBV seems to be silly, but we can show that it is reasonable too.

Being reasonable has nothing to do with finding an efficient strategy. It means that the overhead is not too complex (polynomial) ⟹ relative efficiency.

But still, are there non reasonable strategies? Yes (there’s one example in the literature: Jean-Jacques Lévy’s one).

Is there an optimal strategy (that takes the least number of steps)? No, the optimal strategy is not recursive.

But even though it is not recursive, we can have a notion of parallel optimal strategy, which is recursive (shown by Lévy). But Lévy didn’t know how to implement it. It was done a few years later by someone else. Question that arose: can take $k$ (the minimal number of steps for this optimal parallel strategy) as the complexity of $t$ ? It was proven that no, it’s not reasonable (this is an example of unreasonable strategy).

But it doesn’t make it useless for all that: just because it’s not reasonable doesn’t mean that it’s not efficient (hidden but wrong assumption: steps count as 1, i.e. there are reasonable). Nowadays, we still don’t know if it’s efficient or not.

Comparing the number of steps of strategies that are not reasonable doesn’t make sense.

Weak Call-by-Value (CBV) $λ$ -calculus

v ≝ x ∣ λ x . t

\frac{}{(λ x . t) \underset{―}{v} ⟶_{w β_{v}} t {x \leftarrow v}}

\frac{t ⟶_{w β_{v}} t^{'}}{t u ⟶_{w β_{v}} t^{'} u} \frac{t ⟶_{w β_{v}} t^{'}}{u t ⟶_{w β_{v}} u t^{'}}

NB: we consider only the weak version (we don’t reduce under $λ$ ’s) because generally it’s used with a programming application in mind

Harmony property: if $t$ is closed, then

either $t ⟶_{w β_{v}} t^{'}$

or $t$ is a value (an abstraction)

Proof: by induction on $t$ .

So if $t$ is closed:

either $t$ reduces to another term
or it diverges

NB: if we remove variables from values, nothing changes.

In theoretical papers, values are defined as

v_{t} ≝ x ∣ λ x . t

In papers about abstract machines (practical), values are defined as

v_{p} ≝ λ x . t

⟹ Why nothing changes? Because a variable can never be arguments: the only way to have a subterm of the form $t x$ is to bind the variable: $λ x . t x$ , and then we’re stuck: we don’t reduce under abstractions.

This is better than confluent, it has the diamond property:

\begin{matrix} (\underset{―}{I δ}) (\underset{―}{δ I}) ⟶ δ (δ I) ⟶ δ (I I) \\ (\underset{―}{I δ}) (\underset{―}{δ I}) ⟶ (I δ) (I I) ⟶ δ (I I) \end{matrix}

⟹ we can always close the diagram in one step.

It fails when we’re allowed to duplicate redexes, as in $δ (I I)$ . But in CBV, we can’t: the only terms we can duplicate are values, that are normal.

On top of that, all reduction sequences have the same length.

Right-to-left strategy (the only rule that changes):

\frac{t ⟶_{w β_{v}} t^{'}}{t v ⟶_{w β_{v}} t^{'} v}

So contexts are given by:

R ≝ ⟨ ⟩ ∣ u R ∣ R v

AM:

\begin{matrix} R ⟨ (λ x . t) v ⟩ ∣ E ⇝_{β_{v}} R ⟨ t ⟩ ∣ [x \leftarrow v] :: E \\ R ⟨ x ⟩ ∣ E_{1} :: [x \leftarrow v] :: E_{2} ⇝_{S U B} R ⟨ v^{α} ⟩ ∣ E_{1} :: [x \leftarrow v] :: E_{2} \end{matrix}

We can rewrite the last ones in the same fashion, where $A$ is an applicative context:

Code	Environment		Code	Environment
$A ⟨ (λ x . t) ⟩$	$E$	$⇝_{β}$	$A ⟨ t ⟩$	$[x \leftarrow u] :: E$
$A ⟨ x ⟩$	$E_{1} :: [x \leftarrow u] :: E_{2}$	$⇝_{S U B}$	$A ⟨ u^{α} ⟩$	$E_{1} :: [x \leftarrow u] :: E_{2}$

Share on

Twitter Facebook Google+ LinkedIn