P systems with minimal parallelism

A current research topic in membrane computing is to find more realistic P systems from a biological point of view, and one target in this respect is to relax the condition of using the rules in a maximally parallel way. We contribute in this paper to this issue by considering the minimal parallelism of using the rules: if at least a rule from a set of rules associated with a membrane or a region can be used, then at least one rule from that membrane or region must be used, without any other restriction (e.g., more rules can be used, but we do not care how many). Weak as it might look, this minimal parallelism still leads to universality. We first prove this for the case of symport/antiport rules. The result is obtained both for generating and accepting P systems, in the latter case also for systems working deterministically. Then, we consider P systems with active membranes, and again the usual results are obtained: universality and the possibility to solve NP-complete problems in polynomial time (by trading space for time).     

Graph-based rules and transactions for parallel and active database systems

Active database management systems are becoming increasingly popular because of their relevance to several advanced and complex database applications. The need for user-defined execution orders (or control structures) for rules is well recognized by researchers of active database management systems. Priority-based approaches (e.g., numeric priorities) have been used to specify a desired control structure among rules. However, due to the fact that fixed priorities are assigned to rules, independent of different contexts in which they may be triggered, the existing approaches are not able to allow rules to be executed following different control structures when they are triggered by different events. More flexible and expressive control mechanisms are often needed for rules in advanced database applications such as CAD/CAM, CASE, CIM and flexible manufacturing systems. Since rules in database environments are executed in a transaction framework, an expressive transaction model is needed to model complex control structures among rulesuniformly. In this work, we separate the event part from the condition-action parts of a rule and associate it with a rule graph which represents a set of rules (actually a set of condition-action pairs) sharing the same control structure. Different rule graphs can be defined under different event specifications thereby enabling a set of rules to follow different control structures when triggered by different events. We also use an expressive graph-based transaction model to incorporate the control structures of rule graphs uniformly in a transaction framework. The proposed rule and transaction modeling and execution techniques have been implemented and verified on a shared-nothing multiprocessor computer nCUBE2. In this paper, we also describe the client-server architecture and different parallel transaction and rule execution techniques that have been used for the implementation. Finally, we analyze the speedup and scaleup of the implemented system.     

On the Computational Complexity of P Automata

We characterize the classes of languages over finite alphabets which may be described by P automata, i.e., accepting P systems with communication rules only. Motivated by properties of natural computing systems, and the actual behavior of P automata, we study computational complexity classes with a certain restriction on the use of the available workspace in the course of computations and relate these to the language classes described by P automata. We prove that if the rules of the P system are applied sequentially, then the accepted language class is strictly included in the class of languages accepted by one-way Turing machines with a logarithmically bounded workspace, and if the rules are applied in the maximally parallel manner, then the class of context-sensitive languages is obtained.     

Checking the coherence and redundancy of fuzzy knowledge bases

Checking the coherence of a set of rules is an important step in knowledge base validation. Coherence is also needed in the field of fuzzy systems. Indeed, rules are often used regardless of their semantics, and it sometimes leads to sets of rules that make no sense. Avoiding redundancy is also of interest in real-time systems for which the inference engine is time consuming. A knowledge base is potentially inconsistent or incoherent if there exists a piece of input data that respects integrity constraints and that leads to logical inconsistency when added to the knowledge base. We more particularly consider knowledge bases composed of parallel fuzzy rules. Then, coherence means that the projection on the input variables of the conjunctive combination of the possibility distributions representing the fuzzy rules leaves these variables completely unrestricted (i.e., any value for these variables is possible) or, at least, not more restrictive than integrity constraints. Fuzzy rule representations can be implication-based or conjunction-based; we show that only implication-based models may lead to coherence problems. However, unlike conjunction-based models, they allow to design coherence checking processes. Some conditions that a set of parallel rules has to satisfy in order to avoid inconsistency problems are given for certainty or gradual rules. The problem of redundancy, which is also of interest for fuzzy knowledge bases validation, is addressed for these two kinds of rules     

Hardware circuit for the application of evolution rules in a transition P-system

P systems, or membrane computing, are a type of system based on biological membranes. Transition P systems perform computation through transition between two consecutive configurations. One transition is obtained by applying the evolutionary rules, which are in each region of the system in a nondeterministic maximally parallel manner. This article is part of an investigation whose objective is to implement a hardware system that evolves as it does a transition P system. To achieve this objective, a division of this generic system has been carried out in several stages. The first stage was to determine the active rules in a determined configuration for the membrane. The second stage was developed by obtaining the part of the system that is in charge of the application of the active rules. In fact, the circuit obtained in this article counts the number of times that the active rules are applied. In the first place, the initial specifications are defined in order to outline the synthesis of the circuit of active rule applications. Later, the design and synthesis of the circuit will be shown, as well as the operational tests required to present the experimental results obtained.     

Combining Rough Sets and Bayes' Rule

In rough set theory with every decision rule two conditional probabilities, called certainty and coverage factors, are associated. These two factors are closely related with the lower and the upper approximation of a set, basic notions of rough set theory. It is shown that these two factors satisfy the Bayes' rule.
The Bayes' rule in our case simply shows some relationship in the data, without referring to prior and posterior probabilities intrinsically associated with Bayesian inference. This relationship can be used to "invert" decision rules, i.e., to find reasons (explanation) for decisions thus providing inductive as well as deductive inference in our scheme.     

From Watson-Crick L systems to Darwinian P systems

Watson-Crick L systems are language generating devices making use ofWatson-Crick complementarity, a fundamental concept of DNA computing.These devices are Lindenmayer systems enriched with a trigger forcomplementarity transition: if a ``bad' string is obtained, then thederivation continues with its complement which is always a ``good'string. Membrane systems or P systems are distributed parallel computingmodels which were abstracted from the structure and the way offunctioning of living cells. In this paper, we first interpret theresults known about the computational completeness of Watson-Crick E0Lsystems in terms of membrane systems, then we introduce a related way ofcontrolling the evolution in P systems, by using the triggers not in theoperational manner (i.e., turning to the complement in a ``bad'configuration), but in a ``Darwinian' sense: if a ``bad' configurationis reached, then the system ``dies', that is, no result is obtained.The triggers (actually, the checkers) are given as finite state multisetautomata. We investigate the computational power of these P systems.Their computational completeness is proved, even for systems withnon-cooperative rules, working in the non-synchronized way, andcontrolled by only two finite state checkers; if the systems work in thesynchronized mode, then one checker for each system suffices to obtainthe computational completeness.     

Behavioral Refinement of Graph Transformation-Based Models

Model-driven software engineering requires the refinement of abstract models into more concrete, platform-specific ones. To create and verify such refinements, behavioral models capturing recon- figuration or communication scenarios are presented as instances of a dynamic meta-model, i.e., a typed graph transformation system specifying the concepts and basic operations scenarios may be composed of. Possible refinement relations between models can now be described based on the corresponding meta-models.In contrast to previous approaches, refinement relations on graph transformation systems are not defined as fixed syntactic mappings between abstract transformation rules and, e.g., concrete rule expressions, but allow for a more loose, semantically defined relation between the transformation systems, resulting in a more flexible notion of refinement.     

A multi-threshold, internal rule representation form used to support user modifiable knowledge-based systems

A flat file (i.e., tabular) internal rule representation suitable for storing expert system rules that can make use of a spread-sheet-like user interface is presented. The representation handles individual rule thresholds, different knowledge evidence procedures, and rule structures which can be represented as network graphs. Such representations: (a) help a system's rule structure to be made relatively accessible for those without significant artificial intelligence training, (b) allow for clear understanding of the extent and nature of a rule, and (c) provide opportunities for consistency checking.     

Characterizing the computational power of energy-based P systems

We investigate the computational power of energy-based P systems, a model of membrane systems, where a fixed amount of energy is associated with each object and the rules transform single objects by adding or removing energy from them. We answer the recently proposed open questions about the power of such systems without priorities associated with the rules, for both sequential and maximally parallel modes. We also conjecture that deterministic energy-based P systems are not computationally complete.     

A multilayer perceptron solution to the match phase problem inrule-based artificial intelligence systems

In rule-based artificial intelligence (AI) planning, expert, and learning systems, it is often the case that the left-hand-sides of the rules must be repeatedly compared to the contents of some working memory. Normally, the intent is to determine which rules are relevant to the current situation (i.e., to find the conflict set). A technique using a multilayer perceptron to solve the match phase problem for rule-based AI systems is presented. A syntax for premise formulas (i.e., the left-hand-sides of the rules) is defined, and working memory is specified. From this, it is shown how to construct a multilayer perceptron that finds all of the rules which can be executed for the current situation in working memory. The complexity of the constructed multilayer perceptron is derived in terms of the maximum number of nodes and the required number of layers. A method for reducing the number of layers to at most three is presented     

Minimization strategies for maximally parallel multiset rewriting systems

Maximally parallel multiset rewriting systems (MPMRS) give a convenient way to express relations between unstructured objects. The functioning of various computational devices may be expressed in terms of MPMRS (e.g., register machines and many variants of P systems). In particular, this means that MPMRS are Turing universal; however, a direct translation leads to quite a large number of rules. Like for other classes of computationally complete devices, there is a challenge to find a universal system having the smallest number of rules. In this article we present different rule minimization strategies for MPMRS based on encodings and structural transformations. We apply these strategies to the translation of a small universal register machine (Korec (1996) [9]) and we show that there exists a universal MPMRS with 23 rules. Since MPMRS are identical to a restricted variant of P systems with antiport rules, the results we obtained improve previously known results on the number of rules for those systems.     

Time-free spiking neural P systems

Different biological processes take different times to be completed, which can also be influenced by many environmental factors. In this work, a realistic definition of nonsynchronized spiking neural P systems (SN P systems, for short) is considered: during the work of an SN P system, the execution times of spiking rules cannot be known exactly (i.e., they are arbitrary). In order to establish robust systems against the environmental factors, a special class of SN P systems, called time-free SN P systems, is introduced, which always produce the same computation result independent of the execution times of the rules. The universality of time-free SN P systems is investigated. It is proved that these P systems with extended rules (several spikes can be produced by a rule) are equivalent to register machines. However, if the number of spikes present in the system is bounded, then the power of time-free SN P systems falls, and in this case, a characterization of semilinear sets of natural numbers is obtained.     

Generative languages,codes and parallel processing

A special class of context-sensitive generative languages (CSGLs) that can be used as an indexation in parallel computing is described. The languages are recursively generated, and the algorithm for interprocesses communication is based on the positive resolution of the post correspondence problem (PCP) within CSGLs. This fact follows from the main result that a constructed CSGL has a complete set of production rules, i.e. no new rule can be added to the set without destroying the integrity of the CSGL.     

Coping with indefinite and negative data in deductive databases: A survey

A problem with current database systems is the limitation placed on the type of data which may be represented and manipulated within such systems. In an attempt to broaden this to a wider class of data (i.e. rules as well as facts) and a more powerful set of manipulations, the concept of a deductive database was introduced. However, for the sake of efficiency the type of rule which is allowed in a deductive database is restricted in form. This paper surveys a number of attempts to move towards less restrictive forms of rules in deductive databases which allow indefinite and negative data to be handled.     

Issues in the Design and Control of Parallel Rule-Firing Production Systems

The parallel execution of rules in a production system provides the potential for faster execution, but increases the complexity of control and design issues. We address two issues: controlling the execution of productions without introducing serial bottlenecks and maintaining correctness during the course of simultaneous rule executions. Two novel rule-firing policies are described: an asynchronous rule-firing policy that causes rules to be executed as soon as they become enabled and a task-based scheduler that allows multiple independent tasks to run asynchronously with respect to each other while allowing rules to execute either synchronously or asynchronously within the context of each task. Previous research in parallel rule-firing systems has indicated that a serializable result cannot be guaranteed without a run-time mechanism for detecting potentially harmful rule interactions. Our analysis of such mechanisms indicates that their overhead is prohibitive for asynchronous rule-firing systems. In exchange for improved performance, we trade the guarantee of serializability for the somewhat weaker claim that correct parallel rule-firing programs may be designed, given the appropriate language mechanisms. We present a simple locking scheme for working memory, which, when coupled with the appropriate language idioms, allows serializable programs to be developed without incurring the expense of run-time interference detection. The experimental results of this research are presented in the context of UMass Parallel OPS5, a rule-based language that incorporates parallelism at the rule, action, and match levels, and provides language constructs for supporting the design of parallel rule-based programs. Results are presented for a number of programs illustrating common AI paradigms including search, inference, and constraint satisfaction problems.     

Comments on Singh and Zeng: “Approximation theory of fuzzysystems-SISO case” [and reply]

The author comments on the paper by Singh and Zeng (see ibid., vol.2, no.2, p.162-76, 1994). He states that every bounded function f: R→R has an exact representation as an additive fuzzy system. If f is not constant, one fuzzy set and two rules define the system. Otherwise, a single rule suffices. This result shows that the approximation properties of one-input fuzzy systems derive solely from interpolation between output extrema. The basis for the interpolation at any point is the value of the input fuzzy sets at that point. In reply Singh and Zeng state that in the comments by Watkins, it is proven that every SISO function can be exactly represented by a fuzzy system, which implies that fuzzy approximation (i.e., to approximate functions by fuzzy systems) is unnecessary or moot. However, they state that this conclusion is invalid because his presented representation scheme does not meet the basic requirements in the applications of fuzzy systems and is impractical     

Homogeneous spiking neural P systems working in sequential mode induced by maximum spike number

Spiking neural P systems (SN P systems, for short) are a class of distributed parallel computing devices inspired by the way neurons communicate by means of spikes, where neurons work in parallel in the sense that each neuron that can fire should fire at each computation step, and neurons can be different in the sense that they can have different sets of spiking rules. In this work, we consider SN P systems with the restrictions: (1) all neurons are homogeneous in the sense that each neuron has the same set of rules; (2) at each step the neuron with the maximum number of spikes among the neurons that are active (can spike) will fire. These restrictions correspond to the fact that the system consists of only one kind of neurons and a global view of the whole network makes the system sequential. The computation power of homogeneous SN P systems working in the sequential mode induced by the maximum spike number is investigated. Specifically, it is proved that such systems are universal as both generating and accepting devices.     

信念修正的完全和可操作的方法

给出了命题逻辑上信念修正的两种可操作的完全方法.首先对R-演算的规则进行了修改,使得对任何一个极大协调的子集都通过这组规则得到.然后,给出了求得所有的极小不协调子集的一组规则.最后,给出一个过程,该过程能求得所有的极大协调子集.因为这两种方法都能求得所有的极大协调子集,所以把它们称为完全的.