Multi-Level Languages are Generalized Arrows Adam Megacz - PowerPoint PPT Presentation

Multi-Level Languages are Generalized Arrows Adam Megacz 12-Apr-2011 1/38

Lambda Calculus Review τ := Int | τ -> τ | . . . e := x | e e | λ x . e [Var] x: τ ⊢ x: τ Γ , x: τ 1 ⊢ e: τ 2 [Lam] Γ ⊢ ( λ x . e ) : τ 1 -> τ 2 Γ 1 ⊢ e 1 : τ 1 Γ 2 ⊢ e 2 : τ 1 -> τ 2 [App] Γ 1 , Γ 2 ⊢ e 2 e 1 : τ 2 3/38

Flattening, in Detail What follows is the simplified translation , which works only when higher-order functions are not used. Specifically, the context (area to the left of the turnstile) may not contain any variables with -> ’s in their types. 5/38

Flattening, in Detail Let’s try an example. We’re going to flatten this expression: subtract_second_from_third :: Int -> (Int -> (Int -> Int)) subtract_second_from_third x y z = z - y But first, we need to desugar it. The expression above is really just syntactic sugar for this: subtract_second_from_third = \x -> \y -> \z -> (-) z y Also, note that this expression has (-) as a free variable, with the following type: (-) :: Int -> Int -> Int We’ll come back to this. 7/38

Flattening, in Detail The (simplified) flattening process involves six steps: 1. Construct the proof that the expression is well-typed 2. Skolemize the proof 3. Make contraction, and exchange explicit in the proof 4. Make left and right expansion explicit in the proof 5. Make weakening explicit in the proof 6. Walk the proof In practice, steps 2-5 are performed simultaneously as one big step. In these slides they are presented as separate steps in an order which keeps each of the proofs small enough to fit on a slide. 9/38

Step 1: Construct the Proof λ x λ y subtract_first_from_third = \x -> λ z \y -> app \z -> ((-) z) y app y z (-) [Var] z:Int ⊢ z:Int ⊢ (-) : Int->Int->Int [Var] [App] y:Int ⊢ y:Int z : Int ⊢ (-) z:Int->Int [App] x:Int , y:Int , z:Int ⊢ (-) z y:Int [Lam] x:Int , y:Int ⊢ \z -> (-) z y:Int->Int [Lam] x:Int ⊢ \y -> \z -> (-) z y:Int->(Int->Int) [Lam] ⊢ \x -> \y -> \z -> (-) z y:Int->(Int->(Int->Int)) 11/38

Step 2: Skolemize the Proof Now, we skolemize the proof to eliminate function types a->b . Wherever an expression of function type appears to the right of the turnstile, like this: Γ ⊢ e: α -> β 12/38

Step 2: Skolemize the Proof Now, we skolemize the proof to eliminate function types a->b . Wherever an expression of function type appears to the right of the turnstile, like this: Γ ⊢ e: α -> β we will add a new skolem variable with a fresh name to the left of the turnstile and apply the expression to it, like this: a: α, Γ ⊢ e a: β 12/38

Step 2: Skolemize the Proof Now, we skolemize the proof to eliminate function types a->b . Wherever an expression of function type appears to the right of the turnstile, like this: Γ ⊢ e: α -> β we will add a new skolem variable with a fresh name to the left of the turnstile and apply the expression to it, like this: a: α, Γ ⊢ e a: β Repeated application of the procedure above will leave us with a proof which has no -> ’s to the right of the turnstile. 12/38

Skolemizing Lam y: α, Γ ⊢ e: β [Lam] Γ ⊢ ( λ y . e ) : α -> β 13/38

Skolemizing Lam y: α, Γ ⊢ e: β [Lam] Γ ⊢ ( λ y . e ) : α -> β Notice what happens to the Lam rule when we skolemize it: y: α, Γ ⊢ e: β [Skolemized-Lam] a: α, Γ ⊢ ( λ y . e ) a: β 13/38

Skolemizing Lam y: α, Γ ⊢ e: β [Lam] Γ ⊢ ( λ y . e ) : α -> β Notice what happens to the Lam rule when we skolemize it: y: α, Γ ⊢ e: β [Skolemized-Lam] a: α, Γ ⊢ ( λ y . e ) a: β Because ( λ y . e ) a reduces via β -reduction to e [ y := a ], Skolemized-Lam is nothing more than variable renaming. We can eliminate it entirely by changing the names of the variables in the proof tree above it: . . . . . . . [ y:=a ] . . ⇒ ⇒ y: α, Γ ⊢ e: β y: α, Γ ⊢ e: β a: α, Γ ⊢ e [ y:=a ] : β Γ ⊢ ( λ y . e ) : α -> β a: α, Γ ⊢ ( λ y . e ) a: β 13/38

Multi-Level Languages are Generalized Arrows Adam Megacz - PowerPoint PPT Presentation

Multi-Level Languages are Generalized Arrows Adam Megacz 12-Apr-2011 1/38 Lambda Calculus Review := Int | -> | . . . e := x | e e | x . e [Var] x: x: , x: 1 e: 2 [Lam] ( x . e ) : 1 -> 2

Hardware Design with Generalized Arrows Adam Megacz megacz@cs.berkeley.edu 03.Oct.2011 1/51

Reversible effects as inverse arrows Chris Heunen Robin Kaarsgaard Martti Karvonen 1 / 17

High-level languages High-level languages are not immune to these problems. Actually, the

High-Level Languages Languages Assembly vs Machine Code Assembly vs high-level language

Multi Level Modeling in the Wild with AutomationML Invited Talk @ Multi Level Modeling

Chapter 2 Early History: low level languages The 1950s: first programming languages History of

Policy Languages Express security policies in a precise way High-level languages

The Multi-Level Feedback Queue Operating System: Three Easy Pieces 1 Youjip Won Multi-Level

On multivariate Multi-Resolution Analysis, using generalized (non homogeneous) polyharmonic

Implementing Non-Strict Functional Languages with the Generalized Intensional Transformation

Lax monads and generalized multicategory theory Dimitri Chikhladze 1 A category ( x, a

Debugging Debugging with High Level Languages Same goals as low-level debugging Examine and

Synthesis and Exploration of Multi- Level, Multi-Perspective Architectures of Automotive

Numerical experiments with a level-set tracking algorithm for generalized diffusion equations

Relating Idioms, Arrows and Monads from Monoidal Adjunctions @ SYCO I Exequiel Rivas September

Multi-Level Logic with Constant Depth: Multi-Level Logic with Constant Depth: Recent Research

Low-Level Reactive Languages Jan Tobias Mhlberg jantobias.muehlberg@cs.kuleuven.be

A Multi-start Heuristic Algorithm for the Generalized Traveling Salesman Problem V. Cacchiani, A.

Multi-Level Modeling with XML Dr. Jens Gulden Information Systems and Enterprise Modeling, ICB

Today Arrays One-dimensional Machine-Level Programming IV: Data Multi-dimensional

Statement-Level Control Structures COS 301: Programming Languages UMAINE CIS COS 301

Statement-Level Control Structures COS 301: Programming Languages UMAINE CIS COS 301

Multi-Level Formal Analysis A New Direction for Fault Injection Attack? L. Sauvage, T. Graba, T.

The Bernoulli Generalized Likelihood Ratio test (BGLR) for Non-Stationary Multi-Armed Bandits