Syntax

Processes

An LMNtal process is a multiset (unordered sequence) of the following:

 atoms p(X1, ..., Xn) a graph node with a symbolic name p and an ordered sequence of links Xi cells { Process } a process enclosed with a membrane (curly braces) rules ( Head :- Body ) a rewrite rule for processes, explained below

Both periods (as separators) and commas (as terminators) can be used to sequence the elements of a multiset. An LMNtal program is written as an LMNtal process.

Links are written using alphanumeric tokens starting with capital letters (e.g., X, Res). The other alpha-numeric tokens are treated as names (e.g., foo, 123). Quoted symbols can also be used for atom names (e.g., "foo", 'bar', [:baz:]).

Term Abbreviation Scheme

Each link has at most two occurrences. This enables us to abbreviate

p(s1, ..., sm), q(t1, ..., tn)

to

p(s1, ..., sk-1, q(t1, ..., tn-1), sk+1, ..., sm)

if tn and sk are the same link.

For example,

`c(1,c(2,n),L0)`

is an abbreviation of

`c(A,L1,L0),c(B,L2,L1),n(L2),1(A),2(B).`

This can be written also as

`L0=c(1,c(2,n)) .`

For an atom name p and a membrane, p(..., {...}, ...) stands for a molecule p(..., X, ...), {+X, ...} .

List Notation

The Prolog list syntax can be used in LMNtal. List constructor atoms have three arguments and the name '.' .

`X=[A,B|Rest], Rest=[]`

and

`X=[A,B]`

are abbreviated forms of

`'.'(A,Tmp,X), '.'(B,Rest,Tmp), '[]'(Rest).`

Connector Atoms

Binary atoms with the name = of the form X=Y are called connector atoms. Connector atoms state that the two links in the arguments are identical (in the sense of structural equivalence. Another instance of structural equivalence is the reordering of multiset elements.) For example, ( p(A,X,C), X=B ) is always equivalent to p(A,B,C), as well as to ( p(A,B,X), C=X ), and, finally, to C=p(A,B).

The typical usage of connector atoms can be found in the following example:

```( Res=append([],Y)    :- Res=Y ),
( Res=append([A|X],Y) :- Res=[A|append(X,Y)] )```

Rules

The basic syntax of a rule is

The enclosing parentheses can be omitted if periods are used to delimit the rule. Both of Head and Body are process templates.

Head specifies processes to be rewritten and Body specifies the result of rewriting. Rules work only for the processes residing in the same membrane.

The full syntax of a rule that contains Guard part will be explained later in a separate section.

Process Templates

A process template is a multiset of the following:

 atoms p(X1, ..., Xn) same as in a process cells { Template } or { Template }/ a process template enclosed with a membrane rules ( Head :- Body ) allowed only in a Body process contexts \$p or \$p[X1, ..., Xn] or \$p[X1, ..., Xn|*X] matches with a multiset of atoms and cells (see below) rule contexts @p matches with a multiset of rules

A membrane template with / (the stable flag) can only match with a stable cell (i.e., a cell containing no applicable rules).

Process Contexts

A process context represents a multiset of atoms and cells. The arguments X1, ..., Xn specify the set of free links that must exist in the matched process. The optional *X represents an arbitrary number of extra free links.

The form \$p is an abbreviation of \$p[|*X], i.e., a multiset of atoms and cells with no constraints on the occurrences of free links.

A process context must occur within a membrane in a head. Alternatively, it can either

• occur in a head and an input position of a guard, or
• occur in an output position of a guard.

See Guards for the latter extensions.

You can abbreviate p(s1, ..., sk-1, X, sk+1, ..., sm), \$q[X] to p(s1, ..., sk-1, \$q, sk+1, ..., sm).