In this paper, we introduce a new computational model called the modified P colony with rule application intensity (RAI). This model extends the traditional concept of P colonies by associating each rule with a real-valued intensity that influences how often and under what conditions the rule can be applied. The rule application intensity is dynamically adjusted during the computation based on whether a rule is used or remains unused. We formally define the structure and operational semantics of the system, including the configuration transitions and intensity updates. Several variants of the model are discussed, such as systems with fixed-size agents, -free rule sets, or systems with constant RAI. We also present illustrative examples, including a construction of a finite set generator and a design proposal for an idle game engine based on this model. The article concludes with an outline of current and future research directions, including the development of a simulator and the study of the computational power of these systems.
CEUR Workshop
ISSN1613-0073 tal pressures. For example, certain metabolic enzymes are upregulated when substrates are abundant, while unused or energetically costly processes are suppressed during scarcity. By enabling rule application intensity to vary over time, influenced either internally (by agent dynamics) or externally (via special input from the environment), our model captures these kinds of flexible, context-dependent behaviors, extending the expressive power and modeling depth of P colonies.
The structure of the paper is as follows. After this introduction, Section 2 presents the basic definitions and formal terminology used throughout the paper. The definition and behavior of the original P colony model form the basis for developing our modified variant incorporating rule application intensity. In Section 3, we introduce the new model of Modified P Colonies with Rule Application Intensity (RAI). Section 4 provides several illustrative examples that demonstrate the expressive power and versatility of diferent variants of the model. Finally, in Section 5, we summarize the contributions of this work and outline directions for future research.
Throughout the paper we assume the reader to be familiar with the basics of formal language theory
and membrane computing [
For an alphabet Σ, the set of all words over Σ (including the empty word, ), is denoted by Σ∗. We denote the length of a word ∈ Σ ∗ by | | and the number of occurrences of the symbol ∈ Σ in by | | .
A multiset of objects is a pair = (, ) , where is an arbitrary (not necessarily finite) set of objects and is a mapping ∶ → ℕ ; assigns to each object in its multiplicity in . Any multiset of objects with the set of objects = { 1, … } can be represented as a string over alphabet with | | = ( ); 1 ≤ ≤ . Obviously, all words obtained from by permuting the letters can also represent the same multiset , and represents the empty multiset.
Since this article focuses on a type of membrane system derived from the P Colony model, we provide the definitions related to P Colonies.
The original concept of a P colony was introduced in [
A P colony of capacity , ≥ 1 , is a construct Π = (, , ,
, 1, … , ), where • is an alphabet, its elements are called objects; • ∈ is the basic (or environmental) object of the colony; • ∈ is the final object of the colony; • is a finite multiset over − {} , called the initial state (or initial content) of the environment; • , 1 ≤ ≤ , are agents, where each agent = ( , ) is defined as follows: – is a multiset over consisting of objects, the initial state (or the initial content) of the agent; – = { ,1 , … , , } is a finite set of programs, where each program consists of rules, which are in one of the following forms each: ∗ → , , ∈ , called an evolution rule; ∗ ↔ , , ∈ , called a communication rule; ∗ 1/ 2, called a checking rule; 1, 2 are both evolution rules or both communication rules.
The first type of rules associated with the agents’ programs are the evolution rules, which have the form → . This indicates that object within the agent is rewritten (or evolved) into object .
The second type of rules are the communication rules, expressed as ↔ . When such a rule is applied, object located inside the agent and object in the environment exchange their positions. As a result, after the execution of the rule, object is found inside the agent, and object is placed in the environment.
The third category consists of checking rules. A checking rule is constructed from two rules of the types described above. Denoted as 1/ 2, this rule expresses a priority: rule 1 has precedence over rule 2. When a checking rule is evaluated, the agent first verifies whether rule 1 is applicable. If it is, then 1 must be executed. Otherwise, rule 2 is applied instead.
The program governs the behavior of an agent, allowing it to modify either its own internal state and/or the state of the environment.
The environment is modeled as consisting of a finite number (possibly zero) of copies of nonenvironmental objects, together with a countably infinite supply of a special environmental object denoted by .
When an agent executes a program, each object it contains is afected by the operation. Depending on the program’s rules, its execution may also influence the environment. This interaction between agents and the environment is a fundamental aspect of the functioning of a P Colony.
The computation of a P Colony begins in an initial configuration, which defines the starting state of the system.
The initial configuration of a P Colony is given as an ( + 1) -tuple of multisets, representing the distribution of objects among the agents and the environment at the start of computation. Specifically, it is defined by the multisets for 1 ≤ ≤ , corresponding to the objects within each of the agents, and by the multiset , representing the contents of the environment. Formally, a configuration of a P Colony Π is described by the tuple ( 1, … , , ), where each is a multiset of size (i.e., | | = , for 1 ≤ ≤ ), and ∈ ( ∖ ) ∗ denotes the multiset of objects present in the environment, excluding the infinite supply of .
At each computation step (or transition), the states of the agents and the environment evolve according to a chosen derivation mode. In the maximally parallel mode, each agent that is able to apply one of its programs must do so (a program is selected non-deterministically). In contrast, under the sequential derivation mode, only a single agent is allowed to apply one of its programs at each step, also chosen non-deterministically. If multiple programs are applicable within an agent, one is selected non-deterministically.
A sequence of such transitions forms a computation. A computation is said to be halting if it reaches a configuration in which no further program is applicable in any agent. The result of a halting computation is defined as the number of copies of a distinguished object present in the environment at the halting configuration.
Due to the inherent non-determinism in program selection, multiple distinct computations may arise from the same initial configuration. Accordingly, a P Colony Π computes a set of natural numbers, denoted by (Π) , representing the outputs of all possible halting computations.
As established in [
In the following section, we introduce a novel type of membrane systems that shares both the structural organization and the rule types with P Colonies.
A key structural distinction from P Colonies is found in agent capacity. While P Colonies operate under a strict and constant bound on the number of objects each agent may contain, our model removes this limitation. The number of objects inside an agent can be arbitrary and may vary during the computation due to the application of rules.
In our model, only evolution and communication rules are used.
Each rule is extended with a positive real number that represents its rule application intensity (RAI). At the beginning of the computation, the RAI of each rule is determined by the system definition; in general, the RAI is initially set to 1.
The integer part of RAI specifies how many times the rule is to be applied during a single computational step. Moreover, RAI of each rule is not fixed throughout the computation. It is explicitly updated during last phase of each computation step, reflecting how the rule has been applied in that step. This dynamic adjustment allows the rule’s influence to evolve over time, depending on the system’s state and rule utilization. Let denote the finite alphabet of objects used in the system. Each rule in the system is defined as a quadruple
( , lhs, rhs, ) , where specifies the type of the rule (either evo for evolution or com for communication), lhs and rhs represent the left-hand and right-hand sides of the rule, respectively, with lhs, rhs ∈ ∪ {}
, and ∈ ℝ + denotes the application intensity.
According to the definition of rules, the symbol may occur on either the left-hand side or the right-hand side of a rule. In the case of a communication rule, the presence of on the left-hand side indicates that an object is transferred from the environment into the agent without any object leaving the agent. Conversely, if appears on the right-hand side, the agent sends an object to the environment without receiving anything in return, efectively decreasing the number of objects within the agent. For evolution rules, if appears on the left-hand side, a new object is generated inside the agent. If is on the right-hand side, the corresponding object is removed from the agent. These cases model insertion and deletion operations within the system and extend the expressive power of both rule types. Example 1. Let the object alphabet be = {, , , , } we have an agent with initial content = and let the environmental object be ∈ . Suppose and the environment initially contains the multiset = 2 ∞ (i.e., two copies of and a supply of that is always suficient for any computation step).
Consider the following four rules with their application intensities = 1 , so ⌊⌋ = 1 for all rules: • 1 = (evo, , , ) • 2 = (evo, , , ) • 3 = (com, , , ) • 4 = (com, , , ) : Evolution rule deletes object inside the agent. : Evolution rule generating a new object inside the agent. : Communication rule exporting object from the agent into the environment.
: Communication rule importing object from the environment into the agent. value of RAI may change during the computation, depending on the applicability and application of the rule. If the rule is applicable in the current configuration but not applied, its RAI remains unchanged. If the rule is applied, its RAI is updated according to a predefined positive adjustment. Conversely, if the rule is not applicable, its RAI is modified based on a predefined negative adjustment.
An important aspect of our approach is that the rule application intensity (RAI) is defined as a real number rather than an integer. This choice is motivated by the intended applications of Modified Agent
Agent P Colonies, where a more fine-grained mechanism for both promoting and inhibiting rules is desirable. Real values of RAI allow us to capture gradual adjustments in the activity of rules, reflecting subtle changes in the dynamics of the system. In contrast, integer values would provide only coarse control, limiting the ability to model nuanced behaviors that may arise in practical scenarios.
tuple where:
A modified P colony with rule application intensity with agents, ∈ ℕ , is defined as a Π = (, ,
1, … , , , ⊕ +, ⊖ −, ), Definition 3. a tuple where: • is a finite alphabet of objects,
throughout the computation, • ∈
is an environmental object, assumed to be present in arbitrary quantity in the environment • for each 1 ≤ ≤ , = ( , ) is the -th agent, where:
– = [ 1, … , ] is a finite sequence of – ∈ ∗ is the initial multiset of objects in the agent, rules, each of which is a quadruple = ( , lhs, rhs, ), where: ∗ ∈ { evo, com} indicates the rule type (evolution or communication), ∗ lhs, rhs ∈ ∪ {}
are the left-hand and right-hand sides of the rule, ∗ ∈ ℝ + is the initial application intensity of the rule. • +, − ∈ ℝ
+ are the global positive and negative adjustment parameters, • ∈ ( ∖ {}) ∗ is the initial multiset of non-environmental objects in the environment, • ⊕ and ⊖ are binary operations on ℝ+, used to update the application intensity based on rule usage (e.g., addition/multiplication for ⊕, subtraction/division for ⊖). • is the set of properties of the result. Members of the set are: – ∈
- final object - the result is composed only from the objects , if no final object is specified, then the result of the computation is determined by the occurrences of all objects from the alphabet in the output region. – where ∈ {1, … , , }
- output membrane (or the environment) – result mode: ℎ - result is taken from output membrane after halting computation only; result is taken after every step of computation;
- in each step, the system produces a part of the result.
To capture the evolving state of the system during a computation, we introduce the notion of a configuration , which reflects both the current distribution of objects in agents and the environment, as well as the current values of rule application intensities for each agent. Each configuration thus complements the static definition of the system with a dynamic snapshot of its runtime state, allowing us to formally describe transitions and the computational behavior of the model over time.
A configuration of a modified P colony with RAI Π = (, , 1, … , , , ⊕ +, ⊖ −) is = ( , ( 1, 1), … , ( , )), • ∈ ( ∖ {}) ∗ is the multiset of all non-environmental objects currently present in the environment (the environment is assumed to contain a suficient number of copies of ∈ ), • for each 1 ≤ ≤ :
rule sequence = ( 1, … , ), where ∈ ℝ+ for all . – = ( 1, … ,
– ∈ ∗ is the current multiset of objects inside the -th agent, ) is the vector of rule application intensities corresponding to the rules in the rhs, i.e., rhs⌊ ⌋ ⊆ .
one rule during this step.
A single transition between configurations in the modified P Colony with RAI proceeds in three phases:
In each agent , we identify the subset of applicable rules based on the current multiset of objects and the vector of rule application intensities .
A rule = ( , lhs, rhs, ) is considered applicable if the following conditions hold: • The agent contains at least ⌊ ⌋ copies of the object lhs, i.e., lhs⌊ ⌋ ⊆ . • If the rule is of type com, then the environment contains at least ⌊ ⌋ copies of the object
From the union of applicable rules across all agents, a multiset of selected rules is nondeterministically constructed. The selection must satisfy the following constraints: • Each object in the system (either in agents or in the environment) may be used by at most • The set of selected rules is maximal under the above constraint, i.e., no further applicable rule can be added without violating the exclusivity of object usage.
All selected rules are executed in parallel. The execution results in the following updates: ⊕ +
. ⊖ −
. • The contents of the agents and the environment ( 1, … , , ) are updated based on the type of each applied rule: – For an evolution rule (evo, lhs, rhs, ) , the agent rewrites lhs into rhs inside itself, applied ⌊⌋ times. That is, lhs⌊⌋ is replaced by rhs⌊⌋ . – For a communication rule (com, lhs, rhs, ) , an exchange of objects takes place: ∗ The agent removes lhs⌊⌋ and receives rhs⌊⌋ from the environment, ∗ Simultaneously, the environment removes rhs⌊⌋ and receives lhs⌊⌋ from the agent. • The RAI vectors 1, … , are updated as follows: – If a rule was selected and applied, its RAI is updated via the positive adjustment: ↦ – If a rule was applicable but not selected, its intensity remains unchanged.
– If a rule was not applicable, its intensity is updated via the negative adjustment: ↦ This three-phase process defines a single computation step of the system, where both the multiset contents and the intensities of rule applications evolve according to the agent-environment interaction and usage history of rules.
We now proceed with a formal definition of the update mechanism for the rule application intensity.
Let = ( , lhs, rhs, ) be a rule in the system, where ∈ ℝ + is the current application intensity of . The system is parametrized by two fixed positive real numbers +, − ∈ ℝ+, and by two binary operations ⊕, ⊖ defined over ℝ+.
Given a configuration at time step , the updated application intensity ′ of rule at time + 1 is defined as: ′ = ⎪ ⎧ ⊕ +
⎨ ⎪ ⎩max(1, ⊖ − if the rule is applied in , if the rule is applicable but not applied in , ) if the rule is not applicable in .
To associate a result with a computation (i.e., a sequence of configurations), we consider a set of output-related features that determine how the result is extracted. The result is always derived from the contents of a designated output region—either a specific agent or the environment.
If no terminal object ∈ is specified, the result includes all objects present in the output region at the relevant point of the computation, excluding the occurences of the environmental object . If a terminal object is defined, only the multiplicity of in the output region contributes to the result.
The features in further specify the timing and structure of the result. In the case of epr, the system produces parts of the result incrementally during the computation. In the emr type of result, each configuration contributes one element to the final set. In the halting result (hr ), the result is determined solely by the final configuration.
Several subclasses of the modified P colonies with rule application intensity (RAI) can be considered by introducing restrictions on the structure or dynamics of the system.
One possible variant restricts the number of objects that can be stored inside each agent. This bound may be either an upper bound (≤ ) or an exact constraint (= ), similar to the classical P Colony model, where the capacity of each agent is fixed.
Another subclass includes systems with constant RAI, where the adjustment factors + and − are both set to ×1. In this case, the intensity does not evolve throughout the computation and each rule can be applied at most once per step, similar to traditional rule-based systems.
Further constraints may involve limiting the number of agents in the system or placing a bound on the number of rules associated with each agent. These restrictions are useful for studying the computational power of more resource-constrained models and for exploring trade-ofs between system complexity and expressiveness.
A special variant is the -free system, where the empty string symbol is not allowed on either side of any rule.
In this section, we present a collection of illustrative examples of modified P colonies with RAI to demonstrate the expressive power and behavioral diversity of diferent system variants introduced in the previous section. Each example is designed to highlight a specific constraint or feature such as fixed or unfixed RAI or -free design.
We present a simple modified P colony with rule application intensity (RAI) that generates the set {2 − 1 ∣ ≥ 0} . The system uses a single agent and a single evolution rule. The rule application intensity increases exponentially, doubling after each successful application. The system outputs the number of terminal objects in the agent after each computation step.
Example 2. We define a modified P colony with rule application intensity Π1 = (, ,
1, , ⊕ +, ⊖ −, ), that generates the set {2 − 1 ∣ ≥ 0} , where: • = {, } is the alphabet of objects, with being the terminal object and the environmental object, • is the environmental object, available in suficient quantity in the environment, • 1 = ( 1, 1) is the only agent in the system, where: – 1 = (the agent starts empty),
Step (Environment) 1 (Agent Content) 1 (RAI) 0 1 2 3 4 5 1 2 – 1 = ( ) is a single-rule sequence, with: which creates object inside the agent,
= ( evo, , , 1) • + = 2 and − = 2 are the adjustment parameters, • = (the environment is initially empty of non-environmental objects), • ⊕ = × and ⊖ = / (application intensity is multiplied by 2 when the rule is applied, and divided by 2 when it is not), • = { 1, = , } the result set is produced in each step (emr).
— the result is produced in the agent 1, terminal object is , and one element of
This system works as follows: in each configuration, the agent applies the rule as many times as set by the integer part of its application intensity (RAI). Since the left-hand side of the rule is , the agent creates new objects without consuming any. Initially, the RAI is 1, and it is multiplied by 2 after each application. Therefore, the number of objects generated in the -th step is 2−1 , and the total accumulated number is 2 − 1. The output is read from the agent’s content in each step, as specified in .
The first six configurations of the system are shown in the Table 1.
We now construct a modified P colony with rule application intensity that generates a finite set of natural numbers. The system is lambda-free and operates with a constant RAI — that is, the application intensity of each rule remains unchanged during the computation.
Example 3. We define a modified P colony with rule application intensity that generates a finite set of natural numbers { 1, 2, … , } such that 1 > 2 > ⋯ > . Let = 1 and = . The system Π2 = (, ,
1, … , − , , ⊕ +, ⊖ −, ), is constructed as follows: • The environmental object is , • The environment initially contains objects , i.e., = , • Number of agents: −
, • Each agent is associated with a number from and with a rule type depending on the index , 1 ≤ ≤ ( − )
of the agent. There are two types of rules: 1. (com, ℎ , , 1), 2. (evo, ℎ , ℎ+1 , 1). • Adjustments: + = − = 1, i.e., RAI is constant, • Initially, each agent has object ℎ1: = ℎ1, 1 ≤ ≤ ( − ) . • Result configuration: = { , = , } region) form the result, observed in each step.
, i.e., objects in the environment (which is the output
At step , exactly − +1 agents use their communication rule to move object from the environment into the agent (which removes it from the output), while the remaining agents evolve from ℎ to ℎ+1 . After step , the environment contains +1 copies of object . After − 1 steps, all agents hold object ℎ , and no further rule is applicable — the computation halts.
Let the set to generate be = {6, 5, 2, 0} with Modified P Colony with RAI
1 = 6, 2 = 5, 3 = 2, 4 = 0. Π2 = (, ,
1, … , 6, , ⊕ +, ⊖ −, ), • Initial environment content: = 6, • Number of agents: 6 − 0 = 6, • Agents’ initial contents: = ℎ1 for all = 1, … , 6 , • Rules assigned to agents: – Agent 1 has only one rule: (com, ℎ1, , 1).
(com, ℎ4, , 1). • Adjustment parameters: + = − = 1 (constant RAI), • operators are × and /. • Result is the count of in the environment, • The result property = { , = , }
. – Agents 2, 3, 4 have equivalent sets of rules: (evo, ℎ1, ℎ2, 1); (com, ℎ2, , 1).
– Agents 5, 6 have equivalent sets of rules: (evo, ℎ1, ℎ2, 1), (evo, ℎ2, ℎ3, 1), (evo, ℎ3, ℎ4, 1), At each step , the specified number of agents apply the communication rule to transfer from the environment to their internal content (decreasing the count of in the environment), while the others evolve their internal object ℎ to ℎ+1 . After step , the environment contains +1 copies of . After − 1 = 3 steps, no further rules are applicable, and the computation halts.
The first four configurations of the system are shown in the Table 2.
Step Environment 0 1 2 3
Contents of Agents [ℎ1, ℎ1, ℎ1, ℎ1, ℎ1, ℎ1] [, ℎ 2, ℎ2, ℎ2, ℎ2, ℎ2] [, , , , ℎ [, , , , , ]
Note that at step 3 the environment has 4 = 0 objects . The system successfully generates the set {6, 5, 2, 0} in decreasing order as the number of objects in the environment after each step. Example 4. The next example outlines a design of a system that can serve as a game engine for a class of games known as Idle Games. In such games, active entities (e.g., production units) gradually increase their performance over time, often by paying for upgrades using accumulated in-game currency.
In this modified P colony with RAI, the rule application intensity is not increased automatically but is instead driven by a special input symbol inserted into the environment. This input represents an upgrade and can be added only if the system has accumulated a suficient amount of money objects. The insertion of an upgrade object may be modeled by a simple rewriting rule such as: moneyvalue ⋅ upgrade → upgrade+1 .
Once the symbol upgrade+1 is present in the environment, it can trigger an update of the RAI for the relevant agents via a special rule. The RAI is modified using the adjustment function +, which is not constant but defined as a function of the number of times an upgrade has occurred. For example: +() = +( − 1) +
or +() = +( − 1) ⋅ (1 + 1 ) , where − 1 is the number of completed upgrades.
This design ofers a flexible and controlled mechanism for performance progression: • The rate of production can be tuned based on the game’s economic model, • The system allows diferentiated upgrades with increasing cost and benefit, • RAI is no longer a fixed parameter but a dynamic value, modifiable through environmental interaction.
Overall, this type of system combines the computational model of modified P colonies with an interactive upgrade mechanic, bringing it closer to the logic and dynamics of Idle Games. Figure 2 depicts a production chain utilizing agents in the Modified P Colony.
P raw
M1
M2
final Environment
semi1 Raw material
Semi-product 1
Final product
Sales / Money
In this paper, we introduced a novel computational model — the Modified P colony with Rule Application Intensity (RAI). We presented its formal definition, described the operational semantics in terms of configurations and rule execution phases, and illustrated the behavior of the system through a series of examples. We also introduced several variants of this model, such as systems with a fixed number of objects per agent, constant RAI updates, -free systems, or systems with restrictions on agent count or rule set size.
Currently, our ongoing work focuses on three main directions. First, we are investigating the computational power of the various subclasses of modified P colonies with RAI, aiming to classify their capabilities in relation to classical models of computation. Second, we are developing a software simulator capable of executing computations in these systems, which will support experimentation and visualization. Finally, we are designing a prototype of idle-style game whose core engine will be based on the principles of P colony computations, ofering a practical and interactive application of the model.
S money The research was supported by the Silesian University in Opava under the Student Funding Plan, project SGS/9/2024.
During the preparation of this work, the author(s) used Chat-GPT-4 in order to: Grammar and spelling check. After using these tool(s)/service(s), the author(s) reviewed and edited the content as needed and take(s) full responsibility for the publication’s content.