WireWorld Extendable 3
Mark Jeronimus
first. I'm a computer science student and passionate hobbyist and I'm
always interested in very various fields ranging from Fractals to QR
codes, and this doesn't exclude Cellular Automata.
To satisfy my passion, I've made an automaton based on WireWorld that
is universally extendable without compromising universal
computability. I've called it WWE3 (see below why).
This is not the first extendable WireWorld variant, but it is, as far
as I know, the only one with as little as 11 different states. Other
variants to my knowledge, WWE and WWE2, both by Alan Tennant, use 17
and 23 states, respectively.
This WireWorld Extendable automaton can operate a common construction
or read/write arm using special functions (FORWARD, RETRACT, LEFT,
RIGHT) and at the end of an arm, a remote WIRE cell can be written,
read or erased using special photons (WRITE, READ). The special
functions are coded in different HEAD states (as opposed to TAIL
states). This is a choice I made this choice consciously and it has
nothing to do with doing it differently than WWE. In fact, I had this
idea before I got to know WWE but didn't have enough inspiration back
then. Actually it is more based on Hutton32.
### I've included the RuleTable (in Golly format, see below), golly
colors, golly icons and example designs in a zip file at
http://www.darkwired.nl/~zombie/CA/WWE3.zip
Within the rules, there are some situations which can be parametrized
trivially. More precisely, with very small changes, the rules can
change the behavior of the READ and WRITE head in ways to suit the
user's preferences. These three combinations are possible:
1. Write will write a cell, Read will leave the cell untouched
2. Write will write a cell, Read will erase a cell it reads
3. Write will toggle a cell, Read will erase a cell it reads
I've quickly eliminated option 1 because it leaves no possibility
whatsoever to erase a remote cell.
Between options 2 and 3, I chose 2 because it will make some
structures much easier to build, yet it doesn't change the way "tapes"
can be read (either coaxially or from the side) or how structures can
be built. To change the to option 3, follow the instructions in
the .table file.
The RuleTable is in Golly-only format because in golly, the first rule
that applies is taken. Other applications exist where the last
applying rule is taken. For those programs, the RuleTable needs to be
modified.
For detailes about how and why it works, see the long story inside
the .table file.
For proof that it is still universally computable (and also for fun),
I've included some exampes:
- WWE3.rle contains all kinds of test cases that show what is possible
using the rules.
- WWE3program.rle shows a nice little pattern being constructed and
then fired, from a pre-existing string of special photons (the string
self-erases).
- WWE3builder1.rle shows a universal constructor which will build a
structure from codes stored in a data tape. The timing for the READ
photons comes from a timing feeler that grows just as fast as the
reading arms, in order to time the READ photon intervals. This
prevents the incoming bits that have been read from colliding with new
read commands, regardless of the length of the tape.
- WWE3builder2.rle same as above, but uses a concrete timer instance
to time the READ photon intervals. I actually built this before I
built WWE3builder1 because I don't like timing feelers. This one
includes a lot of notes.
Other things that can be built (I see no reason why not) are a self-
replicator, quadratically growing spacefiller, programmable computer/
constructor, self-growing prime number sieve.
I think this is the best place to share this automaton with the world
and I'd like to hear your opinions. Also, I'd like to see what
structures others can come up with.
I also hope you like the new colors. The standard WireWorld colors in
Golly make things hard to see IMO (both on my CRT and TFT).
Regards,
Mark Jeronimus
Frank Buss
> This is the first time I post here, so let me introduce myself a bit
> first. I'm a computer science student and passionate hobbyist and I'm
> always interested in very various fields ranging from Fractals to QR
> codes, and this doesn't exclude Cellular Automata.
>
> To satisfy my passion, I've made an automaton based on WireWorld that
> is universally extendable without compromising universal
> computability. I've called it WWE3 (see below why).
>
> This is not the first extendable WireWorld variant, but it is, as far
> as I know, the only one with as little as 11 different states. Other
> variants to my knowledge, WWE and WWE2, both by Alan Tennant, use 17
> and 23 states, respectively.
There is Codd's cellular automaton with 8 states:
http://en.wikipedia.org/wiki/Codd%27s_cellular_automaton
It is computation- and construction-universal. I didn't study your
automaton, maybe you can write something about the differences compared to
your automaton? The wire concept of Codd's automaton sounds like it has
some common ideas with the WireWorld automata.
--
Frank Buss, f...@frank-buss.de
http://www.frank-buss.de, http://www.it4-systems.de
Tim Tyler
> There is Codd's cellular automaton with 8 states:
>
> http://en.wikipedia.org/wiki/Codd%27s_cellular_automaton
This makes me wonder if Langton's loops are *really* not universal:
http://en.wikipedia.org/wiki/Langton's_loops
--
__________
|im |yler http://timtyler.org/ t...@tt1lock.org Remove lock to reply.
Mark Jeronimus
> There is Codd's cellular automaton with 8 states:
>
> http://en.wikipedia.org/wiki/Codd%27s_cellular_automaton
>
> It is computation- and construction-universal. I didn't study your
> automaton, maybe you can write something about the differences compared to
> your automaton? The wire concept of Codd's automaton sounds like it has
> some common ideas with the WireWorld automata.
Codd is not a WireWorld variant. Wires in Codd are like tubes, where
the data is contained in a sheath, and hence it is much more bulky.
Regards,
Mark Jeronimus