Exact flow analysis

  title={Exact flow analysis},
  author={Christian Mossin},
  journal={Mathematical Structures in Computer Science},
  pages={125 - 156}
  • C. Mossin
  • Published 8 September 1997
  • Mathematics
  • Mathematical Structures in Computer Science
We present a type-based flow analysis for simply typed lambda calculus with booleans, data-structures and recursion. The analysis is exact in the following sense: if the analysis predicts a redex, there exists a reduction sequence (using standard reduction plus context propagation rules) such that this redex will be reduced. The precision is accomplished using intersection typing. It follows that the analysis is non-elementary recursive – more surprisingly, the analysis is decidable. We argue… 

The Complexity of Flow Analysis in Higher-Order Languages

This dissertation proves lower bounds on the inherent difficulty of deciding flow analysis problems in higher-order programming languages. We give exact characterizations of the computational

Abstract Interpretation Based Formal Methods and Future Challenges

The main point is that in order to reason or compute about a complex system, some information must be lost, that is the observation of executions must be either partial or at a high level of abstraction.

Flow Analysis, Linearity, and PTIME

A core language is identified--the linear i¾?-calculus--where 0CFA, simple closure analysis, and many other known approximations or restrictions to 0C FA are rendered identical and analysis corresponds with (instrumented) evaluation.

Model Checking Higher-Order Programs 1

A novel verification method for higher-order functional programs based on higherorder model checking, which is sound, complete, and automatic for the simply-typed λ-calculus with recursion and finite base types, and for various program verification problems such as reachability, flow analysis, and resource usage verification.

Types in Program Analysis

  • T. Jensen
  • Computer Science
    The Essence of Computation
  • 2002
This paper surveys type-based program analysis with an emphasis on the polyvariant program analyses that can be obtained using conjunctive types and parametric polymorphism, and shows how binding-time analysis and strictness analysis are variations of a common framework based on conj unctive types.

Intersection types and higer-order model checking

A generalisation of the intersection type approach is presented in which higher-order model checking is seen as an instance of exact abstract interpretation, by giving a natural treatment of higher-type properties, which are sets of functions.

Model Checking Higher-Order Programs

A variety of program verification problems can be reduced to model checking problems for recursion schemes, by transforming a program into a recursion scheme that generates a tree representing all the interesting possible event sequences of the program.

A Type- and Control-Flow Analysis for System F

A monovariant flow analysis for System F (with recursion) yields both control-flow information, approximating the λand Λ-expressions that may be bound to variables, and type-flow Information, approximates the type expressions that may instantiate type variables.

Relating complexity and precision in control flow analysis

The analysis of kCFA, a hierarchy of control flow analyses that determine which functions may be applied at a given call-site, identifies a simple decision problem answered by this analysis and proves that in the 0CFA case, the problem is complete for polynomial time.

A type system equivalent to a model checker

The result sheds light on the relationship between type systems and model checking, provides a methodology for studying their relative expressiveness, is a step towards sharing results between the two approaches, and motivates synergistic program analyses involving interplay between them.



A modular, polyvariant and type-based closure analysis

This work uses the principal typing property of a type system to formulate a modular and polyvariant closure analysis, based on the rank 2 intersection types annotated with control-flow information, which can be used in the separate compilation of programs.

Automatic Binding Time Analysis for a Typed lambda-Calculus

Dynamic Typing: Syntax and Proof Theory

Intersection Type Assignment Systems

  • S. V. Bakel
  • Computer Science, Mathematics
    Theor. Comput. Sci.
  • 1995

Higher-Order Value Flow Graphs

  • C. Mossin
  • Computer Science
    Nord. J. Comput.
  • 1998
A method for constructing value flow graphs for typed higher-order functional languages and it is a reasonable assumption that typed programs are only bigger than their untyped equivalent by a constant factor, hence this is an asymptotic improvement over previous algorithms.

A New Technique for Strictness Analysis

Results from Unification Theory and type inference with coercions are combined to produce a new method for performing strictness analysis of functional programs, in which extended types are derivable for terms of the λ-calculus.

A filter lambda model and the completeness of type assignment

In [6, p. 317] Curry described a formal system assigning types to terms of the type-free λ-calculus. In [11] Scott gave a natural semantics for this type assignment and asked whether a completeness

On strictness and its analysis

The discovery that the problem of strictness analysis is a particular case of type inference is found, which provides a sound basis for reasoning about strictness properties of terms by considering only their principal type.

Infinitary control flow analysis: a collecting semantics for closure analysis

This paper shows how to define a collecting semantics for control flow analysis and proves the semantic soundness of the collecting semantics and that all totally deterministic instantiations have a least solution.

The typed λ-calculus is not elementary recursive

  • R. Statman
  • Mathematics
    18th Annual Symposium on Foundations of Computer Science (sfcs 1977)
  • 1977
It is shown that in general this question cannot be answered by a Turing machine in elementary time, and the computational complexity of related questions concerning the typed λ-calculus (for example, the question of whether a given type contains a closed term).