I pass directly to the matter.
UPDATE: now there are demos in D3 for some of the things described here.
Where I’m now. I have a development of the initial chemlambda formalism (introduced in the Chemical concrete machine) which can be coupled with with various algorithms for performing reductions, which range from the most stupid
- on one machine run a program which advances in sequential steps, such that each step begins by finding all possible graph rewrites on a given molecule, then chooses according to a criterion called “priority choice” a maximal collection of graph rewrites which can be done simultaneously; after the application of all graph rewrites there is a second stage when the “COMB” moves are applied, which eliminate the supplementary Arrow elements
to more and more intelligent
- distribute to several machines the stupid strategy but keep a synchronous global control over this
- use one or more machines which maintain channels of communication (which pose synchronization problems) between them, i.e. use process algebra style models of computation over the chemlambda formalism
- on one machine, use a Chemical Reaction Network model of computation by starting the computation with a multiset of molecules and then do as in the stupid strategy, but with a random ingredient added, like for example choosing randomly a subset of graph rewrites from those possible, or allowing randomly moves performed in the opposite direction. Produce probabilistic results about the distribution of numbers of molecules which appear. This of course is a model which is extremely expensive, but perhaps because of the fact that the stupid strategy is very cheap in terms of IT resources, maybe it works.
- same as previously, but on many machines, a CRN style on each machine, a process algebra style between machines.
I claim that all these models don’t add anything really interesting over the stupid model. These are like fashion ornamentation over a bad, but popular design.
None of these additions use in a significant way the advantages of chemlambda, which are:
- is a purely local graph rewrite system
- there are no correct molecules (graphs), nor wrong, or illegal ones
- the graphs ale almost never DAGs, nor they represent a flowchart of a computation
- hence there is no global “meaning” associated to them
- the formalism does not work by passing values from here to there (so why one should think to couple chemlambda with something adapted to the sender-wire-receiver paradigm?)
- the molecules encode a (local) meaning not by their number, but by their shape (therefore why would one want to use CRN for these? )
- the molecules are not identified with their function, so from the point of view of chemlambda it does not matter if you use a functional programming paradigm or an imperative one
I hold that on the contrary, chemlambda is really close to some of Nature’s workings:
- Nature does not need meaning to work, this meaning is simply a human point of view, a hash table which simplify our explanations. To believe that viruses and cells have tasks, or functions, or that they have a representation of themselves, or that they need one, all this is a sterile and confusing, but pervasive belief.
- Nature is purely local, in the sense that everything happens by a chain (or a net, or other analogy that our weak minds hungry for meaning propose) of localized interactions (btw this has little to do with the problem of what is space, and more to do with the one of what is a degree of freedom)
- Nature does not use functions, functionalism is an old and outdated idea which felt into oblivion a long time ago in chemistry, but it is still everywhere used in the hard sciences, especially after the formalization a la Bourbaki (and other blinds), who significantly was incapable of touching more natural fields like geometry
- Nature rarely uses sender-wire-receiver settings, these are, I suppose, the scars of the WW2, when IT started to take shape.
- Nature does not work by passing values, or numbers, or bits, we do use these abstractions for understanding and we build our computers like this
- Nature does not have or need a global point of view, we do in our explanations.
However, there is a social side of research which makes interesting the pursue of the exploration of these familiar models in relation to chemlambda. People believe these models are interesting, so it would be good to see exactly how chemlambda looks with these ornaments on top.
Now let’s pass to really interesting models.
Why put randomness by hand into the model when there is enough randomness in the real world?
Instead of CRN and process algebra (with it’s famous parallel composition operation, which is of course just another manifestation of a global point of view), let’s just preoccupy to understand how the world looks from the point of view of an individual molecule.
Forget about soups of multisets of anonymous molecules, let’s be individualistic. What happens with one molecule?
Well, it enters in chemical interactions with other molecules, depending on where it is relative to others (oups, global pov), depending of many external randomness sources. From time to time the molecule enters in interaction with another one and when it does, the chemical reaction is like a graph rewrite on the molecule and the other, which may happen with some randomness as well, but more important, it happens in certain definite ways, depending on the molecule chemical composition and shape.
That is more or less all, from the chemical point of view.
OK then, let’s ignore the randomness because anyways in the real world there are many sources of randomness, there is plenty of randomness, and let’s try to make a model of one individual molecule which behaves in some ways (does some graph rewrites on the complex formed by itself and the other(s) molecules from the chemical reaction).
In other words, let’s make an actor molecule.
Mind that from the point of view of one molecule there is no global state of the world.
This is what is proposed in section 3 of the article GLC actors, artificial chemical connectomes, topological issues and knots. Not for chemlambda, but for the GLC, the distant parent.
What is the relevance. You can use this for several purposes.
- at once, this gives a decentralized computing system based on artificial chemistry which is very close to Nature way, therefore
- is good to try it on the Net
- and is good to try it in real world (with the condition to identify real chemistry reactions which are like the chemlambda graph rewrites, something I believe is true)
- and moreover is good to try it as an ingredient in the future IoT, where we can import the amazing idea of Craig Venter to send a printer of lifeforms to Mars and then send by radio any DNA encoding from Earth to Mars. Why not do the same entirely on Earth? Imagine: the real world has a chemistry, the virtual one has chemlambda, therefore we can pass smoothly from one to the other because they are based on same principles. The technology behind the IoT would then be a giant, worldwide distributed Venter Printer, in one sense, coupled with a world wide sensor (phones, cameras, fridges and whatnot) which convert the acquired data from the real world into the chemlambda format of the virtual one.
That’s the first batch of uses. There are others, maybe less ambitious but more easily attainable.
- would you want to do a realistical neural network? We may try it by making a fine grained neuron and distribute it over the network. Indeed, each real neuron is the host of a collection of chemical reactions, from the synaptic cleft, to the soma, to the next synaptic cleft.
- too ambitions maybe, so let’s restrict to something simpler: can we do Turing neurons in chemlambda? Sure, done already.
That is more of a principle of organizing computations, and a path to pursue.
- or maybe we want to have a world wide distributed universal computer. It will not be very fast, but the purpose is not be fast, but distributed. I call this “the Soup”. Imagine: everybody who wants to be part of it just downloads a collection of scripts and puts it somewhere which has an URI (like a web page). There is no sneak behaviour there, no net bots or other freaky idea which would transgress any privacy. Each participant will become like an actor molecule (or maybe 10, or 100, depending on the burden of the scripts on the computer). Anybody could launch a designed molecule into the Soup, starting a network of reactions with the others molecules from the Soup (i.e. with the ones which are stored as states of the actors in other computers). The communication between computers will be decentralized and will not make much sense to a sneaker anyways, which brings me to other possible applications
- the first one is something like a distributed homomorphic encryption service. Big words, but what really means is that the Soup could offer this service by default. Some said that this would be a form of obfuscation, because you take a program (like a lambda term) and then you execute it in this weird chemlambda. But this is not at all correct, because, recall, chemlambda has only little to do with lambda terms (a thing which I don’t arrive to stress enough) and there is no correct or illegal molecule (differently from any other formalism which superficially resembles to chemlambda, like GOI or ZX), and there is no global meaning, nor passing of values which can be then intercepted. No, the “encryption” works like in Naure, where, for example the workings of a living cells are “encrypted” by default, by the fact that they carry no meaning, they are purely local and decentralized.
The list of possible application forked, I go back to the previous.
- it is possible that not neurons, which are big chemical entities, may be better understood, but much smaller ones, like bio molecules. Maybe some chemlambda style worlings are relevant at the genetic level. More concretely, perhaps one can identify real molecules or use DNA and enzymes to do chemlambda in reality. Better still, and more realistical I think, maybe chemlambda is only a proof of principle that it is possible to understand life processes at the levels of molecule, not by the usual way. The usual way consists largely into trying to make sense, attribute tasks and functions and do probabilistic calculi on huge quantities of data collected in real chemistry. This new way would consist into the exploration of the molecules as embodied abstractions, embodied programs… Oh, it does not sound original enough, let me try again. Compare with Alchemy of Fontana and Buss. In that amazing research program they propose that molecules are like lambda terms, reactions are like the application operation and active chemical sites like abstraction. In chemlambda the application and abstraction are not operations, but atoms or small parts of molecules. And the molecules are not only lambda terms, but much more varied. Chemical reactions are graph rewrites. Therefore, even if we restrict to molecules which have to do with lambda terms, we see that in chemlambda the application and abstraction are embodied, they are made of matter, be it atoms or molecules. Chemical reactions are like reductions in lambda calculus, or more general, they are graph rewrites. In Alchemy the function of the molecule is the normal form of the lambda term it represents. In chemlambda there is no function, in the sense that there may be actually several, or none, depending on the interaction with other molecules. I believe that this view is closer to Nature than the classical, pervasive one, and that it might help the understanding of the inner working of bio molecules.
What needs to be done. Many things:
- if we use chemlambda with a model of choice, ranging from stupid to intelligent, nevertheless there are new things to learn if you want to program with it. Only by looking at the exploration of the stupid model, started with the scripts made by this mathematician (see the github repo), one has a feeling of overwhelming in front of a new continent. There are many questions to be answered, like: what is the exact rigorous relation between recursion and self-reproduction, seen in chemlambda? how to better program without passing values, as chemlambda proposes? how to geometrize this sort of computation, because when translated to chemlambda many programs are made mostly of currying and uncurrying and other blind procedures which are really not necessary in this model? what is the exact relation between various priority choices and various evaluation strategies in usual programming? how to program without functions, i.e. without extensionality?
In order to answer to such questions are needed CS professionals.
- visualizations of graphs (molecules) and their rewrites are not needed for the formalism to work, but they are helpful for learning how to use it. Like it or not, but most of our brains process non linguistic stuff, and as you know an image is worthy a 1000 words. Finding good ways to visualize chemlambda and the various models helps learning to use it and it offers as well a bridge towards less IT sophisticated researchers, like chemists or biologists.
Help me to build a better chemlambda gui. Step by step, according to opportunistic needs of the explorers, there is no blueprint to execute here.
- as for the decentralized computing fork of the project, this is not hard to do in principle, or at least this is how it appears to this mathematician. However, in practice there are certainly ways better than others to do this.
Again CS guys are needed here. But leave at the door, please, process calculi, CRNs and other ornaments, and after that look at the body under the dress. Does the dress falls well over that body, or if not what is to be done? Ornaments are only a cheap way to trick the customer.
- for the real chemistry branch, real chemists are needed. This is way outside of my competences, but it may be helpful for you, the biochemist. If so, then I have something to learn as well, and maybe you’ll see that a mathematician is much more useful than only as a source of equations and correct probabilistic calculus.
Real chemists, with labs and knowledge about this are needed here! Let’s discuss less about making molecules to do boolean algebra and more about making them into embodied programs.
What do I need for the program. Money, of course. Funds. Brain time. Code. Proofs. Experiments.