Parametric Polymorphism through Run-Time Sealing or, Theorems for Low, Low Prices!

Matthews, Jacob; Ahmed, Amal

doi:10.1007/978-3-540-78739-6_2

Cited by 41 publications

(30 citation statements)

References 15 publications

(15 reference statements)

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The observation that sealing could be useful to combine parametric polymorphism with dynamic typing was already made by Pierce and Sumii [2000]. This idea was further developed with the definition of a gradually-typed language based on this idea [Ahmed et al 2011c;Matthews and Ahmed 2008], the addition of blame in the polymorphic blame calculus [Ahmed et al 2011a], further developed by Igarashi et al [2017] and Ahmed et al [2017]. Ahmed et al also prove a form of parametricity in the polymorphic blame calculus, but their formulation is rather different than existing ones (e.g.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Parametricity versus the universal type

Devriese

Patrignani

Piessens

2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

There has long been speculation in the scientific literature on how to dynamically enforce parametricity such as that yielded by System F. Almost 20 years ago, Sumii and Pierce proposed a formal compiler from System F into the cryptographic lambda calculus: an untyped lambda calculus extended with an idealised model of encryption. They conjectured that this compiler was fully abstract, i.e. that compiled terms are contextually equivalent if and only if the original terms were, a property that can be seen as a form of secure compilation. The conjecture has received attention in several other publications since then, but remains open to this day.More recently, several researchers have been looking at gradually-typed languages that extend System F. In this setting it is natural to wonder whether embedding System F into these gradually-typed languages preserves contextual equivalence and thus parametricity.In this paper, we answer both questions negatively. We provide a concrete counterexample: two System F terms whose contextual equivalence is not preserved by the Sumii-Pierce compiler, nor the embedding into the polymorphic blame calculus. This counterexample relies on the absence in System F of what we call a universal type, i.e., a type that all other types can be injected into and extracted from. As the languages in which System F is compiled have a universal type, the compilation cannot be fully abstract; this paper explains why.We believe this paper thus sheds light on recent results in the field of gradually typed languages and it provides a perspective for further research into secure compilation of polymorphic languages.To better explain and clarify notions, this paper uses colours, please print or view this in colours.

show abstract

Section: Introductionmentioning

confidence: 99%

“…As an instance of a multi-language (as proposed by ), Matthews and Ahmed [2008] construct a language that can embed both Scheme (i.e. an untyped lambda calculus) and ML (i.e.…”

Section: Related Workmentioning

confidence: 99%

Parametricity versus the universal type

Devriese

Patrignani

Piessens

2017

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

show abstract

“…In this paper, we have shown how to preserve ML's parametricity guarantees part-way through the compiler. Going forward we wish to develop a gradually typed assembly language that, following Matthews and Ahmed [16], uses dynamic sealing on the untyped side to enforce parametricity guarantees provided by type abstraction on the typed side.…”

Section: Discussion and Future Workmentioning

confidence: 99%

Verifying an Open Compiler Using Multi-language Semantics

Perconti

Ahmed

2014

Lecture Notes in Computer Science

Self Cite

View full text Add to dashboard Cite

Abstract. Existing verified compilers are proved correct under a closed-world assumption, i.e., that the compiler will only be used to compile whole programs. We present a new methodology for verifying correct compilation of program components, while formally allowing linking with target code of arbitrary provenance. To demonstrate our methodology, we present a two-pass type-preserving open compiler and prove that compilation preserves semantics. The central novelty of our approach is that we define a combined language that embeds the source, intermediate, and target languages and formalizes a semantics of interoperability between them, using boundaries in the style of Matthews and Findler. Compiler correctness is stated as contextual equivalence in the combined language. Note to reader: We use blue, red, and purple to typeset terms in various languages. This paper will be difficult to follow unless read/printed in color.

show abstract

“…But since step-indexed logical relations can be defined by induction on future step counts, the method can be used to reason about untyped languages. In recent work, Acar et al [2008] and Matthews and Ahmed [2008] have demonstrated the use of step-indexed logical relations in untyped settings.…”

Section: Step-indexed Logical Relationsmentioning

confidence: 99%

Semantic foundations for typed assembly languages

Ahmed

Appel

Richards

et al. 2010

ACM Trans. Program. Lang. Syst.

Self Cite

View full text Add to dashboard Cite

Typed Assembly Languages (TALs) are used to validate the safety of machine-language programs. The Foundational Proof-Carrying Code project seeks to verify the soundness of TALs using the smallest possible set of axioms-the axioms of a suitably expressive logic plus a specification of machine semantics. This paper proposes general semantic foundations that permit modular proofs of the soundness of TALs. These semantic foundations include Typed Machine Language (TML), a type theory for specifying properties of low-level data with powerful and orthogonal type constructors, and Lc, a compositional logic for specifying properties of machine instructions with simplified reasoning about unstructured control flow. Both of these components, whose semantics we specify using higher-order logic, are useful for proving the soundness of TALs. We demonstrate this by using TML and Lc to verify the soundness of a low-level, typed assembly language, LTAL, which is the target of our core-ML-to-sparc compiler.To prove the soundness of the TML type system we have successfully applied a new approach, that of step-indexed logical relations. This approach provides the first semantic model for a type system with updatable references to values of impredicative quantified types. Both impredicative polymorphism and mutable references are essential when representing function closures in compilers with typed closure conversion, or when compiling objects to simpler typed primitives.

show abstract

Parametric Polymorphism through Run-Time Sealing or, Theorems for Low, Low Prices!

Cited by 41 publications

References 15 publications

Parametricity versus the universal type

Parametricity versus the universal type

Verifying an Open Compiler Using Multi-language Semantics

Semantic foundations for typed assembly languages

Contact Info

Product

Resources

About