A Language for Counterfactual Generative Models

Total Page:16

File Type:pdf, Size:1020Kb

A Language for Counterfactual Generative Models A Language for Counterfactual Generative Models Zenna Tavares 1 James Koppel 1 Xin Zhang 2 Ria Das 1 Armando Solar Lezama 1 Abstract We present OMEGAC, a probabilistic program- ming language with support for counterfactual inference. Counterfactual inference means to ob- serve some fact in the present, and infer what would have happened had some past intervention been taken, e.g. “given that medication was not effective at dose x, how likely would it have been effective at dose 2x?” We accomplish this by in- troducing a new operator to probabilistic program- ming akin to Pearl’s do, define its formal seman- Figure 1: A speeding driver (Left: driver’s view) crashes tics, provide an implementation, and demonstrate into a pedestrian (yellow) emerging from behind an ob- its utility by examples in population dynamics, struction (blue). Given a single frame of camera footage inverse planning, and graphics. (Right), OMEGAC infers whether driving below the speed limit would have prevented the crash. 1. Introduction To construct counterfactuals, OMEGAC introduces a do op- erator for constructing interventions: In this paper we introduce OMEGAC: a Turing-universal pro- gramming language for causal reasoning. OMEGA allows C Y j do(X ! x) (1) us to automatically derive causal inferences about phenom- ena that can only be modelled faithfully through simulation. This evaluates to what Y would have been had X been We focus on counterfactuals – what-if inferences about the bound to x when Y was defined. Consequently, if Y is a way the world could have been, had things been different. random variable and we define Yx = Y j do(X ! x), OMEGAC programs are simulation models augmented with then P (Yx = y) is the probability Y would have been y probability distributions to represent any uncertainty. In a had X had been x. A counterfactual is then simply Yx j E. similar vein to other probabilistic languages, OMEGAC pro- Note, if E depends on X, conditioning on it affects X’s vides primitive operators for conditioning, which revises the factual, non-intervened value, which is critical to capturing model to be consistent with any observed evidence. Counter- the semantics of counterfactuals. factuals, however, cannot be expressed through probabilistic To illustrate the potential of counterfactual reasoning within conditioning alone. They take the form: "Given that some a universal programming language, consider the scenario of evidence E is true, what would Y have been had X been an expert witness called to determine, from only a frame of different?" For example, given that a drug treatment was recorded video (Figure1), whether a driver was to blame not effective on a patient, would it have been effective at a for them crashing into a pedestrian. Using OMEGA , the ex- stronger dosage? Although one can condition on E being C pert could first construct a probabilistic model that includes true, attempting to condition on X being different to the the car dynamics, the driver and pedestrian’s behaviour, value it actually took is contradictory, and hence impossible. and a rendering function that relates the three dimensional 1CSAIL, MIT, USA 2Key Lab of High Confidence Software scene structure to two dimensional images. She could then Technologies, Ministry of Education, Department of Computer condition the model on the captured images to infer the Science and Technology, Peking University, China. Correspon- conditional distribution over the drivers velocity, determin- dence to: Zenna Tavares <[email protected]>, Xin Zhang ing the probability that the driver had been speeding. Us- <[email protected]>. ing OMEGAC she could then pose a counterfactual, asking Proceedings of the 38 th International Conference on Machine whether the crash would have still occurred even if the driver Learning, PMLR 139, 2021. Copyright 2021 by the author(s). had obeyed the speed limit. If she later wanted to investi- Submission and Formatting Instructions for ICML 2021 gate the culpability of another candidate cause, such as the laws of physics, etc. Any system for counterfactual rea- placement of the crosswalk, she could do so by adding a soning must provide mechanisms to construct hypothetical single-line, and without modifying her underlying models worlds that maintain invariances (and hence share informa- at all. tion) with the factual world, so that for instance the fact that I actually lost the match helps predict whether I would have Causal reasoning is currently done predominantly using won the match had I trained harder. causal graphical models (20): graphs whose vertices are variables, and whose directed edges represent causal de- These requirements have been resolved in the context of pendencies. Despite widespread use, causal graphs cannot causal graphical models. Causal interventions are “surgical easily express many real-world phenomena. One reason procedures” which modify single nodes but leave functional for this is that causal graphs are equivalent to straight-line dependencies intact. Pearl’s twin-network construction (20) programs: programs without conditional branching or loops of counterfactuals duplicates the model into one twice the – just finite sequences of primitive operations. Straight-line size. One half is the original model. The other half is a languages are not Turing-complete; they cannot express un- duplicate, modified to express the counterfactual interven- bounded models with an unknown number of variables. In tions. These halves are joined via a shared dependence on practice, they lack many of the features (composite func- the background facts. Hence, conditioning a variable in the tions, data types, polymorphism, etc.) necessary to express factual world influences the counterfactual world. the kinds of simulation models we would like to perform To generalize the twin-network construction to arbitrary pro- causal inference in. grams, OMEGAC runs two copies of a program, one factual Counterfactual reasoning in OMEGAC alleviates many of execution, and one counterfactual execution which shares these limitations. In an OMEGAC intervention X ! x, x some variables, but where others have been given alternate can be a constant, function, another random variable, or even definitions. It is folklore that programs doing this can be refer to its non-intervened self, e.g. X ! 2X. Moreover, built by hand, but, as in the twin-network construction, each users can construct various forms of stochastic interventions, intervention requires writing a separate model, and each and even condition the corresponding interventional worlds. counterfactual included doubles the size of the program. This allows users to model experimental error, or scenarios The solution in OMEGAC is to provide a new do operator where observers are unsure about which intervention has which removes the need to modify an existing program to taken place. add a counterfactual execution. Instead, t1 j do(x ! t2) is defined to be the value that a term t would take if x had A generic do operator that composes systematically with 1 been set to This works even if any dependencies of t on x conditioning presents several challenges. In particular, to 1 are indirect. For instance, if y = 2x, then y2 j do(x ! f) construct Y , we must be able to copy Y in such a way that X is equivalent to (2f)2. And note that the variable x can be the code that defines it is retroactively modified. This goes any variable, even one that is bound to a function, meaning beyond the capabilities of existing programming languages, users can compactly define interventions which are substan- probabilistic or otherwise, and hence OMEGA requires a C tial modifications. Finally, combining the operator with non-standard semantics and implementation. conditioning automatically gives counterfactual inference. In summary, we (i) present the syntax and semantics of a uni- Our examples show that OMEGA ’s do operator enables versal probabilistic language for counterfactual generative C compact definition of many counterfactual inference prob- models (Section3); (ii) provide a complete implementation lems. Indeed, in Appendix B, we prove that the do operator of OMEGA , and (iii) demonstrate counterfactual genera- C is not expressible as syntactic sugar (as defined by program- tive modelling through a number of examples (Section4). ming language theory). Regarding scope, causal inference includes problems of both (i) inferring a causal model from data, and (ii) given a causal model, predicting the result of interventions and 3. A Calculus for Counterfactuals counterfactuals on that model. This work focuses on the Our language OMEGA augments the functional probabilis- latter. C tic language OMEGA (31) with counterfactuals. To achieve this: (1) the syntax is augmented with a do operator, and 2. Overview of Counterfactuals (2) the language evaluation is changed from eager to lazy, which is key to handling interventions. In this section, we Counterfactual claims assume some structure is invariant introduce λ , a core calculus of OMEGA . We build the between the original factual world and intervened hypothet- C C language up in pieces: first showing the standard/determin- ical world. For instance, the counterfactual “If I had trained istic features, then features for deterministic interventions, more, I would have won the match” is predicated on the and finally the probabilistic ones. Together, intervention and invariance of the opponent’s skill, the existence of the game, Submission and Formatting Instructions for ICML 2021 conditioning give the language the ability to do counterfac- Causal Fragment Our causal fragment adds one new tual inference. Appendix A gives a more formal definition term: the do expression (Fig.3). t1 j do(x ! t2) eval- of the entire λC language. A Haskell implementation which uates t1 to the value that it would have evaluated to, had provides complete execution traces of terms in λC is avail- x been defined as t2 at point of definition. Here, x can able from https://tinyurl.com/y3cusyoe. be any variable that is in scope, bound locally or globally, and t can be any any term denoting a value.
Recommended publications
  • Comparative Studies of Programming Languages; Course Lecture Notes
    Comparative Studies of Programming Languages, COMP6411 Lecture Notes, Revision 1.9 Joey Paquet Serguei A. Mokhov (Eds.) August 5, 2010 arXiv:1007.2123v6 [cs.PL] 4 Aug 2010 2 Preface Lecture notes for the Comparative Studies of Programming Languages course, COMP6411, taught at the Department of Computer Science and Software Engineering, Faculty of Engineering and Computer Science, Concordia University, Montreal, QC, Canada. These notes include a compiled book of primarily related articles from the Wikipedia, the Free Encyclopedia [24], as well as Comparative Programming Languages book [7] and other resources, including our own. The original notes were compiled by Dr. Paquet [14] 3 4 Contents 1 Brief History and Genealogy of Programming Languages 7 1.1 Introduction . 7 1.1.1 Subreferences . 7 1.2 History . 7 1.2.1 Pre-computer era . 7 1.2.2 Subreferences . 8 1.2.3 Early computer era . 8 1.2.4 Subreferences . 8 1.2.5 Modern/Structured programming languages . 9 1.3 References . 19 2 Programming Paradigms 21 2.1 Introduction . 21 2.2 History . 21 2.2.1 Low-level: binary, assembly . 21 2.2.2 Procedural programming . 22 2.2.3 Object-oriented programming . 23 2.2.4 Declarative programming . 27 3 Program Evaluation 33 3.1 Program analysis and translation phases . 33 3.1.1 Front end . 33 3.1.2 Back end . 34 3.2 Compilation vs. interpretation . 34 3.2.1 Compilation . 34 3.2.2 Interpretation . 36 3.2.3 Subreferences . 37 3.3 Type System . 38 3.3.1 Type checking . 38 3.4 Memory management .
    [Show full text]
  • Application and Interpretation
    Programming Languages: Application and Interpretation Shriram Krishnamurthi Brown University Copyright c 2003, Shriram Krishnamurthi This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 United States License. If you create a derivative work, please include the version information below in your attribution. This book is available free-of-cost from the author’s Web site. This version was generated on 2007-04-26. ii Preface The book is the textbook for the programming languages course at Brown University, which is taken pri- marily by third and fourth year undergraduates and beginning graduate (both MS and PhD) students. It seems very accessible to smart second year students too, and indeed those are some of my most successful students. The book has been used at over a dozen other universities as a primary or secondary text. The book’s material is worth one undergraduate course worth of credit. This book is the fruit of a vision for teaching programming languages by integrating the “two cultures” that have evolved in its pedagogy. One culture is based on interpreters, while the other emphasizes a survey of languages. Each approach has significant advantages but also huge drawbacks. The interpreter method writes programs to learn concepts, and has its heart the fundamental belief that by teaching the computer to execute a concept we more thoroughly learn it ourselves. While this reasoning is internally consistent, it fails to recognize that understanding definitions does not imply we understand consequences of those definitions. For instance, the difference between strict and lazy evaluation, or between static and dynamic scope, is only a few lines of interpreter code, but the consequences of these choices is enormous.
    [Show full text]
  • Haskell Communities and Activities Report
    Haskell Communities and Activities Report http://tinyurl.com/haskcar Thirty Fourth Edition — May 2018 Mihai Maruseac (ed.) Chris Allen Christopher Anand Moritz Angermann Francesco Ariis Heinrich Apfelmus Gershom Bazerman Doug Beardsley Jost Berthold Ingo Blechschmidt Sasa Bogicevic Emanuel Borsboom Jan Bracker Jeroen Bransen Joachim Breitner Rudy Braquehais Björn Buckwalter Erik de Castro Lopo Manuel M. T. Chakravarty Eitan Chatav Olaf Chitil Alberto Gómez Corona Nils Dallmeyer Tobias Dammers Kei Davis Dimitri DeFigueiredo Richard Eisenberg Maarten Faddegon Dennis Felsing Olle Fredriksson Phil Freeman Marc Fontaine PÁLI Gábor János Michał J. Gajda Ben Gamari Michael Georgoulopoulos Andrew Gill Mikhail Glushenkov Mark Grebe Gabor Greif Adam Gundry Jennifer Hackett Jurriaan Hage Martin Handley Bastiaan Heeren Sylvain Henry Joey Hess Kei Hibino Guillaume Hoffmann Graham Hutton Nicu Ionita Judah Jacobson Patrik Jansson Wanqiang Jiang Dzianis Kabanau Nikos Karagiannidis Anton Kholomiov Oleg Kiselyov Ivan Krišto Yasuaki Kudo Harendra Kumar Rob Leslie David Lettier Ben Lippmeier Andres Löh Rita Loogen Tim Matthews Simon Michael Andrey Mokhov Dino Morelli Damian Nadales Henrik Nilsson Wisnu Adi Nurcahyo Ulf Norell Ivan Perez Jens Petersen Sibi Prabakaran Bryan Richter Herbert Valerio Riedel Alexey Radkov Vaibhav Sagar Kareem Salah Michael Schröder Christian Höner zu Siederdissen Ben Sima Jeremy Singer Gideon Sireling Erik Sjöström Chris Smith Michael Snoyman David Sorokin Lennart Spitzner Yuriy Syrovetskiy Jonathan Thaler Henk-Jan van Tuyl Tillmann Vogt Michael Walker Li-yao Xia Kazu Yamamoto Yuji Yamamoto Brent Yorgey Christina Zeller Marco Zocca Preface This is the 34th edition of the Haskell Communities and Activities Report. This report has 148 entries, 5 more than in the previous edition.
    [Show full text]
  • Pure Quick Reference
    Pure Quick Reference Albert Graf¨ April 15, 2018 Abstract This is a quick reference guide to the Pure programming language for the impa- tient. It briefly summarizes all important language constructs and gives a few basic examples, so that seasoned programmers can pick up the language at a glance and start hacking away as quickly as possible. Copyright © 2009-2018 Albert Gräf. Permission is granted to copy, distribute and/or modify this docu- ment under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation. See http://www.gnu.org/copyleft/fdl.html. The latest version of this document can be found at https://agraef.github.io/pure-lang/quickref/pure-quickref.pdf. Contents 1 Introduction 3 1.1 Background and Recommended Reading . 3 1.2 Getting Started . 4 2 Lexical Matters 5 3 Expressions 6 3.1 Primary Expressions . 7 3.2 Function Applications . 9 3.3 Operators . 11 3.4 Predefined Operators . 13 3.5 Patterns . 15 3.6 Conditional Expressions . 18 3.7 Block Expressions . 19 3.8 Lexical Scoping . 21 3.9 Comprehensions . 22 3.10 Special Forms . 23 1 4 Definitions 26 4.1 The Global Scope . 26 4.2 Rule Syntax . 27 4.3 Function Definitions . 29 4.4 Variable Definitions . 33 4.5 Constant Definitions . 33 4.6 Type Definitions . 34 4.7 Macro Definitions . 37 5 Programs and Modules 38 5.1 Modules . 38 5.2 Namespaces . 39 5.3 Private Symbols . 42 5.4 Hierarchical Namespaces . 42 6 C Interface 43 7 The Interpreter 45 7.1 Running the Interpreter .
    [Show full text]
  • Rxjs in Action
    Paul P. Daniels Luis Atencio FOREWORD BY Ben Lesh MANNING www.allitebooks.com RxJS in Action www.allitebooks.com www.allitebooks.com RxJS in Action COVERS RXJS 5 PAUL P. DANIELS LUIS ATENCIO FOREWORD BY BEN LESH MANNING SHELTER ISLAND www.allitebooks.com For online information and ordering of this and other Manning books, please visit www.manning.com. The publisher offers discounts on this book when ordered in quantity. For more information, please contact Special Sales Department Manning Publications Co. 20 Baldwin Road PO Box 761 Shelter Island, NY 11964 Email: [email protected] ©2017 by Manning Publications Co. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by means electronic, mechanical, photocopying, or otherwise, without prior written permission of the publisher. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in the book, and Manning Publications was aware of a trademark claim, the designations have been printed in initial caps or all caps. Recognizing the importance of preserving what has been written, it is Manning’s policy to have the books we publish printed on acid-free paper, and we exert our best efforts to that end. Recognizing also our responsibility to conserve the resources of our planet, Manning books are printed on paper that is at least 15 percent recycled and processed without the use of elemental chlorine. Manning Publications Co. Development
    [Show full text]
  • Functional Programming and the Lambda Calculus
    Functional Programming and the Lambda Calculus Stephen A. Edwards Columbia University Fall 2008 Functional vs. Imperative Imperative programming concerned with “how.” Functional programming concerned with “what.” Based on the mathematics of the lambda calculus (Church as opposed to Turing). “Programming without variables” It is elegant and a difficult setting in which to create subtle bugs. It’s a cult: once you catch the functional bug, you never escape. Referential transparency The main (good) property of functional programming is referential transparency. Every expression denotes a single value. The value cannot be changed by evaluating an expression or by sharing it between different parts of the program. No references to global data; there is no global data. There are no side-effects, unlike in referentially opaque languages. The Lambda Calculus Fancy name for rules about how to represent and evaluate expressions with unnamed functions. Theoretical underpinning of functional languages. Side-effect free. Very different from the Turing model of a store with evolving state. O’Caml: The Lambda Calculus: fun x ­> 2 * x λx . ∗ 2 x English: The function of x that returns the product of two and x Grammar of Lambda Expressions expr → constant | variable-name | expr expr | (expr) | λ variable-name . expr Constants are numbers; variable names are identifiers and operators. Somebody asked, “does a language needs to have a large syntax to be powerful?” Bound and Unbound Variables In λx . ∗ 2 x, x is a bound variable. Think of it as a formal parameter to a function. “∗ 2 x” is the body. The body can be any valid lambda expression, including another unnnamed function.
    [Show full text]
  • Brno University of Technology Just-In-Time
    BRNO UNIVERSITY OF TECHNOLOGY VYSOKÉ UČENÍ TECHNICKÉ V BRNĚ FACULTY OF INFORMATION TECHNOLOGY FAKULTA INFORMAČNÍCH TECHNOLOGIÍ DEPARTMENT OF INTELLIGENT SYSTEMS ÚSTAV INTELIGENTNÍCH SYSTÉMŮ JUST-IN-TIME COMPILATION OF THE DEPENDENTLY-TYPED LAMBDA CALCULUS JUST-IN-TIME PŘEKLAD ZÁVISLE TYPOVANÉHO LAMBDA KALKULU MASTER’S THESIS DIPLOMOVÁ PRÁCE AUTHOR Bc. JAKUB ZÁRYBNICKÝ AUTOR PRÁCE SUPERVISOR Ing. ONDŘEJ LENGÁL, Ph.D. VEDOUCÍ PRÁCE BRNO 2021 Brno University of Technology Faculty of Information Technology Department of Intelligent Systems (DITS) Academic year 2020/2021 Master's Thesis Specification Student: Zárybnický Jakub, Bc. Programme: Information Technology Field of Intelligent Systems study: Title: Just-in-Time Compilation of Dependently-Typed Lambda Calculus Category: Compiler Construction Assignment: 1. Investigate dependent types, simply-typed and dependently-typed lambda calculus, and their evaluation models (push/enter, eval/apply). 2. Get familiar with the Graal virtual machine and the Truffle language implementation framework. 3. Create a parser and an interpreter for a selected language based on dependently-typed lambda calculus. 4. Propose a method of normalization-by-evaluation for dependent types and implement it for the selected language. 5. Create a just-in-time (JIT) compiler for the language using the Truffle API. 6. Compare the runtime characteristics of the interpreter and the JIT compiler, evaluate the results. Recommended literature: https://www.graalvm.org/ Löh, Andres, Conor McBride, and Wouter Swierstra. "A tutorial implementation of a dependently typed lambda calculus." Fundamenta Informaticae 21 (2001): 1001-1031. Marlow, Simon, and Simon Peyton Jones. "Making a fast curry: push/enter vs. eval/apply for higher-order languages." Journal of Functional Programming 16.4-5 (2006): 415-449.
    [Show full text]
  • An Introduction to Probabilistic Programming Arxiv:1809.10756V1
    An Introduction to Probabilistic Programming Jan-Willem van de Meent College of Computer and Information Science Northeastern University [email protected] Brooks Paige Alan Turing Institute University of Cambridge [email protected] Hongseok Yang School of Computing KAIST [email protected] Frank Wood Department of Computer Science University of British Columbia [email protected] arXiv:1809.10756v1 [stat.ML] 27 Sep 2018 Contents Abstract1 Acknowledgements3 1 Introduction8 1.1 Model-based Reasoning . 10 1.2 Probabilistic Programming . 21 1.3 Example Applications . 26 1.4 A First Probabilistic Program . 29 2 A Probabilistic Programming Language Without Recursion 31 2.1 Syntax . 32 2.2 Syntactic Sugar . 37 2.3 Examples . 42 2.4 A Simple Purely Deterministic Language . 48 3 Graph-Based Inference 51 3.1 Compilation to a Graphical Model . 51 3.2 Evaluating the Density . 66 3.3 Gibbs Sampling . 74 3.4 Hamiltonian Monte Carlo . 80 3.5 Compilation to a Factor Graph . 89 3.6 Expectation Propagation . 94 4 Evaluation-Based Inference I 102 4.1 Likelihood Weighting . 105 4.2 Metropolis-Hastings . 116 4.3 Sequential Monte Carlo . 125 4.4 Black Box Variational Inference . 131 5 A Probabilistic Programming Language With Recursion 138 5.1 Syntax . 142 5.2 Syntactic sugar . 143 5.3 Examples . 144 6 Evaluation-Based Inference II 155 6.1 Explicit separation of model and inference code . 156 6.2 Addressing Transformation . 161 6.3 Continuation-Passing-Style Transformation . 165 6.4 Message Interface Implementation . 171 6.5 Likelihood Weighting . 175 6.6 Metropolis-Hastings .
    [Show full text]
  • LEAGER PROGRAMMING Abstract
    LEAGER PROGRAMMING Anthony Chyr UUCS-19-002 School of Computing University of Utah Salt Lake City, UT 84112 USA February 26, 2019 Abstract Leager programming, a portmanteau of “lazy” and “eager” or “limit” and “eager,” is an evaluation strategy that mixes lazy evaluation and eager evaluation. This evaluation strategy allows iterators to precompute the next value in a separate thread, storing the result in a cache until it is needed by the caller. Leager programming often takes the form of an iterator, which alone allows data to be prefetched, and when chained together can be used to form concurrent pipelines. We found a dramatic reduction in latency on par with code written with asynchronous callbacks, while making minimal modifications to the initial sequential code. LEAGER PROGRAMMING by Anthony Chyr A senior thesis submitted to the faculty of The University of Utah in partial fulfillment of the requirements for the degree of Bachelor of Computer Science School of Computing The University of Utah May 2019 Approved: / / Matthew Flatt H. James de St. Germain Supervisor Director of Undergraduate Studies School of Computing / Ross Whitaker Diretor School of Computing Copyright c Anthony Chyr 2019 All Rights Reserved ABSTRACT Leager programming, a portmanteau of “lazy” and “eager” or “limit” and “eager,” is an evaluation strategy that mixes lazy evaluation and eager evaluation. This evaluation strategy allows iterators to precompute the next value in a separate thread, storing the result in a cache until it is needed by the caller. Leager programming often takes the form of an iterator, which alone allows data to be prefetched, and when chained together can be used to form concurrent pipelines.
    [Show full text]
  • A Distributed Execution Engine Supporting Data-Dependent Control flow
    A distributed execution engine supporting data-dependent control flow Derek Gordon Murray University of Cambridge Computer Laboratory King’s College July 2011 This dissertation is submitted for the degree of Doctor of Philosophy Declaration This dissertation is the result of my own work and includes nothing which is the outcome of work done in collaboration except where specifically indicated in the text. This dissertation does not exceed the regulation length of 60,000 words, including tables and footnotes. A distributed execution engine supporting data-dependent control flow Derek G. Murray Summary In computer science, data-dependent control flow is the fundamental concept that enables a machine to change its behaviour on the basis of intermediate results. This ability increases the computational power of a machine, because it enables the machine to execute iterative or recursive algorithms. In such algorithms, the amount of work is unbounded a priori, and must be determined by evaluating a fixpoint condition on successive intermediate results. For example, in the von Neumann architecture—upon which almost all modern computers are based—these algorithms can be programmed using a conditional branch instruction. A distributed execution engine is a system that runs on a network of computers, and provides the illusion of a single, reliable machine that provides a large aggregate amount of compu- tational and I/O performance. Although each individual computer in these systems is a von Neumann machine capable of data-dependent control flow, the effective computational power of a distributed execution engine is determined by the expressiveness of the execution model that describes distributed computations.
    [Show full text]
  • Name Synopsis Options Description
    Pure(1) Pure(1) NAME pure − the Pure interpreter SYNOPSIS pure [options ...] [script ...] [-- args ...] pure [options ...] -x script [args ...] OPTIONS --help, -h Print help message and exit. -i Force interactive mode (read commands from stdin). -Idirectory Add a directory to be searched for included source scripts. -Ldirectory Add a directory to be searched for dynamic libraries. --noediting Do not use readline for command-line editing. --noprelude, -n Do not load the prelude. --norc Do not run the interactive startup files. -q Quiet startup (suppresses sign-on message in interactive mode). -v[level] Set verbosity level. See belowfor details. --version Print version information and exit. -x Execute script with givencommand line arguments. -- Stop option processing and pass the remaining command line arguments in the argv variable. DESCRIPTION Pure is a modern-style functional programming language based on term rewriting. Pure programs are basi- cally collections of equational rules used to evaluate expressions in a symbolic fashion by reducing them to normal form. A brief overviewofthe language can be found in the PURE OVERVIEW section below. (In case you’re wondering, the name ‘‘Pure’’actually refers to the adjective.But you can also write it as ‘‘PURE’’and takethis as a recursive acronym for the ‘‘Pure Universal Rewriting Engine’’.) pure is the Pure interpreter.The interpreter has an LLVM backend which JIT-compiles Pure programs to machine code, hence programs run blazingly fast and interfacing to C modules is easy,while the interpreter still provides a convenient, fully interactive environment for running Pure scripts and evaluating expres- sions. Pure programs (a.k.a.
    [Show full text]
  • Optimising Compilers
    Computer Laboratory Optimising Compilers Computer Science Tripos Part II Timothy Jones Lent 2019 [email protected] http://www.cl.cam.ac.uk/Teaching/1819/OptComp/ Learning Guide The course as lectured proceeds fairly evenly through these notes, with 7 lectures devoted to part A, 5 to part B and 3 or 4 devoted to parts C and D. Part A mainly consists of analy- sis/transformation pairs on flowgraphs whereas part B consists of more sophisticated analyses (typically on representations nearer to source languages) where typically a general framework and an instantiation are given. Part C consists of an introduction to instruction scheduling and part D an introduction to decompilation and reverse engineering. One can see part A as intermediate-code to intermediate-code optimisation, part B as (al- ready typed if necessary) parse-tree to parse-tree optimisation and part C as target-code to target-code optimisation. Part D is concerned with the reverse process. Rough contents of each lecture are: Lecture 1: Introduction, flowgraphs, call graphs, basic blocks, types of analysis Lecture 2: (Transformation) Unreachable-code elimination Lecture 3: (Analysis) Live variable analysis Lecture 4: (Analysis) Available expressions Lecture 5: (Transformation) Uses of LVA Lecture 6: (Continuation) Register allocation by colouring Lecture 7: (Transformation) Uses of Avail; Code motion Lecture 8: Static Single Assignment; Strength reduction Lecture 9: (Framework) Abstract interpretation Lecture 10: (Instance) Strictness analysis Lecture 11: (Framework) Constraint-based analysis; (Instance) Control-flow analysis (for λ-terms) Lecture 12: (Framework) Inference-based program analysis Lecture 13: (Instance) Effect systems Lecture 13a: Points-to and alias analysis Lecture 14: Instruction scheduling Lecture 15: Same continued, slop Lecture 16: Decompilation.
    [Show full text]