Propositional Logic Formulas Research Articles

An Agent-Based Model of the Emergence and Transmission of a Language System for the Expression of Logical Combinations

This paper presents an agent-based model of the emergence and transmission of a language system for the expression of logical combinations of propositions. The model assumes the agents have some cognitive capacities for invention, adoption, repair, induction and adaptation, a common vocabulary for basic categories, and the ability to construct complex concepts using recursive combinations of basic categories with logical categories. It also supposes the agents initially do not have a vocabulary for logical categories (i.e. logical connectives), nor grammatical constructions for expressing logical combinations of basic categories through language. The results of the experiments we have performed show that a language system for the expression of logical combinations emerges as a result of a process of self-organisation of the agents' linguistic interactions. Such a language system is concise, because it only uses words and grammatical constructions for three logical categories (i.e. and, or, not). It is also expressive, since it allows the communication of logical combinations of categories of the same complexity as propositional logic formulas, using linguistic devices such as syntactic categories, word order and auxiliary words. Furthermore, it is easy to learn and reliably transmitted across generations, according to the results of our experiments.

A Constructive Argumentation Framework

Dung's argumentation framework is an abstract framework based on a set of arguments and a binary attack relation defined over the set. One instantiation, among many others, of Dung's framework consists in constructing the arguments from a set of propositional logic formulas. Thus an argument is seen as a reason for or against the truth of a particular statement. Despite its advantages, the argumentation approach for inconsistency handling also has important shortcomings. More precisely, in some applications what one is interested in are not so much only the conclusions supported by the arguments but also the precise explications of such conclusions. We show that argumentation framework applied to classical logic formulas is not suitable to deal with this problem. On the other hand, intuitionistic logic appears to be a natural alternative candidate logic (instead of classical logic) to instantiate Dung's framework. We develop constructive argumentation framework. We show that intuitionistic logic offers nice and desirable properties of the arguments. We also provide a characterization of the arguments in this setting in terms of minimal inconsistent subsets when intuitionistic logic is embedded in the modal logic S4.

Model checking linear temporal logic of rewriting formulas under localized fairness

This paper presents the linear temporal logic of rewriting (LTLR) model checker under localized fairness assumptions for the Maude system. The linear temporal logic of rewriting extends linear temporal logic (LTL) with spatial action patterns that describe patterns of rewriting events. Since LTLR generalizes and extends various state-based and event-based logics, mixed properties involving both state propositions and actions, such as fairness properties, can be naturally expressed in LTLR. However, often the needed fairness assumptions cannot even be expressed as propositional temporal logic formulas because they are parametric, that is, they correspond to universally quantified temporal logic formulas. Such universal quantification is succinctly captured by the notion of localized fairness; for example, fairness is localized to the object name parameter in object fairness conditions. We summarize the foundations, and present the language design and implementation of the Maude Fair LTLR model checker, developed at the C++ level within the Maude system by extending the existing Maude LTL model checker. Our tool provides not only an efficient LTLR model checking algorithm under parameterized fairness assumptions but also suitable specification languages as part of its user interface. The expressiveness and effectiveness of the Maude Fair LTLR model checker are illustrated by five case studies. This is the first tool we are aware of that can model check temporal logic properties under parameterized fairness assumptions.

ON FLATTENING ELIMINATION RULES

AbstractIn proof-theoretic semantics of intuitionistic logic it is well known that elimination rules can be generated from introduction rules in a uniform way. If introduction rules discharge assumptions, the corresponding elimination rule is a rule of higher level, which allows one to discharge rules occurring as assumptions. In some cases, these uniformly generated elimination rules can be equivalently replaced with elimination rules that only discharge formulas or do not discharge any assumption at all—they can be flattened in a terminology proposed by Read. We show by an example from propositional logic that not all introduction rules have flat elimination rules. We translate the general form of flat elimination rules into a formula of second-order propositional logic and demonstrate that our example is not equivalent to any such formula. The proof uses elementary techniques from propositional logic and Kripke semantics.

Assumption-based Reasoning with Constraints for Diagnosing Program Errors

Model checking is an efficient technique for detecting errors of a system. However diagnosing program errors is the most time consuming hard work. One of the major advantages of model checking is the production of a counterexample when a property violation is detected. The error trace produced by a model checker may exhibit the symptom related to the cause of errors. Thus, counterexamples can be enough and are indicative for the cause of violation of the property. We present an assumption-based approach to localize the cause of a property violation using reasoning with constraints. The assumption among the statements in counterexample is made to point out which statement(s) is (are) faulty. Some constraints will be introduced from the specifications of the program. Moreover, we transform the counterexample into a propositional logic formula which is then fed to a SAT solver or a theorem prover together with constraints. A calculus of reasoning with these constraints proceeds under certain assumptions. If the result is satisfiable, the assumption is correct, otherwise, the assumption is wrong and a new assumption should be proposed. Some examples are presented to support the applicability and effectiveness of our approach.

A formal approach for run-time verification of web applications using scope-extended LTL

ContextIn the past decade, the World Wide Web has been subject to rapid changes. Web sites have evolved from static information pages to dynamic and service-oriented applications that are used for a broad range of activities on a daily basis. For this reason, thorough analysis and verification of Web Applications help assure the deployment of high quality applications. ObjectivesIn this paper, an approach is presented to the formal verification and validation of existing web applications. The approach consists of using execution traces of a web application to automatically generate a communicating automata model. The obtained model is used to model checking the application against predefined properties, to perform regression testing, and for documentation. MethodsTraces used in the proposed approach are collected by monitoring a web application while it is explored by a user or a program. An automata-based model is derived from the collected traces by mapping the pages of the application under test into states and the links and forms used to browse the application into transitions between the states. Properties, meanwhile, express correctness and quality requirements on web applications and might concern all states of the model; in many cases, these properties concern only a proper subset of the states, in which case the model is refined to designate the subset of the global states of interest. A related problem of property specification in Linear Temporal Logic (LTL) over only a subset of states of a system is solved by means of specialized operators that facilitate specifying properties over propositional scopes in a concise and intuitive way. Each scope constitutes a subset of states that satisfy a propositional logic formula. ResultsAn implementation of the verification approach that uses the model checker Spin is presented where an integrated toolset is developed and empirical results are shown. Also, Linear Temporal Logic is extended with propositional scopes. Conclusiona formal approach is developed to build a finite automata model tuned to features of web applications that have to be validated, while delegating the task of property verification to an existing model checker. Also, the problem of property specification in LTL over a subset of the states of a given system is addressed, and a generic and practical solution is proposed which does not require any changes in the system model by defining specialized operators in LTL using scopes.

Model Checking Multirate Hybrid Systems with Dense Timed Interval Temporal Logic

This paper investigates the model checking issue of multirate hybrid systems. To this end, multirate automata are used to represent the possible behavior of multirate hybrid systems, and a dense timed interval temporal logic (DTITL) is defined to describe the desirable property. To check whether a multirate automaton satisfies a DTITL formula, a corresponding region automaton and a propositional interval temporal logic (PITL) formula are constructed. After each vertex of the region automaton being labeled with propositions appearing in the corresponding PITL formula, the model checking problem for mutirate hybrid systems is reduced to the same issue for PITL, which can be solved readily.

Finite-valued Logics for Information Processing

We examine the issue of collecting and processing information from various sources, which involves handling incomplete and inconsistent information. Inspired by the framework first proposed by Belnap, we consider structures consisting of information sources which provide information about the values of formulas of classical propositional logic, and a processor which collects that information and extends it by deriving conclusions following from it according to the truth tables of classical logic, applied forward and backward. Our model extends Belnap's in allowing the sources to provide information also about complex formulas. As that framework cannot be captured using finite ordinary logical matrices, if we want to represent each of the relevant logics with a single matrix, we employ Nmatrices for that purpose. In opposition to the approach proposed in our earlier work, we assume that the information sources are reasonable, i.e. that they provide information consistent with certain coherence rules. We provide sound and complete sequent calculi admitting strong cut elimination for the logic of a single information source, and (several variants of) the logic generated by the source and processor structures described above. In doing this, we also provide new characterizations for some known logics. We prove that, in opposition to the variantwith unconstrained information sources considered earlier, the latter logic cannot be generated by structures with any bounded number of sources.

Validation of microcontroller codes: an architecture oriented approach

PurposeThe purpose of this paper is to describe an approach towards code validation of RISC microcontrollers, which helps to automate software debugging. A static machine code analysis which checks the appropriateness of instructions in a sequence to identify any logical mistakes and also to identify redundant codes appearing in a program for the target processor is presented.Design/methodology/approachValidation is done with the help of rules of inferences formulated for the target processor. The rules govern the occurrence of illegitimate/out of place instructions and code sequences for executing the computational and integrated peripheral functions. The stipulated rules are encoded in propositional logic formulae and their compliance is tested in all possible execution paths of the application programs. An incorrect sequence of machine code pattern is identified using slicing techniques on the control flow graph generated from machine code.FindingsThe results explain that the technique is independent of compiler/assembler and contributes to early detection of software bugs that are otherwise hard to detect. Program states are identified mainly with machine code pattern, which drastically reduces the state space creation contributing to an improved state‐of‐the‐art model checking.Research limitations/implicationsThough the technique described is general, the implementation is highly architecture oriented, and hence the feasibility study is conducted only on PIC16F87X microcontrollers.Practical implicationsThis validation tool can be integrated to the system development environment resulting in improved software quality and reduced debugging time.Originality/valueIt is a novel and original approach at machine code level applicable to a wide range of processors once appropriate rules are available.

Isomorphic formulae in classical propositional logic

AbstractIsomorphism between formulae is defined with respect to categories formalizing equality of deductions in classical propositional logic and in the multiplicative fragment of classical linear propositional logic caught by proof nets. This equality is motivated by generality of deductions. Characterizations are given for pairs of isomorphic formulae, which lead to decision procedures for this isomorphism.

Fault Localization through Reasoning and SAT Solving

Model checking is an efficient technique for detecting errors of a system. However diagnosing program faults are most time consuming hard work. One of the major advantages of model checking is the production of a counterexample when a property violation is detected. The error trace produced by a model checker may exhibit the symptom related to the cause of errors. Thus, counterexamples can be enough and are indicative for the cause of violation of the property. We present an assumption-based approach to localize the cause of a property violation using reasoning with constraints. The assumption among the statements in counterexample is made to point out which statement(s) is (are) faulty. Some constraints will be introduced from the specifications of the program. Moreover, we transform the counterexample into a propositional logic formula which is then fed to a SAT solver or a theorem prover together with constraints. A calculus of reasoning with these constraints proceeds under a certain assumption. If the result is satisfied, the assumption is correct (we localize errors in those statements which the assumption suppose them to be faulty), otherwise, the assumption is wrong and another assumption should be made. Some examples support the applicability and effectiveness of our approach.

Logical types for untyped languages

Programmers reason about their programs using a wide variety of formal and informal methods. Programmers in untyped languages such as Scheme or Erlang are able to use any such method to reason about the type behavior of their programs. Our type system for Scheme accommodates common reasoning methods by assigning variable occurrences a subtype of their declared type based on the predicates prior to the occurrence, a discipline dubbed occurrence typing . It thus enables programmers to enrich existing Scheme code with types, while requiring few changes to the code itself. Three years of practical experience has revealed serious shortcomings of our type system. In particular, it relied on a system of ad-hoc rules to relate combinations of predicates, it could not reason about subcomponents of data structures, and it could not follow sophisticated reasoning about the relationship among predicate tests, all of which are used in existing code. In this paper, we reformulate occurrence typing to eliminate these shortcomings. The new formulation derives propositional logic formulas that hold when an expression evaluates to true or false, respectively. A simple proof system is then used to determine types of variable occurrences from these propositions. Our implementation of this revised occurrence type system thus copes with many more untyped programming idioms than the original system.

Lower Bounds on the Randomized Communication Complexity of Read-Once Functions

We prove lower bounds on the randomized two-party communication complexity of functions that arise from read-once boolean formulae. A read-once boolean formula is a formula in propositional logic with the property that every variable appears exactly once. Such a formula can be represented by a tree, where the leaves correspond to variables, and the internal nodes are labeled by binary connectives. Under certain assumptions, this representation is unique. Thus, one can define the depth of a formula as the depth of the tree that represents it. The complexity of the evaluation of general read-once formulae, has attracted interest mainly in the decision tree model. In the communication complexity model, many interesting results deal with specific read-once formulae, such as DISJOINTNESS and TRIBES. In this paper we use information theory methods to prove lower bounds that hold for any read-once formula. Our lower bounds are of the form n(f)/c^{d(f)}, where n(f) is the number of variables and d(f) the depth of the formula, and they are optimal up to the constant c in the denominator.

On the Complexity of Semantic Self-minimization

Partial Kripke structures model only parts of a state space and so enable aggressive abstraction of systems prior to verifying them with respect to a formula of temporal logic. This partiality of models means that verifications may reply with true (all refinements satisfy the formula under check), false (no refinement satisfies the formula under check) or don't know . Generalized model checking is the most precise verification for such models (all don't know answers imply that some refinements satisfy the formula, some don't), but computationally expensive. A compositional model-checking algorithm for partial Kripke structures is efficient, sound (all answers true and false are truthful), but may lose precision by answering don't know instead of a factual true or false . Recent work has shown that such a loss of precision does not occur for this compositional algorithm for most practically relevant patterns of temporal logic formulas. Formulas that never lose precision in this manner are called semantically self-minimizing. In this paper we provide a systematic study of the complexity of deciding whether a formula of propositional logic, propositional modal logic or the propositional modal mu-calculus is semantically self-minimizing.

Theory of (n) truth degrees of formulas in modal logic and a consistency theorem

The theory of (n) truth degrees of formulas is proposed in modal logic for the first time. A consistency theorem is obtained which says that the (n) truth degree of a modality-free formula equals the truth degree of the formula in two-valued propositional logic. Variations of (n) truth degrees of formulas w.r.t. n in temporal logic is investigated. Moreover, the theory of (n) similarity degrees among modal formulas is proposed and the (n) modal logic metric space is derived therefrom which contains the classical logic metric space as a subspace. Finally, a kind of approximate reasoning theory is proposed in modal logic.

Randomization of classical inference patterns and its application

By means of randomization, the concept of D-randomized truth degree of formulas in two-valued propositional logic is introduced, and it is proved that the set of values of D-randomized truth degree of formulas has no isolated point in [0,1]. The concepts of D-logic pseudo-metric and D-logic metric space are also introduced and it is proved that there is no isolated point in the space. The new built D-randomized concepts are extensions of the corresponding concepts in quantified logic. Moreover, it is proved that the basic logic connectives are continuous operators in D-logic metric space. Lastly, three different types of approximate reasoning patterns are proposed.

A decision procedure for propositional projection temporal logic with infinite models

This paper investigates the satisfiability of Propositional Projection Temporal Logic (PPTL) with infinite models. A decision procedure for PPTL formulas is given. To this end, Normal Form (NF) and Labeled Normal Form Graph (LNFG) for PPTL formulas are defined, and algorithms for transforming a formula to its normal form and constructing the LNFG for the given formula are presented. Further, the finiteness of LNFGs is proved in details. Moreover, the decision procedure is extended to check the satisfiability of the formulas of Propositional Interval Temporal Logic. In addition, examples are also given to illustrate how the decision procedure works.

Solving peptide sequencing as satisfiability

This paper presents an approach for determining the amino acid sequence of a peptide through the solution of propositional satisfiability problems. Data obtained from the mass spectrometry analysis of a peptide are used to build a propositional logic formula, whose models represent coherent interpretations of that set of data and can be used to generate all possible correct results of the analysis itself. Some computational results on real-world peptide analysis problems are reported, which show the effectiveness of our approach.

The Complexity of Dual Models Problem of Propositional Linear Temporal Logics

In this paper, the concept of dual models of a propositional linear temporal logic formula is defined: A formula f has dual models if it has two models (namely two ω-sequences of states) such that the assignments to atomic propositions at each position of them are dual. Then for various propositional linear temporal logics, the complexity of the problem deciding whether a formula f has dual models (denoted by DM) and the problem of determination of dual models in a Kripke-structure for a formula f (denoted by KDM) are investigated. It is shown that DM and KDM are NP-complete for the logic with F (Future) operator, and they are PSPACE-complete for the logic with F, X (Next) operators, the logic with U (Until) operator, the logic with U, S, X operators, and the logic with regular operators given by Wolper (known as extended temporal logic, ETL).

Checking Consistency and Completeness of On-Line Product Manuals

As products are growing more complex, so is their documentation. With an increasing number of product options, the diversity in service and maintenance procedures grows accordingly. This trend also holds for large-scale medical devices such as magnetic resonance (MR) tomographs. Siemens Medical Solutions has thus decided against one common on-line service handbook for all its MR tomographs. Instead, they fragment the on-line documentation into small packages, out of which a suitable subset is selected for each individual product instance. Selection of (so-called) help packages is controlled by XML terms encoding Boolean choice conditions. To assure that the set of available help packages is sufficient for all valid product instances, we developed a tool called HelpChecker that provides a transformation of XML terms to propositional logic formulas and then employs BDD-based methods to ascertain completeness of the on-line documentation and to support authors in locating any gaps. Experiments with SAT-Solvers were also made.