Higher-order minimal function graphs

Jones, Neil D.; Rosendahl, Mads

doi:10.1007/3-540-58431-5_17

Cited by 6 publications

(4 citation statements)

References 3 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Both of these have close connections with this paper's results, and each has led to several papers and much further research, e.g., Jagannathan and Weeks [16], and Stefanescu and Zhou [30]. A "minimal function graph" approach using higher-order functions at analysis time may be seen in [22].…”

Section: Since 1987mentioning

confidence: 70%

Flow analysis of lazy higher-order functional programs

Jones

Andersen

2007

Theoretical Computer Science

View full text Add to dashboard Cite

In recent years much interest has been shown in a class of functional languages including HASKELL, lazy ML, SASL/KRC/MIRANDA, ALFL, ORWELL, and PONDER. It has been seen that their expressive power is great, programs are compact, and program manipulation and transformation is much easier than with imperative languages or more traditional applicative ones. Common characteristics: they are purely applicative, manipulate trees as data objects, use pattern matching both to determine control flow and to decompose compound data structures, and use a "lazy" evaluation strategy.In this paper we describe a technique for data flow analysis of programs in this class by safely approximating the behavior of a certain class of term rewriting systems. In particular we obtain "safe" descriptions of program inputs, outputs and intermediate results by regular sets of trees. Potential applications include optimization, strictness analysis and partial evaluation. The technique improves earlier work because of its applicability to programs with higher-order functions, and with either eager or lazy evaluation. The technique addresses the call-by-name aspect of laziness, but not memoization. This paper extends [19] (a chapter in the out-of-print [2]) with proofs that the algorithm terminates and yields safe (i.e., sound or correct) approximations to program behavior. Relevance to this festschrift: John Reynolds' 1969 and 1972 papers developed a related first-order program analysis framework [27], and inspired our method for handling higher-order functions [28].

show abstract

Section: Since 1987mentioning

confidence: 70%

Flow analysis of lazy higher-order functional programs

Jones

Andersen

2007

Theoretical Computer Science

View full text Add to dashboard Cite

show abstract

“…An alternative to using partial functions could be to describe functional arguments as closures. In some situations this may work and give simple solutions to examples like the cat example above [29,20]. The technique, however, is not generally applicable as a fixpoint iteration technique as it may lead to infinite sequences of closures.…”

Section: Higher-order Fixpoint Iterationmentioning

confidence: 99%

“…A closure-based semantics may, however, be used as a standard semantics in an abstract interpretation [20] to prove the correctness of a closure analysis. In a similar style minimal function graphs were introduced [19] as an instrumented standard semantics to prove the correctness of constant propagation of an applicative language.…”

Section: Higher-order Fixpoint Iterationmentioning

confidence: 99%

Abstract Interpretation as a Programming Language

Rosendahl

2013

Electron. Proc. Theor. Comput. Sci.

Self Cite

View full text Add to dashboard Cite

In David Schmidt's PhD work he explored the use of denotational semantics as a programming language. It was part of an effort to not only treat formal semantics as specifications but also as interpreters and input to compiler generators. The semantics itself can be seen as a program and one may examine different programming styles and ways to represent states. Abstract interpretation is primarily a technique for derivation and specification of program analysis. As with denotational semantics we may also view abstract interpretations as programs and examine the implementation. The main focus in this paper is to show that results from higher-order strictness analysis may be used more generally as fixpoint operators for higher-order functions over lattices and thus provide a technique for immediate implementation of a large class of abstract interpretations. Furthermore, it may be seen as a programming paradigm and be used to write programs in a circular style

show abstract

“…This work is an abstract interpretation [4,[14][15][16] in the sense that an abstraction of an operational semantics is defined. It differs from abstract interpretation in that we are not interested in abstracting away any of the (infinite) structure of the underlying data domains, and that we wish to derive an inductive structure.…”

Section: Related Workmentioning

confidence: 99%

The Nuggetizer: Abstracting Away Higher-Orderness for Program Verification

Shroff

Skalka

Smith

Programming Languages and Systems

View full text Add to dashboard Cite

Abstract. We develop a static analysis which distills first-order computational structure from higher-order functional programs. The analysis condenses higher-order programs into a first-order rule-based system, a nugget, that characterizes all value bindings that may arise from program execution. Theorem provers are limited in their ability to automatically reason about higher-order programs; nuggets address this problem, being inductively defined structures that can be simply and directly encoded in a theorem prover. The theorem prover can then prove non-trivial program properties, such as the range of values assignable to particular variables at runtime. Our analysis is flow-and path-sensitive, and incorporates a novel prune-rerun analysis technique to approximate higher-order recursive computations.

show abstract

Higher-order minimal function graphs

Cited by 6 publications

References 3 publications

Flow analysis of lazy higher-order functional programs

Flow analysis of lazy higher-order functional programs

Abstract Interpretation as a Programming Language

The Nuggetizer: Abstracting Away Higher-Orderness for Program Verification

Contact Info

Product

Resources

About