scholarly journals Correctness of Automatic Differentiation via Diffeologies and Categorical Gluing

2020 ◽  
pp. 319-338 ◽  
Author(s):  
Mathieu Huot ◽  
Sam Staton ◽  
Matthijs Vákár
Keyword(s):  
Automatic Differentiation ◽  
Higher Order ◽  
Data Types ◽  
Structure Preserving ◽  
Correctness Proofs ◽  
Unique Structure ◽  
Order Language ◽  
Algebraic Data Types ◽  
Semantic Correctness

AbstractWe present semantic correctness proofs of Automatic Differentiation (AD). We consider a forward-mode AD method on a higher order language with algebraic data types, and we characterise it as the unique structure preserving macro given a choice of derivatives for basic operations. We describe a rich semantics for differentiable programming, based on diffeological spaces. We show that it interprets our language, and we phrase what it means for the AD method to be correct with respect to this semantics. We show that our characterisation of AD gives rise to an elegant semantic proof of its correctness based on a gluing construction on diffeological spaces. We explain how this is, in essence, a logical relations argument. Finally, we sketch how the analysis extends to other AD methods by considering a continuation-based method.

scholarly journals Sharing analysis in the Pawns compiler

2015 ◽  
Author(s):  
Lee Naish
Keyword(s):  
Programming Language ◽  
Data Structures ◽  
Source Code ◽  
Higher Order ◽  
Declarative Programming ◽  
Data Types ◽  
Shared Data ◽  
Algebraic Data Types ◽  
Higher Order Functions

Pawns is a programming language under development which supports algebraic data types, polymorphism, higher order functions and "pure" declarative programming. It also supports impure imperative features including destructive update of shared data structures via pointers, allowing significantly increased efficiency for some operations. A novelty of Pawns is that all impure "effects" must be made obvious in the source code and they can be safely encapsulated in pure functions in a way that is checked by the compiler. Execution of a pure function can perform destructive updates on data structures which are local to or eventually returned from the function without risking modification of the data structures passed to the function. This paper describes the sharing analysis which allows impurity to be encapsulated. Aspects of the analysis are similar to other published work, but in addition it handles explicit pointers and destructive update, higher order functions including closures and pre- and postconditions concerning sharing for functions.

scholarly journals Finally tagless, partially evaluated: Tagless staged interpreters for simpler typed languages

2009 ◽  
Vol 19 (5) ◽  
pp. 509-543 ◽  
Author(s):  
JACQUES CARETTE ◽  
OLEG KISELYOV ◽  
CHUNG-CHIEH SHAN
Keyword(s):  
Partial Evaluation ◽  
Higher Order ◽  
Dependent Types ◽  
Abstract Syntax ◽  
Object Language ◽  
Data Types ◽  
Initial Algebra ◽  
The Family ◽  
De Bruijn ◽  
Algebraic Data Types

AbstractWe have built the first family of tagless interpretations for a higher-order typed object language in a typed metalanguage (Haskell or ML) that require no dependent types, generalized algebraic data types, or postprocessing to eliminate tags. The statically type-preserving interpretations include an evaluator, a compiler (or staged evaluator), a partial evaluator, and call-by-name and call-by-value continuation-passing style (CPS) transformers. Our principal technique is to encode de Bruijn or higher-order abstract syntax using combinator functions rather than data constructors. In other words, we represent object terms not in an initial algebra but using the coalgebraic structure of the λ-calculus. Our representation also simulates inductive maps from types to types, which are required for typed partial evaluation and CPS transformations. Our encoding of an object term abstracts uniformly over the family of ways to interpret it, yet statically assures that the interpreters never get stuck. This family of interpreters thus demonstrates again that it is useful to abstract over higher-kinded types.

scholarly journals Sharing analysis in the Pawns compiler

2015 ◽  
Author(s):  
Lee Naish
Keyword(s):  
Programming Language ◽  
Data Structures ◽  
Source Code ◽  
Higher Order ◽  
Declarative Programming ◽  
Data Types ◽  
Shared Data ◽  
Algebraic Data Types ◽  
Higher Order Functions

Pawns is a programming language under development that supports algebraic data types, polymorphism, higher order functions and "pure" declarative programming. It also supports impure imperative features including destructive update of shared data structures via pointers, allowing significantly increased efficiency for some operations. A novelty of Pawns is that all impure "effects" must be made obvious in the source code and they can be safely encapsulated in pure functions in a way that is checked by the compiler. Execution of a pure function can perform destructive updates on data structures that are local to or eventually returned from the function without risking modification of the data structures passed to the function. This paper describes the sharing analysis which allows impurity to be encapsulated. Aspects of the analysis are similar to other published work, but in addition it handles explicit pointers and destructive update, higher order functions including closures and pre- and post-conditions concerning sharing for functions.

scholarly journals Sharing analysis in the Pawns compiler

2015 ◽  
Author(s):  
Lee Naish
Keyword(s):  
Programming Language ◽  
Data Structures ◽  
Source Code ◽  
Higher Order ◽  
Declarative Programming ◽  
Data Types ◽  
Shared Data ◽  
Algebraic Data Types ◽  
Higher Order Functions

Pawns is a programming language under development that supports algebraic data types, polymorphism, higher order functions and "pure" declarative programming. It also supports impure imperative features including destructive update of shared data structures via pointers, allowing significantly increased efficiency for some operations. A novelty of Pawns is that all impure "effects" must be made obvious in the source code and they can be safely encapsulated in pure functions in a way that is checked by the compiler. Execution of a pure function can perform destructive updates on data structures that are local to or eventually returned from the function without risking modification of the data structures passed to the function. This paper describes the sharing analysis which allows impurity to be encapsulated. Aspects of the analysis are similar to other published work, but in addition it handles explicit pointers and destructive update, higher order functions including closures and pre- and post-conditions concerning sharing for functions.

Higher Order Language: Risk, Promotive, and Risk-Based Protective Associations with Youth Offending

2021 ◽  
pp. 001112872110077
Author(s):  
Stavroola A. S. Anderson ◽  
David J. Hawes ◽  
Pamela C. Snow
Keyword(s):  
Oral Language ◽  
Figurative Language ◽  
Protective Factor ◽  
Language Skills ◽  
Theoretical Models ◽  
Higher Order ◽  
Protective Effects ◽  
Youth Offenders ◽  
Order Language ◽  
Nonverbal Skills

Research has implicated oral language deficits as risk factors for antisocial behavior. The aim of this study was to investigate the relationship between higher order language skills and youth offending through a risk, promotive and risk-based protective factor paradigm. In a sample of adolescent males ( n = 130; 13 to 20 years; 62% youth offenders) skills in understanding ambiguity, making inferences, and understanding figurative language were demonstrated to have risk and promotive effects in association with youth offending. Figurative language also met criteria for having risk-based protective effects for youth at high offending risk due to poor nonverbal skills. Conceptualization of higher order language skills through this paradigm promotes a broader frame of reference for considering theoretical models and practical interventions.

DERIVING AND SCHEDULING COMMUNICATION OPERATIONS FOR GENERIC SKELETON IMPLEMENTATIONS

2005 ◽  
Vol 15 (03) ◽  
pp. 337-352 ◽  
Author(s):  
THOMAS NITSCHE
Keyword(s):  
Iterative Solution ◽  
Synchronous Communication ◽  
Data Types ◽  
Communication Scheduling ◽  
Overlapping Data ◽  
Abstract Notion ◽  
Algebraic Data Types ◽  
Data Elements ◽  
Communication Operations

Data distributions are an abstract notion for describing parallel programs by means of overlapping data structures. A generic data distribution layer serves as a basis for implementing specific data distributions over arbitrary algebraic data types and arrays as well as generic skeletons. The necessary communication operations for exchanging overlapping data elements are derived automatically from the specification of the overlappings. This paper describes how the communication operations used internally by the generic skeletons are derived, especially for the asynchronous and synchronous communication scheduling. As a case study, we discuss the iterative solution of PDEs and compare a hand-coded MPI version with a skeletal one based on overlapping data distributions.

Sign in / Sign up

Export Citation Format

Share Document