Progress on Abstract Interpretation Based Formal Methods and Future Challenges

In order to contribute to the software reliability problem, tools have been designed in order to analyze statically the run-time behavior of programs. Because the correctness problem is undecidable, some form of approximation is needed. The whole purpose of abstract interpretation is to formalize this idea of approximation. We illustrate in­ formally the application of abstraction to the semantics of programming languages as well as to program static analysis. 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. In the second part of the paper, we compare program static analysis with deductive methods, model-checking and type inference. Their foun­ dational ideas are shortly reviewed, and the shortcomings of these four tools are discussed, including when they are combined. Alternatively, since program debugging is still the main program verification method used in the software industry, we suggest to combine formal with informal methods. Finally, the grand challenge for all formal methods and tools is to solve the software reliability, trustworthiness or robustness problems. Few chal­ lenges more specific to program analysis by abstract interpretation are shortly discussed. 1 Introductive Motivations The evolution of hardware by a factor of 106 over the past 25 years has lead to the explosion of the size of programs in similar proportions. The scope of application of very large programs (from 1 to 40 millions of lines) is likely to widen rapidly in the next decade. These big programs will have to be designed at a reasonable cost and then modified and maintained during their lifetime (which is often over 20 years). The size and efficiency of the programming and maintenance teams in charge of their design and follow-up cannot grow up in similar proportions. At a not so uncommon (and often optimistic) rate of one bug per thousand lines such huge programs might rapidly become hardly manageable in particular for safety critical systems (128). Therefore in the next 10 years, the software reliability problem is likely to become a major concern and challenge to modern highly computer-dependent societies.

[1]  A. Tarski.  A LATTICE-THEORETICAL FIXPOINT THEOREM AND ITS APPLICATIONS , 1955 .

[2]  Saul A. Kripke,et al.  Semantical Analysis of Modal Logic I Normal Modal Propositional Calculi , 1963 .

[3]  Peter Naur.  Proof of Algorithms by General Snapshots , 1966 .

[4]  Robert W. Floyd,et al.  Assigning meaning to programs , 1967 .

[5]  R. Hindley.  The Principal Type-Scheme of an Object in Combinatory Logic , 1969 .

[6]  Gary A. Kildall,et al.  A unified approach to global program optimization , 1973, POPL.

[7]  Robert M. Keller,et al.  Formal verification of parallel programs , 1976, CACM.

[8]  Patrick Cousot,et al.  Static determination of dynamic properties of programs , 1976 .

[9]  Patrick Cousot,et al.  Static Determination of Dynamic Properties of Recursive Procedures , 1977, Formal Description of Programming Concepts.

[10]  Patrick Cousot,et al.  Automatic synthesis of optimal invariant assertions: Mathematical foundations , 1977, Artificial Intelligence and Programming Languages.

[11]  Patrick Cousot,et al.  Static determination of dynamic properties of generalized type unions , 1977, Language Design for Reliable Software.

[12]  William W. Wadge,et al.  Data Types as Objects , 1977, ICALP.

[13]  Patrick Cousot,et al.  Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints , 1977, POPL.

[14]  Patrick Cousot,et al.  Méthodes itératives de construction et d'approximation de points fixes d'opérateurs monotones sur un treillis, analyse sémantique des programmes , 1978 .

[15]  Nicolas Halbwachs,et al.  Automatic discovery of linear restraints among variables of a program , 1978, POPL.

[16]  P. Cousot,et al.  Constructive versions of tarski's fixed point theorems , 1979 .

[17]  Patrick Cousot,et al.  Systematic design of program analysis frameworks , 1979, POPL.

[18]  Neil D. Jones,et al.  Flow analysis and optimization of LISP-like structures , 1979, POPL.

[19]  Nicolas Halbwachs.  Détermination automatique de relations linéaires vérifiées par les variables d'un programme , 1979 .

[20]  Patrick Cousot,et al.  A constructive characterization of the lattices of all retractions, pre-closure, quasi-closure and closure operators on a complete lattice , 1979 .

[21]  Edmund M. Clarke.  Synthesis of resource invariants for concurrent programs , 1979, POPL '79.

[22]  Dana S. Scott,et al.  Lambda Calculus: Some Models, Some Philosophy , 1980 .

[23]  Alan Mycroft,et al.  The Theory and Practice of Transforming Call-by-need into Call-by-value , 1980, Symposium on Programming.

[24]  Patrick Cousot,et al.  Semantic Analysis of Communicating Sequential Processes (Shortened Version) , 1980, ICALP.

[25]  Neil D. Jones,et al.  Complexity of flow analysis, inductive assertion synthesis and a language due to Dijkstra , 1980, 21st Annual Symposium on Foundations of Computer Science (sfcs 1980).

[26]  Mordechai Ben-Ari,et al.  The temporal logic of branching time , 1981, POPL '81.

[27]  Albert R. Meyer,et al.  Specifying the Semantics of while Programs: A Tutorial and Critique of a Paper by Hoare and Lauer , 1981, TOPL.

[28]  Patrick Cousot,et al.  Semantic foundations of program analysis , 1981 .

[29]  Alan Mycroft,et al.  Abstract interpretation and optimising transformations for applicative programs , 1982 .

[30]  Robin Milner,et al.  Principal type-schemes for functional programs , 1982, POPL '82.

[31]  Flemming Nielson,et al.  Strong Abstract Interpretation Using Power Domains (Extended Abstract) , 1983, ICALP.

[32]  A. Prasad Sistla,et al.  Automatic verification of finite state concurrent system using temporal logic specifications: a practical approach , 1983, POPL '83.

[33]  Alan Mycroft,et al.  Polymorphic Type Schemes and Recursive Definitions , 1984, Symposium on Programming.

[34]  Patrick Cousot,et al.  Invariance proof methods and analysis techniques for parallel programs , 1984 .

[35]  Phil Wadfer,et al.  Strictness analysis on non-fiat domains (by abstract interpretation over finite domains) , 1985 .

[36]  Alvin M. Despain,et al.  Semi-Intelligent Backtracking of Prolog Based on Static Data Dependency Analysis , 1985, SLP.

[37]  Doug DeGroot,et al.  AND-Parallelism of Logic Programs Based on a Static Data Dependency Analysis , 1985, COMPCON.

[38]  Neil D. Jones,et al.  A relational framework for abstract interpretation , 1985, Programs as Data Objects.

[39]  John Hughes,et al.  Strictness detection in non-flat domains , 1985, Programs as Data Objects.

[40]  Chris Hankin,et al.  The theory of strictness analysis for higher order functions , 1985, Programs as Data Objects.

[41]  Randal E. Bryant,et al.  Graph-Based Algorithms for Boolean Function Manipulation , 1986, IEEE Transactions on Computers.

[42]  Paul Feautrier,et al.  Automatic Parallelization of Fortran Programs in the Presence of Procedure Calls , 1986, ESOP.

[43]  Flemming Nielson,et al.  Abstract Interpretation of Denotational Definions (A Survey) , 1986, STACS.

[44]  Krzysztof R. Apt,et al.  Countable nondeterminism and random assignment , 1986, JACM.

[45]  Paul Hudak,et al.  Higher-order strictness analysis in untyped lambda calculus , 1986, POPL '86.

[46]  Chris Hankin,et al.  Strictness Analysis for Higher-Order Functions , 1986, Sci. Comput. Program..

[47]  Harald Søndergaard,et al.  An Application of Abstract Interpretation of Logic Programs: Occur Check Reduction , 1986, ESOP.

[48]  Gilles Kahn,et al.  Natural Semantics , 1987, STACS.

[49]  Fred Kröger,et al.  Temporal Logic of Programs , 1987, EATCS Monographs on Theoretical Computer Science.

[50]  Tadashi Kanamori,et al.  Polymorphic Type Inference in Prolog by Abstract Interpretation , 1988, LP.

[51]  Paul Hudak,et al.  Path Semantics , 1987, MFPS.

[52]  Robin Milner,et al.  A Type Discipline for Program Modules , 1987, TAPSOFT, Vol.2.

[53]  Bart Demoen,et al.  Abstract Interpretation: Towards the Global Optimization of Prolog Programs , 1987, SLP.

[54]  Nicolas Halbwachs,et al.  LUSTRE: A declarative language for programming synchronous systems* , 1987 .

[55]  Flemming Nielson,et al.  Strictness analysis and denotational abstract interpretation , 1987, POPL '87.

[56]  Philip Wadler,et al.  Projections for strictness analysis , 1987, FPCA.

[57]  Pierre Jouvelot,et al.  Semantic parallelization: a practical exercise in abstract interpretation , 1987, POPL '87.

[58]  Peter Dybjer,et al.  Inverse Image Analysis , 1987, ICALP.

[59]  Tsung-Min Kuo,et al.  On strictness and its analysis , 1987, POPL '87.

[60]  Thierry Coquand,et al.  The Calculus of Constructions , 1988, Inf. Comput..

[61]  Gerda Janssens,et al.  An Instance of Abstract Interpretation Integrating Type and Mode Inferencing , 1988, ICLP/SLP.

[62]  Philip Wadler,et al.  Strictness analysis aids time analysis , 1988, POPL '88.

[63]  Flemming Nielson,et al.  Automatic binding time analysis for a typed λ-calculus , 1988, POPL '88.

[64]  Saumya K. Debray,et al.  Automatic Mode Inference for Logic Programs , 1988, J. Log. Program..

[65]  Philip Wadler,et al.  Backwards Strictness Analysis: Proved and Improved , 1989, Functional Programming.

[66]  Ken Kennedy,et al.  A technique for summarizing data access and its use in parallelism enhancing transformations , 1989, PLDI '89.

[67]  Tsung-Min Kuo,et al.  Strictness analysis: a new perspective based on type inference , 1989, FPCA.

[68]  Dean Jacobs,et al.  Accurate and Efficient Approximation of Variable Aliasing in Logic Programs , 1989, NACLP.

[69]  John Hughes,et al.  Abstract Interpretation of Polymorphic Functions , 1989, Functional Programming.

[70]  Olivier Coudert,et al.  Verification of Synchronous Sequential Machines Based on Symbolic Execution , 1989, Automatic Verification Methods for Finite State Systems.

[71]  John Launchbury.  Dependent Sums Express Separation of Binding Times , 1989, Functional Programming.

[72]  Alain Deutsch,et al.  On determining lifetime and aliasing of dynamically allocated data in higher-order functional specifications , 1989, POPL '90.

[73]  Rick Evertsz.  The Generation of 'Critical Problems' by Abstract Interpretations of Student Models , 1989, IJCAI.

[74]  I. V. Ramakrishnan,et al.  Small domains spell fast strictness analysis , 1989, POPL '90.

[75]  Fausto Giunchiglia,et al.  Abstract Theorem Proving , 1989, IJCAI.

[76]  Sebastian Hunt,et al.  Frontiers and open sets in abstract interpretation , 1989, FPCA.

[77]  John Hughes.  Projections for Polymorphic Strictness Analysis , 1989, Category Theory and Computer Science.

[78]  Geoffrey L. Burn.  A relationship between abstract interpretation and projection analysis , 1989, POPL '90.

[79]  Philippe Granger.  Static analysis of arithmetical congruences , 1989 .

[80]  David Sands,et al.  Complexity Analysis for a Lazy Higher-Order Language , 1989, Functional Programming.

[81]  Daniel Le Métayer,et al.  A new method for strictness analysis on non-flat domains , 1989, Fourth IEEE Region 10 International Conference TENCON.

[82]  David L. Dill,et al.  Timing Assumptions and Verification of Finite-State Concurrent Systems , 1989, Automatic Verification Methods for Finite State Systems.

[83]  Peter D. Mosses,et al.  Denotational semantics , 1995, LICS 1995.

[84]  John C. Mitchell,et al.  Type Systems for Programming Languages , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[85]  Olivier Coudert,et al.  Verifying Temporal Properties of Sequential Machines without Building Their State Diagrams , 1990, CAV.

[86]  Wolfgang Thomas,et al.  Automata on Infinite Objects , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[87]  Patrick Cousot,et al.  Methods and Logics for Proving Programs , 1990, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[88]  Flemming Nielson,et al.  Using Transformations in the Implementation of Higher-Order Functions , 1990 .

[89]  François Bourdoncle,et al.  Interprocedural Abstract Interpretation of Block Structured Languages with Nested Procedures, Aliasing and Recursivity , 1990, PLILP.

[90]  Robert K. Brayton,et al.  Implicit state enumeration of finite state machines using BDD's , 1990, 1990 IEEE International Conference on Computer-Aided Design. Digest of Technical Papers.

[91]  Rob J. van Glabbeek,et al.  The Linear Time-Branching Time Spectrum (Extended Abstract) , 1990, CONCUR.

[92]  Samson Abramsky,et al.  A relational approach to strictness analysis for higher-order polymorphic functions , 1991, POPL '91.

[93]  Pierre Jouvelot,et al.  Polymorphic type, region and effect inference , 1992, Journal of Functional Programming.

[94]  Dmitri Boulanger,et al.  Deep Logic Program Transformation Using Abstract Interpretation , 1990, RCLP.

[95]  Geoffrey L. Burn,et al.  Lazy functional languages - abstract interpretation and compilation , 1991, Research monographs in parallel and distributed computing.

[96]  Yves Caseau.  Abstract Interpretation of Constraints on Order-Sorted Domains , 1991, ISLP.

[97]  Danny De Schreye,et al.  Deriving Termination Proofs for Logic Programs, Using Abstract Procedures , 1991, International Conference on Logic Programming.

[98]  Reinhard Wilhelm,et al.  Grammar Flow Analysis , 1991, Attribute Grammars, Applications and Systems.

[99]  Robin Milner,et al.  Co-Induction in Relational Semantics , 1991, Theor. Comput. Sci..

[100]  David Sands,et al.  Binding time analysis: a new PERspective , 1991, PEPM '91.

[101]  Gilberto Filé,et al.  Abstract Interpretation for Type Checking , 1991, PLILP.

[102]  Ian T. Foster,et al.  Copy Avoidance through Compile-Time Analysis and Local Reuse , 1991, ISLP.

[103]  Fritz Henglein,et al.  Efficient Type Inference for Higher-Order Binding-Time Analysis , 1991, FPCA.

[104]  Pierre Jouvelot,et al.  Algebraic reconstruction of types and effects , 1991, POPL '91.

[105]  Pascal Van Hentenryck,et al.  A Generic Abstract Interpretation Algorithm and its Complexity Analysis , 1991, ICLP.

[106]  Gebreselassie Baraki,et al.  A Note on Abstract Interpretation of Polymorphic Functions , 1991, FPCA.

[107]  Philippe Granger.  Analyses semantiques de congruence , 1991 .

[108]  Guy E. Blelloch,et al.  Size and access inference for data-parallel programs , 1991, PLDI '91.

[109]  A. Cortesi,et al.  Prop revisited: propositional formula as abstract domain for groundness analysis , 1991, [1991] Proceedings Sixth Annual IEEE Symposium on Logic in Computer Science.

[110]  I. V. Ramakrishnan,et al.  On the power and limitation of strictness analysis based on abstract interpretation , 1991, POPL '91.

[111]  Michael Codish,et al.  Derivation and Safety of an Abstract Unification Algorithm for Groundness and Aliasing Analysis , 1991, ICLP.

[112]  Timothy S. McNerney.  Verifying the correctness of compiler transformations on basic blocks using abstract interpretation , 1991, PEPM '91.

[113]  Pierre Crégut.  Interprétation abstraite pour améliorer la représentation des environnements dans les langages fonctionnels , 1991, JTASPEFT/WSA.

[114]  Kim Marriott,et al.  Some Global Compile-Time Optimizations for CLP(R) , 1991, ISLP.

[115]  Nicolas Mercouroff,et al.  An Algorithm for Analyzing Communicating Processes , 1991, MFPS.

[116]  David A. Wright,et al.  A New Technique for Strictness Analysis , 1991, TAPSOFT, Vol.2.

[117]  Peter Dybjer,et al.  Inverse Image Analysis Generalises Strictness Analysis , 1991, Inf. Comput..

[118]  Pascal Raymond,et al.  The synchronous data flow programming language LUSTRE , 1991, Proc. IEEE.

[119]  Philippe Granger,et al.  Static Analysis of Linear Congruence Equalities among Variables of a Program , 1991, TAPSOFT, Vol.1.

[120]  Olin Shivers.  Useless-Variable Elimination , 1991, JTASPEFT/WSA.

[121]  Gilberto Filé,et al.  Computations, Abstractions and Constraints (abstract) , 1991, JTASPEFT/WSA.

[122]  Lutz Plümer.  Automatic Termination Proofs for Prolog Programs Operating on Nonground Terms , 1991, ISLP.

[123]  SEBASTIAN HUNT,et al.  Fixed points and frontiers: a new perspective , 1991, Journal of Functional Programming.

[124]  Alan Mycroft,et al.  Uniform Ideals and Strictness Analysis , 1991, ICALP.

[125]  Olin Shivers,et al.  The semantics of Scheme control-flow analysis , 1991, PEPM '91.

[126]  Manuel V. Hermenegildo,et al.  Combined Determination of Sharing and Freeness of Program Variables through Abstract Interpretation , 1991, ICLP.

[127]  Agostino Cortesi,et al.  Abstract Interpretation of Logic Programs: An Abstract Domain for Groundness, Sharing, Freeness and Compoundness Analysis , 1991, PEPM.

[128]  Thomas P. Jensen,et al.  Strictness Analysis in Logical Form , 1991, FPCA.

[129]  Paul Hudak,et al.  Collecting interpretations of expressions , 1991, TOPL.

[130]  Roberto Barbuti,et al.  A Bottom-Up Polymorphic Type Inference in Logic Programming , 1992, Sci. Comput. Program..

[131]  Thomas P. Jensen,et al.  Disjunctive strictness analysis , 1992, [1992] Proceedings of the Seventh Annual IEEE Symposium on Logic in Computer Science.

[132]  Jan Stransky,et al.  A Lattice for Abstract Interpretation of Dynamic (LISP-Like) Structures , 1992, Information and Computation.

[133]  Mads Dam,et al.  Fixed Points of Büchi Automata , 1992, FSTTCS.

[134]  Manuel V. Hermenegildo,et al.  Compile-Time Derivation of Variable Dependency Using Abstract Interpretation , 1992, J. Log. Program..

[135]  Thomas E. Cheatham,et al.  A Suite of Optimizers Based on Abstract Interpretation , 1992, PEPM.

[136]  Bruno Monsuez,et al.  Polymorphic Typing by Abstract Interpretation , 1992, FSTTCS.

[137]  Nevin Heintze.  Practical Aspects of Set Based Analysis , 1992, JICSLP.

[138]  Alan Mycroft,et al.  Minimal Function Graphs are not Instrumented , 1992, WSA.

[139]  François Bourdoncle,et al.  Abstract interpretation by dynamic partitioning , 1992, Journal of Functional Programming.

[140]  David E. Culler,et al.  Global analysis for partitioning non-strict programs into sequential threads , 1992, LFP '92.

[141]  Edmund M. Clarke,et al.  Symbolic Model Checking: 10^20 States and Beyond , 1990, Inf. Comput..

[142]  John Hughes,et al.  Reversing Abstract Interpretations , 1992, Sci. Comput. Program..

[143]  Flemming Nielson,et al.  Inference Systems for Binding Time Analysis , 1992, WSA.

[144]  Patrick Cousot,et al.  Abstract Interpretation Frameworks , 1992, J. Log. Comput..

[145]  Erik Ruf,et al.  Improving the Accuracy of Higher-Order Specialization using Control Flow Analysis , 1992, PEPM.

[146]  Maurice Bruynooghe,et al.  A Framework for Analyzing the Termination of Definite Logic Programs with respect to Call Patterns , 1992, FGCS.

[147]  A. E. Ayers.  Efficient Closure Analysis with Reachability , 1992, WSA.

[148]  Flemming Nielson,et al.  Bounded fixed point iteration , 1992, POPL '92.

[149]  Simon Hughes,et al.  Compile-Time Garbage Collection for Higher-Order Functional Languages , 1992, J. Log. Comput..

[150]  Jean-Louis Giavitto,et al.  Inférer rapidement la géométrie des collections , 1992, WSA.

[151]  Roberto Bagnara,et al.  Static Analysis of CLP Programs over Numeric Domains , 1992, WSA.

[152]  Pierre Jouvelot,et al.  Polymorphic time systems for estimating program complexity , 1992, LOPL.

[153]  Laura Ricci,et al.  Detecting Determinate Computations by Bottom-up Abstract Interpretation , 1992, ESOP.

[154]  A. Deutsch,et al.  A storeless model of aliasing and its abstractions using finite representations of right-regular equivalence relations , 1992, Proceedings of the 1992 International Conference on Computer Languages.

[155]  Patrick Cousot,et al.  Abstract Interpretation and Application to Logic Programs , 1992, J. Log. Program..

[156]  Andy King,et al.  Schedule Analysis of Concurrent Logic programs , 1992, JICSLP.

[157]  Marc Gengler,et al.  A Polyvariant Binding Time Analysis Handling Partially Known Values , 1992, WSA.

[158]  Prateek Mishra,et al.  A precise relationship between the deductive power of forward and backward strictness analysis , 1992, LFP '92.

[159]  Alan Mycroft.  Incremental Polymorphic Type Checking with Update , 1992, LFCS.

[160]  Nicolas Halbwachs,et al.  Minimal State Graph Generation , 1992, Science of Computer Programming.

[161]  Benjamin Goldberg,et al.  A syntactic approach to fixed point computation on finite domains , 1992, LFP '92.

[162]  Geoff W. Hamilton,et al.  Sharing Analysis of Lazy First-Order Functional Programs , 1992, WSA.

[163]  Saumya K. Debray,et al.  Understanding Finiteness Analysis Using Abstract Interpretation , 1992, JICSLP.

[164]  Bernhard Rytz,et al.  A Polyvariant Binding Time Analysis , 1992, PEPM.

[165]  Diego Latella,et al.  Using Abstract Interpretation for Gate splitting in LOTOS Specifications , 1992, WSA.

[166]  John Hughes,et al.  Projections for polymorphic first-order strictness analysis , 1992, Mathematical Structures in Computer Science.

[167]  Clement A. Baker-Finch,et al.  Relevant Logic and Strictness Analysis , 1992, WSA.

[168]  Robert Muller,et al.  Abstract interpretation in weak powerdomains , 1992, LFP '92.

[169]  Gerda Janssens,et al.  Deriving Descriptions of Possible Values of Program Variables by Means of Abstract Interpretation , 1990, J. Log. Program..

[170]  Natarajan Shankar,et al.  PVS: A Prototype Verification System , 1992, CADE.

[171]  John S. Conery,et al.  An Abstract Interpretation Scheme for Groundedness, Freeness, and Sharing Analysis of Logic Programs , 1992, FSTTCS.

[172]  Danny De Schreye,et al.  Automatic Termination Analysis , 1992, LOPSTR.

[173]  R. Nigel Horspool,et al.  Compile-Time Analysis of Object-Oriented Programs , 1992, CC.

[174]  Nevin Charles Heintze,et al.  Set based program analysis , 1992 .

[175]  Gerard R. Renardel de Lavalette.  Strictness Analysis via Abstract Interpretation for Recursively Defined Types , 1992, Inf. Comput..

[176]  Pascal Van Hentenryck,et al.  On the Design of Generic Abstract Interpretation Frameworks , 1992, WSA.

[177]  Jyh-Herng Chow,et al.  Compile-time analysis of parallel programs that share memory , 1992, POPL '92.

[178]  John Hughes,et al.  Relational Reversal of Abstract Interpretation , 1992, J. Log. Comput..

[179]  Flemming Nielson,et al.  Finiteness conditions for fixed point iteration , 1992, LFP '92.

[180]  Pierre Jouvelot,et al.  Control-Flow Effects for Escape Analysis , 1992, WSA.

[181]  Thomas P. Jensen,et al.  Axiomatising Uniform Properties of Recursive Data Structures , 1992, WSA.

[182]  Manuel V. Hermenegildo,et al.  A Practical Application of Sharing and Freeness Inference , 1992, WSA.

[183]  Chris Hankin,et al.  A Lattice of Abstract Graphs , 1993, PLILP.

[184]  John C. Mitchell,et al.  On the type structure of standard ML , 1993, TOPL.

[185]  Pascal Van Hentenryck,et al.  Optimization Techniques for General Purpose Fixpoint Algorithms - Practical Efficiency for the Abstract Interpretation of Prolog , 1993, WSA.

[186]  Alan Mycroft,et al.  Completeness and predicate-based abstract interpretation , 1993, PEPM '93.

[187]  Peter Sestoft,et al.  Partial evaluation and automatic program generation , 1993, Prentice Hall international series in computer science.

[188]  Edmund M. Clarke,et al.  Verification Tools for Finite-State Concurrent Systems , 1993, REX School/Symposium.

[189]  Éric Villemonte de la Clergerie,et al.  How to build quickly an efficient implementation of the domain Prop with DyALog , 1993, LPE.

[190]  Carl F. Schaefer,et al.  Static analysis of exception handling in Ada , 1993, Softw. Pract. Exp..

[191]  Jean-Claude Fernandez,et al.  Abstract Interpretation and Verification of Reactive Systems , 1993, WSA.

[192]  Fosca Giannotti,et al.  Data Sharing Analysis for a Database Programming Lanaguage via Abstract Interpretation , 1993, VLDB.

[193]  Paul Y. Gloess,et al.  Inheritance in Datalog , 1993, LPE.

[194]  R. Nigel Horspool,et al.  Static Analysis of PostScript Code , 1993, Comput. Lang..

[195]  Kim Marriott,et al.  On propagation-based analysis of logic programs , 1993 .

[196]  Clement A. Baker-Finch,et al.  Usage Analysis with Natural Reduction Types , 1993, WSA.

[197]  Fosca Giannotti,et al.  Static Analysis of Transactions: an Experiment of Abstract Interpretation Usage , 1993, FMLDO.

[198]  Christine Paulin-Mohring,et al.  Synthesis of ML Programs in the System Coq , 1993, J. Symb. Comput..

[199]  John L. Hennessy,et al.  Compile‐time copy elimination , 1993, Softw. Pract. Exp..

[200]  François Bourdoncle,et al.  Semantic Analysis of Interval Congruences. , 1993, FME 1993.

[201]  Mikhail A. Bulyonkov.  Extracting polyvariant binding time analysis from polyvariant specializer , 1993, PEPM '93.

[202]  Michael Wolfe,et al.  Interprocedural alias analysis: Implementation and empirical results , 1993, Softw. Pract. Exp..

[203]  François Bourdoncle,et al.  Assertion-based Debugging of Imperative Programs by Abstract Interpretation , 1993, ESEC.

[204]  Gilberto Filé,et al.  Static Analysis of Prolog with Cut , 1993, LPAR.

[205]  Roberto Giacobazzi,et al.  Joining Abstract and Concrete Computations in Constraint Logic Programming , 1993, AMAST.

[206]  Gerda Janssens,et al.  Freeness Analysis in the Presence of Numerical Constraints , 1993, ICLP.

[207]  Pascal Van Hentenryck,et al.  Generic abstract interpretation algorithms for Prolog: Two optimization techniques and their experimental evaluation , 1993, Softw. Pract. Exp..

[208]  Shing-Chi Cheung,et al.  Tractable Flow Analysis for Anomaly Detection in Distributed Programs , 1993, ESEC.

[209]  Bruno Monsuez,et al.  Polymorphic Types and Widening Operators , 1993, WSA.

[210]  Diego Latella,et al.  Gate Splitting in LOTOS Specifications Using Abstract Interpretation , 1993, Sci. Comput. Program..

[211]  Flemming Nielson,et al.  Finiteness Conditions for Strictness Analysis , 1993, WSA.

[212]  Charles Consel,et al.  Polyvariant binding-time analysis for applicative languages , 1993, PEPM '93.

[213]  François Bourdoncle,et al.  Abstract debugging of higher-order imperative languages , 1993, PLDI '93.

[214]  Jian Chen,et al.  Defining Soft Sortedness by Abstract Interpretation , 1993, MFCS.

[215]  Alberto Ferrari,et al.  Type Inference, Abstract Interpretation and Strictness Analysis , 1993, Theor. Comput. Sci..

[216]  Gilberto Filé,et al.  Freeness Analysis for Logic Programs - And Correctness? , 1993, ICLP.

[217]  Kei Davis.  Higher-order binding-time analysis , 1993, PEPM '93.

[218]  Patrick Cousot,et al.  Galois Connection Based Abstract Interpretations for Strictness Analysis (Invited Paper) , 1993, Formal Methods in Programming and Their Applications.

[219]  Spiridon Kalogeropulos.  Identifying the Available Parallelism Using Static Analysis , 1993, ACPC.

[220]  Nick Benton,et al.  Strictness Properties of Lazy Algebraic Datatypes , 1993, WSA.

[221]  Bruno Monsuez,et al.  Polymorphic Typing for Call-by-Name Semantics , 1993, Formal Methods in Programming and Their Applications.

[222]  Carl A. Gunter,et al.  Computing ML Equality Kinds Using Abstract Interpretation , 1993, Inf. Comput..

[223]  Daniel Le Métayer,et al.  Proving the Correctness of Compiler Optimizations Based on Strictness Analysis , 1993, PLILP.

[224]  Eric Goubault,et al.  Semantics and Analysis of Linda-Based Languages , 1993, WSA.

[225]  Maurice Bruynooghe,et al.  Deriving Fold/Unfold Transformations of Logic Programs Using Extended OLDT-Based Abstract Interpretation , 1993, J. Symb. Comput..

[226]  Jens Palsberg,et al.  Correctness of binding-time analysis , 1993, Journal of Functional Programming.

[227]  Geoffrey L. Burn.  The Abstract Interpretation of Functional Languages , 1993, Theory and Formal Methods.

[228]  Niels Jørgensen.  Chaotic Fixpoint Iteration Guided by Dynamic Dependency , 1993, WSA.

[229]  Claire Loiseaux,et al.  A Tool for Symbolic Program Verification and Abstration , 1993, CAV.

[230]  Maurice Bruynooghe,et al.  Freeness, Sharing, Linearity and Correctness - All at Once , 1993, WSA.

[231]  E. Goubault,et al.  A lattice for the abstract interpretation of term graph rewriting systems , 1993 .

[232]  Mads Rosendahl.  Higher-Order Chaotic Iteration Sequences , 1993, PLILP.

[233]  Michael Hanus,et al.  Analysis of Nonlinear Constraints in CLP(R) , 1993, ICLP.

[234]  Nicolas Halbwachs,et al.  Delay Analysis in Synchronous Programs , 1993, CAV.

[235]  John Hughes,et al.  Fast Abstract Interpretation Using Sequential Algorithms , 1993, WSA.

[236]  Chris Hankin,et al.  Abstract reduction: towards a theory via abstract interpretation , 1993 .

[237]  François Bourdoncle,et al.  Efficient chaotic iteration strategies with widenings , 1993, Formal Methods in Programming and Their Applications.

[238]  Samuel N. Kamin,et al.  On the Power of Abstract Interpretation , 1993, Comput. Lang..

[239]  Pascal Van Hentenryck,et al.  Groundness analysis for Prolog: implementation and evaluation of domain prop , 1993, PEPM '93.

[240]  Rance Cleaveland,et al.  A linear-time model-checking algorithm for the alternation-free modal mu-calculus , 1993, Formal Methods Syst. Des..

[241]  Thomas E. Cheatham,et al.  A Suite of Analysis Tools Based on a General Purpose Abstract Interpreter , 1994, CC.

[242]  Maurizio Gabbrielli,et al.  Goal independency and call patterns in the analysis of logic programs , 1994, SAC '94.

[243]  Pierre Jouvelot,et al.  Separate Abstract Interpretation for Control-Flow Analysis , 1994, TACS.

[244]  David K. Gifford,et al.  Static dependent costs for estimating execution time , 1994, LFP '94.

[245]  Flemming Nielson,et al.  The Tensor Product in Wadler's Analysis of Lists , 1992, ESOP.

[246]  Edmund M. Clarke,et al.  Model checking and abstraction , 1994, TOPL.

[247]  Chris Hankin,et al.  Approximate Fixed Points in Abstract Interpretation , 1992, Sci. Comput. Program..

[248]  Baudouin Le Charlier,et al.  Abstract Interpretation and Finite Domain Symbolic Constraints , 1994, Constraint Programming.

[249]  Maurice Bruynooghe,et al.  Abstract Unification for a Composite Domain Deriving Sharing and Freeness Properties of Program Variables , 1994, ICLP Workshop: Verification and Analysis of Logic Languages.

[250]  Nevin Heintze,et al.  Set-based analysis of ML programs , 1994, LFP '94.

[251]  Helmut Seidl.  Least Solutions of Equations over N , 1994, ICALP.

[252]  Pascal Van Hentenryck,et al.  Combinations of abstract domains for logic programming , 1994, POPL '94.

[253]  Robert Harper,et al.  A Simplified Account of Polymorphic References , 1994, Inf. Process. Lett..

[254]  William Pugh,et al.  Static analysis of upper and lower bounds on dependences and parallelism , 1994, TOPL.

[255]  Daniel Jackson,et al.  Abstract Model Checking of Infinite Specifications , 1994, FME.

[256]  Chris Hankin,et al.  A Type-based Framework for Program Analysis , 1994, SAS.

[257]  Fritz Henglein.  Iterative Fixed Point Computation for Type-Based Strictness Analysis , 1994, SAS.

[258]  Susanne Graf,et al.  Verification of a Distributed Cache Memory by Using Abstractions , 1994, CAV.

[259]  Jens Palsberg,et al.  Static Typing for Object-Oriented Programming , 1991, Sci. Comput. Program..

[260]  R. Nigel Horspool,et al.  Flow Grammars - a Flow Analysis Methodology , 1994, CC.

[261]  Charles Consel,et al.  Fast Strictness Analysis Via Symbolic Fixpoint Iteration , 1994, SAS.

[262]  Manuel V. Hermenegildo,et al.  Effectiveness of Global Analysis in Strict Independence-Based Automatic Parallelization , 1994, ILPS.

[263]  Saumya K. Debray,et al.  Detection and Optimization of Suspension-Free Logic Programs , 1994, J. Log. Program..

[264]  Jens Palsberg,et al.  Efficient inference of partial types , 1992, Proceedings., 33rd Annual Symposium on Foundations of Computer Science.

[265]  Neil D. Jones.  Abstract Interpretation and Partial Evaluation in Functional and Logic Programming , 1994, ILPS.

[266]  Michael Hanus,et al.  Mode Analysis of Functional Logic Programs , 1994, SAS.

[267]  Spiro Michaylov,et al.  Optimizing Compilation of Linear Arithmetic in a Class of Constraint Logic Programs , 1994, ILPS.

[268]  Pascal Van Hentenryck,et al.  Experimental Evaluation of a Generic Abstract Interpretation Algorithm for PROLOG , 1992, ACM Trans. Program. Lang. Syst..

[269]  Charles Consel,et al.  Fixpoint computation for polyvariant static analyses of higher-order applicative programs , 1994, TOPL.

[270]  Jean Goubault-Larrecq,et al.  Generalized Boxings, Congruences and Partial Inlining , 1994, SAS.

[271]  Robert Cartwright,et al.  A practical soft type system for scheme , 1997, TOPL.

[272]  Hergen Pargmann,et al.  Model Checking Using Adaptive State and Data Abstraction , 1994, CAV.

[273]  Alain Deutsch,et al.  Interprocedural may-alias analysis for pointers: beyond k-limiting , 1994, PLDI '94.

[274]  Laurent Mauborgne.  Abstract Interpretation Using TDGs , 1994, SAS.

[275]  Kirack Sohn.  Constraints among Argument Sizes in Logic Programs. , 1994, PODS 1994.

[276]  Kjell Post.  Mutally Exclusive Rules in Logic Programming , 1994, ILPS.

[277]  Kim Marriott,et al.  Boolean Functions for Dependency Analysis: Algebraic Properties and Efficient Representation , 1994, SAS.

[278]  Kwangkeun Yi.  Compile-time Detection of Uncaught Exceptions in Standard ML Programs , 1994, SAS.

[279]  Manuel V. Hermenegildo,et al.  Extracting Non-Strict Independent And-Parallelism Using Sharing and Freeness Information , 1994, SAS.

[280]  Niels Jørgensen.  Finding fixpoints in finite function spaces using neededness analysis and chaotic iteration , 1994 .

[281]  G. Ramalingam,et al.  The undecidability of aliasing , 1994, TOPL.

[282]  Peter J. Stuckey,et al.  Approximating Interaction between Linear Arithmetic Constraints , 1994, ILPS.

[283]  Adrienne G. Bloss.  Path analysis and the optimization of nonstrict functional languages , 1994, TOPL.

[284]  Pascal Van Hentenryck,et al.  An Abstract Interpretation Framework which Accurately Handles Prolog Search-Rule and the Cut , 1994, ILPS.

[285]  Fosca Giannotti,et al.  Conservative Multigranularity Locking for an Obiect-Oriented Persistent Language via Abstract Interpretation , 1994, SEBD.

[286]  Somesh Jha,et al.  An Improved Algorithm for the Evaluation of Fixpoint Expressions , 1994, Theor. Comput. Sci..

[287]  Johan Lewi,et al.  Efficient FixPoint Computation , 1994, SAS.

[288]  Dan C. Stefanescu,et al.  An equational framework for the flow analysis of higher order functional programs , 1994, LFP '94.

[289]  Gilberto Filé,et al.  Improving Abstract Interpretations by Systematic Lifting to the Powerset , 1994, ILPS.

[290]  Jyh-Herng Chow,et al.  State space reduction in abstract interpretation of parallel programs , 1994, Proceedings of 1994 IEEE International Conference on Computer Languages (ICCL'94).

[291]  Nicolas Halbwachs,et al.  Verification of Linear Hybrid Systems by Means of Convex Approximations , 1994, SAS.

[292]  Giorgio Levi,et al.  Abstract Debugging of Logic Program , 1994, META.

[293]  Marcel Beemster.  Strictness optimization for graph reduction machines (why id might not be strict) , 1994, TOPL.

[294]  Michael Hanus,et al.  Towards the Global Optimization of Functional Logic Programs , 1994, CC.

[295]  Akinori Yonezawa,et al.  Static Analysis of Communication for Asynchronous Concurrent Programming Languages , 1995, SAS.

[296]  Roberto Giacobazzi,et al.  Generalized Semantics and Abstract Interpretation for Constraint Logic Programs , 1995, J. Log. Program..

[297]  Stavros Tripakis,et al.  The Tool KRONOS , 1996, Hybrid Systems.

[298]  Julian Seward,et al.  Beyond Prototype Implementations: Polymorphic Projection Analysis for Glasgow Haskell , 1995, SAS.

[299]  Pierre Wolper,et al.  An Automata-Theoretic Approach to Presburger Arithmetic Constraints (Extended Abstract) , 1995, SAS.

[300]  Christian Fecht.  GENA - A Tool for Generating Prolog Analyzers from Specifications , 1995, SAS.

[301]  Christer Bäckström,et al.  Planning with Abstraction Hierarchies can be Exponentially Less Efficient , 1995, IJCAI.

[302]  Karl-Filip Faxén.  Optimizing Lazy Functional Programs Using Flow Inference , 1995, SAS.

[303]  Franck Védrine.  Binding-Time Analysis and Strictness Analysis by Abstract Interpretation , 1995, SAS.

[304]  Monica S. Lam,et al.  Interprocedural Analysis for Parallelization , 1995, LCPC.

[305]  Bruno Monsuez,et al.  System F and Abstract Interpretation , 1995, SAS.

[306]  Samuel P. Midkiff.  Dependence Analysis in Parallel Loops with i±k Subscripts , 1995, LCPC.

[307]  Saumya K. Debray,et al.  Formal bases for dataflow analysis of logic programs , 1995 .

[308]  Sérgio Vale Aguiar Campos,et al.  Verus: A Tool for Quantitative Analysis of Finite-State Real-Time Systems , 1995, Workshop on Languages, Compilers, & Tools for Real-Time Systems.

[309]  Jens Palsberg,et al.  A type system equivalent to flow analysis , 1995, TOPL.

[310]  Joseph Sifakis,et al.  Property preserving abstractions for the verification of concurrent systems , 1995, Formal Methods Syst. Des..

[311]  M. Codish,et al.  Improving abstract interpretations by combining domains , 1995, TOPL.

[312]  Howard Wong-Toi,et al.  Automated Analysis of an Audio Control Protocol , 1995, CAV.

[313]  Alan Mycroft,et al.  Uniform PERs and Comportment Analysis , 1995, PLILP.

[314]  Elena Marchiori,et al.  Proving Termination of Logic Programs with Delay Declarations , 1995, ILPS.

[315]  Mads Tofte.  Region Inference for Higher-Order Functional Languages , 1995, SAS.

[316]  T. Henzinger,et al.  Algorithmic Analysis of Nonlinear Hybrid Systems , 1998, CAV.

[317]  Thomas P. Jensen.  Clock analysis of synchronous dataflow programs , 1995, PEPM '95.

[318]  Patrick Cousot,et al.  Formal language, grammar and set-constraint-based program analysis by abstract interpretation , 1995, FPCA '95.

[319]  John Hannan.  A Type-based Analysis for Stack Allocation in Functional Languages , 1995, SAS.

[320]  Kwangkeun Yi,et al.  Efficient computation of fixpoints that arise in complex program analysis , 1995, J. Program. Lang..

[321]  Thomas A. Henzinger,et al.  The Algorithmic Analysis of Hybrid Systems , 1995, Theor. Comput. Sci..

[322]  Erik Schon,et al.  On the Computation of Fixpoints in Static Program Analysis with an Application to Analysis of AKL , 1995 .

[323]  Giorgio Levi,et al.  Efficient Detection of Incompleteness Errors in the Abstract Debugging of Logic Programs , 1995, AADEBUG.

[324]  Nevin Heintze.  Control-Flow Analysis and Type Systems , 1995, SAS.

[325]  David A. Schmidt.  Natural-Semantics-Based Abstract Interpretation (Preliminary Version) , 1995, SAS.

[326]  Girish Bhat,et al.  Efficient on-the-fly model checking for CTL , 1995, Proceedings of Tenth Annual IEEE Symposium on Logic in Computer Science.

[327]  Håkan Millroth,et al.  IGOR: A Tool for Developing Prolog Dataflow Analyzers , 1995, SAS.

[328]  Bruno Monsuez.  Using abstract interpretation to define a strictness type inference system , 1995, PEPM '95.

[329]  Jürgen Giesl,et al.  Termination Analysis for Functional Programs using Term Orderings , 1995, SAS.

[330]  Fritz Henglein,et al.  A Semantic Model of Binding Times for Safe Partial Evaluation , 1995, PLILP.

[331]  Régis Cridlig,et al.  Semantic analysis of shared-memory concurrent languages using abstract model-checking , 1995, PEPM '95.

[332]  Jens Palsberg,et al.  Closure analysis in constraint form , 1995, TOPL.

[333]  Christopher Colby.  Determining Storage Properties of Sequential and Concurrent Programs with Assignment and Structured Data , 1995, SAS.

[334]  Martin Alt,et al.  Generation of Efficient Interprocedural Analyzers with PAG , 1995, SAS.

[335]  François Irigoin,et al.  Interprocedural Array Region Analyses , 1996, International Journal of Parallel Programming.

[336]  I. V. Ramakrishnan,et al.  Fast strictness analysis based on demand propagation , 1995, TOPL.

[337]  Morten Heine Sørensen,et al.  Call-By-Name CPS-Translation as a Binding-Time Improvement , 1995, SAS.

[338]  Roberto Giacobazzi.  "Optimal" Collecting Semantics for Analysis in a Hierarchy of Logic Program Semantics , 1995, STACS.

[339]  Eric Goubault,et al.  Schedulers as abstract interpretations of higher-dimensional automata , 1995, PEPM '95.

[340]  Jens Palsberg.  Efficient Inference of Object Types , 1995, Inf. Comput..

[341]  I-Peng Lin,et al.  Type Synthesis for Logic Programs , 1996, JICSLP.

[342]  Markus Mohnen,et al.  Efficient Closure Utilisation by Higher-Order Inheritance Analysis , 1995, SAS.

[343]  David L. Dill,et al.  Verification of Real-Time Systems by Successive Over and Under Approximation , 1995, CAV.

[344]  Pavel G. Emeljanov.  Analysis of the Equality Relations for the Program Terms , 1996, SAS.

[345]  J. Michael Ashley.  A practical and flexible flow analysis for higher-order languages , 1996, POPL '96.

[346]  Peter Lee,et al.  The TIL/ML Compiler: Performance and Safety through Types , 1996 .

[347]  Ross Paterson,et al.  Compiling Laziness Using Projections , 1996, SAS.

[348]  Laurie J. Hendren,et al.  Is it a tree, a DAG, or a cyclic graph? A shape analysis for heap-directed pointers in C , 1996, POPL '96.

[349]  Satoshi Yamane,et al.  The symbolic model-checking for real-time systems , 1996, Proceedings of the Eighth Euromicro Workshop on Real-Time Systems.

[350]  Fausto Giunchiglia,et al.  A General Purpose Reasoner for Abstraction , 1996, Canadian Conference on AI.

[351]  Yukihide Takayama.  Extraction of Concurrent Processes from Higher Dimensional Automata , 1996, CAAP.

[352]  Kazunori Ueda,et al.  Diagnosing Non-Well-Moded Concurrent Logic Programs , 1996, JICSLP.

[353]  Patrice Godefroid,et al.  Model Checking in Practice: An Analysis of the ACCESS.bus Protocol using SPIN , 1996, FME.

[354]  Bart Demoen,et al.  A Freeness and Sharing Analysis of Logic Programs Based on a Pre-interpretation , 1996, SAS.

[355]  Lunjin Lu,et al.  A Mode Analysis of Logic Programs by Abstract Interpretation , 1996, Ershov Memorial Conference.

[356]  Neil D. Jones,et al.  An introduction to partial evaluation , 1996, CSUR.

[357]  Arnaud Venet,et al.  Abstract Cofibered Domains: Application to the Alias Analysis of Untyped Programs , 1996, SAS.

[358]  Edmund M. Clarke,et al.  Verification of All Circuits in a Floating-Point Unit Using Word-Level Model Checking , 1996, FMCAD.

[359]  J. Urgen Giesl,et al.  Termination Analysis for Partial Functions ? , 1996 .

[360]  Gilberto Filé,et al.  On the Design of a Correct Freeness Analysis for Logic Programs , 1995, J. Log. Program..

[361]  Fausto Giunchiglia,et al.  ABSFOL: A Proof Checker with Abstraction , 1996, CADE.

[362]  Frank Pfenning,et al.  Mode and Termination Checking for Higher-Order Logic Programs , 1996, ESOP.

[363]  Rance Cleaveland,et al.  The Concurrency Factory: A Development Environment for Concurrent Systems , 1996, CAV.

[364]  Giorgio Levi,et al.  Proving Properties of Logic Programs by Abstract Diagnosis , 1996, LOMAPS.

[365]  Patrick Hicks,et al.  Demand Transformation Analysis for Concurrent Constraint Programs , 2000, J. Log. Program..

[366]  Véronique Benzaken,et al.  Ensuring Efficiently the Integrity of Persistent Object Systems via Abstract Interpretation , 1996, POS.

[367]  David Cyrluk,et al.  Inverting the Abstraction Mapping: A Methodology for Hardware Verification , 1996, FMCAD.

[368]  Roland H. C. Yap,et al.  Effectiveness of Optimizing Compilation for CLP(R) , 1996, JICSLP.

[369]  Carsten Kehler Holst,et al.  Termination Analysis for Offline Partial Evaluation of a Higher Order Functional Language , 1996, SAS.

[370]  Kamel Adi,et al.  Resolution of Goals with the Functional and Logic Programming Language LPG: Impact of Abstract Interpretation , 1996, AMAST.

[371]  Robert Harper.  A Note on "A Simplified Account of Polymorphic References" , 1996, Inf. Process. Lett..

[372]  Fausto Giunchiglia,et al.  Computing Abstraction Hierarchies by Numerical Simulation , 1996, AAAI/IAAI, Vol. 1.

[373]  Reinhard Wilhelm,et al.  Solving shape-analysis problems in languages with destructive updating , 1998, TOPL.

[374]  Gilberto Filé,et al.  Complementation of Abstract Domains made Easy , 1996, JICSLP.

[375]  Rance Cleaveland,et al.  The NCSU Concurrency Workbench , 1996, CAV.

[376]  Rance Cleaveland,et al.  The Concurrency Factory Software Development Environment , 1996, TACAS.

[377]  Régis Cridlig,et al.  Implementing a Static Analyzer of Concurrent Programs: Problems and Perspectives , 1996, LOMAPS.

[378]  David A. Schmidt.  Abstract Interpretation of Small-Step Semantics , 1996, LOMAPS.

[379]  Natarajan Shankar,et al.  PVS: Combining Specification, Proof Checking, and Model Checking , 1996, FMCAD.

[380]  John M. Rushby,et al.  Automated Deduction and Formal Methods , 1996, CAV.

[381]  Peter Lee,et al.  Trace-based program analysis , 1996, POPL '96.

[382]  Christian Fecht.  An Efficient and Precise Sharing Domain for Logic Programs , 1996, PLILP.

[383]  Patrice Godefroid,et al.  Symbolic Verification of Communication Protocols with Infinite State Spaces Using QDDs (Extended Abstract) , 1996, CAV.

[384]  Maria Handjieva.  STAN: A Static Analyzer for CLP(R) Based on Abstract Interpretation , 1996, SAS.

[385]  C. Flanagan,et al.  Static Debugging: Browsing the Web of Program Invariants , 1996, PLDI.

[386]  Agostino Cortesi,et al.  Optimal Groundness Analysis Using Propositional Logic , 1996, J. Log. Program..

[387]  Natarajan Shankar,et al.  Unifying Verification Paradigms , 1996, FTRTFT.

[388]  Régis Cridlig.  Semantic analysis of concurrent ML by abstract model-checking , 1996, INFINITY.

[389]  Martin Müller,et al.  Automated Modular Termination Proofs for Real Prolog Programs , 1996, SAS.

[390]  Matthias Felleisen,et al.  Program verification through soft typing , 1996, CSUR.

[391]  Torben Æ. Mogensen.  A Semantics-Based Determinacy Analysis for Prolog with Cut , 1996, Ershov Memorial Conference.

[392]  Gilberto Filé,et al.  A unifying view of abstract domain design , 1996, CSUR.

[393]  Hassen Saïdi.  A Tool for Proving Invariance Properties of Concurrent Systems Automatically , 1996, TACAS.

[394]  Ross Paterson.  Transforming Lazy Functions Using Comportment Properties , 1997, PLILP.

[395]  Armin Biere,et al.  µcke - Efficient µ-Calculus Model Checking , 1997, CAV.

[396]  Patrick Cousot,et al.  Parallel combination of abstract interpretation and model-based automatic analysis of software , 1997 .

[397]  Martin C. Rinard,et al.  Commutativity analysis: a new analysis technique for parallelizing compilers , 1997, TOPL.

[398]  Saumya K. Debray,et al.  Lower Bound Cost Estimation for Logic Programs , 1997, ILPS.

[399]  Roberto Giacobazzi,et al.  Refining and Compressing Abstract Domains , 1997, ICALP.

[400]  Patrice Godefroid,et al.  VeriSoft: A Tool for the Automatic Analysis of Concurrent Reactive Software , 1997, CAV.

[401]  Susan Horwitz,et al.  Precise flow-insensitive may-alias analysis is NP-hard , 1997, TOPL.

[402]  Nicolas Halbwachs,et al.  Verification of Real-Time Systems using Linear Relation Analysis , 1997, Formal Methods Syst. Des..

[403]  Atsushi Igarashi,et al.  Type-Based Analysis of Communication for Concurrent Programming Languages , 1997, SAS.

[404]  Luddy Harrison.  Can Abstract Interpretation Become a Mainstream Compiler Technology? (Abstract) , 1997, SAS.

[405]  Lobel Crnogorac,et al.  Abstract Interpretation of Active Rules and its Use in Termination Analysis , 1997, ICDT.

[406]  Corrado Priami,et al.  True Concurrency via Abstract Interpretation , 1997, SAS.

[407]  Pierre Wolper,et al.  The Power of QDDs (Extended Abstract) , 1997, SAS.

[408]  Frank Zartmann.  Denotational Abstract Interpretation of Functional Logic Programs , 1997, SAS.

[409]  Andy King,et al.  Lower-bound Time-complexity Analysis of Logic Programs , 1997, ILPS.

[410]  Philippe Granger.  Static Analyses of Congruence Properties on Rational Numbers (Extended Abstract) , 1997, SAS.

[411]  Roberto Giacobazzi,et al.  Completeness in Abstract Interpretation: A Domain Perspective , 1997, AMAST.

[412]  Christel Baier,et al.  Symbolic Model Checking for Probabilistic Processes , 1997, ICALP.

[413]  I-Peng Lin,et al.  Recursive Modes for Precise Analysis of Logic Programs , 1997, ILPS.

[414]  Manfred Schmidt-Schauß,et al.  TEA: Automatically Proving Termination of Programs in a Non-strict Higher-Order Functional Language , 1997, SAS.

[415]  Jürgen Brauburger.  Automatic Termination Analysis for Partial Functions Using Polynomial Orderings , 1997, SAS.

[416]  Saumya K. Debray,et al.  Interprocedural control flow analysis of first-order programs with tail-call optimization , 1997, TOPL.

[417]  Christian Mossin,et al.  Exact flow analysis , 1997, Mathematical Structures in Computer Science.

[418]  Roberto Bagnara,et al.  Set-Sharing is Redundant for Pair-Sharing , 1997, SAS.

[419]  Barbara G. Ryder.  Practical Compile-Time Analysis , 1997, SAS.

[420]  Thomas P. Jensen,et al.  Disjunctive program analysis for algebraic data types , 1997, TOPL.

[421]  Natarajan Shankar,et al.  Integration in PVS: Tables, Types, and Model Checking , 1997, TACAS.

[422]  Matthias Felleisen,et al.  Componential set-based analysis , 1997, TOPL.

[423]  John C. Mitchell,et al.  ML and beyond , 1997, SIGP.

[424]  Kwangkeun Yi,et al.  Towards a Cost-Effective Estimation of Uncaught Exceptions in SML Programs , 1997, SAS.

[425]  Abelardo Pardo,et al.  Automatic Abstraction Techniques for Propositional µ-calculus Model Checking , 1997, CAV.

[426]  Roberto Giacobazzi,et al.  Abstracting Synchronization in Concurrent Constraint Programming , 1994, J. Funct. Log. Program..

[427]  Neil D. Jones,et al.  Combining Abstract Interpretation and Partial Evaluation (Brief Overview) , 1997, SAS.

[428]  Hassen Saïdi,et al.  Construction of Abstract State Graphs with PVS , 1997, CAV.

[429]  Richard Gerber,et al.  Symbolic Model Checking of Infinite State Systems Using Presburger Arithmetic , 1997, CAV.

[430]  Orna Grumberg,et al.  Abstract interpretation of reactive systems , 1997, TOPL.

[431]  Patrick Cousot.  Program analysis: the abstract interpretation perspective , 1997, SIGP.

[432]  Patrick Cousot,et al.  Constructive design of a hierarchy of semantics of a transition system by abstract interpretation , 2002, MFPS.

[433]  Suresh Jagannathan,et al.  Type-Directed Flow Analysis for Typed Intermediate Languages , 1997, SAS.

[434]  Rance Cleaveland,et al.  Modeling and Verifying Active Structural Control Systems , 1997, Sci. Comput. Program..

[435]  Kim G. Larsen,et al.  Formal modeling and analysis of an audio/video protocol: an industrial case study using UPPAAL , 1997, Proceedings Real-Time Systems Symposium.

[436]  Gilberto Filé,et al.  Abstract Interpretation from Improving WAM Code , 1997, SAS.

[437]  Alexander Aiken,et al.  Program Analysis Using Mixed Term and Set Constraints , 1997, SAS.

[438]  Arne Skou,et al.  Formal Verification of an Audio/Video Power Controller using the Real-Time Model Checker UPPAAL , 1997 .

[439]  Stanislav Tzolovski.  Data Dependence as Abstract Interpretations , 1997, SAS.

[440]  Ian Mackie.  Static Analysis of Interaction Nets for Distributed Implementations , 1997, SAS.

[441]  Neil D. Jones,et al.  Higher-Order Minimal Function Graphs , 1997, J. Funct. Log. Program..

[442]  David Toman,et al.  Constraint Databases and Program Analysis Using Abstract Interpretation , 1997, CDB.

[443]  Roberto Giacobazzi.  A Tutorial on Domain Theory in Abstract Interpretation , 1998, SAS.

[444]  Kim Marriott,et al.  Two Classes of Boolean Functions for Dependency Analysis , 1998, Sci. Comput. Program..

[445]  Kwangkeun Yi.  An Abstract Interpretation for Estimating Uncaught Exceptions in Standard ML Programs , 1998, Sci. Comput. Program..

[446]  Rastislav Bodík,et al.  Path-sensitive value-flow analysis , 1998, POPL '98.

[447]  Natarajan Shankar,et al.  PVS: An Experience Report , 1998, FM-Trends.

[448]  Corrado Priami,et al.  Constructing Specific SOS Semantics for Concurrency via Abstract Interpretation , 1998, SAS.

[449]  Flemming Nielson,et al.  Strictness and Totality Analysis , 1998, SAS.

[450]  Michael Codish,et al.  The Boolean Logic of Set Sharing Analysis , 1998, PLILP/ALP.

[451]  David A. Schmidt,et al.  Stackability in the Simply-Typed Call-by-Value lambda Calculus , 1998, Sci. Comput. Program..

[452]  Giorgio Levi,et al.  Abstract Interpretation of Prolog Programs , 1999, AMAST.

[453]  Christian Mossin.  Higher-Order Value Flow Graphs , 1998, Nord. J. Comput..

[454]  John Hannan.  Program Analysis in Lambda-Prolog , 1998, PLILP/ALP.

[455]  Nicolas Halbwachs,et al.  Synchronous Programming of Reactive Systems , 1992, CAV.

[456]  Arnaud Venet,et al.  Automatic Determination of Communication Topologies in Mobile Systems , 1998, SAS.

[457]  Tobias Nipkow,et al.  Javalight is type-safe—definitely , 1998, POPL '98.

[458]  Danny De Schreye,et al.  Termination Analysis: Some Practical Properties of the Norm and Level Mapping Space , 1998, IJCSLP.

[459]  Henny B. Sipma,et al.  Visual Abstractions for Temporal Verification , 1999, AMAST.

[460]  Roberto Bagnara,et al.  Factorizing Equivalent Variable Pairs in ROBDD-Based Implementations of Pos , 1998, AMAST.

[461]  Roberto Bagnara,et al.  The Correctness of Set-Sharing , 1998, SAS.

[462]  Tomás E. Uribe,et al.  Generating Finite-State Abstractions of Reactive Systems Using Decision Procedures , 1998, CAV.

[463]  Michael Hind,et al.  Assessing the Effects of Flow-Sensitivity on Pointer Alias Analyses , 1998, SAS.

[464]  Saumya K. Debray,et al.  Alias analysis of executable code , 1998, POPL '98.

[465]  K. Rustan M. Leino,et al.  An Extended Static Checker for Modular-3 , 1998, CC.

[466]  Bruno Blanchet,et al.  Escape analysis: correctness proof, implementation and experimental results , 1998, POPL '98.

[467]  Nicolas Halbwachs,et al.  About Synchronous Programming and Abstract Interpretation , 1998, Sci. Comput. Program..

[468]  Andreas Podelski,et al.  Set-Based Analysis of Reactive Infinite-State Systems , 1998, TACAS.

[469]  Laurie J. Hendren,et al.  Putting pointer analysis to work , 1998, POPL '98.

[470]  T. B. Dinesh,et al.  Equations as a uniform framework for partial evaluation and abstract interpretation , 1998, CSUR.

[471]  C. Faure,et al.  Sparse Jacobian Computation in Automatic Differentiation by Static Program Analysis , 1998, SAS.

[472]  Stavros Tripakis,et al.  Kronos: A Model-Checking Tool for Real-Time Systems , 1998, CAV.

[473]  Fausto Giunchiglia,et al.  Verification of a safety-critical railway interlocking system with real-time constraints , 1998, Digest of Papers. Twenty-Eighth Annual International Symposium on Fault-Tolerant Computing (Cat. No.98CB36224).

[474]  Giorgio Levi,et al.  Derivation of Proof Methods by Abstract Interpretation , 1998, PLILP/ALP.

[475]  Jens Palsberg,et al.  From polyvariant flow information to intersection and union types , 1998, POPL '98.

[476]  Suresh Jagannathan,et al.  Single and loving it: must-alias analysis for higher-order languages , 1998, POPL '98.

[477]  Doron A. Peled,et al.  Ten Years of Partial Order Reduction , 1998, CAV.

[478]  Thomas P. Jensen,et al.  Inference of polymorphic and conditional strictness properties , 1998, POPL '98.

[479]  Nancy A. Lynch,et al.  A Proof of Burns N-Process Mutual Exclusion Algorithm Using Abstraction , 1998, TACAS.

[480]  Michael Leuschel,et al.  On the Power of Homeomorphic Embedding for Online Termination , 1998, SAS.

[481]  David Grove,et al.  Fast interprocedural class analysis , 1998, POPL '98.

[482]  Matthew B. Dwyer,et al.  Staging Static Analyses Using Abstraction-Based Program Specialization , 1998, PLILP/ALP.

[483]  Yassine Lakhnech,et al.  Computing Abstractions of Infinite State Systems Compositionally and Automatically , 1998, CAV.

[484]  Laurent Mauborgne.  Abstract Interpretation Using Typed Decision Graphs , 1998, Sci. Comput. Program..

[485]  Masami Hagiya,et al.  On a New Method for Dataflow Analysis of Java Virtual Machine Subroutines , 1998, SAS.

[486]  Michael Leuschel,et al.  Program Specialisation and Abstract Interpretation Reconciled , 1998, IJCSLP.

[487]  David A. Schmidt,et al.  Program Analysis as Model Checking of Abstract Interpretations , 1998, SAS.

[488]  Roberto Giacobazzi,et al.  Building Complete Abstract Interpretations in a Linear Logic-based Setting , 1998, SAS.

[489]  Xavier Leroy,et al.  Security properties of typed applets , 1998, POPL '98.

[490]  Jörg Köller,et al.  A New Class of Functions for Abstract Interpretation , 1999, SAS.

[491]  Masahiro Fujita,et al.  Symbolic model checking using SAT procedures instead of BDDs , 1999, DAC '99.

[492]  Bruno Blanchet,et al.  Escape analysis for object-oriented languages: application to Java , 1999, OOPSLA '99.

[493]  Marco Pistore,et al.  Finite State Verification for the Asynchronous pi-Calculus , 1999, TACAS.

[494]  Saburo Muroga,et al.  Binary Decision Diagrams , 2000, The VLSI Handbook.

[495]  Johann Blieberger,et al.  Symbolic pointer analysis for detecting memory leaks , 1999 .

[496]  David Monniaux,et al.  Abstracting cryptographic protocols with tree automata , 1999, Sci. Comput. Program..

[497]  Bernhard Steffen,et al.  Model-Checking: A Tutorial Introduction , 1999, SAS.

[498]  Marius Bozga,et al.  State space reduction based on live variables analysis , 1999, Sci. Comput. Program..

[499]  Danny De Schreye,et al.  Constraint-based termination analysis of logic programs , 1999, TOPL.

[500]  Florian Martin,et al.  Generating program analyzers , 1999 .

[501]  Gilberto Filé,et al.  The Powerset Operator on Abstract Interpretations , 1999, Theor. Comput. Sci..

[502]  Parosh Aziz Abdulla,et al.  Verification of Infinite-State Systems by Combining Abstraction and Reachability Analysis , 1999, CAV.

[503]  Gilberto Filé,et al.  A Simple and General Method for Integrating Abstract Interpretation in SICStus , 1999, PPDP.

[504]  Arnaud Venet,et al.  Automatic Analysis of Pointer Aliasing for Untyped Programs , 1999, Sci. Comput. Program..

[505]  Mizuhito Ogawa,et al.  Automatic Verification Based on Abstract Interpretation , 1999, Fuji International Symposium on Functional and Logic Programming.

[506]  Danny De Schreye,et al.  Modular Termination Proofs for Prolog with Tabling , 1999, PPDP.

[507]  Natarajan Shankar,et al.  Abstract and Model Check While You Prove , 1999, CAV.

[508]  Edmund M. Clarke,et al.  State space reduction using partial order techniques , 1999, International Journal on Software Tools for Technology Transfer.

[509]  Alexander Aiken,et al.  Introduction to Set Constraint-Based Program Analysis , 1999, Sci. Comput. Program..

[510]  H. Seidl,et al.  A Faster Solver for General Systems of Equations , 1999, Sci. Comput. Program..

[511]  Agostino Cortesi,et al.  Sharing is Optimal , 1999, J. Log. Program..

[512]  Frank Huch,et al.  Verification of Erlang programs using abstract interpretation and model checking , 1999, ICFP '99.

[513]  Dominique Cansell,et al.  Abstract Animator for Temporal Specifications: Application to TLA , 1999, SAS.

[514]  Emin Gün Sirer,et al.  Static Analyses for Eliminating Unnecessary Synchronization from Java Programs , 1999, SAS.

[515]  Jörn Schneider,et al.  Pipeline behavior prediction for superscalar processors by abstract interpretation , 1999, LCTES '99.

[516]  Nicolas Halbwachs,et al.  Dynamic Partitioning in Analyses of Numerical Properties , 1999, SAS.

[517]  Flemming Nielson,et al.  Type and Effect Systems , 1999, Correct System Design.

[518]  Manuel V. Hermenegildo,et al.  Effectivness of abstract interpretation in automatic parallelization: a case study in logic programming , 1999, TOPL.

[519]  Sérgio Vale Aguiar Campos,et al.  ProbVerus: Probabilistic Symbolic Model Checking , 1999, ARTS.

[520]  Roberto Giacobazzi,et al.  The Reduced Relative Power Operation on Abstract Domains , 1999, Theor. Comput. Sci..

[521]  J Urgen Brauburger,et al.  Approximating the Domains of Functional and Imperative Programs , 1999 .

[522]  Roberto Barbuti,et al.  Abstract Interpretation of Trace Semantics for Concurrent Calculi , 1999, Inf. Process. Lett..

[523]  Patrick Cousot,et al.  The calculational design of a generic abstract interpreter , 1999 .

[524]  Sérgio Vale Aguiar Campos,et al.  Analysis and verification of real-time systems using quantitative symbolic algorithms , 1999, International Journal on Software Tools for Technology Transfer.

[525]  Peter J. Stuckey,et al.  Sharing and groundness dependencies in logic programs , 1999, TOPL.

[526]  Patrick Cousot.  Directions for research in approximate system analysis , 1999, CSUR.

[527]  Laurent Mauborgne.  Binary Decision Graphs , 1999, SAS.

[528]  Richard Gerber,et al.  Model-checking concurrent systems with unbounded integer variables: symbolic representations, approximations, and experimental results , 1999, TOPL.

[529]  Carl Pixley,et al.  Model checking: a hardware design perspective , 1999, International Journal on Software Tools for Technology Transfer.

[530]  Danny De Schreye,et al.  Termination Analysis of Tabled Logic Programs Using Mode and Type Information , 1999, Fuji International Symposium on Functional and Logic Programming.

[531]  Stavros Tripakis.  Timed Diagnostics for Reachability Properties , 1999, TACAS.

[532]  Frédéric Malésieux,et al.  Typed Static Analysis: Application to Groundness Analysis of PROLOG and lambda-PROLOG , 1999, Fuji International Symposium on Functional and Logic Programming.

[533]  Reinhard Wilhelm,et al.  Cache Behavior Prediction by Abstract Interpretation , 1996, Sci. Comput. Program..

[534]  Giorgio Levi,et al.  Abstract Diagnosis , 1999, J. Log. Program..

[535]  Moshe Y. Vardi.  Probabilistic Linear-Time Model Checking: An Overview of the Automata-Theoretic Approach , 1999, ARTS.

[536]  Somesh Jha,et al.  Abstract BDDs: A Technique for Using Abstraction in Model Checking , 1999, CHARME.

[537]  Non pair-sharing and freeness analysis through linear refinement , 1999, PEPM '00.

[538]  Roberto Bagnara,et al.  Widening Sharing , 1999, APPIA-GULP-PRODE.

[539]  John P. Gallagher,et al.  An Integration of Partial Evaluation in a Generic Abstract Interpretation Framework , 1999, PEPM.

[540]  Mahmut T. Kandemir,et al.  A global communication optimization technique based on data-flow analysis and linear algebra , 1999, TOPL.

[541]  Christoph Beierle,et al.  Using Types as Approximations for Type Checking Prolog Programs , 1999, Fuji International Symposium on Functional and Logic Programming.

[542]  Salvador Lucas,et al.  A Semantics for Program Analysis in Narrowing-Based Functional Logic Languages , 1999, Fuji International Symposium on Functional and Logic Programming.

[543]  Matthias Blume,et al.  Dependency analysis for Standard ML , 1999, TOPL.

[544]  Giorgio Delzanno,et al.  Model Checking in CLP , 1999, TACAS.

[545]  Cornelia Pusch,et al.  Proving the Soundness of a Java Bytecode Verifier Specification in Isabelle/HOL , 1999, TACAS.

[546]  Laurie Hendren,et al.  Soot---a java optimization framework , 1999 .

[547]  David L. Dill,et al.  Experience with Predicate Abstraction , 1999, CAV.

[548]  Kazunori Ueda,et al.  Linearity Analysis of Concurrent Logic Programs , 1999, WOID@ICLP.

[549]  Patrick Cousot,et al.  Abstract interpretation: Achievements and perspectives , 2000 .

[550]  Flemming Nielson,et al.  Shape analysis for mobile ambients , 2000, POPL '00.

[551]  Farn Wang,et al.  Efficient Data Structure for Fully Symbolic Verification of Real-Time Software Systems , 2000, TACAS.

[552]  Chris Hankin,et al.  Safety of Strictness Analysis via Term Graph Rewriting , 2000, SAS.

[553]  Yassine Lakhnech,et al.  A Transformational Approach for Generating Non-linear Invariants , 2000, SAS.

[554]  P. Cousot.  Partial Completeness of Abstract Fixpoint Checking (Invited paper) , 2000 .

[555]  Francesca Rossi,et al.  An Abstraction Framework for Soft Constraints and Its Relationship with Constraint Propagation , 2000, SARA.

[556]  Patrick Cousot,et al.  Temporal abstract interpretation , 2000, POPL '00.

[557]  Giorgio Levi,et al.  Abstract interpretation based verification of logic programs , 2003, Sci. Comput. Program..

[558]  David Monniaux,et al.  Abstract Interpretation of Probabilistic Semantics , 2000, SAS.

[559]  Michael Codish,et al.  An Algebraic Approach to Sharing Analysis of Logic Programs , 1997, SAS.

[560]  Jérôme Feret,et al.  Confidentiality Analysis of Mobile Systems , 2000, SAS.

[561]  Amir Pnueli,et al.  Control and data abstraction: the cornerstones of practical formal verification , 2000, International Journal on Software Tools for Technology Transfer.

[562]  Hassen Saïdi,et al.  Model Checking Guided Abstraction and Analysis , 2000, SAS.

[563]  Laurent Mauborgne,et al.  Improving the Representation of Infinite Trees to Deal with Sets of Trees , 2000, ESOP.

[564]  Parosh Aziz Abdulla,et al.  Symbolic Reachability Analysis Based on SAT-Solvers , 2000, TACAS.

[565]  Shmuel Sagiv,et al.  TVLA: A System for Implementing Static Analyses , 2000, SAS.

[566]  Patrick Cousot,et al.  Abstract interpretation based program testing , 2000 .

[567]  Stephan Merz,et al.  Model Checking , 2000 .

[568]  Somesh Jha,et al.  Partial Order Reductions for Security Protocol Verification , 2000, TACAS.

[569]  David L. Dill,et al.  Automatic checking of aggregation abstractions through stateenumeration , 1997, IEEE Trans. Comput. Aided Des. Integr. Circuits Syst..

[570]  Laurent Mauborgne.  Tree Schemata and Fair Termination , 2000, SAS.

[571]  Reinhard Wilhelm,et al.  Shape Analysis , 2000, CC.

[572]  Manuel V. Hermenegildo,et al.  Grid-Based Histogram Arithmetic for the Probabilistic Analysis of Functions , 2000, SARA.

[573]  Michael Rodeh,et al.  Checking Cleanness in Linked Lists , 2000, SAS.

[574]  Anna Philippou,et al.  Tools and Algorithms for the Construction and Analysis of Systems , 2018, Lecture Notes in Computer Science.

[575]  Amir Pnueli,et al.  Symbolic model checking with rich assertional languages , 2001, Theor. Comput. Sci..

[576]  Jérôme Feret,et al.  Occurrence Counting Analysis for the pi-Calculus , 2000, GETCO.

[577]  Roberto Bagnara,et al.  Decomposing non-redundant sharing by complementation , 2002, Theory Pract. Log. Program..

[578]  Francesca Scozzari,et al.  Logical optimality of groundness analysis , 1997, Theor. Comput. Sci..