latest results + request

[Tim Hutton]

Hello everyone,

Here's a report on Organic Builder things, since it's been a bit quiet
here. The latest server logs show the following stats:

Levels solved: 2564

Unique IP addresses: 286

By level:

Level 1 solved by 236 unique IPs (309 total)
Level 2 solved by 187 unique IPs (234 total)
Level 3 solved by 166 unique IPs (198 total)
Level 4 solved by 166 unique IPs (205 total)
Level 5 solved by 163 unique IPs (214 total)
Level 6 solved by 138 unique IPs (163 total)
Level 7 solved by 112 unique IPs (130 total)
Level 8 solved by 116 unique IPs (135 total)
Level 9 solved by 127 unique IPs (150 total)
Level 10 solved by 124 unique IPs (150 total)
Level 11 solved by 121 unique IPs (148 total)
Level 12 solved by 104 unique IPs (152 total)
Level 13 solved by 107 unique IPs (133 total)
Level 14 solved by 61 unique IPs (80 total)
Level 15 solved by 43 unique IPs (55 total)
Level 16 solved by 39 unique IPs (43 total)
Level 17 solved by 23 unique IPs (26 total)
Level 18 solved by 29 unique IPs (31 total)
Level 19 solved by 6 unique IPs (8 total)

By month:

Sep : 690
Oct : 171
Nov : 91
Dec : 497
Jan : 241
Feb : 103
Mar : 192
Apr : 16
May : 153
Jun : 184
Jul : 226

The later levels are harder, so the number of solutions drops - or
maybe people get bored by then?

The numbers have been picking up a bit in the last couple of months,
perhaps because the Organic Builder was mentioned in Christof
Teuscher's tutorial at ALife X.
http://www.teuscher.ch/tikiwiki/tiki-index.php?page=AlifeX+Tutorial

But here's the main reason I'm writing: there's a special issue on
Artificial Chemistries to appear in the Artificial Life journal:
http://lists.idyll.org/pipermail/alife-announce/2006-July/000354.html
It struck me that at least two noteworthy creations have been
discovered as a result of people playing around with the rules of the
Organic Builder, and this experiment in public design of artificial
chemistries could be written up as a report for that special issue. So
here's my request: please write to this list with anything interesting
you've created using the Organic Builder, and even if it turns out
that there's not enough for a paper, it will have been fun to see what
everyone has been up to.

Thanks,

Tim

--
Tim Hutton - http://www.sq3.org.uk

[Christopher LaSota]

Tim,

Congratulations on the publicity. I wish I had something to contribute
for your paper, but alas, my teaching and research have left little time
for interesting things. I experimented with level 14 by first making
the chain loop around and bind its ends together. The new atoms are
then all forced to line up on the correct side of the chain (the
exterior of the loop). Because the template surface is radially exposed
to the environment, the duplication step forms a bit faster than the
"ladder growth" technique. The problem is that forming the initial loop
takes longer than the ladder method. I never found a method that was
"foolproof". Fun stuff.

I had a question which may have been asked before, so please forgive me
if I've been underwater for too long. Is it possible to add a feature
to Organic Builder where the rules one creates could use a variable for
the numerical state on the left side of the reaction? As an example,
suppose I wanted an "a13" atom to bind to any other "a" atom and have a
result of "a13a14". In other words, in the selection lists for the
state (0-49), perhaps you could add "n" to mean any number.

Just an idea.

Cheers,

Chris LaSota
Physics Dept.
Kenyon College
http://physics.kenyon.edu/people/lasota/lasota.html

[tim.h...@gmail.com]

Hi Chris,

The looped DNA idea is very interesting - especially since prokaryotic
cells have circular DNA. In 2D of course there is a problem of repeated
replication, analagous to the unknotting problem of circular DNA in 3D.

In fact, in 2D there is the interesting possibility that the 'DNA'
could itself form the membrane of a cell, keeping chemical compounds
inside and interacting with the outside world. It might be worth
exploring how this would work.

Regarding variables for atom states, this would make sense, I might add
it to the Organic Builder applet. The 'x' and 'y' variables for atom
type are just there to save having to write out the reactions in full,
and don't add any special function, so there would be no problem with
adding variables for states, maybe 'i' and 'j'? In the past I've tended
to avoid this since I never came across the need for them but if people
would find them useful I will.

Thanks,

Tim

[Tim Hutton]

Hello Organic Builder users,

A while back I mentioned that I might be putting together a report
about OB for the artificial life journal. I am pleased to report that
this paper has been accepted!

Here's a draft:
http://www.sq3.org.uk/papers/ob_report.pdf (691kb)

If you've got any suggestions for improvements or things to add, then
just let me know. I've got a few days to let them know a page length,
and then the final paper is due in April.

Dave and Ralph have seen this already, in case you were wondering.

Thanks to everyone for the interest in OB.

Tim

On 01/08/06, Tim Hutton <tim.h...@gmail.com> wrote:
> Hello everyone,
...

[Pessimis...@gmail.com]

I dunno exactly the method used by other people, but in case mine is
any different, here's my solve for level 16

a3a4 => a2a2 *turns that pesky a3 and a4 into a2s, so you have a solid
ring
a0 + a2 => a0a3 *whenever a spare yellow appears, attach it to one of
the molecules in the ring, and signify whichmolecule it connected to.
This step then occurs
again, when the 1bonded a0 hits a neighbor
of the molecule it attached to
a3a3 => a2 + a2 *once this double a3 is noted, that means there is a
triangle between the two ring molecules and the new molecule, so you
can take out the 'base' of
the triangle, and change them back to a2s in
case the next a0 hits the same place
a2a0 => a2a2 * just sets the newest a0 to a normal part of the ring

I only mention this solution since the a3a4 seems to indicate that the
author had a different approach in mind. Instead, I drew inspiration
from how a cell takes in a vacuole. It merges the bubble to the
outside of the wall, and then breaks the wall underneath it so that
the organelles (or the f1 if you prefer) never has a chance to exit,
because the wall is never broken.

[Tim Hutton]

Hi PessimistByNature,

Thanks for writing! (I wish more OB users would...)

Your solution works fine as a solution to level 16. That
triangle-based insertion procedure is exactly what I had in mind for
the solution (not that this is relevant).

So why the a3-a4 pair? Well, consider what happens when two a0 atoms
happen to join at the same time. We would end up with:

a0 a0
| |
---a3---a3---

And the third reaction would then break the membrane! For a real cell
this would be fatal...

I came across this problem for real when I was trying to get my cell
model to work. I couldn't understand why every so often the cell
membrane would break, and it took me a while to track down.

If you run your solution several times you will eventually see this
happen. Of course OB doesn't demand that its solutions work all the
time, so that doesn't matter. The a3-a4 pair was just to provide a
unique starting point to avoid the breakage problem.

And so the obvious question is: does a solution exist that would work
100% of the time on level 16 if we hadn't provided that a3a4 pair?

(In my evolving cells paper I use a 3-way reaction (OB doesn't support
these) for membrane growth, as a cop-out.)

Tim

--
Tim Hutton - http://www.sq3.org.uk

Take the Organic Builder challenge -
http://www.sq3.org.uk/Evolution/Squirm3/OrganicBuilder/

[Ralph Hartley]

Tim Hutton wrote:

> And so the obvious question is: does a solution exist that would work
> 100% of the time on level 16 if we hadn't provided that a3a4 pair?

Certainly! You can make your own a3a4 by:

f1 + a2 => f2a5
a5a2 => a6a4
a6f2 => a3 + f3

A equally obvious question is: is it possible with neither the a3a4 pair
nor the f1.

I think it is, but it is *much* harder.

Ralph Hartley

[Tim Hutton]

Here's a solution to this problem. It relies on the fact that there
are 8 atoms in the loop. There is a single rare failure case
(mentioned below) but it otherwise works reliably.

Working on this problem and related ones has suggested several
possible improvements to OB:

a) We could do with an extra symbol for reversible reactions, to save
having to write them out twice. The possiblity of using reversible
reactions (reaction selection is random) needs to be mentioned on the
help pages. No challenge currently requires them but I think we should
think of some that do. (I don't use reversible reactions in this
solution.)

b) Some challenges are more interesting if we demand that they work
reliably - we could demand that they succeed in 20 test runs, for
example?

c) At some point we will need debugging facilities. Eg. step back
through the last few reactions, seeing what happened.

Tim

// ============================================
// Starting point: level 16 "grow"

// Problem: if the a3a4 starting point hadn't been provided, and the
f1 atom wasn't there,
// how can we reliably grow the membrane without breaking it?

// Approach: first determine a unique gate point, and grow from there.
(There is currently no known
// method for growing a membrane at arbitrary multiple points
simultaneously, without risk of breaking.)
// Use an increasing signal to determine completion, and
attempt-and-retract until that completion is reached.

// Caveats: the method below uses the fact that the loop is exactly 8
atoms long - solving this for
// loops of an unknown length is much harder, perhaps impossible?
Picture two scenarios: a single
// atom bonding to a loop of length N, and two atoms simultaneously
bonding at opposite sides of
// a loop of length 2N. How can we distinguish between these two
scenarios using just signals (or
// anything else)?

// Testing: "number of atoms" set to 30 and a world size of 360x360
gives almost a worst-case
// situation for membrane growth, giving sometimes quite protracted
negotiation. The solution is intended
// to work all the time - please report configurations where it gets stuck.

// Known defects: only one case is known to cause a problem - where
four a0's bond simultaneously to
// alternate membrane atoms. Please suggest a way to solve this!

// Remove the provided starting point
a3a4->a2a2

// Allow one atom to bond
a0+a2->a5a6

// Spread the signal, counting how far we've got.
// State 8 is used to indicate where we've been, and should only be
found between our starting a7
// and the head of the signal.
a6a2->a7a9
a9a2->a8a10
a10a2->a8a11
a11a2->a8a12
a12a2->a8a13
a13a2->a8a14
a14a2->a8a15

// There are two retraction triggers: 101 and 107.

// Retraction for state 101. We keep the 'debonder' state (104)
protected from the a2's we leave behind, in case
// a new a0 bonds to one of them in the meanwhile, and becomes an a7
before we've moved on (rare but
// possible).
a101a8->a103a104
a104a8->a105a8
a103a105->a2a101
a104a7->a106a102
a103a106->a2a2

// Retraction for state 107
a107a7->a2a102

// Final stage of retraction: 102 causes unbonding
a102a5->a2+a0

// If a14 or lower reaches an a7 then we know that this isn't us
because the loop is length 8 - we retract.
// Here we use state 101 because we don't want the unbonding to act on
this a7, and we know that
// there are a8's behind the signal being retracted
a14a7->a101a7
a13a7->a101a7
a12a7->a101a7
a11a7->a101a7
a10a7->a101a7

// Trigger the same retraction if the signal encounters a signal
coming the other way!
// We use state 101 where there are known to be a8's behind the other
signal, and 107 where
// we know that there is just an a7 on the other side
a10a10->a10a101
a11a11->a11a101
a11a10->a11a101
a12a10->a12a101
a9a9->a9a107
a10a9->a10a107
a11a9->a11a107
a12a9->a12a107
a13a9->a13a107

// If our signal reaches an a6 then they can be safely removed without
needing us to retract.
a7a6->a7a102
a9a6->a9a102
a10a6->a10a102
a11a6->a11a102
a12a6->a12a102
a13a6->a13a102
a14a6->a14a102

// Allow for a special case where an atom bonds to every membrane atom
at the same time.
a6a6->a6a102
// NB. This reaction isn't necessary on level 16 because there are 6
a0's and 8 membrane atoms.
// And in fact this suggests another solution to the problem - join
the a0's together *first* into a single
// structure, and use that *when complete* (knowing this is the tricky
bit) to make a unique starting point.
// Perhaps this in itself would make a suitable level somehow?
// We leave this reaction here in order that the solution doesn't need
to make any assumptions about the
// number of a0's available.

// If an a15 appears then we have succeeded in establishing a unique
point - can proceed with the growing.
a5+a15->a16a17
a17a7->a18+a8
a16a18->a15a19
a19+a0->a7a5

//===========================================

[Tim Hutton]

As an attachment to avoid line break issues when cutting-and-pasting...

[Ralph Hartley]

Tim Hutton wrote:
> Known defects: only one case is known to cause a problem - where four

> a0's bond simultaneously to alternate membrane atoms. Please suggest

> a way to solve this!

a9+a9=>a107+a107 ?

Ralph Hartley

[Tim Hutton]

Sadly not. What would often happen is this:

- a7 - a9 - a7 - a9 - a7 - (side links not shown)

- a7 - a107 - a7 - a107 - a7 -

- a102 - a2 - a7 - a2 - a102 -

- a2 - a2 - a7 - a2 - a2 -

where the 107's would retract the wrong a7's.