Jacek Chrząszcz

Implementing Modules in the Coq System

The paper describes the implementation of interactive ML-style modules in the recent version 7.4 of Coq proof assistant. Modules (especially higher-order) provide a very convenient tool for parametrized theories which was lacking in Coq for years. Their interactive character extends naturally the interactive environment provided by the proof assistant. The implementation follows the paradigm of recent versions of Coq to separate the correctness-critical code from the rest of the system, using abstraction barriers.

BML and Related Tools

The Bytecode Modeling Language (BML) is a specification language for Java bytecode, that provides a high level of abstraction, while not restricting the format of the bytecode. Notably, BML specifications can be stored in class files, so that they can be shipped together with the bytecode. This makes BML particularly suited as property specification language in a proof-carrying code framework. Moreover, BML is designed to be close to the source code level specification language JML, so that specifications (and proofs) developed at -- the more intuitive -- source code level can be compiled into bytecode level. This paper describes the BML language and its binary representation. It also discusses the tool set that is available to support BML, containing BMLLib, a library to inspect and edit BML specifications; Umbra, a BML viewer and editor, integrated in Eclipse; JML2BML, a compiler from JML to BML specifications; BML2BPL, a translator from BML to BoogiePL, so that the BoogiePL verification condition generator can be used; and CCT, a tool to store proofs in class files.

Towards rewriting in Coq

Equational reasoning in Coq is not straightforward. For a few years now there has been an ongoing research process towards adding rewriting to Coq. However, there are many research problems on this way. In this paper we give a coherent view of rewriting in Coq, we describe what is already done and what remains to be done. We discuss such issues as strong normalization, confluence, logical consistency, completeness, modularity and extraction.

ESC/Java2 as a Tool to Ensure Security in the Source Code of Java Applications*

The paper shows how extended static checking tools like ESC/Java2 can be used to ensure source code security properties of Java applications. It is demonstrated in a case study on a simple personal password manager. In case of such an application the ensuring of security is one of the most important goals. We present the possible threats connected with the current state of the code and its possible future extensions. This investigation is further accompanied by a presentation on how these threats can be controlled by JML specifications and ESC/Java2.

Consistency and completeness of rewriting in the calculus of constructions

Adding rewriting to a proof assistant based on the Curry-Howard isomorphism, such as Coq, may greatly improve usability of the tool. Unfortunately adding an arbitrary set of rewrite rules may render the underlying formal system undecidable and inconsistent. While ways to ensure termination and confluence, and hence decidability of type-checking, have already been studied to some extent, logical consistency has got little attention so far. In this paper we show that consistency is a consequence of canonicity, which in turn follows from the assumption that all functions defined by rewrite rules are complete. We provide a sound and terminating, but necessarily incomplete algorithm to verify this property. The algorithm accepts all definitions that follow dependent pattern matching schemes presented by Coquand and studied by McBride in his PhD thesis. Moreover, many definitions by rewriting containing rules which depart from standard pattern matching are also accepted.

Minik: A Tool for Maintaining Proper Java Code Structure

Maintaining discipline of code in an evolving software project is known to be difficult. We present Minik, an automatic tool written in Java and for Java, that assists technical managers to enforce high and medium level design decisions on programmers. The tool supports hierarchical encapsulation of software components and helps to maintain order in dependencies between parts of the project’s source code and to control calls to external libraries.

Function definitions for compound values in object-oriented languages

Declarative programming features are gradually included in the design of object-oriented languages such as Java and C++. These languages recently adopted anonymous function definitions and offer basic primitives that restrict changes on data, namely final and const keywords, respectively. We propose a type system for an object-oriented Java-like language that facilitates declarative programming while leaving programmers significant freedom in use of imperative features. The system allows one to delimit compound value representations and effectively define values that are common in functional programming languages. Given that, we distinguish methods that work as first-order functions on such values. In this framework functions may modify internal working state that is clearly separated from the global state of the program. The system exploits access modes for method arguments, which describe the way the method operates on the given entity representation.

The role of polymorphism in the characterisation of complexity by soft types

Soft type assignment systems STA, STA + , and STA B characterise by means of reduction of terms computation in complexity classes PTIME, NP, and PSPACE, respectively. All these systems are inspired by linear logic and include polymorphism similar to the one of System F. We show that the presence of polymorphism gives the undecidability of typechecking and type inference. We also show that reductions in decidable monomorphic versions of these systems also capture the same complexity classes in a way sufficient for the traditional complexity theory. The translations we propose show in addition that the monomorphic systems to serve as a programming language require some metalanguage support since the program which operates on data has form and type which depend on the size of the input.

Java Loops Are Mainly Polynomial

Although there exist rare cases where exponential algorithms are used with success, practical software projects mostly consist of polynomial code. We present an automatic analysis tool which divides while-loops in a Java software project into polynomial ones and the rest. The analysis can be useful for example in software quality assurance, maintenance and design of new programming language idioms. After running our tool on two sets of several medium size Java projects we conclude that almost 80% of while-loops are trivially polynomial.

A distributed service oriented system for GUI map generation

Contemporary programs come with complex user interfaces hard to analyze without automated support. There are many applications when precise analysis of a system GUI organization is needed and required --- e.g. generation of GUI map. Unfortunately it requires a lot of complex computations. In this paper we show how this task can be automatically accomplished by using specific software architecture --- distributed service oriented one.