Formal compiler construction in a logical framework

For the most part, rewriting techniques have been developed and applied to support efficient equational reasoning and equational specification, verification, and programming. Therefore, a rewrite rule \(t \longrightarrow t'\) has been usually interpreted as a directed equation t = t ’. Rewriting logic is a substantial broadening of the semantics given to rewrite rules. The equational reading is abandoned, in favor of a more dynamic interpretation. There are now in fact two complementary readings of a rule \(t \longrightarrow t'\), one computational, and another logical: (i) computationally, the rewrite rule \(t \longrightarrow t'\) is interpreted as a local transition in a concurrent system; (ii) logically, the rewrite rule \(t \longrightarrow t'\) is interpreted as an inference rule. The experience gained so far strongly suggest that rewriting is indeed a very flexible and general formalism for both computational and logical applications. This means that from the computational point of view rewriting logic is a very expressive semantic framework, in which many different models of concurrency, languages, and distributed systems can be specified and programmed; and that from a logical point of view is a general logical framework in which many different logics can be represented and implemented. This paper introduces the main concepts of rewriting logic and of the Maude rewriting logic language, and discusses a wide range of semantic framework and logical framework applications that have been developed in rewriting logic using Maude.KeywordsInference RuleEquational TheoryLinear LogicLogical FrameworkConcurrent SystemThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Rewriting logic expresses an essential equivalence between logic and computation. Systemstatesare in bijective correspondence withformulas, and concurrentcomputationsare in bijective correspondence withproofs.Given this equivalence between computation and logic, a rewriting logic axiom of the form t → t’ has two readings. Computationally, it means that a fragment of a system’s state that is an instance of the patterntcanchangeto the corresponding instance oft’concurrently with any other state changes; logically, it just means that we can derive the formulat’from the formulat.Rewriting logic is entirely neutral about the structure and properties of the formulas/statest.They are entirelyuser-definableas an algebraic data type satisfying certain equational axioms. Because of this ecumenical neutrality, rewriting logic has, from a logical viewpoint, good properties as alogical framework, in which many other logics can be naturally represented. And, computationally, it has also good properties as asemantic framework, in which many different system styles and models of concurrent computation and many different languages can be naturally expressed without any distorting encodings. The goal of this paper is to provide a relatively gentle introduction to rewriting logic, and to paint in broad strokes the main research directions that, since its introduction in 1990, have been pursued by a growing number of researchers in Europe, the US, and Japan. Key theoretical developments, as well as the main current applications of rewriting logic as a logical and semantic framework, and the work on formal reasoning to prove properties of specifications are surveyed.

Twenty years of rewriting logic

The field of application for distributed algorithms is growing with the ongoing demand for new network applications. Wherever a global goal must be achieved by a number of peers, a distributed algorithm consisting of local computations and communication protocols must be developed. In asynchronous environments the design of a distributed algorithm must respect the fact that processes may vary in speed and that messages might be delayed for an arbitrarily long time. Moreover, it is often required that the algorithm still works in the presence of crash failures, i.e., in scenarios, where some processes stop working at some time. The complex nature of concurrent executions in distributed systems often hinder the application of common methods for modeling and verification. Although many different formal approaches for modeling fault tolerant distributed algorithms, like e.g. I/O automata and process calculi have been proposed, many works in the field of distributed systems use informal pseudo-code representations to introduce new algorithms. On most cases this leads to informal and crude arguments for correctness, which usually become incomprehensible if all race conditions must be taken into account. This work proposes new formal strategies to model and verify distributed algorithms, whereas we focus on two main goals. Firstly, we introduce a means to satisfy a designer’s demands by using methods that are easy to understand and to work with and which are very similar to common applied methods as e.g. TLA and Abstract State Machines. Secondly, our strategies are suitable for the formal use in a theorem proving environment. This enables mechanical verification of our algorithms and therefore, we are able to produce machinechecked proofs for correctness. Our model adopts abstractions from the work of Fuzzati, which examines two similar distributed algorithms in a logical framework. We lifted these abstractions to a more general level to make them suitable and reusable for as many distributed algorithms as possible. Furthermore, we present a new method to place local computation steps in the respective global context. The advantage of our method is that, on the on hand, like with pseudo code, computations can be described as local steps, but, on the other hand, it is possible to formally reason over global system states. Our model for communication mechanisms comprises modules for different kinds of message passing, broadcasts, and shared memory access. We are convinced that our model can easily be extended to support almost all kinds of communication infrastructures that can formally be described. We show how properties that have to be verified can be expressed in terms of our model to enable formal reasoning. Furthermore, we present appropriate strategies to verify different classes of properties. For the theorem proving environment Isabelle/HOL we provide a library which incorporates all introduced abstractions and can, therefore, be reused and extended for further applications, new algorithms, and further verification projects. Finally, we present case studies for the verification of different distributed algorithms to demonstrate the applicability of our strategies. Four known algorithms are verified in our model using our framework for Isabelle/HOL. The algorithms vary in complexity, the used communication infrastructure, the failure model, and other constraints, so that many different modeling and verification aspects are exemplified.

Comparing Higher-Order Encodings in Logical Frameworks and Tile Logic

Type theories, logical frameworks and meta-languages form a common foundation\nfor designing, implementing, and reasoning about formal languages and their\nsemantics. They are central to the design of modern programming languages,\ncertified software, and domain specific logics. More generally, they continue\nto influence applications in many areas in mathematics, logic and computer\nscience.\n The Logical Frameworks and Meta-languages: Theory and Practice workshop aims\nto bring together designers, implementers, and practitioners working on these\nareas, and in particular about: the automation and implementation of the\nmeta-theory of programming languages and related calculi; the design of proof\nassistants, automated theorem provers, and formal digital libraries building\nupon logical framework technology; theoretical and practical issues concerning\nthe encoding of variable binding and fresh name generation, especially the\nrepresentation of, and reasoning about, datatypes defined from binding\nsignatures; case studies of meta-programming, and the mechanization of the\n(meta) theory of descriptions of programming languages and other calculi.\n This volume contains the final and revised versions of the papers presented\nat LFMTP 2010, which was held on July 14, 2010 in Edinburgh (UK). LFMTP 2010\nwas part of the Federated Logic Conference (FLoC 2010), and affilated with LICS\n2010.\n

Preface: Volume 59, Issue 4

Preface: Volume 36

In this paper the theoretical basis is presented and the implementation of a term rewriting system based on algebraic specifications is described. The input to this system is represented by an algebraic specification language, which forms not only the set of axioms but also the sorts, variables, operators and terms of a specific simulated theory or application. Rewriting and matching mechanisms provide the formal methodology for evaluating terms and proving assertions in an algebraic theory. Specifications are evaluated by interpreting terms by means of rewrite rules. The rules are described by the axioms of the specifications where the finite termination and congruence properties are assumed. A term rewriting system to recognize handwritten Hindu numerals is introduced as a case study. Besides rewriting, a robust algorithm is proposed to segment the numeral's image into strokes based on feature points and to identify cavity features. A syntactic representation (term) of the input image is matched and rewritten against a set of rules. Experimental results proved that the proposed system is tolerant to recognize a variety of numeral shapes with 96% successful recognition rate.

Many array-centric algorithms from computational science and engineering, especially those based on dynamic and irregular data structures, can be coded rather elegantly in a purely functional style. The challenge, when compared to imperative array languages, is performance.These lecture notes discuss the shortcomings of Haskell’s standard arrays in this context and present an alternative approach that decouples array from list processing and is based on program transformation and generic programming. In particular, we will present (1) an array library that uses type analysis to achieve unboxing and flattening of data structures as well as (2) equational array fusion based on array combinators and compiler-driven rewrite rules. We will make use of a range of advanced language extensions to Haskell, such as multi-parameter type classes, functional dependencies, rewrite rules, unboxed values, and locally state-based computations.KeywordsRepresentation TypeParallel ArrayRepresentation TransformationType ConstructorVectorisation ContextThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Knowledge augmented policy conflict analysis for services collaboration

We explore the features of rewriting logic and, in particular, of the rewriting logic language Maude as a logical and semantic framework for representing and executing inference systems. In order to illustrate the general ideas we consider two substantial case studies. In the first one, we represent both the semantics of Milner's CCS and a modal logic for describing local capabilities of CCS processes. Although a rewriting logic representation of the CCS semantics is already known, it cannot be directly executed in the default interpreter of Maude. Moreover, it cannot be used to answer questions such as which are the successors of a process after performing an action, which is used to define the semantics of Hennessy-Milner modal logic. Basically, the problems are the existence of new variables in the righthand side of the rewrite rules and the nondeterministic application of the semantic rules, inherent to CCS. We show how these problems can be solved in a general, not CCS dependent way by controlling the rewriting process by means of reflection. This executable specification plus the reflective control of rewriting can be used to analyze CCS processes. The same techniques are also used to implement a symbolic semantics for LOTOS in our second case study. The good properties of Maude as a metalanguage allow us to implement a whole formal tool where LOTOS specifications without restrictions in their data types (given as ACT ONE specifications) can be executed. In summary, we present Maude as an executable semantic framework by providing easy-tool-building techniques for a language given its operational semantics.

The paper presents a logical framework for the integration of interactions between institutional agents, human agents and software agents. It is shown, through a case study, that the relationships between actions performed by these three kinds of agents are defined in terms of the Searle’s ”counts as” concept and their justifications are based on the roles hold by human agents or by a causal relationships between human agent actions and software agent actions.The logical framework concentrates on the concepts of counts as, causality and role.

Foresight activities are valued in many countries since 1990s due to their long term strategic planning. These governments consequently allocate most resources in these foresight activities. As a result, the paper mainly develops the evaluation framework of technology foresight program, by integrating the concepts of evaluation and logic framework with the experience of foresight evaluation from developed countries, for instance European Union, Britain etc., to realize the outcomes of implementing foresight act ivies. Taking Sweden as a case study, the paper is also proposed to show the effectiveness of this new framework.

This paper presents a procedure for deep transformation of logic programs, which is based upon partial evaluation of source logic programs and includes unfolding, term rewriting and deriving new predicates. Controlling of these operations is based upon abstract OLDT interpretation, which is used to produce transformation guide for a corresponding residual code generator. The abstract interpretation schema includes the rules for abstract domains construction, which can be tuned for a particular application. The algorithms are applicable for deep transformations, which occur when compiling meta-interpreters.KeywordsLogic ProgramPartial EvaluationAbstract InterpretationSource ProgramUnit ClauseThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.