Presenting Functors by Operations and Equations

José Maria Fernando Medina, diretor da Diretoria de Planejamento Social e Urbano da Fundação João Pinheiro (DPSU/FJP).

Model checkers use automated state exploration in order to prove various properties such as reachability, non-reachability, and bisimulation over state transition systems. While model checkers have proved valuable for locating errors in computer models and specifications, they can also be used to prove properties that might be consumed by other computational logic systems, such as theorem provers. In such a situation, a prover must be able to trust that the model checker is correct. Instead of attempting to prove the correctness of a model checker, we ask that it outputs its "proof evidence" as a formally defined document--a proof certificate--and that this document is checked by a trusted proof checker. We describe a framework for defining and checking proof certificates for a range of model checking problems. The core of this framework is a (focused) proof system that is augmented with premises that involve "clerk and expert" predicates. This framework is designed so that soundness can be guaranteed independently of any concerns for the correctness of the clerk and expert specifications. To illustrate the flexibility of this framework, we define and formally check proof certificates for reachability and non-reachability in graphs, as well as bisimulation and non-bisimulation for labeled transition systems. Finally, we describe briefly a reference checker that we have implemented for this framework.

A proof system for a language L is a function f such that Range( f ) is exactly L . In this article, we look at proof systems from a circuit complexity point of view and study proof systems that are computationally very restricted. The restriction we study is proof systems that can be computed by bounded fanin circuits of constant depth (NC 0 ) or of O (log log n ) depth but with O (1) alternations (poly log AC 0 ). Each output bit depends on very few input bits; thus such proof systems correspond to a kind of local error correction on a theorem-proof pair. We identify exactly how much power we need for proof systems to capture all regular languages. We show that all regular languages have poly log AC 0 proof systems, and from a previous result (Beyersdorff et al. [2011a], where NC 0 proof systems were first introduced), this is tight. Our technique also shows that M aj has poly log AC 0 proof system. We explore the question of whether T aut has NC 0 proof systems. Addressing this question about 2TAUT, and since 2TAUT is closely related to reachability in graphs, we ask the same question about Reachability. We show that if Directed reachability has NC 0 proof systems, then so does 2TAUT. We then show that both Undirected Reachability and Directed UnReachability have NC 0 proof systems, but Directed Reachability is still open. In the context of how much power is needed for proof systems for languages in NP, we observe that proof systems for a good fraction of languages in NP do not need the full power of AC 0 ; they have SAC 0 or coSAC 0 proof systems.

Reachability Logic is a formalism that can be used, among others, for expressing partial-correctness properties of transition systems. In this paper we present three proof systems for this formalism, all of which are sound and complete and inherit the coinductive nature of the logic. The proof systems differ, however, in several aspects. First, they use induction and coinduction in different proportions. The second aspect regards compositionality, broadly meaning their ability to prove simpler formulas on smaller systems, and to reuse those formulas as lemmas for more complex formulas on larger systems. The third aspect is the difficulty of their soundness proofs. We show that the more induction a proof system uses, and the more specialised is its use of coinduction (with respect to our problem domain), the more compositional the proof system is, but the more difficult its soundness proof becomes. We also briefly present mechanisations of these results in the Isabelle/HOL and Coq proof assistants.

A methodology for developing sound proof systems for program verification is demonstrated by the development of a proof system for reasoning about concurrent programs based on the unity logic of K.M. Chandy and J. Misra (1988). This proof system has been validated by an automated theorem prover, a computer program that checks the correctness of proofs. The Boyer-Moore logic in which the proof system is formalized and the Boyer-Moore theorem prover which mechanizes this logic are described. The motivation behind the unity logic and the way in which it may be used to prove the correctness of concurrent programs are examined. A proof system for concurrent programs based on the unity logic system is provided as an example. An operational semantics of concurrency is formalized in Boyer-Moore logic by use of the transition system model. Unity's proof rules are proved as theorems about this operational semantics. The proofs of these theorems are mechanically checked. The entire proof system has been verified by the Boyer-Moore prover, making it possible to prove mechanically the consequence of other concurrent programs.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

In formal design verification, successful model checking is typically preceded by a laborious manual process of constructing design abstractions. We present a methodology for partially—and in some cases, fully—bypassing the abstraction process. For this purpose, we provide to the designer abstraction operators which, if used judiciously in the description of a design, structure the corresponding state space hierarchically. This structure can then be exploited by verification tools, and makes possible the automatic and exhaustive exploration of state spaces that would otherwise be out of scope for existing model checkers.Specifically, we present the following contributions: - A temporal abstraction operator that aggregates transitions and hides intermediate steps. Mathematically, our abstraction operator is a function that maps a flat transition system into a two-level hierarchy where each atomic upper-level transition expands into an entire lower-level transition system. For example, an arithmetic operation may expand into a sequence of bit operations. - A BDD-based algorithm for the symbolic exploration of multi-level hierarchies of transition systems. The algorithm traverses a level-n transition by expanding the corresponding level-(n − 1) transition system on-the-fly. The level-n successors of a state are determined by computing a level-(n − 1) reach set, which is then immediately released from memory. In this fashion, we can exhaustively explore hierarchically structured state spaces whose flat counterparts cause memory overflows. - We experimentally demonstrate the efficiency of our method with three examples—a multiplier, a cache coherence protocol, and a multiprocessor system. In the first two examples, we obtain significant improvements in run times and peak BDD sizes over traditional state-space search. The third example cannot be model checked at all using conventional methods (without manual abstractions), but can be analyzed fully automatically using transition hierarchies. KeywordsModel CheckTransition RelationParallel CompositionReactive ModuleReachability AnalysisThese 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.

On the parameterized complexity of the synthesis of Boolean nets with restricted place environments

On the epidemiology, biology and food-dependent reproduction of the feral pigeon (Columba livia)

This article revisits soundness and completeness of proof systems for proving that sets of states in infinite-state labeled transition systems satisfy formulas in the modal mu-calculus in order to develop proof techniques that permit the seamless inclusion of new features in this logic. Our approach relies on novel results in lattice theory, which give constructive characterizations of both greatest and least fixpoints of monotonic functions over complete lattices. We show how these results may be used to reason about the sound and complete tableau method for this problem due to Bradfield and Stirling. We also show how the flexibility of our lattice-theoretic basis simplifies reasoning about tableau-based proof strategies for alternative classes of systems. In particular, we extend the modal mu-calculus with timed modalities, and prove that the resulting tableau method is sound and complete for timed transition systems.

Imposing certain restrictions on the transition system that defines the behaviour of a process allows us to characterize the readiness semantics of [OH86] by means of black-box testing experiments, or more precisely by lighted button testing experiments [BM92]. As divergence is considered we give the semantics as a preorder, the readiness preorder, which kernel coincides with the readiness equivalence of [OH86]. This leads to a bisimulation like characterization and a modal characterization of the semantics. A concrete language, recursive free CCS without tau, is introduced, a proof system defined and it is shown to be sound and complete with respect to the readiness preorder. In the completeness proof the modal characterization plays an important role as it allows us to prove algebraicity of the preorder purely operationally.

The complexity of modern software systems entails the need for reconfiguration mechanisms gov- erning the dynamic evolution of their execution configurations in response to both external stimulus or internal performance measures. Formally, such systems may be represented by transition systems whose nodes correspond to the different configurations they may assume. Therefore, each node is en- dowed with, for example, an algebra, or a first-order structure, to precisely characterise the semantics of the services provided in the corresponding configuration. Hybrid logics, which add to the modal description of transition structures the ability to refer to specific states, offer a generic framework to approach the specification and design of this sort of systems. Therefore, the quest for suitable notions of equivalence and refinement between models of hybrid logic specifications becomes fundamental to any design discipline adopting this perspective. This paper contributes to this effort from a distinctive point of view: instead of focussing on a specific hybrid logic, the paper introduces notions of bisimilarity and refinement for hybridised logics, i.e. standard specification logics (e.g. propositional, equational, fuzzy, etc) to which modal and hybrid features were added in a systematic way.

In this paper, we give a new definition of partial Higher Dimension Automata using lax functors. This definition is simpler and more natural from a categorical point of view, but also matches more clearly the intuition that pHDA are Higher Dimensional Automata with some missing faces. We then focus on trees. Originally, for example in transition systems, trees are defined as those systems that have a unique path property. To understand what kind of unique property is needed in pHDA, we start by looking at trees as colimits of paths. This definition tells us that trees are exactly the pHDA with the unique path property modulo a notion of homotopy, and without any shortcuts. This property allows us to prove two interesting characterisations of trees: trees are exactly those pHDA that are an unfolding of another pHDA; and trees are exactly the cofibrant objects, much as in the language of Quillen’s model structure. In particular, this last characterisation gives the premisses of a new understanding of concurrency theory using homotopy theory.

Overeducation: A Disease of the School-to-Work Transition System

Benin has seen a rapid proliferation of political parties since the country’s democratic transition in 1990. Recent counts suggest that over a hundred political parties are registered in this nation of just over 9 million people. No single party dominates the political landscape. Thus, compared to the one-party-dominant systems elsewhere on the African continent, the Beninese party system configuration shows an interesting contrast. This chapter seeks to answer two interrelated questions: First, how exactly does Benin’s party system compare to other party systems and, more specifically, how should it be classified? Second, what does the Beninese case suggest about the relationship between party system configurations and democratic outcomes?KeywordsPolitical PartyPresidential ElectionVote ShareParty SystemDemocratic TransitionThese 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.

A particular way of relating logics, specially useful in the framework of automated theorem proving is proposed. From the definition of the semantics of a logic (called source logic and abbreviated henceforth SL) in another logic (called target logic and abbreviated henceforth TL or TLS), we translate formulas of SL into TL using known techniques. Then we show how to partially translate proofs found in TL into SL. More precisely, the main theoretical result of the paper is a theorem establishing that for a class of non-classical logics — taking first-order sorted logic with equality as target logic — given a formula f in SL, it is possible from a proof P of f (obtained in TL) to backward translate into SL some (sometimes all) formulas in P. This set of backward translated formulas are proved to be semantically related each other and to define a partial consequence relation in SL. We get therefore an entailment sequence for f in SL. Our approach is applicable to source logics either without “computationally interesting” proof systems or without proof systems at all. One running example is fully treated. We compare the results of our method with the ones of a specialized tableaux-based theorem prover for the logic S4(p). Some hints of future work are given.KeywordsClassical LogicTheorem ProveProof SystemPredicate SymbolAutomate Theorem ProveThese 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.