Fernando Arroyo

A hardware circuit for selecting active rules in transition P systems

This paper presents the first step in the design of a hardware circuit implementing evolution inside membranes of a transition P system. The work presented here is part of a very ambitious project: to find and to implement a hardware system, as general as possible, able to simulate P systems evolution. Due to the complexity of this generic system, the process has been divided into several stages. Each one of these stages has concrete objectives. In particular, a circuit able to determine active rules in a determined configuration for the membrane is presented here. In order to proceed in an appropriate manner, it is needed to define a data structure containing information about the initial membrane state, that is, the initial multiset of objects, the set of evolution rules and the corresponding priority relation among them. The circuit takes these data entrances and then produce as output a set of evolution rules, active rules, which are able to produce the needed changes into the system in order to make evolve it to the next configuration.

A Software Simulation of Transition P Systems in Haskell

P systems are a parallel and distributed computational model, based on the membrane structure notion. Membranes define regions. Inside regions, objects and rules are placed in order to make evolve the P system. Evolution is achieved by transitions between two consecutive system configurations. Therefore, a computation can be obtained as a transitions series between consecutive configurations. Where and how P systems can be implemented is nowadays an open problem, but implementation on digital computers could be one way to show the capabilities of such systems. This paper presents a transition P systems implementation in Haskell, based on a theoretical framework previously developed.

Biocircuit design through engineering bacterial logic gates

Designing synthetic biocircuits to perform desired purposes is a scientific field that has exponentially grown over the past decade. The advances in genome sequencing, bacteria gene regulatory networks, as well as the further knowledge of intraspecies bacterial communication through quorum sensing signals are the starting point for this work. Although biocircuits are mostly developed in a single cell, here we propose a model in which every bacterium is considered to be a single logic gate and chemical cell-to-cell connections are engineered to control circuit function. Having one genetically modified bacterial strain per logic process would allow us to develop circuits with different behaviors by mixing the populations instead of re-programming the whole genetic network within a single strain. Two principal advantages of this procedure are highlighted. First, the fully connected circuits obtained where every cellgate is able to communicate with all the rest. Second, the resistance to the noise produced by inappropriate gene expression. This last goal is achieved by modeling thresholds for input signals. Thus, if the concentration of input does not exceed the threshold, it is ignored by the logic function of the gate.

Hardware Implementation of a Bounded Algorithm for Application of Rules in a Transition P-System

The transition P-systems performs a computation through transition between two consecutive configurations. A configuration consists in a m-tuple of multisets present at any moment in the existing m regions of the system. Transitions between two configurations are performed by using evolution rules which are in each region of the system in a non-deterministic maximally parallel manner. This paper is part of exhaustive investigation line whose objective is to implement a hardware system that evolves as it makes a transition P-system. To achieve this objective, it has been carried out a division of this generic system in several stages. The first stage was to determine active rules in a determined configuration for the membrane. The second stage is developed by obtaining the part of the system that is in charge of the application of the active rules. To count the number of times that the active rules is applied exist different algorithms. In this paper presents an algorithm with improved aspects: the number of necessary iterations to reach the final values is perfectly defined, and their adaptation to systems with any number of rules is simple

A Binary Data Structure for Membrane Processors: Connectivity Arrays

This paper defines membrane processors as digital processors capable of implementing local processing performed inside membranes in transition P systems. In order to encode the membrane structures of transition P systems, additional binary data structures are needed. Such binary data structures are named ”connectivity arrays”. The main purposes of the connectivity arrays are to distribute information about the system membrane structure among the different processors that implement the transition P system, and to facilitate communication processes among different membrane processors. The information kept in processor has to be versatile and compact; versatile means to easily permit changes in the membrane structure of the system processors, and compact means that not too much memory space is needed.

Networks of Polarized Evolutionary Processors Are Computationally Complete

In this paper, we consider the computational power of a new variant of networks of evolutionary processors which seems to be more suitable for a software and hardware implementation. Each processor as well as the data navigating throughout the network are now considered to be polarized. While the polarization of every processor is predefined, the data polarization is dynamically computed by means of a valuation mapping. Consequently, the protocol of communication is naturally defined by means of this polarization. We show that tag systems can be simulated by these networks with a constant number of nodes, while Turing machines can be simulated, in a time-efficient way, by these networks with a number of nodes depending linearly on the tape alphabet of the Turing machine.

Hardware and software architecture for implementing membrane systems: a case of study to transition P systems

Membrane Systems are computation models inspired in some basic features of biological membranes. Many variants of such computing devices have already been investigated. Most of them are computationally universal, i.e., equal in capacity to Turing machines. Some variant of these systems are able to trade space for time and solve, by making use of an exponential space, intractable problems in a feasible time. This work presents a software architecture that completes the generic hardware prototype based on microcontrollers presented in a previous work. This parallel hardware/software architecture is based on a low cost universal membrane hardware component that allows to efficiently run any kind of membrane systems. This solution was less enclosed and floppier than the hardware specifically designed, and cheaper than those based on clusters of PCs.

Accepting splicing systems with permitting and forbidding words

In this paper we propose a generalization of the accepting splicing systems introduced in Mitrana et al. (Theor Comput Sci 411:2414–2422, 2010). More precisely, the input word is accepted as soon as a permitting word is obtained provided that no forbidding word has been obtained so far, otherwise it is rejected. Note that in the new variant of accepting splicing system the input word is rejected if either no permitting word is ever generated (like in Mitrana et al. in Theor Comput Sci 411:2414–2422, 2010) or a forbidding word has been generated and no permitting word had been generated before. We investigate the computational power of the new variants of accepting splicing systems and the interrelationships among them. We show that the new condition strictly increases the computational power of accepting splicing systems. Although there are regular languages that cannot be accepted by any of the splicing systems considered here, the new variants can accept non-regular and even non-context-free languages, a situation that is not very common in the case of (extended) finite splicing systems without additional restrictions. We also show that the smallest class of languages out of the four classes defined by accepting splicing systems is strictly included in the class of context-free languages. Solutions to a few decidability problems are immediately derived from the proof of this result.

Towards an Electronic Implementation of Membrane Computing: A Formal Description of Non-deterministic Evolution in Transition P Systems

This paper is part of a program of our research group, aiming to implement membrane computing on electronic computers. We here present Transition P systems, which is the preliminary steep of our approach. The formalisation we before have in mind the functional programming framework for developing the software modules. Part of these modules has already realised, in Haskell, and they are briefly described in the second section of the paper.

Structures and Bio-language to Simulate Transition P Systems on Digital Computers

The aim of this paper is to show that some computational models inspired from biological membranes, such as P systems, can be simulated on digital computers in an efficient manner. To this aim, it is necessary to characterize non-determinism and parallel execution of evolution rules inside regions. Both these issues are formally described here in order to obtain a feasible description in terms of data structures and operations able to be implemented in a functional programming language. Static and dynamic structures of transition P systems are formalised in order to define a bio-language to represent them. Finally, a draft of a language for describing a transition P systems is presented. It will facilitate the description of transition P systems in terms of sentences in a high level programming language; such sentences will define a program. A process of compilation will parse the program to appropriate data structures and will launch the execution of the simulation process.