• A. Meski, M. Koutny, L. Mikulski, I. Petre, W. Penczek, M. Piatkowski: Model checking for distributed reaction systems with temporal-epistemic properties. Nat. Comput. 24(4): 1101-1117 (2025)
• A. Meski, M. Koutny, L. Mikulski, W. Penczek: Reaction mining for reaction systems. Nat. Comput. 23(2): 323-343 (2024)
• A. Meski, M. Koutny, W. Penczek: Reaction Mining for Reaction Systems. UCNC 2018: 131-144
• A. Meski, M. Koutny, W. Penczek: Verification of Linear-Time Temporal Properties for Reaction Systems with Discrete Concentrations. Fundam. Informaticae 154(1-4): 289-306 (2017)
• A. Meski, M. Koutny, W. Penczek: Towards Quantitative Verification of Reaction Systems. UCNC 2016: 142-154
• A. Meski, W. Penczek, G. Rozenberg: Model checking temporal properties of reaction systems. Inf. Sci. 313: 22-42 (2015)

• macOS 15.4 (Sequoia)
• FreeBSD 14.x
• Arch Linux (kernel 6.19), GCC 15.2, Bison 3.8.2

BDD-Based Module

Dependencies

A C++14 compiler, GNU make, Bison, and flex are required. The parser was originally developed against Bison 2.5, but more recent versions (tested up to 3.8.2) build without changes.

On macOS, if you have MacPorts installed, it should be sufficient to just run:

% sudo port install bison

On FreeBSD you may need to install GNU make:

# pkg install gmake

On Arch Linux all required tools are typically already present via base-devel. If not, install them with:

# pacman -S --needed base-devel bison flex

On Debian/Ubuntu:

# apt install build-essential bison flex

Build

Clone the ReactICS’s repository and run the build procedure:

% git clone https://codeberg.org/arturmeski/reactics.git
% cd reactics
% ./reactics setup

Examples

The examples directory contains sample input files specified using RSSL.

Multi-agent reaction systems (rsCTLK verification)

To quickly test the BDD module you can perform verification of the TGC controller consiting of three trains:

$ ./reactics bdd -c f1 examples/bdd/tgc.drs

The above should print:

 ------------------------------------------------
 -- ReactICS -- Reaction Systems Model Checker --
 ------------------------------------------------

Using BDD-based Bounded Model Checking
Formula ((EF(E< proc0.allowed >X(proc0.in)) AND EF(E< proc1.allowed >X(proc1.in))) AND EF(E< proc2.allowed >X(proc2.in))) holds

SMT-Based Module

Installation

Python 3 with the Z3 module installed should be sufficient to run the SMT-based module of ReactICS.

On Arch Linux, install the system Z3 package (which provides the Python bindings):

# pacman -S z3

On Debian/Ubuntu:

# apt install python3-z3

Alternatively, on any platform, install via pip:

$ pip install z3-solver

Usage & Examples

Reachability

To test the SMT module you can perform reachability verification of the scalable chain system:

Running the benchmark without any arguments tells us what parameters are available:

$ ./reactics smt examples/smt/scalable_chain.py

 ------------------------------------------------
 -- ReactICS -- Reaction Systems Model Checker --
 ------------------------------------------------

arguments: <chainLen> <maxConc> <formulaNumber>

We may execute the benchmark for chainLen=2, maxConc=3, and formulaNumber=1 using the following command:

$ ./reactics smt examples/smt/scalable_chain.py 2 3 1

rsLTL verification

To test the SMT module for rsLTL verification the scalable chain system benchmark may be used.

$ ./reactics smt examples/smt/scalable_chain.py 2 5 1

Reaction synthesis

To test the reaction synthesis approach on a mutual exclusion protocol modelling three processes, run the following command (three processes, parametric verification, result optimised with OptSMT):

$ ./reactics smt examples/smt/mutex_param.py 3 p -o

To check the available parameters for the benchmark, we run it with -h:

$ ./reactics smt examples/smt/mutex_param.py -h

 ------------------------------------------------
 -- ReactICS -- Reaction Systems Model Checker --
 ------------------------------------------------

usage: mutex_param.py [-h] [-v] [-o] scaling {p,np-p,np-np}

positional arguments:
  scaling         scaling parameter value
  {p,np-p,np-np}  Selects the mode: p - parameter synthesis (parametric
                  implementation), np-p - non-parametric with parametric
                  implementation (with the parameters substituted), np-np -
                  non-parametric with non-parametric implementation
                  (parameters substituted)

optional arguments:
  -h, --help      show this help message and exit
  -v, --verbose   turn verbosity on
  -o, --optimise  minimise the parametric computation result

Here is an example of how to encode the Train-Gate-Controller model as a Distributed Reaction System (with Context Automaton):

options { use-context-automaton; make-progressive; };
reactions {

    train0 {
        {{out}, {} -> {approach}};
        {{approach}, {req} -> {req}};
        {{allowed}, {} -> {in}};
        {{in}, {} -> {out,leave}};
        {{req}, {in} -> {req}};
    };

    train1 {
        {{out}, {} -> {approach}};
        {{approach}, {req} -> {req}};
        {{allowed}, {} -> {in}};
        {{in}, {} -> {out,leave}};
        {{req}, {in} -> {req}};
    };

    train2 {
        {{out}, {} -> {approach}};
        {{approach}, {req} -> {req}};
        {{allowed}, {} -> {in}};
        {{in}, {} -> {out,leave}};
        {{req}, {in} -> {req}};
    };
};

context-automaton {
    states { init, green, red };
    init-state { init };
    transitions {
        { train0={out} train1={out} train2={out} }: init -> green;
        { train0={allowed} }: green -> red : train0.req;
        { train1={allowed} }: green -> red : train1.req;
        { train2={allowed} }: green -> red : train2.req;
        { train0={} }: green -> green : ~train0.req AND ~train1.req AND ~train2.req;
        { train1={} }: green -> green : ~train0.req AND ~train1.req AND ~train2.req;
        { train2={} }: green -> green : ~train0.req AND ~train1.req AND ~train2.req;
        { train0={} }: red -> green : train0.leave;
        { train1={} }: red -> green : train1.leave;
        { train2={} }: red -> green : train2.leave;
        { train0={} }: red -> red : ~train0.leave AND ~train1.leave AND ~train2.leave;
        { train1={} }: red -> red : ~train0.leave AND ~train1.leave AND ~train2.leave;
        { train2={} }: red -> red : ~train0.leave AND ~train1.leave AND ~train2.leave;

    };
};

Properties expressed in rsCTLK can be specified in the following way:

rsctlk-property { f1 : EF( E<train0.allowed>X( train0.in ) ) AND EF( E<train1.allowed>X( train1.in ) ) AND EF( E<train2.allowed>X( train2.in ) ) };

rsctlk-property { f2 : EF( train0.approach AND train1.approach AND train2.approach ) };

rsctlk-property { f3 : AG( train0.in IMPLIES K[train0](~train1.in AND ~train2.in) ) };

rsctlk-property { f4 : AG( train0.in IMPLIES C[train0,train1,train2](~train1.in AND ~train2.in) ) };

• Maciej Koutny
• Artur Meski
• Łukasz Mikulski
• Wojciech Penczek
• Ion Petre
• Marcin Piątkowski
• Grzegorz Rozenberg

(in alphabetical order)

Current Maintainers of ReactICS

• Artur Meski
• Marcin Piątkowski

Contributing

If you would like to contribute or use ReactICS to implement your experiments or ideas, please feel free to reach out to us. We will do our best to help you get started with the tool and the source code.

You can contribute by creating a pull request.