Conference Paper

Modeling Systems in CLP.

Conference: Logic Programming, 21st International Conference, ICLP 2005, Sitges, Spain, October 2-5, 2005, Proceedings
Source: DBLP


We present a methodology for the modeling of complex program behavior in CLP. In the first part we present an informal description about how to represent a system in CLP. At its basic level, this representation captures the trace semantics of concurrent programs, or even high-level specifications, in the form of a predi- cate transformer. Based on traces, the method can also capture properties of the underlying runtime system such as the scheduler and the microarchitecture, so as to provide a foundation for reasoning about resources such as time and space. The second part presents a formal and compositional proof method for rea- soning about safety properties of the underlying system. The idea is that a safety property is simply a CLP goal, and is proof established by executing the goal by a CLP interpreter. However, a traditional CLP interpreter does not suffice. We thus introduce a technique of coinductive tabling to CLP. Essentially, this extends CLP so that it can inductively use proof obligations that are assumed but not yet proven, and it can generate new proof obligations assertions dynamically. 1 Outline We present a general CLP approach for program verification: We model a wide range of programs and systems in CLP We present a proof method to reason about any CLP program Poster structure: Modeling (Sec. 2) - Symbolic representation of transition relations in CLP - Modeling examples (Sec. 3) Sequential program Concurrent program: synchronous and asynchronous composition Scheduling

Full-text preview

Available from:
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Program slicing is a technique to extract relevant parts of a pro- gram, and it is widely used in program debugging, parallelization, testing, reverse engineering, etc. This paper concerns static slic- ing and it follows the Weiser's definition of slicing that consis ts of computing what statements of the program might affect the value of some particular variable at a specified program point. We a rgue that although there is a broad variety of static slicing meth ods, it is commonly assumed that all paths are executable. However, this limitation may be completely unacceptable in, for instance, debug- ging and program understanding tasks since the slice is often quite big. In this paper, we present a fully path-sensitive slicing that iden- tifies infeasible paths in order to obtain accurate slices. I nfeasible paths are detected by performing symbolic execution of the pro- gram. The major challenge is that in general there are exponentially many paths. Our method traverses the symbolic execution tree, in a post-order manner, and discovers an interpolant which general- izes the execution context of the tree. This enhances the likelihood that the dependencies computed for that tree can be reused in mul- tiple contexts. Another key feature is that our algorithm st ores, for each dependency, the executable path that defines it, that is , the representative path formulathat gives rise to it. By doing so, the dependency information is accurate since it is only used if t he new context demonstrates that the representative is executabl e. In fact, for loop-free programs, our algorithm computes exactly the state- ments relevant to the slicing criterion.
    Preview · Article · Jan 2010
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: We consider the problem of exploring the search tree of a CLP goal in pursuit of a target property. Essential to such a process is a method of tabling to prevent duplicate exploration. Typically, only actually traversed goals are memoed in the table. In this paper we present a method where, upon the successful traversal of a subgoal, a generalization of the subgoal is memoed. This enlarges the record of already traversed goals, thus providing more pruning in the subsequent search process. The key feature is that the abstraction computed is guaranteed not to give rise to a spurious path that might violate the target property. A driving application area is the use of CLP to model the behavior of other programs. We demonstrate the performance of our method on a benchmark of program verfication problems.
    Preview · Conference Paper · Sep 2009
  • Source
    [Show abstract] [Hide abstract]
    ABSTRACT: Security protocols are hard to design, even under the assumption of perfect cryptography. This is especially true when a protocol involves different timing aspects such as timestamps, timeout, delays and a set of timing constraints. In this paper, we propose a methodology for modeling and analyzing security protocols that are aware of timing aspects. We develop a formalism for modeling security protocols by extending Timed CSP with the capability of stating complicated timing behaviors for processes and events. A reasoning mechanism for the proposed formalism is developed based on Constraint Logic Programming (CLP). Using the reasoning engine built in CLP, the authentication properties of timed security protocols are able to be verified and attacks can be discovered. We demonstrate the capability of our method by modeling and verifying real-world security protocols. New approaches of using timing information to unfold and prevent potential attacks are also presented.
    Full-text · Conference Paper · Jan 2010
Show more