Linear typing schemes guarantee single-threadedness and so the soundness of in-place update with respect to a functional semantics. But linear

Destructive array update optimization is critical for writing scientific codes in functional languages. We present set constraints for an interprocedural update optimization that runs in polynomial time. This is a multi-pass optimization, involving interprocedural flow analyses for aliasing and liveness. We characterize and prove the soundness of these analyses using smallstep operational semantics. We also prove that any sound liveness analysis induces a correct program transformation.

Specification languages like PVS are designed to be expressive rather than executable. However, execution is useful for animating and validating specifications, and for automating certain kinds of proofs. A surprisingly large fragment of PVS turns out to be executable as a functional language with quite reasonable efficiency. Execution is achieved by generating Common Lisp code from PVS. The key step in generating efficient code is the use of static analysis to determine safe destructive array updates. Contents 1 Introduction 5 2 A Brief Summary of the PVS Specification Language 7 3 Executing PVS 13 3.1 Translating Primitive Operations . . . . . . . . . . . . . . . . 15 3.2 Translating Expressions . . . . . . . . . . . . . . . . . . . . . 16 3.3 Optimizing Unary to Multiary Function Application . . . . . . 19 3.3.1 Examples . . . . . . . . . . . . . . . . . . . . . . . . . 20 3.4 Translating Recursive Datatypes . . . . . . . . . . . . . . . . . 25 4 Optimizing Nondestructive to Destr...

this paper is for a generic functional language and requires no prior knowledge of PVS.

Abstract. We present a multi-pass interprocedural analysis and transformation for the functional aggregate update problem. Our solution handles untyped programs, including unrestricted closures and nested arrays. Also, it can handle programs that contain a mix of functional and destructive updates. Correctness of all the analyses and of the transformation itself is proved. 1

Many predominantly lazy languages now incorporate strictness enforcing primitives, for example a strict let or sequential composition seq. Reasons for doing this include gains in time or space efficiencies, or control of parallel evaluation. This thesis studies how to prove equivalences between programs in languages with selective strictness, specifically, we use a restricted core lazy functional language with a selective strictness operator seq whose operational semantics is a variant of one considered by van Eckelen and de Mol, which itself was derived from Launchbury’s natural semantics for lazy evaluation. The main research contributions are as follows: We establish some of the first ever equivalences between programs with selective strictness. We do this by manipulating operational semantics derivations, in

This thesis studies how to prove equivalences between programs in languages with selective strictness, specifically, we use a restricted core lazy functional language with a selective strictness operator seq. We establish some of the first ever equivalences between lazy programs with selective strictness by manipulating operational semantics derivations. Our operational semantics is similar to that used by van Eekelen and De Mol, though we introduce a ‘garbage-collecting’ rule for (let) which turns out to cause expressiveness restrictions. For example, arguably reasonable lazy programs such as let y = λz.z in λx.y do not reduce in our operational semantics. We prove some properties of seq, including associativity, idempotence, and left-commutativity. The proofs use our three notions of program equivalence defined