Papers
Topics
Authors
Recent
Gemini 2.5 Flash
Gemini 2.5 Flash
139 tokens/sec
GPT-4o
7 tokens/sec
Gemini 2.5 Pro Pro
46 tokens/sec
o3 Pro
4 tokens/sec
GPT-4.1 Pro
38 tokens/sec
DeepSeek R1 via Azure Pro
28 tokens/sec
2000 character limit reached

Regular Abstractions for Array Systems (2401.02618v1)

Published 5 Jan 2024 in cs.SE and cs.LO

Abstract: Verifying safety and liveness over array systems is a highly challenging problem. Array systems naturally capture parameterized systems such as distributed protocols with an unbounded number of processes. Such distributed protocols often exploit process IDs during their computation, resulting in array systems whose element values range over an infinite domain. In this paper, we develop a novel framework for proving safety and liveness over array systems. The crux of the framework is to overapproximate an array system as a string rewriting system (i.e. over a finite alphabet) by means of a new predicate abstraction that exploits the so-called indexed predicates. This allows us to tap into powerful verification methods for string rewriting systems that have been heavily developed in the last few decades (e.g. regular model checking). We demonstrate how our method yields simple, automatically verifiable proofs of safety and liveness properties for challenging examples, including Dijkstra's self-stabilizing protocol and the Chang-Roberts leader election protocol.

Definition Search Book Streamline Icon: https://streamlinehq.com
References (94)
  1. Martin Abadi. 1989. The power of temporal proofs. Theoretical Computer Science 65, 1 (1989), 35–83.
  2. Parosh Aziz Abdulla. 2012. Regular Model Checking. International Journal on Software Tools for Technology Transfer (STTT) 14, 2 (2012), 109–118.
  3. Constrained Monotonic Abstraction: A CEGAR for Parameterized Verification. In International Conference on Concurrency Theory (CONCUR). Springer, 86–101.
  4. Approximated Parameterized Verification of Infinite-State Processes with Global Conditions. Formal Methods in System Design (FMSD) 34, 2 (2009), 126–156.
  5. Parameterized Verification Through View Abstraction. International Journal on Software Tools for Technology Transfer (STTT) 18, 5 (2016), 495–516.
  6. Regular Model Checking for LTL(MSO). International Journal on Software Tools for Technology Transfer (STTT) 14, 2 (2012), 223–241.
  7. Lazy Abstraction with Interpolants for Arrays. In International Conference on Logic Programming and Automated Reasoning (LPAR). Springer, 46–61.
  8. SAFARI: SMT-Based Abstraction for Arrays with Interpolants. In International Conference on Computer-Aided Verification (CAV). Springer, 679–685.
  9. A Framework for the Verification of Parameterized Infinite-State Systems. Fundamenta Informaticae 150, 1 (2017), 1–24.
  10. George Argyros and Loris D’Antoni. 2018. The Learnability of Symbolic Automata. In International Conference on Computer Aided Verification (CAV). Springer, 427–445.
  11. Symbolic counter abstraction for concurrent software. In International Conference on Computer Aided Verification (CAV). Springer, 64–78.
  12. Jaroslav Bendík and Ivana Černá. 2020. MUST: minimal unsatisfiable subsets enumeration tool. In Tools and Algorithms for the Construction and Analysis of Systems (TACAS). Springer, 135–152.
  13. Recursive online enumeration of all minimal unsatisfiable subsets. In Automated Technology for Verification and Analysis (ATVA). Springer, 143–159.
  14. Definable Relations and First-Order Query Languages over Strings. Journal of the ACM (JACM) 50, 5 (2003), 694–751.
  15. Decidability of Parameterized Verification. Morgan & Claypool Publishers.
  16. Achim Blumensath and Erich Gradel. 2000. Automatic Structures. In Symposium on Logic in Computer Science (LICS). IEEE, 51–62.
  17. Achim Blumensath and Erich Grädel. 2004. Finite Presentations of Infinite Structures: Automata and Interpretations. Theory of Computing Systems (TCS) 37, 6 (2004), 641–674.
  18. Abstract Regular Model Checking. In International Conference on Computer-Aided Verification (CAV). Springer, 372–386.
  19. Regular Model Checking. In International Conference on Computer-Aided Verification (CAV). Springer, 403–418.
  20. Aaron R. Bradley and Zohar Manna. 1998. The Calculus of Computation: Decision Procedures with Applications to Verification. Springer.
  21. What’s Decidable about Arrays?. In International Conference on Verification, Model Checking, and Abstract Interpretation (VMCAI). Springer, 427–442.
  22. Ernest Chang and Rosemary Roberts. 1979. An Improved Algorithm for Decentralized Extrema-Finding in Circular Configurations of Processes. Communications of the ACM (CACM) 22, 5 (1979), 281–283.
  23. Learning to Prove Safety over Parameterised Concurrent Systems. In International Conference on Formal Methods in Computer-Aided Design (FMCAD). Springer, 76–83.
  24. IC3 Modulo Theories via Implicit Predicate Abstraction. In International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS). Springer, 46–61.
  25. Infinite-state invariant checking with IC3 and predicate abstraction. Formal Methods in System Design 49 (2016), 190–218.
  26. Verification of SMT Systems with Quantifiers. In International Symposium on Automated Technology for Verification and Analysis (ATVA). Springer, 154–170.
  27. Universal Invariant Checking of Parametric Systems with Quantifier-free SMT Reasoning. In International Conference on Automated Deduction (CADE). Springer, 131–147.
  28. Environment Abstraction for Parameterized Verification. In International Workshop on Verification, Model Checking, and Abstract Interpretation (VMCAI). Springer, 126–141.
  29. Proving Ptolemy Right: The Environment Abstraction Framework for Model Checking Concurrent Systems. In International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS). Springer, 33–47.
  30. Reasoning about Networks with Many Identical Finite State Processes. In Symposium on Principles of Distributed Computing (PODC). ACM, 240–248.
  31. Model Checking. MIT press.
  32. Thomas Colcombet and Christof Löding. 2007. Transforming Structures by Set Interpretations. Logical Methods in Computer Science (LMCS) 3, 2 (2007), paper–4.
  33. Proving Thread Termination. In Programming Language Design and Implementation (PLDI). ACM, 320–330.
  34. Patrick Cousot and Radhia Cousot. 1977. Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints. In Symposium on Principles of Programming Languages (POPL). ACM, 238–252.
  35. Infinite-State Liveness-To-Safety via Implicit Abstraction and Well-Founded Relations. In International Conference on Computer-Aided Verification (CAV). Springer, 271–291.
  36. Leonardo Mendonça de Moura and Nikolaj Bjørner. 2008. Z3: An Efficient SMT Solver. In International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS). Springer, 337–340.
  37. Temporal logics in computer science: finite-state systems. Vol. 58. Cambridge University Press.
  38. Edsger W. Dijkstra. 1982. Self-Stabilization in Spite of Distributed Control. In Selected Writings on Computing: A Personal Perspective. Springer, 41–46.
  39. Symmetry-aware predicate abstraction for shared-variable concurrent programs. In International Conference on Computer-Aided Verification (CAV). Springer, 356–371.
  40. Counterexample-Guided Abstraction Refinement for Symmetric Concurrent Programs. Formal Methods in System Design (FMSD) 41, 1 (2012), 25–44.
  41. Samuel Drews and Loris D’Antoni. 2017. Learning Symbolic Automata. In Tools and Algorithms for the Construction and Analysis of Systems (TACAS), Vol. 10205. Springer, 173–189.
  42. E. Allen Emerson and Kedar S. Namjoshi. 2003. On Reasoning about Rings. International Journal of Foundations of Computer Science 14, 04 (2003), 527–549.
  43. Proving termination of probabilistic programs using patterns. In International Conference on Computer-Aided Verification (CAV). Springer, 123–138.
  44. Proving Liveness of Parameterized Programs. In Symposium on Logic in Computer Science (LICS). IEEE, 1–12.
  45. Quantified Invariants via Syntax-Guided Synthesis. In Computer Aided Verification (CAV). Springer, 259–277.
  46. SMT-based safety checking of parameterized multi-agent systems. In Proceedings of the AAAI Conference on Artificial Intelligence (AAAI), Vol. 35. PKP Publishing, 6321–6330.
  47. Lazy Automata Techniques for WS1S. In International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS). Springer, 407–425.
  48. Cormac Flanagan and Shaz Qadeer. 2002. Predicate Abstraction for Software Verification. In Symposium on Principles of Programming Languages (POPL). ACM, 191–202.
  49. Counting dynamically synchronizing processes. International Journal on Software Tools for Technology Transfer (STTT) 18 (2016), 517–534.
  50. Yeting Ge and Leonardo De Moura. 2009. Complete Instantiation for Quantified Formulas in Satisfiability Modulo Theories. In International Conference on Computer Aided Verification (CAV). Springer, 306–320.
  51. Steven M. German and A. Prasad Sistla. 1992. Reasoning about Systems with Many Processes. Journal of the ACM (JACM) 39, 3 (1992), 675–735.
  52. Interpolation and Amalgamation for Arrays with MaxDiff. In International Conference on Foundations of Software Science and Computation Structures (FoSSaCS). Springer, 268–288.
  53. SMT-Based Verification of Parameterized Systems. In International Symposium on Foundations of Software Engineering (FSE). ACM, 338–348.
  54. Quantifiers on Demand. In Automated Technology for Verification and Analysis (ATVA). Springer, 248–266.
  55. A Logic of Singly Indexed Arrays. In International Conference on Logic Programming and Automated Reasoning (LPAR). Springer, 558–573.
  56. Decidable Fragments of First-Order Temporal Logics. In Annals of Pure and Applied Logic. Elsevier, 181–185.
  57. Jochen Hoenicke and Tanja Schindler. 2018. Efficient interpolation for the theory of arrays. In International Joint Conference on Automated Reasoning (IJCAR). Springer, 549–565.
  58. Chih-Duo Hong. 2022. Symbolic techniques for parameterised verification. Ph. D. Dissertation. University of Oxford.
  59. Ranjit Jhala and Kenneth L. McMillan. 2007. Array Abstractions from Proofs. In International Conference on Computer-Aided Verification (CAV). Springer, 193–206.
  60. Predicate Abstraction for Program Verification: Safety and Termination. In Handbook of Model Checking. Springer, 447–491.
  61. Lost in abstraction: Monotonicity in multi-threaded programs. Information and Computation 252 (2017), 30–47.
  62. Jeroen Ketema and Alastair F. Donaldson. 2017. Termination Analysis for GPU Kernels. Science of Computer Programming 148 (2017), 107–122.
  63. Nils Klarlund and Anders Møller. 2001. Mona Version 1.4: User Manual. BRICS, Department of Computer Science, University of Aarhus Denmark.
  64. MONA Implementation Secrets. International Journal of Foundations of Computer Science 13, 04 (2002), 571–586.
  65. Compositional Verification of Procedural Programs using Horn Clauses over Integers and Arrays. In Formal Methods in Computer-Aided Design (FMCAD). IEEE, 89–96.
  66. Daniel Kroening and Ofer Strichman. 2016. Decision Procedures. Springer.
  67. Shuvendu K. Lahiri and Randal E. Bryant. 2004a. Constructing Quantified Invariants via Predicate Abstraction. In International Conference on Verification, Model Checking, and Abstract Interpretation (VMCAI). Springer, 267–281.
  68. Shuvendu K. Lahiri and Randal E. Bryant. 2004b. Indexed Predicate Discovery for Unbounded System Verification. In International Conference on Computer-Aided Verification (CAV). Springer, 135–147.
  69. Shuvendu K. Lahiri and Randal E. Bryant. 2007. Predicate Abstraction with Indexed Predicates. ACM Transactions on Computational Logic (TOCL) 9, 1 (2007), 4–es.
  70. Fast, flexible MUS enumeration. Constraints 21 (2016), 223–250.
  71. Anthony W. Lin and Philipp Rümmer. 2016. Liveness of Randomised Parameterised Systems under Arbitrary Schedulers. In International Conference on Computer-Aided Verification (CAV). Springer, 112–133.
  72. Anthony W. Lin and Philipp Rümmer. 2022. Regular model checking revisited. In Model Checking, Synthesis, and Learning: Essays Dedicated to Bengt Jonsson on The Occasion of His 60th Birthday. Springer, 97–114.
  73. I4: incremental inference of inductive invariants for verification of distributed protocols. In The Symposium on Operating Systems Principles (SOSP). ACM, 370–384.
  74. Precise thread-modular verification. In International Static Analysis Symposium (SAS). Springer, 218–232.
  75. Counterexample-Guided Prophecy for Model Checking Modulo the Theory of Arrays. Logical Methods in Computer Science (LMCS) 18 (2022), 131–147.
  76. Zohar Manna and Amir Pnueli. 2012. The Temporal Logic of Reactive and Concurrent Systems: Specification. Springer Science & Business Media.
  77. John McCarthy. 1993. Towards a mathematical science of computation. Program Verification: Fundamental Issues in Computer Science 1, 1 (1993), 35–56.
  78. Kenneth L. McMillan. 2008. Quantified Invariant Generation Using an Interpolating Saturation Prover. In International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS). Springer, 413–427.
  79. Kenneth L. McMillan. 2018. Eager Abstraction for Symbolic Model Checking. In International Conference on Computer Aided Verification (CAV). Springer, 191–208.
  80. Kenneth L. McMillan and Oded Padon. 2018. Deductive Verification in Decidable Fragments with Ivy. In International Static Analysis Symposium (SAS). Springer, 43–55.
  81. Kenneth L. McMillan and Oded Padon. 2020. Ivy: A Multi-Modal Verification Tool for Distributed Algorithms. In International Conference on Computer Aided Verification (CAV). Springer, 190–202.
  82. Reducing Liveness to Safety in First-Order Logic. Symposium on Principles of Programming Languages (POPL) 2, POPL (2017), 1–33.
  83. Temporal prophecy for proving temporal properties of infinite-state systems. Formal Methods in System Design (FMSD) 57 (2021), 246–269.
  84. Rely-guarantee bound analysis of parameterized concurrent shared-memory programs: With an application to proving that non-blocking algorithms are bounded lock-free. Formal Methods in System Design (FMSD) 57, 2 (2021), 270–302.
  85. Thread-modular counter abstraction: automated safety and termination proofs of parameterized software by reduction to sequential program verification. Formal Methods in System Design (FMSD) 60 (2023), 1–38.
  86. SMT sampling via model-guided approximation. In International Symposium on Formal Methods (FM). Springer, 74–91.
  87. Corneliu Popeea and Andrey Rybalchenko. 2012. Compositional Termination Proofs for Multi-Threaded Programs. In International Conference on Tools and Algorithms for the Construction and Analysis of Systems (TACAS). Springer, 237–251.
  88. Silvio Ranise and Silvio Ghilardi. 2010. Backward Reachability of Array-Based Systems by SMT Solving: Termination and Invariant Synthesis. Logical Methods in Computer Science (LMCS) 6, 4 (2010), 25–44.
  89. Viktor Schuppan and Armin Biere. 2006. Liveness Checking as Safety Checking for Infinite State Spaces. Electronic Notes in Theoretical Computer Science (ENTCS) 149, 1 (2006), 79–96.
  90. Abstraction Refinement for Quantified Array Assertions. In Static Analysis Symposium (SAS). Springer, 3–18.
  91. CoqQFBV: A Scalable Certified SMT Quantifier-Free Bit-Vector Solver. In International Conference on Computer Aided Verification (CAV). Springer, 149–171.
  92. Dirk van Dalen. 1994. Logic and structure. Vol. 3. Springer.
  93. Moshe Y. Vardi and Pierre Wolper. 1986. An Automata-Theoretic Approach to Automatic Program Verification. In Symposium on Logic in Computer Science (LICS). IEEE, 322–331.
  94. Fast bit-vector satisfiability. In International Symposium on Software Testing and Analysis (ISSTA). ACM, 38–50.
Citations (2)

Summary

We haven't generated a summary for this paper yet.

X Twitter Logo Streamline Icon: https://streamlinehq.com