Extending sized type with collection analysis

ChinWei-Ngan,; KhooSiau-Cheng,; XuDana, N

doi:10.1145/966049.777397

“…This capability is particularly important for analyses that handle dynamically allocated data structures where the number of objects is statically unbounded (Møller and Schwartzbach, 2001;Yorsh et al, 2004;Sagiv et al, 2002). Recently, these approaches were extended to handle the combinations of the constraints representing data structure contents and constraints representing numerical properties of data structures (Rugina, 2004;Chin et al, 2003). Our result provides a systematic mechanism for building precise and predictable versions of such analyses.…”

Section: Related Workmentioning

confidence: 99%

Deciding Boolean Algebra with Presburger Arithmetic

Kunčak¹,

Nguyen

²

,

Rinard

³

2006

View full text Add to dashboard Cite

Abstract. We describe an algorithm for deciding the first-order multisorted theory BAPA, which combines 1) Boolean algebras of sets of uninterpreted elements (BA) and 2) Presburger arithmetic operations (PA). BAPA can express the relationship between integer variables and cardinalities of unbounded finite sets, and supports arbitrary quantification over sets and integers.Our original motivation for BAPA is deciding verification conditions that arise in the static analysis of data structure consistency properties. Data structures often use an integer variable to keep track of the number of elements they store; an invariant of such a data structure is that the value of the integer variable is equal to the number of elements stored in the data structure. When the data structure content is represented by a set, the resulting constraints can be captured in BAPA. BAPA formulas with quantifier alternations arise when verifying programs with annotations containing quantifiers, or when proving simulation relation conditions for refinement and equivalence of program fragments. Furthermore, BAPA constraints can be used for proving the termination of programs that manipulate data structures, as well as in constraint database query evaluation and loop invariant inference.We give a formal description of an algorithm for deciding BAPA. We analyze our algorithm and show that it has optimal alternating time complexity, and that the complexity of BAPA matches the complexity of PA. Because it works by a reduction to PA, our algorithm yields the decidability of a combination of sets of uninterpreted elements with any decidable extension of PA. When restricted to BA formulas, the algorithm can be used to decide BA in optimal alternating time. Furthermore, the algorithm can eliminate individual quantifiers from a formula with free variables and therefore perform projection onto a desirable set of variables.We have implemented our algorithm and used it to discharge verification conditions in the Jahob system for data structure consistency checking of Java programs; our experience suggest that a straightforward implementation of the algorithm is effective on non-trivial formulas as long as the number of set variables is small. We also report on a new algorithm for solving the quantifier-free fragment of BAPA.

show abstract

“…Note that the unwinding only contains functions that are involved in the counterexample, that is, main and H (as well as F and G beyond depth 2) are sliced out. 7 We discuss the key properties of unwinding. First, because d is simply typable, d…”

Section: Unwindingmentioning

confidence: 99%

“…Chin et al [6,7] have also suggested a constraint unrolling approach with the Omega test [33] as the backend solver. These approaches use neither candidate types nor a fixed-point type inference routine, but they resemble the refinement phase of our work in that they also reduce the inference problem to finding a solution to a set of first-order logic constraints.…”

Section: Inferring Dependent Typesmentioning

confidence: 99%

Dependent types from counterexamples

Terauchi

¹

2010

Proceedings of the 37th Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages

View full text Add to dashboard Cite

Motivated by recent research in abstract model checking, we present a new approach to inferring dependent types. Unlike many of the existing approaches, our approach does not rely on programmers to supply the candidate (or the correct) types for the recursive functions and instead does counterexample-guided refinement to automatically generate the set of candidate dependent types. The main idea is to extend the classical fixed-point type inference routine to return a counterexample if the program is found untypable with the current set of candidate types. Then, an interpolating theorem prover is used to validate the counterexample as a real type error or generate additional candidate dependent types to refute the spurious counterexample. The process is repeated until either a real type error is found or sufficient candidates are generated to prove the program typable. Our system makes non-trivial use of "linear" intersection types in the refinement phase.The paper presents the type inference system and reports on the experience with a prototype implementation that infers dependent types for a subset of the Ocaml language. The implementation infers dependent types containing predicates from the quantifierfree theory of linear arithmetic and equality with uninterpreted function symbols.

show abstract

“…The rest of the rules remain the same, just replacing ⊢ with ⊢ 1 , and ⊢∧ with ⊢ 1 ∧ . We eliminate any intersection of base types via the equivalence {u:B | θ1} ∧ {u:B | θ2} = 7 The implementation performs additional optimizations that can further reduce the size of the unwinding by slicing out more irrelevant parts.…”

Section: Linear Intersection Typesmentioning

confidence: 99%

Dependent types from counterexamples

2010

View full text Add to dashboard Cite

Motivated by recent research in abstract model checking, we present a new approach to inferring dependent types. Unlike many of the existing approaches, our approach does not rely on programmers to supply the candidate (or the correct) types for the recursive functions and instead does counterexample-guided refinement to automatically generate the set of candidate dependent types. The main idea is to extend the classical fixed-point type inference routine to return a counterexample if the program is found untypable with the current set of candidate types. Then, an interpolating theorem prover is used to validate the counterexample as a real type error or generate additional candidate dependent types to refute the spurious counterexample. The process is repeated until either a real type error is found or sufficient candidates are generated to prove the program typable. Our system makes non-trivial use of "linear" intersection types in the refinement phase.The paper presents the type inference system and reports on the experience with a prototype implementation that infers dependent types for a subset of the Ocaml language. The implementation infers dependent types containing predicates from the quantifierfree theory of linear arithmetic and equality with uninterpreted function symbols.

show abstract

Extending sized type with collection analysis

Cited by 7 publications

References 20 publications

Deciding Boolean Algebra with Presburger Arithmetic

Deciding Boolean Algebra with Presburger Arithmetic

Dependent types from counterexamples

Dependent types from counterexamples

Contact Info

Product

Resources

About