The proof theory of the constructive modal logic S4 (hereafter $\mathsf{CS4}$ ) has been settled since the beginning of this century by means of either standard natural deduction and sequent calculi or by the reconstruction of modal logic through hypothetical and categorical judgments à la Martin-Löf, an approach carried out by using a special kind of sequents, which keeps two separated contexts representing ordinary and enhanced hypotheses, intuitively interpreted as true and valid assumptions. These so-called dual-context sequents, originated in linear logic, are used to define a natural deduction system handling judgments of validity, truth, and possibility, resulting in a formalism equivalent to an axiomatic system for $\mathsf{CS4}$ . However, this proof-theoretical study of $\mathsf{CS4}$ lacks, to the best of our knowledge, its third fundamental constituent, namely a sequent calculus. In this paper, we define such a dual-context formalism, called ${\bf DG_{CS4}}$ , and provide detailed proofs of the admissibility for the ordinary cut rule as well as the elimination of a second cut rule, which manipulates enhanced hypotheses. Furthermore, we make available a formal verification of the equivalence of this proposal with the previously defined axiomatic and dual-context natural deduction systems for $\mathsf{CS4}$ , using the Coq proof-assistant.

We devise imperative programming languages for verified real number computation where real numbers are provided as abstract data types such that the users of the languages can express real number computation by considering real numbers as abstract mathematical entities. Unlike other common approaches toward real number computation, based on an algebraic model that lacks implementability or transcendental computation, or finite-precision approximation such as using double precision computation that lacks a formal foundation, our languages are devised based on computable analysis, a foundation of rigorous computation over continuous data. Consequently, the users of the language can easily program real number computation and reason about the behaviours of their programs, relying on their mathematical knowledge of real numbers without worrying about artificial roundoff errors. As the languages are imperative, we adopt precondition–postcondition-style program specification and Hoare-style program verification methodologies. Consequently, the users of the language can easily program a computation over real numbers, specify the expected behaviour of the program, including termination, and prove the correctness of the specification. Furthermore, we suggest extending the languages with other interesting continuous data, such as matrices, continuous real functions, et cetera.

Abstract taken directly from the thesis.

E-mail: sewonpark17@gmail.com

URL: https://sewonpark.com/thesis

Formal reasoning about finite sets and cardinality is important for many applications, including software verification, where very often one needs to reason about the size of a given data structure. The Constraint Logic Programming tool $$\{ log\} $$ provides a decision procedure for deciding the satisfiability of formulas involving very general forms of finite sets, although it does not provide cardinality constraints. In this paper we adapt and integrate a decision procedure for a theory of finite sets with cardinality into $$\{ log\} $$ . The proposed solver is proved to be a decision procedure for its formulas. Besides, the new CLP instance is implemented as part of the $$\{ log\} $$ tool. In turn, the implementation uses Howe and King’s Prolog SAT solver and Prolog’s CLP(Q) library, as an integer linear programming solver. The empirical evaluation of this implementation based on +250 real verification conditions shows that it can be useful in practice.

Under consideration in Theory and Practice of Logic Programming (TPLP)

In this paper, we study the problem of formal verification for Answer Set Programming (ASP), namely, obtaining a formal proof showing that the answer sets of a given (non-ground) logic program P correctly correspond to the solutions to the problem encoded by P, regardless of the problem instance. To this aim, we use a formal specification language based on ASP modules, so that each module can be proved to capture some informal aspect of the problem in an isolated way. This specification language relies on a novel definition of (possibly nested, first order) program modules that may incorporate local hidden atoms at different levels. Then, verifying the logic program P amounts to prove some kind of equivalence between P and its modular specification.

The software approach to developing Digital Signal Processing (DSP) applications brings some great features such as flexibility, re-usability of resources and easy upgrading of applications. However, it requires long and tedious tests and verification phases because of the increasing complexity of the software applications. This implies the need of a software programming environment capable of putting together DSP modules and providing facilities to debug, verify and validate the code. The objective of the work is to provide such facilities as simulation and verification for developing DSP software applications. This led us to developing an extension toolkit, EPSPECTRA, built upon PSPECTRA, one of the first toolkits available to design basic software radio applications on standard PC workstations. In this paper, we first present EPSPECTRA, an ESTEREL-based extension of PSPECTRA that makes the design and implementation of portable DSP applications easier. It allows the drastic reduction of testing and verification time while requiring relatively little expertise in formal verification methods. Second, we demonstrate the use of EPSPECTRA, taking as an example the radio interface part of a GSM base station. We also present the verification procedures for the three safety properties of the implementation programs which have complex control-paths. These have to obey strict scheduling rules. In addition, EPSPECTRA achieves the verification of the targeted application since the same model is used for the executable code generation and for the formal verification.

We address the problem of verifying clique avoidance in the TTP protocol. TTP allows several stations embedded in a car to communicate. It has many mechanisms to ensure robustness to faults. In particular, it has an algorithm that allows a station to recognize itself as faulty and leave the communication. This algorithm must satisfy the crucial ‘non-clique’ property: it is impossible to have two or more disjoint groups of stations communicating exclusively with stations in their own group. In this paper, we propose an automatic verification method for an arbitrary number of stations $N$ and a given number of faults $k$. We give an abstraction that allows to model the algorithm by means of unbounded (parametric) counter automata. We have checked the non-clique property on this model in the case of one fault, using the ALV tool as well as the LASH tool.