In this paper, we study the state complexities of four combined operations: L* 1 ∪ L2 , L* 1 ∩ L2 , LR 1 ∪ L2 , and LR 1 ∩ L2 . The tight bounds for all these combined operations on regular languages are obtained and proved. We show that, as usual, t

We consider the transition complexity of regular languages based on the incomplete deterministic finite automata. We establish tight bounds for the transition complexity of Boolean operations, in the case of union the upper and lower bounds differ by a multiplicative constant two. We show that the transition complexity results for union and complementation are very different from the state complexity results for the same operations. However, for intersection, the transition complexity bounds turn out to be similar to the corresponding bounds for state complexity.

The P systems were recently introduced as distributed parallel computing models of a biochemical type. Multisets of objects are placed in a hierarchical structure of membranes and they evolve according to given rules, which are applied in a synchronous manner: at each step, all objects which can evolve, from all membranes, must evolve. We consider here the case when this restriction is removed. As expected, unsynchronized systems (even using catalysts) are weaker than the synchronized ones, providing that no priority relation among rules is considered. The power of P systems is not diminished when a priority is used and, moreover, the catalysts can change their states, among two possible states for each catalyst.

New constructs for synchronization termed synchronization expressions (SEs) have been developed as high-level language constructs for parallel programming languages [8, 9]. Statements that are constrained by certain synchronization requirements are tagged, and synchronization requests are specified as expressions of statement tags. In this paper, we introduce a new family of languages named synchronization languages which we use to give a precise semantic description for SEs. Under this description, relations such as equivalence and inclusion between SEs can be easily understood and tested. In practice, it also provides us with a systematic way for the implementation as well as the simplification of SEs in parallel programming languages. We show that each synchronization language is closed under the following rewriting rules: (1) a s b s → b s a s , (2) a t b t → b t a t , (3) a s b t → b t a s , (4) a t a s b t b s → b t b s a t a s and also h(a t a s b t b s ) → h(b t b s a t a s ) for any morphism h that satisfies certain conditions which will be specified in the paper. We conjecture that closure under the above rewriting rules is a sufficient condition for a regular st-language to be a synchronization language. Several other properties of synchronization languages are also studied.

New constructs for synchronization in parallel programming languages are presented for shared memory multiprocessors. The motivation behind the design of these new constructs is to relieve programmers from the burden of imposing synchronization, requiring them only to specify the necessary constraints. Statement tags are introduced. Synchronization is specified by means of regular expressions of statement tags, termed synchronization expressions. Unlike path expressions, the synchronization expressions demand no structural changes on the base language and allow much more complicated synchronization constraints to be expressed and expressed easily. This is due to the use of statement tags and the presence of guards in the latter. Examples are presented to demonstrate the simplicity and the power of synchronization expressions.>

The limit sets of cellular automata, defined by Wolfram, play an important role in applications of cellular automata to complex systems. A number of results on limit sets are proved, considering both finite and infinite configurations of cellular automata. The main concern of this paper is with testing membership and (essential) emptiness of limit sets for linear and two-dimensional cellular automata.