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

Compilerconstructie najaar 2016 http://www.liacs.leidenuniv.nl/~vlietrvan1/coco/ Rudy van Vliet

A proof checking kernel for the -calculus modulo Mathieu Boespflug, cole Polytechnique

Distance Metric Learning with Joint Representation Diversification Xu Chu 1,2 Yang Lin 1,2 Yasha

Inductive Types for Free Representing Nested Inductive Types using W-types Michael Abbott (U.

CLASE Cursor Library for A Structured Editor Zip! Photo from

Full reduction at full throttle Section 1 Maxime Klusman Radboud University Nijmegen January

Normalizing Structured Graphs (ongoing work) Eijiro Sumii Joint work with Kazuma Kikuchi Tohoku

Automated Time-domain Astrophysics is entering its golden age with a number of new telescopes