Transferable Knowledge in P Colonies LucieCiencialovΓ‘ lucie.ciencialova@fpf.slu.cz Institute of Computer Science and Research Institute of the IT4Innovations Centre of Excellence Silesian University in Opava
Opava Czech Republic
LudΔ›kCienciala ludek.cienciala@fpf.slu.cz Institute of Computer Science and Research Institute of the IT4Innovations Centre of Excellence Silesian University in Opava
Opava Czech Republic
Transferable Knowledge in P Colonies 1613-0073 7AEA58C6E8249AEF8481029AEE3B5242 GROBID - A machine learning software for extracting information from scholarly documents membrane computing P colonies transferable knowledge paralell computing multi-agent system

In this paper we introduce the notion of transferable programs as shared knowledge applied in different types of P colonies. We will discuss the basic type of P colonies and 2D P colonies. We will show the possibilities of using transferable programs using examples.
Introduction

P colony is very simple computational device related to membrane systems inspired by colonies of formal grammars. Since 2004, when P colonies were introduced in [1], many types of these systems have been developed. Basically, these are P colonies with different restrictions on the type of programs used (restricted, homogeneous) or working with an environment that is not only in the form of a multiset, but also a string or a 2D grid. Even P colonies whose environment changes dynamically have been introduced. The interested reader is referred to [2] for detailed information on membrane systems (P systems) and to [3] and [4] for more information to grammar systems theory. For more details on P colonies consult the surveys [5] and [6].

A basic P colony consists of a finite number of agents and their joint shared environment. The agents are formed from a finite number of objects and their functioning is based on programs consisting of rules. These rules are of two types: they may change the objects of the agents and they can be used for interacting with the shared environment of the agents. In the case of a basic P colony, the environment is a multiset of objects. The number of objects inside each agent is set by definition and it is usually a very small number: 1, 2 or 3. The environment is processed by the agents and it is used as a communication channel for the agents as well since through the environment, the agents can affect the behaviour of another agent.

The idea of shared knowledge lies in transferable programs. These are programs that are equipped with a condition that, when satisfied, allows the program to be transferred to the agent's program set or, conversely, from this set to the environment.

The agent's program set consists of two kinds of programs.

The first type can be named internal programs. These are the agent's essential programs and cannot be shared. This does not mean that such programs are unique in the P colony. They can be such acts of the agent that can be compared to the basic acts of living organisms such as respiration, digestion, and perception. Thus, they are functions that the organism knows by definition, does not have to learn, and cannot be taught to other organisms.

The second type, called transferable, is the opposite of the first type. It is the knowledge and abilities of an agent that can be shared with the environment under certain conditions.

The environment may also contain transferable programs. These are programs that allow agents to perform activities they did not know how to do -their program set did not contain such programs. These can be instructions on how to use various devices present in the environment, instructions contained in someone else's DNA, etc.

The paper is structured as follows: after the introductory section introducing readers to preliminaries and basic notions, there is a section on basic P colonies and their extension to transferable programs. The fourth section is devoted to shared programs in a 2D P colony environment. In conclusion, we summarize the content of the paper and outline future research goals for the behaviour of P colonies.

Preliminaries and Basic Notions

Throughout the paper we assume the reader to be familiar with the basics of the formal language theory and membrane computing [7,2].

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.

Basic P colonies

The original concept of a P colony was introduced in [1] and presented in a developed form in [8,9]. The first type of rules associated with the programs of the agents, the evolution rules, are of the form π‘Ž β†’ 𝑏. This means that object π‘Ž inside the agent is rewritten to (evolved to be) object 𝑏.

The second type of rules, the communication rules, are of the form 𝑐 ↔ 𝑑. If a communication rule is performed, then object 𝑐 inside the agent and object 𝑑 in the environment swap their location. Thus, after executing the rule, object 𝑑 appears inside the agent and object 𝑐 is located in the environment.

The third type of rules is the checking rule. A checking rule is formed from two rules of one of the two previous types. If a checking rule π‘Ÿ1/π‘Ÿ2 is performed, then the rule π‘Ÿ1 has higher priority to be executed over the rule π‘Ÿ2. This means that the agent checks whether or not rule π‘Ÿ1 is applicable. If the rule can be executed, then the agent must use this rule. If rule π‘Ÿ1 cannot be applied, then the agent uses rule π‘Ÿ2.

The program determines the activity of the agent: the agent can change its state and/or the state of the environment.

The environment is represented by a finite number of copies of non-environmental objects and countably infinite copies of the environmental object 𝑒.

In every step, each object inside an agent is affected by the execution of a program. Depending on the rules in the program, the program execution may affect the environment as well.

The functioning of the P colony starts from its initial configuration (initial state).

The initial configuration of a P colony is an (𝑛 + 1)tuple of multisets of objects present in the P colony at the beginning of the computation. It is given by the multisets π‘œπ‘– for 1 ≀ 𝑖 ≀ 𝑛 and by multiset 𝑣𝐸. Formally, the configuration of the P colony Ξ  is given by (𝑀1, . . . , 𝑀𝑛, 𝑀𝐸), where |𝑀𝑖| = π‘˜, 1 ≀ 𝑖 ≀ 𝑛, 𝑀𝑖 represents all the objects present inside the 𝑖-th agent, and 𝑀𝐸 ∈ (𝐴 βˆ’ {𝑒}) * represents all the objects in the environment different from the object 𝑒.

At each step of the computation (at each transition), the state of the environment and that of the agents change in the following manner: In the maximally parallel derivation mode, each agent which can use any of its programs should use one (non-deterministically chosen), whereas, in the sequential derivation mode, only one agent at a time is allowed to use one of its programs (nondeterministically chosen). If the number of applicable programs for an agent is higher than one, then the agent non-deterministically chooses one of the programs.

A sequence of transitions is named a computation. A computation is halting if in the last configuration that is obtained there is no program that can be applied. With a halting computation, we associate a result which is given as the number of copies of the objects 𝑓 present in the environment in the halting configuration.

Because of the non-determinism in choosing the programs, starting from the initial configuration we obtain several computations, hence, with a P colony, we can associate a set of numbers, denoted by 𝑁 (Ξ ), computed by all possible halting computations of given P colony.

In the original model (see [1]) the number of objects inside each agent is set to two, and the programs were formed from only two rules. Moreover, the initial configuration was defined as (𝑛 + 1)-tuple (𝑒𝑒, . . . , 𝑒𝑒, πœ€) so at the beginning of the computation the environment of the P colony is "empty", it is without input information.

Although P colonies are very simple computing devices, due to their (mainly parallel) working mode and distributed nature they demonstrate large expressive (computational) power. In most cases, computational completeness can be obtained with these constructs even with very few components and very few restrictions on the programs.

P Colonies with transferable programs

In this section, we focus on the definition of transferable programs. Under what conditions can a program be transferred into an agent, and under what conditions can an agent transfer a program into an environment? A transferable program is an ordered pair (program, condition). We distinguish two kinds of conditions: 1. Object condition -for a program to be transferred, the destination must contain (or must not content) certain objects. A condition is specified as a set of multisets of objects. Each of the multisets has a size equal to the capacity P of the colony. 2. program condition -for a program to be transferred, the destination must contain (or not contain) a certain program.

Let Ξ  be a P colony of capacity 2 with one agent and working with objects π‘Ž, 𝑏, 𝑒, 𝑓 . Examples of transferable programs are: Such programs can be considered knowledge sources (and in some cases object sources). Permanent transferable programs may allow an agent to produce an object that does not exist in the environment and that the agent could not otherwise obtain before getting the program.

β€’ (βŸ¨π‘Ž β†’ 𝑏; π‘Ž ↔ π‘’βŸ© ; {π‘Žπ‘Ž}) -

Initial content of the environment is now defined as multiset over 𝐴 βˆͺ {set of transferable programs }.

Using transferable programs within a computation -In every step of a computation an agent can apply one of its applicable programs or transfer program in or out. It means that moving a program takes one step of computation as well as applying the program.

Example 1. Let Ξ 1 be a P colony with one agent whose environment is a workshop with machines that enable the processing of the product. If the agent has (contains) raw materials that the machine can process, then the agent uses the machine. That is, it obtains a program from the environment that allows it to process the raw materials.

P colony Ξ 1 = (︁ 𝐴,𝑒 } 𝑣𝑒 = pow pow pow pow pow 4n p s-b s-b s-b s-b (︁⟨ pow β†’ tt , 𝑒 ↔ 𝑒 ⟩ , { pow 𝑒} )︁ saw (︁⟨ pow β†’ l , 𝑒 ↔ 𝑒 ⟩ , { pow 𝑒} )︁ wood lathe (︁⟨ tt β†’ tth , 𝑒 ↔ 𝑒 ⟩ , { tt 𝑒} )︁ drill (︁⟨ l β†’ lh , 𝑒 ↔ 𝑒 ⟩ , { l 𝑒} )︁ drill (οΈ€βŸ¨οΈ€ tc β†’ ts , 𝑒 ↔ 𝑒 βŸ©οΈ€ , { tc 𝑒} )οΈ€(𝑒𝑒) ⟨ 𝑒↔ pow ,𝑒↔𝑒 ⟩ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’β†’ (︁ pow 𝑒 )︁

The agent himself can't process a piece of marrow. There are two programs in the environment that (if the agent contains a piece of wood) can be transferred to the agent. These programs allow the agent to process pieces of wood into a table top or leg. we can imagine that the agent, by transferring the program, "picks up" a saw or uses a wood lathe.

(︁ pow 𝑒 )︁ import βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (οΈ‚βŸ¨ pow β†’ tt ,𝑒↔𝑒 ⟩ ,{ pow 𝑒} )οΈ‚ (︁ pow 𝑒 )︁

Now the agent can use this program to make the table top from piece of wood.

(︁ pow 𝑒 )︁ (οΈ‚βŸ¨ pow β†’ tt ,𝑒↔𝑒 ⟩ ,{ pow 𝑒} )οΈ‚ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (οΈ€ tt 𝑒 )οΈ€

Because of non-determinism the agent can import the second transferable program instead of using the first one. In the next step, the agent can import a new program from the environment that allows it to drill holes in the table top. In the next step, the agent use imported program and then the agent move the table top with holes into the environment.

(οΈ€ tt 𝑒 )οΈ€ import βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (οΈ‚βŸ¨ tt β†’ tth ,𝑒↔𝑒 ⟩ ,{ tt 𝑒} )οΈ‚ (οΈ€ tt 𝑒 )οΈ€ (οΈ€ tt 𝑒 )οΈ€ (οΈ‚βŸ¨ tt β†’ tth ,𝑒↔𝑒 ⟩ ,{ tt 𝑒} )οΈ‚ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ tth 𝑒 )︁ (︁ tth 𝑒 )︁ ⟨ tth ↔𝑒,𝑒↔𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (𝑒𝑒)

Now, the agent is prepared for processing another piece of wood or mounting the nuts into the holes in the table top. The next scheme shows nuts assembly to the table top with holes.

(𝑒𝑒) ⟨ 𝑒↔ tth ,𝑒↔ 4n ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ tth 4n )︁ (︁ tth 4n )︁ ⟨ tth β†’ ttn , 4n →𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (οΈ€ ttn 𝑒 )οΈ€ (οΈ€ ttn 𝑒 )οΈ€ ⟨ ttn ↔𝑒,𝑒↔𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (𝑒𝑒)

The leg production is similar to the table top production. The agent consumes a piece of wood, imports program for leg making using wood lathe and changes the piece of wood into the table leg. Then the agent import program for hole making with drill and by applying it the agent obtain leg with hole. Then agent put the leg to the environment and consume it together with double ended screw bolt to assembly screw to hole in the leg. The agent can put complete leg into environment.

(︁ pow 𝑒 )︁ import βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (οΈ‚βŸ¨ pow β†’ l ,𝑒↔𝑒 ⟩ ,{ pow 𝑒} )οΈ‚ (︁ pow 𝑒 )︁ (︁ pow 𝑒 )︁ (οΈ‚βŸ¨ pow β†’ l ,𝑒↔𝑒 ⟩ ,{ pow 𝑒} )οΈ‚ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ l 𝑒 )︁ (︁ l 𝑒 )︁ import βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’β†’ (οΈ‚βŸ¨ l β†’ lh ,𝑒↔𝑒 ⟩ ,{ l 𝑒} )οΈ‚ (︁ l 𝑒 )︁ (︁ l 𝑒 )︁ (οΈ‚βŸ¨ l β†’ lh ,𝑒↔𝑒 ⟩ ,{ l 𝑒} )οΈ‚ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’β†’ (︁ lh 𝑒 )︁ (︁ lh 𝑒 )︁ ⟨ lh ↔𝑒,𝑒↔𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (𝑒𝑒) (𝑒𝑒) ⟨ 𝑒↔ lh ,𝑒↔ s-b ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ lh s-b )︁ (︁ lh s-b )︁ ⟨ lh β†’ lc , s-b →𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ lc 𝑒 )︁ (︁ lc 𝑒 )︁ ⟨ lc ↔𝑒,𝑒↔𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (𝑒𝑒)

The agent can make the legs and the table tops up to a total quantity of five. Only such computations where agents makes one table top and four legs leads to successful end -production of one painted table.

(𝑒𝑒) ⟨ 𝑒↔ ttn ,𝑒↔ lc ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ ttn lc )︁ (︁ ttn lc )︁ ⟨ ttn β†’ tt1l , lc →𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ tt1l 𝑒 )︁ (︁ tt1l 𝑒 )︁ ⟨ tt1l ↔𝑒,𝑒↔𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (𝑒𝑒) (𝑒𝑒) ⟨ 𝑒↔ tt1l ,𝑒↔ lc ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ tt1l lc )︁ (︁ tt1l lc )︁ ⟨ tt1l β†’ tt2l , lc →𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ tt2l 𝑒 )︁ (︁ tt2l 𝑒 )︁ ⟨ tt2l ↔𝑒,𝑒↔𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (𝑒𝑒) (𝑒𝑒) ⟨ 𝑒↔ tt2l ,𝑒↔ lc ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ tt2l lc )︁ (︁ tt2l lc )︁ ⟨ tt2l β†’ tt3l , lc →𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ tt3l 𝑒 )︁ (︁ tt3l 𝑒 )︁ ⟨ tt3l ↔𝑒,𝑒↔𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (𝑒𝑒) (𝑒𝑒) ⟨ 𝑒↔ tt3l ,𝑒↔ lc ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ tt3l lc )︁ (︁ tt3l lc )︁ ⟨ tt3l β†’ ttc , lc →𝑒 ⟩ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’β†’ (οΈ€ ttc 𝑒 )οΈ€

During the computation, the agent can export programs that allow the processing of a piece of wood -if there is a piece of wood in the environment the program can be transferred. After processing the last piece of wood, the program remains in the agent's set of programs.

When the agent contains the complete table, it can import program that allows agent to use angle grinder and proceed from the complete table to the sanded table. Then the agent can take the paint and import the last program to spray the table with paint using a paint spray gun.

(οΈ€ tc 𝑒 )οΈ€ import βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’β†’ (οΈ‚βŸ¨ tc β†’ ts ,𝑒↔𝑒 ⟩ ,{ tc 𝑒} )οΈ‚ (οΈ€ tc 𝑒 )οΈ€ (οΈ€ tc 𝑒 )οΈ€ (οΈ‚βŸ¨ tc β†’ ts ,𝑒↔𝑒 ⟩ ,{ tc 𝑒} )οΈ‚ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’β†’ (οΈ€ ts 𝑒 )οΈ€ (οΈ€ ts 𝑒 )οΈ€ ⟨ ts β†’ ts ,𝑒↔𝑝 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (𝑒𝑒) (οΈ€ ts 𝑝 )οΈ€ import βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (οΈ‚βŸ¨ ts β†’ tp ,𝑝→𝑒 ⟩ ,{ ts 𝑒} )οΈ‚ (οΈ€ ts 𝑒 )οΈ€ (οΈ€ ts 𝑒 )οΈ€ (οΈ‚βŸ¨ ts β†’ tp ,𝑝→𝑒 ⟩ ,{ ts 𝑒} )οΈ‚ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (︁ tp 𝑒 )︁

The last executed program is to put painted table into environment.

(︁ tp 𝑒 )︁ ⟨ tp ↔𝑒,𝑒↔𝑒 ⟩ βˆ’ βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’βˆ’ β†’ (οΈ€ e 𝑒 )οΈ€

If we add a special object to the environment, which will be part of the condition for transfer in all transferable programs, the agent can end computation only when it "returns" all transferred programs back to the environment.

2D P Colonies

In [10] a new model, called 2D P colony was introduced. As in the original model, the P colony is of capacity two and the agents are equipped with sets of the programs formed from rules -communication and evolution. The main change is in the environment. The authors put the agents into the 2D grid of square cells and they provide the agent with the possibility to move -the motion program. The direction of the movement of the agent is determined by the contents of cells surrounding the cell in which the agent is placed. The motion program can contain one motion rule and one evolution rule. Definition 2. A 2D P colony is a construct Ξ  = (𝐴, 𝑒, 𝐸𝑛𝑣, 𝐡1, . . . , 𝐡 π‘˜ , 𝑓 ), π‘˜ β‰₯ 1, where A configuration of the 2D P colony is given by the state of the environment -matrix of type π‘š Γ— 𝑛 with multisets of objects over 𝐴 βˆ’ {𝑒} as its elements, and by the state of all agents -pairs of objects from alphabet 𝐴 and the coordinates of the agents. An initial configuration is given by the definition of the 2D P colony.

A computational step consists of three parts. The first part lies in determining the set of applicable programs according to the current configuration of the 2D P colony. In the second part, we have to select from this set one program for each agent, in such a way that there is no collision between the communication rules belonging to different programs. The third part is the execution of the chosen programs.

A change of the configuration is triggered by the execution of programs and it involves changing the state of the environment, contents and placement of the agents.

A computation is non-deterministic and maximally parallel. The computation ends by halting when there is no agent with applicable program.

The result of the computation is the number of copies of the final object placed in the environment at the end of the computation.

The aim of introducing 2D P colonies is not studying their computational power but monitoring their behaviour during the computation.

2D P Colonies with transferable programs

We can introduce transferable programs into 2D P colonies model. Aspects of transferable programs composed of evolutionary and communication rules have already been mentioned in the previous section.

A transferable motion program can upgrade an agent's motion capabilities. For example, an agent that previously could only move in one direction now has the ability to move left, right, or backwards. The agent's program

⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ ⇑; π‘Ž β†’ π‘Ž ⟩ The transferred program ⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ ⇐; π‘Ž β†’ π‘Ž ⟩

If the agent had any restrictions in the original motion programs under which it could move in a certain direction, these restrictions can be changed. For example, if the agent could only move to the left if there was an object 𝐿 on the left, then after importing the program, it will also be able to move to the left if there is an object 𝑇 to the left of the agent. The agent's program

⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝐿 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ ⇐; π‘Ž β†’ π‘Ž ⟩ The transferred program ⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑇 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ ⇐; π‘Ž β†’ π‘Ž ⟩

Similarly, constraints can be imposed on the agent's content. The agent may be given "one-time permission" to turn left in the form of object 𝐿, which it will be able to rewrite 𝐿 to another object while according to the agent's movement rule agent moves left.

The The environment has a size 5 Γ— 5 and each cell contains only environmental objects except for the cell with address [4,4], which also contains transferable program

(βŸ¨π‘’ β†’ 𝑠; 𝑒 β†’ π‘’βŸ© , {𝑒𝑒}) .

The first agent 𝐡1 = (𝑒𝐹, 𝑃1, [0, 0]) has a set of programs 𝑃1 that include the following programs:

(βŸ¨π‘’ β†’ 𝑒; 𝑒 ↔ π‘ βŸ© , {𝑒𝑒}) 𝑝 ⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ β‡’; 𝐹 β†’ 𝑠 ⟩ ⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ ⇐; 𝐹 β†’ 𝑠 ⟩ ⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ ⇑; 𝐹 β†’ 𝑠 ⟩ ⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ ⇓; 𝐹 β†’ 𝑠 ⟩ βŸ¨π‘’ β†’ 𝐹 ; 𝑠 ↔ π‘’βŸ©

The first agent 𝐡2 is defined as (𝑒𝑒, 𝑃2, [2,2]). Its set of programs is formed by following programs:

⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ β‡’; 𝑠 β†’ 𝑒 ⟩ ⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ ⇐; 𝑠 β†’ 𝑒 ⟩ ⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ ⇑; 𝑠 β†’ 𝑒 ⟩ ⟨ ⎑ ⎣ 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 𝑒 ⎀ ⎦ β†’ ⇓; 𝑠 β†’ 𝑒 ⟩

The first agent starts the computation in the state 𝑒𝐹 with two options -1. export the transferable program, or 2. apply one of the motion programs. Executing the motion program changes the agent's position and also changes its state to 𝑒𝑠. In the following step, the agent can also export a program or apply a program βŸ¨π‘’ β†’ 𝐹 ; 𝑠 ↔ π‘’βŸ©. By executing the program, the agent places the slave object 𝑠 in the cell and changes its state to 𝑒𝐹 .

The second agent is in state 𝑒𝑒 at the beginning of the computation. It has no applicable program until the first agent visits its position and places transferable program (βŸ¨π‘’ β†’ 𝑒; 𝑒 ↔ π‘ βŸ© , {𝑒𝑒}) there. Thus, the movement of agent 𝐡2 is thus dependent on this program and the presence of object 𝑠 in the environment.

If agent 𝐡2 reaches cell [4,4] during the computation, it can import a program whose application can evolve object 𝑠 from the environmental object and thus becomes independent of the presence of object 𝑠 in the environment.

Example 3. Imagine a student moving within the school building to acquire the necessary knowledge and pass an exam. We can simulate such a situation by using a 2D P colony.

The single cells of the 2D environment represent parts of a school building (or multiple buildings) such as classrooms, laboratories, libraries, teachers' offices, etc. The student's goal is to obtain a grade in the course (object 𝑀 -mark). At the beginning of the computation, agent -student can contain either only environmental symbols or also an object that expresses his intention to successfully complete the course (object π‘š). Its movement through environment can be random (the agent can use any of movement program, it can move in any direction)

There may be other agents in the environment such as teachers who will move from their office to the classroom or lab and back again. If they encounter a student in these rooms (the student places their marker in the environment), they can provide a program that allows the student to advance closer to obtaining the 𝑀 object. Let to get the grade require attending a class, gaining knowledge by studying in the library and lab, and finally passing an exam. Thus, object π‘š can be acquired over time by a subscript that captures the facts of the actions taken (T -teacher, L -library, A -lab, C -consultation). We can determine under which conditions it is possible to change the index just with the help of transferable programs that are available in different rooms -cells.

We leave it to the esteemed reader to construct particular programs for student and teacher.

Conclusion

In this paper we introduced the notion of transferable programs in two models of P colonies -basic P colonies and 2D P colonies. One of the main features of P colonies is the use of environment agents to store shared objects. Thus, objects can be used by all agents that are in a given part of the environment and know how to handle the object (have programs that process the object). Transferable programs allow not only to share objects, but also to share the ability to handle these objects.

Our goal for the future is to introduce a type of numerical P colony with transferable programs, whose agents would acquire their abilities by moving around in an environment that has a specified structure. Agents in such a P colony would perform search algorithms known, for example, from graph theory.

Definition 1. 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;pro-grams, where each program consists of π‘˜rules, which are in one of the following formseach:* π‘Ž β†’ 𝑏, π‘Ž, 𝑏 ∈ 𝐴, called an evolutionrule;* 𝑐 ↔ 𝑑, 𝑐, 𝑑 ∈ 𝐴, called a communi-cation rule;* π‘Ÿ1/π‘Ÿ2, called a checking rule; π‘Ÿ1, π‘Ÿ2are both evolution rules or both com-munication rules.Now, we add brief explanations of the components ofthe P 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
The P colony starts an computation with all supplies in the environment. Agent contents two environmental objects. In this configuration agent can use only one program. This program allow it to consume one piece of wood.Agent 𝐡 is in the initial state 𝑒𝑒 and its set of programsis formed from its ability to work with or without handtools:𝑃 = {βŸ¨π‘’ ↔ pow , 𝑒 ↔ 𝑒 ⟩,take a piece of wood⟨lh β†’ lh , 𝑒 ↔ s-b⟩,take a screw bolt⟨lh β†’ lc , s-b β†’ 𝑒 ⟩, mount the screw bolt⟨lc ↔, 𝑒 ↔ π‘’βŸ©,put down complete leg⟨tth β†’ tth , 𝑒 ↔ 4n⟩,take four nuts⟨tth ↔ ttn , 4n β†’ 𝑒 ⟩, put nuts on the holesβŸ¨π‘’ ↔ ttn , 𝑒 ↔ lc⟩,take the table topand complete leg⟨ttn ↔ tt1l , lc β†’ 𝑒 ⟩, mount the complete legon the table top⟨tt1l ↔ 𝑒, 𝑒 ↔ 𝑒 ⟩,put down the table topwith one legβŸ¨π‘’ ↔ tt1l , 𝑒 ↔ lc⟩, take the table top with legand the second complete leg⟨tt1l ↔ tt2l , lc β†’ 𝑒 ⟩, mount the second legon the table top⟨tt2l ↔ 𝑒, 𝑒 ↔ 𝑒 ⟩,put down the table topwith two legsβŸ¨π‘’ ↔ tt2l , 𝑒 ↔ lc⟩, take the table top with2 legs and the second complete leg⟨tt2l ↔ tt3l , lc β†’ 𝑒 ⟩, mount the third legon the table top⟨tt3l ↔ 𝑒, 𝑒 ↔ 𝑒 ⟩,put down the table topwith three legsβŸ¨π‘’ ↔ tt3l , 𝑒 ↔ lc⟩,take the table topand the third complete leg⟨tt3l ↔ tc , lc β†’ 𝑒 ⟩, mount the fourth legon the table topβŸ¨οΈ€ts β†’ ts , 𝑒 ↔ π‘βŸ©οΈ€,take the paint⟨angle grinder(︁⟨ts β†’ tp , 𝑝 β†’ 𝑒 ⟩, { ts 𝑝})︁paint spray gun
tp ↔ 𝑒, 𝑒 ↔ 𝑒 ⟩ , put down the painted table }
‒𝐴 is an alphabet of the colony, its elements are called objects, β€’ 𝑒 ∈ 𝐴 is the basic environmental object of the 2D P colony, β€’ 𝐸𝑛𝑣 is a pair (π‘š Γ— 𝑛, 𝑀𝐸), where π‘š Γ— 𝑛, π‘š, 𝑛 ∈ 𝑁 is the size of the environment and 𝑀𝐸 is the initial contents of environment, it is a matrix of size π‘š Γ— 𝑛 of multisets of objects over 𝐴 βˆ’ {𝑒}. β€’ 𝐡𝑖, 1 ≀ 𝑖 ≀ π‘˜, are agents, each agent is a construct 𝐡𝑖 = (π‘œπ‘–, 𝑃𝑖, [π‘œ, 𝑝]) , 0 ≀ π‘œ ≀ π‘š, 0 ≀ 𝑝 ≀ 𝑛, where -π‘œπ‘– is a multiset over 𝐴, it determines the initial state (contents) of the agent, |π‘œπ‘–| = 2, -𝑃𝑖 = {𝑝𝑖,1, . . . , 𝑝 𝑖,𝑙 𝑖 } , 𝑙 β‰₯ 1, 1 ≀ 𝑖 ≀ π‘˜ is a finite set of programs, where each program contains exactly 2 rules, which are in one of the following forms each: * π‘Ž β†’ 𝑏, called the evolution rule, π‘Ž, 𝑏 ∈ 𝐴, * 𝑐 ↔ 𝑑, called the communication rule, 𝑐, 𝑑 ∈ 𝐴, * [π‘Žπ‘ž,π‘Ÿ] β†’ 𝑠, 0 ≀ π‘ž, π‘Ÿ ≀ 2, 𝑠 ∈ {⇐ , β‡’, ⇑, ⇓}, called the motion rule, β€’ 𝑓 ∈ 𝐴 is the final object of the colony.
Acknowledgments

This work was supported partially by European Union under European Structural and Investment Funds Operational Programme Research, Development and Education project ZvΓ½Ε‘enΓ­ kvality vzdΔ›lΓ‘vΓ‘nΓ­ na SlezskΓ© univerzitΔ› v OpavΔ› ve vazbΔ› na potΕ™eby MoravskoslezskΓ©ho kraje, CZ.02.2.69/0.0/0.0/18_058/0010238 and by the Silesian University in Opava under the Student Funding Scheme, project SGS/8/2022.

Preview of P colonies: A biochemically inspired computing model JKelemen AKelemenovÑ Gh Păun Workshop and Tutorial Proceedings. Ninth International Conference on the Simulation and Synthesis of Living Systems (Alife IX)
Boston, Massachusetts, USA
 2004 Gh GPăun ARozenberg Salomaa The Oxford Handbook of Membrane Computing
New York, NY, USA
 Oxford University Press, Inc 2010 A grammartheoretic treatment of multiagent systems JKelemen AKelemenovÑ 10.1080/01969729208927485 Cybern. Syst 23 1992 Grammar Systems: A Grammatical Approach to Distribution and Cooperation ECsuhaj-Varjú JKelemen GhPăun JDassow 1994 Gordon and Breach Science Publishers, Inc USA 1st ed P Colonies AKelemenovÑ The Oxford Handbook of Membrane Computing Gh GPăun ARozenberg Salomaa
New York, NY, USA
 Oxford University Press, Inc 2010 1st. ed <author> <persName><forename type="first">L</forename><surname>CiencialovΓ‘</surname></persName> </author> <author> <persName><forename type="first">E</forename><surname>Csuhaj-VarjΓΊ</surname></persName> </author> <author> <persName><forename type="first">L</forename><surname>Cienciala</surname></persName> </author> <author> <persName><forename type="first">P</forename><surname>SosΓ­k</surname></persName> </author> <author> <persName><surname>Colonies</surname></persName> </author> <idno type="DOI">10.1007/s41965-019-00019-w</idno> <ptr target="https://doi.org/10.1007/s41965-019-00019-w.doi:10.1007/s41965-019-00019-w" /> </analytic> <monogr> <title level="j">Journal of Membrane Computing 1 2019 Handbook of Formal Languages: Beyonds words, Handbook of Formal Languages GRozenberg ASalomaa 1997 Springer On P colonies, a biochemically inspired model of computation JKelemen AKelemenovΓ‘ Proc. of the 6 π‘‘β„Ž International Symposium of Hungarian Researchers on Computational Intelligence of the 6 π‘‘β„Ž International Symposium of Hungarian Researchers on Computational Intelligence
Budapest TECH, Hungary
 2005 Computing with cells in environment: P colonies ECsuhaj-Varjú JKelemen AKelemenovÑ Gh Păun Gy Vaszil Journal of Multiple-Valued Logic and Soft Computing 12 2006 LCienciala LCiencialovÑ MPerdek Colonies 10.1007/978-3-642-36751-9_12 Proceedings of the 13th International Conference on Membrane Computing, CMC'12 the 13th International Conference on Membrane Computing, CMC'12
Berlin, Heidelberg
 Springer-Verlag 2012