Tag Archives: chemlambda

Announcement: chemlambda can be done with RNA (final update)

There exists an encoding of chemlambda molecules with RNA, in such a way that the chemlambda model can be realized via real RNA computing. 
I shall update this post with details concerning my motivations and about how the second part of the announcement fits with my activities.
I open a bidding session concerning a contract based collaboration which could convince me that you’re an expert and you can provide me with the means to do this together. As concerns the collaboration, I shall give you an edge into being the first who does it. Letters of interest may be addressed to Marius.Buliga@gmail.com, Marius.Buliga@imar.ro or via the chemlambda repository (gh-pages branch) .
Follow this post for updates.
UPDATE: the bidding session ends on OCT 30 2016. As a funny simulation enjoy
which however does not disclose almost anything about the main subject of this post. Compare it with the simulation (needing js enabled in your browser) from the article Molecular computers (which is the ancestor of the ideas relevant here).

UPDATE 2:  Bidding ends today  OCT 30 2016 at 12 PM UTC time, measured from the timestamp of messages reaching me.  You may say that this is a random boundary and I agree, that is why I propose the following use of words  in future public references to this boundary  distinction. Anybody who meaningfully contacted and contributed to this project before the time boundary will be publicly called a supporter. This will be only a small expression of my gratitude, dear supporters please expect much more.

I thought about using the word legacy in relation to the others. This would be true per the use of the word in computing (or open science). Nah, is enough that I’ll know and you’ll know 🙂

UPDATE 3: Bidding closed.


More about chemical transactions

There is much more about these chemical transactions and their proofs. First is that transactions are partially independent on the molecules. The blockchain may be useful only for having a distributed database of transactions and proofs, available for further use. But there’s more.

Think about this database as one of valid computations, which can then be reused in any combination or degree of parallelism. Then, that’s the field of several competitions.

The same transaction can have several proofs, shorter or longer. It can have big left pattern therefore costly to use it in another computation. Maybe a transaction goes too long and therefore it is not useful to use in combination with others.

When there is a molecule to reduce, the application of a transaction means:
– identify a subgraph isomorphic with the left pattern and pick one such subgraph
– apply the transaction to this particular subgraph (which is equivalent with: reduce only that subgraph of the molecule, and freeze the rest of the molecule, but do it in one step because the sequence of reductions is already pre-computed)

Now, which is more convenient, to reduce the molecule by using the random algorithm and the available graph rewrites, or to use some transactions which fit, which is fast (as concerns step 2) but costly (as concerns step 1), moreover it may be that there is a transaction with shorter proof for that particular molecule, which mixes parts of several available precomputed transactions.

Therefore the addition of transactions and their proofs (needed to be able to validate them) into the database should be made in such a way which profit from this competition.

If I see the reduction of a molecule (which may be itself distributed) as a service then besides the competition for making available the most useful transactions with the shortest proofs, there is another competition between brute force reducing it and using the available transactions, with all the time costs they need.

If well designed, these competitions should lead to the emergence of clusters of useful transactions (call such a cluster a “chemlisp”) and also to the emergence of better strategies for reducing molecules.

This will lead to more and more complex computations which are feasible with this system and probably fast enough they will become very hard to understand by a human mind, or even by using IT tools on a limited part of the users of the system.

Chemical transactions and their proofs

By definition a transaction is either a rewrite from the list of
accepted rewrites (say of chemlambda) or a composition of two
transaction which match. A transaction has a left and a right pattern
and a proof (which is the transaction expressed as a cascade of
accepted rewrites).

When you reduce a molecule, the output is a proof of a transaction.
The transaction proof itself is more important than the molecule from
the start. Indeed, if you think that the transaction proof looks like
a list

rm leftpattern1
add rightpattern1

where leftpattern1 is a list of lines of a mol file, same for the rightpattern1,

then you can deduce from the transaction proof only the following:
– the minimal initial molecule needed to apply this transaction, call
it the left pattern of the transaction
– the minimal final molecule appearing after the transaction, call it
the right pattern of the transaction

and therefore any transaction has:
– a left pattern
– a right pattern
– a proof made of a chain of other transaction which match (the right
pattern of transaction N contains the left pattern of transaction N+1)

It would be useful to think in term of transactions and their proofs
as the basic objects, not molecules.

A library of chemlambda molecules

More than 400 molecules are now  available at the the github repository for chemlambda, at this link. Many of them have been used to produce the animations from the chemlambda collection at google+.

There are more than 200 animations in that collection, which attracted an average stream of 150000 views/day and more than 30000 followers. I am proud about that because the subject is rather hard and almost all posts contain original research animations.

If you want to identify the mol file (i.e. the molecule) which has been used to create a certain animation, then follow the  path:

  • click on the animation, you’ll be presented with a page where the animated gif runs
  • try to save the gif, you’ll see a name.gif
  • in another window go to the library of molecules and look for name.mol.

In most of the cases this works, but there might be rare cases where I forgot to preserve the correspondence between name.gif and name.mol.

During the time these animations have been produced, I used various versions of the scripts (all available at the repository). They should be all compatible, but it is possible that some mol files will not work as input for the scripts. If this happens, then it is because I used, mistakenly, a port variable in a bad place and then I forgot to delete the faulty version. Please excuse me for that, in case it happens (maybe, maybe 4 or 5 mol files from the about 440 are like this).

To see how to use the repository please go to the README.md file.

It is important to understand how I made the animations.

  • you need a linux or a mac, because the scripts are in shell or awk
  • I used a mac. I went to the folder where the scripts and the mol files are (so if you copy the mol files from the library, then copy  them in the same folder as the folder called “dynamic”, before you use the scripts). In a terminal window I typed, for example “bash quiner_shuffle.sh”. A list of all the mol files in that folder appear.
  • I type the complete name.mol and hit enter
  • then the main script does the magic and I obtain name.html
  • mind that the parameters for the computation are in the most important part, the script quiner_shuffle.awk (and quiner_shuffle.sh is just a wrapper of this, same for all the pairs of scripts .sh and .awk)
  • I used a browser to see name.html. Important: Safari works the best, by far, then Chrome. Firefox sucks for very obscure reasons. There is a solution for making the name.html to work on Firefox as well, is to find in the quiner_shuffle.awk the line “time_val=4; ” and to modify it into something like “time_val=120; “, for example. This variable controls the speed of the javascript animation, bigger is it, slower the animation.
  • You’ll see that the d3.js animation can take, depending on the molecule (and on the number of steps given by this line “cycounter=10000;” in quiner_shuffle.awk), from minutes to hours.
  • I made a screen capture of the animation and then I sped it, for example with ffmpeg.


If you make nice stuff with it, then tell me and I’ll be glad to host your creation here and in the chemlambda collection.

Neurons rewrites

A real neural network is a huge cascade of chemical rewrites. So I can try my chemlambda with that task. From a programming point of view, the problem is to understand neural networks as a graph rewrite model of computation, together with a (yet undiscovered) discipline of using them.

Further are some pretty images showing the first tries. They are all made by filming real simulations obtained with chemlambda.

Before giving them, I tell you that this task seems hard and now I believe that an easier one would be to use the ideas of chemlambda in the frame of quantum computing. (Do I have to add that in a new way, different from what was proposed in the many graphical formalisms associated to category theory? Probably! All those formalisms fall into the family: topological changes do not compute. Wait and see.)


The replicant

This is a molecular machine designed as a patch which would upgrade biological ribosomes. Once it attaches to a ribosome, it behaves in an almost similar ways as the synthetic ribosome Ribo-T, recently announced in  Nature 524,119–124(06 August 2015) doi:10.1038/nature14862  [1].  It thus enables an orthogonal genetic system, (i.e., citing from the mentioned Nature letter “genetic systems that could be evolved for novel functions without interfering with native translation”).

The novel function is designed for is more ambitious than specialized new proteins synthesis. It is, instead, a  two-ways translation device, between real chemistry and programmable artificial chemistry.

It behaves like a bootstrapper in computing. It is itself simulated in chemlambda, an artificial chemistry which was recently proposed as a means towards molecular computers [2].  The animation shows one of the first successful simulations.




With this molecular device in place, we can program living matter by using living cells themselves, instead of using, for example, complex, big 3D DNA printers like the ones developed by Craig Venter.

The only missing step, until recently, was the discovery of the basic translation of the building blocks of chemlambda into real chemistry.

I am very happy to make public a breakthrough result by Dr. Eldon Tyrell/Rosen, a genius who went out of academia some years ago and pursued a private career. It appears that he got interested early in this mix of lambda calculus, geometry and chemistry and he arrived to reproduce with real chemical ingredients two of the chemlambda graph rewrites: the beta rewrite and one of the DIST rewrites.

He tells me in a message  that he is working on prototypes of replicants already.

He suggested the name “replicant” instead of a synthetic ribosome because a replicant, according to him, is a device which replicates a computer program (in chemlambda molecular form) into a form compatible with the cellular DNA machine, and conversely, it may convert certain (RNA) strands into chemlambda molecules, i.e. back into  synthetic form corresponding to a computer program.

[1] Protein synthesis by ribosomes with tethered subunits,  C. Orelle, E. D. Carlson, T. Szal,  T. Florin,  M. C. Jewett, A. S. Mankin

[2] Molecular computers, M Buliga

[This post is a reply to +Yonatan Zunger  post

where he shows that the INCEPT DATE of the Blade Runner replicant Roy Batty appears to be 8 Jan, 2016.
So here is a replicant, in the inception phase 🙂 ]

PS: The post appeared as well in the chemlambda collection: