This is the 7th (continuing from part I and part II and part III and part IV and part V and part VI) in a series of expository posts where we put together in one place the pieces from various places about:
- how is treated lambda calculus in chemlambda
- how it works, with special emphasis on the fixed point combinator.
I hope to make this presentation self-contained. (However, look up this page, there are links to online tutorials, as well as already many posts on the general subjects, which you may discover either by clicking on the tag cloud at left, or by searching by keywords in this open notebook.)
_________________________________________________________
This series of posts may be used as a longer, more detailed version of sections
- The chemlambda formalism
- Chemlambda and lambda calculus
- Propagators, distributors, multipliers and guns
- The Y combinator and self-multiplication
from the article M. Buliga, L.H. Kauffman, Chemlambda, universality and self-multiplication, arXiv:1403.8046 [cs.AI], which is accepted in the ALIFE 14 conference, 7/30 to 8/2 – 2014 – Javits Center / SUNY Global Center – New York, (go see the presentation of Louis Kauffman if you are near the event.) Here is a link to the published article, free, at MIT Press.
_________________________________________________________
In this post I take a simple example which contains beta reduction and self-multiplication.
Maybe self-multiplication is a too long word. A short one would be “dup”, any tacit programming language has it. However, chemlambda is only superficially resembling to tacit programming (and it’s not a language, arguably, but a GRS, nevermind).
Or “self-dup” because chemlambda has no “dup”, but a mechanism of self-multiplication, as explained in part VI.
Enough with the problem of the right denomination, because
“A rose by any other name would smell as sweet”
as somebody wrote, clearly not believing that the limit of his world is the limit of his language.
Let’s consider the lambda term (Lx.xx)(Ly.yz). In lambda calculus there is the following string of reductions:
(Lx.xx)(Ly.yz) -beta-> (Ly.yz) (Lu.uz) -beta-> (Lu.uz) z -beta-> zz
What we see? Let’s take it slower. Denote by C=xx and by B= Ly.yz. Then:
(Lx.C)B -beta-> C[x:=B] = (xx)[x:=B] = (x)[x:=B] (x)[x:=B] = BB = (Ly.yz) B -beta-> (yz)[y:=B] = (y)[y:=B] (z)[y:=B] = Bz = (Lu.uz)z -beta=> (uz)[u:=z] = (u)[u:=z] (z)[u:=z] = zz
Now, with chemlambda and its moves performed only from LEFT to RIGHT.
The g-pattern which represents (Lx.xx)(Ly.yz) is
L[a1,x,a] FO[x,u,v] A[u,v,a1] A[a,c,b] L[w,y,c] A[y,z,w]
We can only do a beta move:
L[a1,x,a] FO[x,u,v] A[u,v,a1] A[a,c,b] L[w,y,c] A[y,z,w]
<–beta–>
Arrow[a1,b] Arrow[c,x] FO[x,u,v] A[u,v,a1] L[w,y,c] A[y,z,w]
We can do two COMB moves
Arrow[a1,b] Arrow[c,x] FO[x,u,v] A[u,v,a1] L[w,y,c] A[y,z,w]
2 <–COMB–>
FO[c,u,v] A[u,v,b] L[w,y,c] A[y,z,w]
Now look, that is not a representation of a lambda term, because of the fact that FO[c,u,v] is “in the middle”, i.e. the middle.in port of the FO[c,u,v] is the out port of B, i.e. the right.out port of the lambda node L[w,y,c]. On the same time, the out ports of FO[c,u,v] are the in ports of A[u,v,b].
The only move which can be performed is DIST, which starts the self-dup or self-multiplication of B = L[w,y,c] A[y,z,w] :
FO[c,u,v] A[u,v,b] L[w,y,c] A[y,z,w]
<–DIST–>
FI[e,f,y] FO[w,g,h] L[h,e,v] L[g,f,u] A[u,v,b] A[y,z,w]
This is still not a representation of a lambda term. Notice also that the g-pattern which represents B has not yet self-multiplied. However, we can already perform a beta move for L[g,f,u] A[u,v,b] and we get (after 2 COMB moves as well)
FI[e,f,y] FO[w,g,h] L[h,e,v] L[g,f,u] A[u,v,b] A[y,z,w]
<–beta–>
FI[e,f,y] FO[w,g,h] L[h,e,v] Arrow[g,b] Arrow[v,f] A[y,z,w]
2 <–COMB–>
FI[e,f,y] FO[w,b,h] L[h,e,f] A[y,z,w]
This looks like a weird g-pattern. Clearly is not a g-pattern coming from a lambda term, because it contains the fanin node FI[e,f,y]. Let’s write again the g-pattern as
L[h,e,f] FI[e,f,y] A[y,z,w] FO[w,b,h]
(for our own pleasure, the order of the elements in the g-pattern does not matter) and remark that A[y,z,w] is “conjugated” by the FI[e,f,y] and FO[w,b,h].
We can apply another DIST move
L[h,e,f] FI[e,f,y] A[y,z,w] FO[w,b,h]
<–DIST–>
A[i,k,b] A[j,l,h] FO[y,i,j] FO[z,k,l] FI[e,f,y] L[h,e,f]
and now there is only one move which can be done, namely a FAN-IN:
A[i,k,b] A[j,l,h] FO[y,i,j] FO[z,k,l] FI[e,f,y] L[h,e,f]
<–FAN-IN–>
Arrow[e,j] Arrow[f,i] A[i,k,b] A[j,l,h] FO[z,k,l] L[h,e,f]
which gives after 2 COMB moves:
Arrow[e,j] Arrow[f,i] A[i,k,b] A[j,l,h] FO[z,k,l] L[h,e,f]
2 <–COMB–>
A[f,k,b] A[e,l,h] FO[z,k,l] L[h,e,f]
The g-pattern
A[f,k,b] A[e,l,h] FO[z,k,l] L[h,e,f]
is a representation of a lambda term, finally: the representation of (Le.ez)z. Great!
From here, though, we can apply only a beta move at the g-pattern A[f,k,b] L[h,e,f]
A[f,k,b] A[e,l,h] FO[z,k,l] L[h,e,f]
<–beta–>
Arrow[h,b] Arrow[k,e] A[e,l,h] FO[z,k,l]
2 <–COMB–>
FO[z,k,l] A[k,l,b]
which represents zz.
_____________________________________________________
Like this:
Like Loading...