Chemical Reaction Networks are the stderr shadow of Molecular Computers

Suppose any graph rewrite (like in chemlambda, or dirIC, chemSKI, etc) is a command, where “x” is the name, or the kind, type of rewrite:

rewrite -x graph > graph

Then

stdin is graph before rewrite

stdout is graph after rewrite

stderr is true if a rewrite of type “x” was performed, followed by the number of such rewrites performed in parallel.

Then a chemical reaction network (CRN) view of a graph rewriting computation would be like programming with stderr mainly, not with stdin and stdout.

Indeed, either we already have a CRN (then why would we do a computation if we already know all the intermediary steps) ot we don’t and then we generate it on the fly (thus solving at each step isomorphisms of graphs).

Then, in either case we use stderr to transform the computation into a CRN style one.

We don’t care about the computation, see?

Moreover, the CRN version is based on solving graph isomorphisms first, at each step.

So, instead of the computation which is actually in $graph as it changes over time, we do the bean count of the CRN.

As an example, just suppose that our “graph” is a folders and files system and our rewrites are list, copy, move, remove commands, according to patterns in folders of files names expressed as regular expressions.

The CRN version would be a counter about how many files or folders named with concrete names change into how many other files or folders named with other concrete names.

What is the use of this CRN view? It is totally obscure.

The explanation for the popularity of CRN’s is, I believe, because users actually know already the nodes (species) and the possible reactions and they are interested in measuring their complex interactions effects in time.

Therefore CRN are for a different use case than performing computations via graph rewrites, where the interesting part is the graph version of the execution of a program.

A CRN is therefore a shadow of the graph rewriting computation as proposed in Molecular Computers, ie: “Define a molecular computer as one molecule which transforms, by random chemical reactions mediated by a collection of enzymes, into a predictable other molecule, such that the output molecule can be conceived as the result of a computation encoded in the initial molecule.”

The procedure we keep is to generate a CRN from a graph rewriting computation, by following these steps.

First we start from a computation which is interesting, like:

• a program which we know will stop
• or a program which we know will not stop, but it will have some nice time properties (like periodic)

This program is converted into a graph.

The graph is modified, simplified, according to graph rewriting level experience (like for example the graphs in the chemlambda collection of animations).

Then the graph is reduced by graph rewriting.

During this reduction we generate gradually a CRN.

Maybe we do many instances of reductions and we LEARN the CRN.

Finally we study the CRN we thus produced, with CRN equations.