ConwayLife.com - A community for Conway's Game of Life and related cellular automata
Home  •  LifeWiki  •  Forums  •  Download Golly

Other Loop rules

For discussion of other cellular automata.

Other Loop rules

Postby Sphenocorona » February 22nd, 2014, 9:32 pm

So I was thinking, it would be nice if there was a rule similar to EvoLoop (in that loops can 'evolve') that is missing one or both of its sheaths, and the ability to turn both left and right. I'm not sure I fully understand how those rules work though, so it would be rather hard for me to create such a rule on my own. If anyone wants to create a rule like I described or other interesting Loop rules, post the finished rules here.
Sphenocorona
 
Posts: 478
Joined: April 9th, 2013, 11:03 pm

Re: Other Loop rules

Postby twinb7 » February 23rd, 2014, 1:08 am

Goucher loops are on the ruletable repository, which I find cooler because small size isn't selected for, as it is in Evoloop.
twinb7
 
Posts: 175
Joined: February 11th, 2014, 8:08 pm
Location: Ames, Iowa

Re: Other Loop rules

Postby c0b0p0 » May 1st, 2014, 4:08 pm

To extend the idea to its radical limit, how about an evolving "photon loop" that not only does away with the sheath, but with the wire as well? The only problem would be the construction, but that could probably be done with "moving signals" that moved the construction cell. With this kind of rule, loops would be much more immune to other loops, being able to pass through each other. Loops could also be very small.
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Re: Other Loop rules

Postby c0b0p0 » May 3rd, 2014, 5:54 pm

c0b0p0 wrote:To extend the idea to its radical limit, how about an evolving "photon loop" that not only does away with the sheath, but with the wire as well? The only problem would be the construction, but that could probably be done with "moving signals" that moved the construction cell. With this kind of rule, loops would be much more immune to other loops, being able to pass through each other. Loops could also be very small.

The EvoPhotonLoop seems to be rather problematic. The construction is quite easy, but normal loops in other rules first make a loop in one direction, then use a "wire-eater" to turn the "construction cell" into another portion of the loop and make another loop in a different direction. As you know, EvoPhotonLoop does not have wires, so I am trying to find another way to do this.
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Re: Other Loop rules

Postby Sphenocorona » May 4th, 2014, 1:05 am

It would almost certainly be possible to make a loop rule where there are tiny segments of sheathing on the outside of the corners of loops and at the end of the arm. It may not be as satisfactory, but it would work.
Sphenocorona
 
Posts: 478
Joined: April 9th, 2013, 11:03 pm

Re: Other Loop rules

Postby c0b0p0 » May 4th, 2014, 7:19 pm

@Sphenocorona: The rule that I'm thinking of would use one state to perform each operation on a photon, e.g., it would have "turner" and "splitter" cells at the corners of loops and would use different signals to perform operations on the "construction" cell.

I finally came up with a solution to the "wire-eater" problem, based on an "immune" signal that can pass through other signals and that is created when the construction of the child loop finishes. What happens next goes as follows.

1. The immune signal reaches a corner of the parent loop.
2. The splitter cell becomes a "turner + latcher" cell, not only turning the signal but giving its head a different state to signify that another signal is latched on to it.
3. When the "latched" signal reaches another turner cell, the turner cell becomes a "presplitter" cell and releases a "preconstruction" cell. The preconstruction cell at once changes into a construction cell and moves, while the presplitter cell changes into a splitter cell with a signal in it. The signal is then duplicated and sent towards the construction cell.
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Re: Other Loop rules

Postby simsim314 » May 5th, 2014, 3:25 pm

Here is a loop rule that works on reflectors and particles alone:
@RULE LoopParticles

@TABLE

# 0 dead
# 1 Tail
# 2 push constructor particle
# 3 create reflector particle
# 4 construction unit
# 5 reflection unit
# 6 duplication unit
# 7 special event state
# 8 special event state
# 9-11 states for closure

n_states:13
neighborhood:Moore
symmetries:rotate4reflect

var p={2,3}
var a = {0,1,2,3,4,5,6,7,8,9}
var b = {a}
var c = {a}
var d = {a}
var e = {a}
var f = {a}
var g = {a}
var h = {a}

var con1 = {0, 1, 4}
var con2 = {0, 1, 4, 5, 6}
var dup = {5,6}

#special case
1,0,8,0,0,0,0,0,0,8

#send particle 11
6,11,0,0,0,0,0,0,0,5


#particles move
0,p,0,con1,con2,a,b,0,0,p
p,a,b,c,d,e,f,g,h,1
1,a,b,c,d,e,f,g,h,0

#construction push
4,2,1,0,0,0,0,0,0,0
0,4,2,0,0,0,0,0,0,4

#construction reflect
4,3,1,0,0,0,0,0,0,5
0,4,3,1,0,0,0,0,0,7

#reflect
0,dup,0,p,1,0,a,b,c,p
0,p,dup,0,0,a,b,0,0,p

#duplicate
0,6,0,p,0,0,0,con1,0,p
0,5,7,0,0,0,0,0,0,8
7,5,1,0,0,0,0,0,0,8
0,8,5,8,0,0,0,0,0,7
8,5,8,7,0,0,0,0,0,0
0,7,8,0,0,0,0,0,0,7
7,7,7,0,0,0,0,0,0,0
7,7,0,7,0,0,5,0,0,0
0,7,7,7,0,0,0,0,0,4

#finish loop
0,4,2,0,1,2,0,0,0,8
8,1,2,0,0,0,1,0,0,0
1,0,8,0,0,0,0,0,0,8
0,8,3,0,0,0,0,0,0,9
0,1,3,0,0,9,8,0,0,9
0,9,9,8,0,0,0,0,0,7

#send particle 11
0,9,7,0,0,0,0,0,0,11
0,7,9,0,0,0,0,0,0,8
9,9,8,7,0,0,0,0,0,0
7,9,9,8,0,0,0,0,0,0
8,9,9,7,0,0,0,0,0,11
9,9,7,8,0,0,0,0,0,1
1,11,0,0,0,0,0,0,0,0
0,11,0,0,0,0,0,0,0,11
0,11,0,0,dup,0,0,0,0,11
11,1,0,0,0,0,0,0,0,1
0,11,0,dup,0,0,0,0,0,11
11,1,0,0,dup,0,0,0,0,1
0,11,8,0,0,0,0,0,0,5
8,11,0,0,0,0,0,0,0,0
11,8,0,0,0,0,0,0,0,1

#send particle with 6 back to 5
6,11,1,0,0,0,0,0,0,5
0,6,11,0,0,0,0,0,0,1
0,11,6,0,0,0,0,0,0,11
11,1,0,6,0,0,0,0,0,0
1,11,6,0,0,0,0,0,0,0
1,5,0,11,0,0,0,0,0,0
11,1,5,0,0,0,0,0,0,1
1,11,0,0,5,0,0,0,0,0
0,11,0,0,1,0,0,0,0,11

#particle 11 open gate
5,11,1,0,0,0,0,0,0,6
11,5,0,1,0,0,0,0,0,10
0,10,6,0,0,0,0,0,0,9
0,6,10,0,0,0,0,0,0,12
10,9,12,6,0,1,0,0,0,0
9,12,6,10,0,0,0,0,0,1
12,9,10,6,0,0,0,0,0,1
0,9,12,0,0,0,0,0,0,10
0,12,9,0,0,0,0,0,0,12

0,10,12,0,0,0,0,0,0,11
0,12,10,0,0,0,0,0,0,12
1,10,12,1,6,0,0,0,0,0
1,12,10,1,0,6,0,0,0,0
10,1,1,12,0,0,0,0,0,1
12,1,1,10,0,0,0,0,0,1
1,11,12,1,0,0,0,0,0,0
1,12,11,1,0,0,0,0,0,0
11,1,1,12,0,0,0,0,0,1
12,1,1,11,0,0,0,0,0,1
0,12,11,0,0,0,0,0,0,8
0,11,12,0,0,0,0,0,0,12
0,8,12,0,0,0,0,0,0,4
12,8,1,1,0,0,0,0,0,0
8,12,1,1,0,0,0,0,0,0
1,12,8,1,0,0,0,0,0,0
1,8,12,1,0,0,0,0,0,0

0,2,1,0,6,10,0,0,0,9
6,10,9,0,0,0,0,0,1,5
10,9,0,6,0,1,0,0,0,0
9,10,6,0,0,1,0,0,0,0

0,2,0,0,9,1,2,0,0,2
0,9,12,0,0,0,5,0,0,12

12,12,1,1,0,0,5,0,0,0
12,12,1,1,0,0,0,0,0,0
1,1,12,12,0,0,0,0,6,12
1,1,12,12,0,0,0,6,0,12

6,12,12,0,0,0,0,0,0,5
12,12,6,0,0,0,0,0,0,0
12,12,0,6,0,0,0,0,0,0


Here is the smallest loop (quadratic replicator):

x = 18, y = 13, rule = LoopParticles
2.E$2.AB.AB$.B10.F4.D$.A2$.B$.A2$.B$.A$E$.BA.BA.BA.CA$10.E!


Here is a bit larger loop:

x = 58, y = 53, rule = LoopParticles
2.E$.B.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB$.A50.F4.D2$.B$.A
2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.
A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$EA$2.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.
BA.BA.BA.BA.BA.BA.CA$50.E!


Here is a script to generate any size loop (change the variable "n" to set the size):

import golly as g


n = 50
g.setcell(1,-n,5)
g.run(1)

g.setcell(n + 1,-n+2,5)
g.setcell(n + 6,-n+2,4)
g.setcell(n - 1,2,5)

for i in xrange(0, n - 1):
   if i == n - 2:
      g.putcells(g.parse("C$A!"), 0, 3 * i)
   else:
      g.putcells(g.parse("B$A!"), 0, 3 * i)

      
g.run(3 * (n + 2))
g.setcell(-1,0,5)
g.run(3 * (n - 4))
g.setcell(n + 1,-n+2,6)
cells = g.getcells(g.getrect())
g.reset()
g.putcells(cells)
User avatar
simsim314
 
Posts: 1673
Joined: February 10th, 2014, 1:27 pm

Re: Other Loop rules

Postby simsim314 » May 5th, 2014, 3:51 pm

On my opinion, the loops are pretty boring by themselves, as the "dumb" replicators. So there is a few "futuristic" projects that can be done here:

1. First and simplest of all, is to create a loop that can hold DNA of quadratic size, using only linear time to replicate. With reflectors it can be done using "snake" pattern, in which the reflectors will be places in "linear" order, so their creation will be linear. but the snake will hold quadratic amount of data. This is possible only in this kind of loops, which based on reflection. So the "construction arm" can make shortcuts.

2. This will allow to use "extra DNA" for universal calculations. So the next challenge would be to integrate some sort of universal computing, inside the loop. The extra DNA left from replication in step 1. can be used to replicate the "brain" of the pattern.

3. Next due to reflection based design, the brain can "move" the reflectors so the reflectors based loop, can actually move in space. The main challenge would be to synchronize the movements, and allow the brain to move as well (that means the bran as well should be reflector based).

4. Having brain (and preferably movement), one can start to speak about communication between the loops. So the next challenge would be to use the brain to communicate send messages etc. could be even possible to make some male-female interaction and replication in this stage.

5. Finally having all of the above we can "limit resources" and have some competition. Let's say the construction unit dies after single replication, and should be "searched" for in space (think of vitamins in human). The construction units should be common, and easy to gain, but it needs to be recognized etc.

6. This competition setup could be very fun to compete as designers, for the "most efficient" replicator. Places inside same space, and same "basic unit" we can write different "brain algorithms" etc. to optimize the performance of these replicators. It's also can be a nice starting point toward evolutionary loops.

EDIT If I wasn't clear about the quadratic snake. Look at this pattern:

x = 58, y = 42, rule = LoopParticles
2.E2$52.E4.D3$3.E46.E3$5.E46.E3$3.E46.E3$5.E46.E3$3.E46.E3$5.E46.E3$
3.E46.E3$5.E46.E3$3.E46.E3$5.E46.E3$3.E46.E3$5.E46.E$E2$50.E!


With proper set of commands it takes O(N) time for the construction arm to build it. Now look at this:

x = 66, y = 49, rule = LoopParticles
5$6.E$6.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB$5.B50.E4.D
$5.A49.A$8.A.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.B$5.B.EB45.
E$5.A$8.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AC.AB.AB.AB.AB.AB$5.B3.E45.AE$
5.A49.B$8.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA$5.B.E46.E$
5.A2.A$8.B.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.A$5.C3.E45.BE
$5.A$8.BA.BA.BA.BA.CA8.BA.BA.BA.BA.BA.BA.BA.BA.BA$5.B.E46.E$5.A2.A$8.
B.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.A$5.B3.E45.BE$5.A$9.BA
.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA$5.B.EA45.E$5.A2.B$9.AB.
AB.AB.AB.AB.AB.AB.AB.AB.AB.AC.AB.AB.AB.AB.AB$5.B3.E46.E$5.A49.A$8.A.B
A.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.B$5.B.EB45.E$5.A$8.AB.AB.
AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB$5.B3.E45.AE$5.A49.B$8.BA.BA
.BA.BA.BA.BA.CA.BA.BA.BA.BA.BA.BA.BA.BA.BA$5.B.E46.E$5.A2.A$8.B.AB.AB
.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.A$5.B3.E45.BE$4.EA$6.BA.BA.BA
.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA.BA$54.E!


This loop contains O(N^2) genetic material. So as N growth, the replication part of it will get smaller and smaller, and a lot of the construction commands can go more and more for other functions.
User avatar
simsim314
 
Posts: 1673
Joined: February 10th, 2014, 1:27 pm

Re: Other Loop rules

Postby c0b0p0 » May 6th, 2014, 7:47 pm

@simsim314: Here's a gun:
x = 58, y = 53, rule = LoopParticles
2.E$.B.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB$.A50.F4.D2$.B$
.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B
$.A2$.B$.A2$.B$.A2$.B$.A2$.B$.A2$.B$EA$2.BA.BA.BA.BA.BA.BA.BA.BA.BA.B
A.BA.BA.BA.BA.BA.BA.CA$50.E!

Apparently the loops cannot send a "construction done" signal to the other loops, so fulfilling the OP's request is still a work in progress. Nevertheless, I think that your rule should go into the Rule Table Repository -- a small particle loop is unprecedented!

Here's a revision of stages 0-1 of the wire-eater problem.
0. When the construction is done, a signal is sent next to the outgoing signals. When touched by the head of the incoming signal, the outgoing signals are destroyed.
1. When the signal reaches a reflector, it is destroyed and Step 2 follows at once.
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Re: Other Loop rules

Postby simsim314 » May 7th, 2014, 3:43 am

c0b0p0 wrote:Apparently the loops cannot send a "construction done" signal to the other loops


There is no way to make loops without "construction done" signal. But because of some details concerning the loops circular design, which make the "space", a real issue, and so the closure of the loop needs addition states and rule to handle it correctly.

So here is how the closure of the loop works:

1. The final loop reaches the stream while it's still streaming so it needs to wait for the stream to finish (the finish is recognized by the "turn" operation.

Here is an example of what happens in the final stages, notice how "something" happens when the turn-op particle is passing:

x = 26, y = 17, rule = LoopParticles
2$.AC.AB.AB.AB.AB.AB.AB.AB2$15.D$14.B$14.A2$14.B$14.A2$14.B$14.A2$14.
C$14.A!


Notice that this happens only in one of the three possible cases:

x = 101, y = 22, rule = LoopParticles
4$6.AC.AB.AB.AB.AB.AB.AB.AB7.AC.AB.AB.AB.AB.AB.AB.AB8.AC.AB.AB.AB.AB.
AB.AB.AB2$19.D28.D29.D$18.B28.B29.B$18.A28.A29.A2$18.B28.B29.B$18.A
28.A29.A2$18.B28.B29.B$18.A28.A29.A2$18.C28.C29.C$18.A28.A29.A!


So you can't just change the phase of the loop, and expect it to work. The rule is designed having loops in mind, and very specific loops. You can modify the rule of course to perform in those cases as well, but I really see no point in doing that.

Now this didn't work entirely, because usually there will be a duplicator near by (and now it works):

x = 25, y = 17, rule = LoopParticles
$.AC.AB.AB.AB.AB.AB.AB.AB$12.F$15.D$14.B$14.A2$14.B$14.A2$14.B$14.A2$
14.C$14.A!


Notice the reflector created on 18-generation. This property should be "hard-coded" into the rule. You can't create this reflector using construction unit (at least not in the non "quadratic DNA" loops).

Now another detail to notice is "end loop operation particle". In the rule it's called particle 11. The major operations of particle 11 are: convert duplicator back into reflector, and convert reflector into duplicator + construction unit. You can't just finish with regular "end op" because you need to do some modification to the loop design. Closing duplicators (convert them into reflectors), and open reflectors to construction options. This is all done with particle 11.

x = 30, y = 10, rule = LoopParticles
2$10.F$2.AK16.AK$27.E2$12.E!


In this interaction the main issue is to create a construction unit 5 cells apart from the replication unit, this requires some extra states and rules, just to send signal "5 cells ahead".

----

I'm planning to create the "quadratic DNA" rule, which will create the "reflection shell" by construction ops alone. This rule should be more "logical" having less "specialized rules", and more "construction instructions options". Still the "self modification mechanism" that occurs in the end of replication, will require some additional state. I don't see a way to avoid it.
User avatar
simsim314
 
Posts: 1673
Joined: February 10th, 2014, 1:27 pm

Re: Other Loop rules

Postby c0b0p0 » May 20th, 2014, 7:14 pm

@simsim314: It seems like the best way to implement your "quadratic DNA" design might be to make GoucherParticleLoop (that is, a particle loop rule with left and right turn signals). For example, Goucher's "complex" loop looks suspiciously like your "quadratic DNA" design:
x = 33, y = 33, rule = GoucherLoops
13.5B$12.B.AG.AB$12.BG3BGB$12.BAB.B.B$9.4B.B.BAB$8.BAD.ADB.BEB$8.B.4B
2.B.B$8.BGB5.BAB$8.BA4B2.BEB4.5B$8.B.GA.GB.B.B3.BG.AE.C$9.4BAB.BAB3.B
A3BAB$12.B.B.BGB3.B.B.BEB$12.BDB.B.5BGB.B.4B$12.BAB.BAG.AG.AB.BAG.AGB
$.12B.B2.7B3.4B.B$BE.AG.AG.AG.ADB15.BAB$BA12B5.12BGB$B.B15.B.GA.GA.GA
.GA.B$BE4B3.7B2.BA12B$BA.GA.B.B.GA.GA.B.BGB$.4BGB.BA5BGB.B.B$4.BAB.BD
B3.BAB.BAB$4.B.3B.B3.B.B.BI4B$4.BGA.DAB3.BDB.B.4AB$5.5B4.BAB2.4BAB$
14.B.B5.BAB$14.BNB2.4BAB$14.BAB.B5AB$14.B.B.BA4B$14.BGB.BAB$14.BA3BAB
$14.B.G3AB$15.4BK!

However, Goucher used a "parasite" cell for evolution, and I don't know what might replace that.
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Re: Other Loop rules

Postby simsim314 » May 21st, 2014, 3:51 am

c0b0p0 wrote:It seems like the best way to implement your "quadratic DNA" design might be to make GoucherParticleLoop


Actually Goucher's loops have "left" and "right" operations, and the quadratic DNA loop, requires only "backward" operation that will also kill the "turning block" while "stepping back", and doesn't require "turn right".

Another worth considering approach is Tempesti's loop (comes with golly), the only other "space efficient" approach to loops. Tempesti thought of having "dynamic" building cell, instead of static in other rules. This allowed him to build a loop with only 4 operations for turning the "moving building cell" four time, and the other operations could go for construction. It's also can easily be converted into particle rule as well (or some can consider it to be "dense" photon particle rule, due to the fact it doesn't have any shells, and it uses "reflectors" to turn signals). It's only problem, as with other loops, is the linear storage. And although it can be modified to have quadratic storage, the approach in general is a "hacking" approach and not a "logical" one. With Tempesti one can't place the construction command anywhere, they all should be placed at exact places for correct timing. With particle approach, one can place the commands where he pleases, leaving a lot of "continuous" space for other construction operations.

Anyway as quadratic vs linear loops are considered, Tempesti have no advantage over particles. It's still require linear storage for construction operations (for quadratic storage case).
User avatar
simsim314
 
Posts: 1673
Joined: February 10th, 2014, 1:27 pm

Re: Other Loop rules

Postby c0b0p0 » June 5th, 2014, 10:41 pm

@simsim314: The reflectors might take O(N) signals to construct, but before the last reflector is produced (ending construction and leaving the loop empty) the loop must insert its tape into the framework, taking O(N^2) signals using vN-style construction!
Because of this, I have decided to try to make another particle loop rule. This rule can easily be extended to be capable of universal computation.
@RULE GoucherParticleLoop
#state 0 is blank
#state 1 is tail
#state 2 is head
#state 3 is right reflector
#state 4 is left reflector
#state 5 is construction cell
#state 6 is duplicator
#state 7 is special state
#state 8 is right turn
@TABLE
n_states:9
neighborhood:Moore
symmetries:rotate4
var a={0,1,2,3,4,5,6,7,8}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={0,3,4,5,6,7}
var j={i}
var k={i}
var l={i}
var m={i}
var n={i}
var o={i}
var p={2,8}
1,a,b,c,d,e,f,g,h,0
p,a,b,c,d,e,f,g,h,1
0,p,i,j,k,l,m,n,o,p
0,p,3,i,j,k,l,m,1,p
0,p,1,i,m,l,k,j,4,p
0,p,6,i,m,k,j,n,1,p
0,p,1,i,k,j,n,m,6,p
5,2,3,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,4,7
5,2,6,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,6,7
5,2,0,0,0,0,0,0,0,7
7,a,b,c,d,e,f,g,h,0
0,7,0,0,0,0,0,0,0,5
5,8,0,0,0,0,0,0,0,3
0,8,5,0,0,0,0,0,1,5
@COLORS
1 255 255 255 #white
2 0   0   255 #blue
3 255 0   0   #red
4 122 107 255 #lavender
5 0   255 255 #cyan
6 0   255 0   #green
8 255 128 128 #pale red
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Re: Other Loop rules

Postby c0b0p0 » June 6th, 2014, 8:52 pm

The loop rule is almost complete -- the only things needed now are the "construction done" signal and a method to duplicate the construction cells.
@RULE GoucherParticleLoop
#state 0 is blank
#state 1 is tail
#state 2 is head
#state 3 is right reflector
#state 4 is left reflector
#state 5 is construction cell
#state 6 is duplicator
#state 7 is special state
#state 8 is right turn
#state 9 is left turn
#state 10 is left duplicator constructor
#state 11 is right duplicator constructor
@TABLE
n_states:12
neighborhood:Moore
symmetries:rotate4
var a={0,1,2,3,4,5,6,7,8,9,10,11}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={0,3,4,5,6,7}
var j={i}
var k={i}
var l={i}
var m={i}
var n={i}
var o={i}
var p={2,8,9,10,11}
1,a,b,c,d,e,f,g,h,0
p,a,b,c,d,e,f,g,h,1
0,p,i,j,k,l,m,n,o,p
0,p,3,i,j,k,l,m,1,p
0,p,1,i,m,l,k,j,4,p
0,p,6,i,m,k,j,n,1,p
0,p,1,i,k,j,n,m,6,p
5,2,3,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,4,7
5,2,6,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,6,7
5,2,0,0,0,0,0,0,0,7
7,a,b,c,d,e,f,g,h,0
0,7,0,0,0,0,0,0,0,5
5,8,0,0,0,0,0,0,0,3
0,8,5,0,0,0,0,0,1,5
5,9,0,0,0,0,0,0,0,4
0,0,0,0,5,9,1,0,0,5
5,10,0,0,0,0,0,0,0,6
0,0,0,0,5,10,1,0,0,5
5,11,0,0,0,0,0,0,0,6
0,11,5,0,0,0,0,0,1,5
@COLORS
1 255 255 255 #white
2 0   0   255 #blue
3 255 0   0   #red
4 122 107 255 #lavender
5 0   255 255 #cyan
6 0   255 0   #green
8 255 128 128 #pale red
9 200 150 255 #pale lavender
10 200 255 255 #pale lavender-green
11 255 255 0   #red-green   
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Re: Other Loop rules

Postby c0b0p0 » June 8th, 2014, 8:21 pm

c0b0p0 wrote:we need ... a method to duplicate the construction cells

That turned out to be quite easy. I simply changed signal 10 to duplicate the construction cell and made a new signal to turn the duplicator into a left reflector.
@RULE GoucherParticleLoop
#state 0 is blank
#state 1 is tail
#state 2 is head
#state 3 is right reflector
#state 4 is left reflector
#state 5 is construction cell
#state 6 is duplicator
#state 7 is special state
#state 8 is right turn
#state 9 is left turn
#state 10 is left and right duplicator constructor
#state 11 is pre-duplicator-deletor
#state 12 turns duplicator into left reflector
@TABLE
n_states:13
neighborhood:Moore
symmetries:rotate4
var a={0,1,2,3,4,5,6,7,8,9,10,11,12}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={0,3,4,5,6,7}
var j={i}
var k={i}
var l={i}
var m={i}
var n={i}
var o={i}
var p={2,8,9,10}
1,a,b,c,d,e,f,g,h,0
p,a,b,c,d,e,f,g,h,1
0,p,i,j,k,l,m,n,o,p
0,p,3,i,j,k,l,m,1,p
0,p,1,i,m,l,k,j,4,p
0,p,6,i,m,k,j,n,1,p
0,p,1,i,k,j,n,m,6,p
5,2,3,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,4,7
5,2,6,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,6,7
5,2,0,0,0,0,0,0,0,7
11,a,b,c,d,e,f,g,h,1
0,11,i,j,k,l,m,n,o,11
0,11,3,i,j,k,l,m,1,11
0,11,1,i,m,l,k,j,4,11
0,11,6,i,m,k,j,n,1,12
0,11,1,i,k,j,n,m,6,11
0,12,i,j,k,l,m,n,o,12
12,a,b,c,d,e,f,g,h,1
6,12,a,b,c,d,e,f,g,4
7,a,b,c,d,e,f,g,h,0
0,7,0,0,0,0,0,0,0,5
5,8,0,0,0,0,0,0,0,3
0,8,5,0,0,0,0,0,1,5
5,9,0,0,0,0,0,0,0,4
0,0,0,0,5,9,1,0,0,5
5,10,0,0,0,0,0,0,0,6
0,0,0,0,5,10,1,0,0,5
5,10,0,0,0,0,0,0,0,6
0,10,5,0,0,0,0,0,1,5
@COLORS
1 255 255 255 #white
2 0   0   255 #blue
3 255 0   0   #red
4 122 107 255 #lavender
5 0   255 255 #cyan
6 0   255 0   #green
8 255 128 128 #pale red
9 200 150 255 #pale lavender
10 200 255 255 #pale lavender-green
11 122 230 255 #lavender-green

Coincidentally, this change makes for some special effects.
x = 31, y = 110, rule = GoucherParticleLoop
29.E9$29.J$29.A4$29.B$29.A4$29.B$29.A4$29.J$29.A59$.C$2.AJ26.F3$.B$.A
4$.B$.A4$.J$.A9$C$29.C!
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Re: Other Loop rules

Postby wildmyron » June 9th, 2014, 6:41 am

@simsim314: I really like your LoopParticle rule and I'm looking forward to it's extension if you decide to work on it further. Thank you also for the explanation of how it works - I had noticed that changing the position of the construction head resulted in loops that failed to complete, and now I see why.

While experimenting with this and other loop rules, I now see why you propose the backward operation. Even for loop rules with right and left turn built in to the rule and a complex loop shape which fills in the empty space, you still need a program 3/4 the length of the available program space. It seems obvious from your explanation now but for some reason I had to try building one to see why.

I've also been thinking about a fractal style loop shape. This could be another way to allow greater than linear program storage - but there seems to be a serious problem with this idea - namely the four fold symmetry. This is evident in most loops using four copies of the program to build the next loop, although Goucher Loops use five by extending the arm with the first copy (suppressing the turn operations to do so). To reuse part of the program to build a fractal shape essentially requires some form of recursion which I believe requires significantly greater complexity - something like the program execution model in Perrier loops. Without this recursion you end up with the same linear dependence between program length and storage.

------

c0b0p0 wrote:Because of this, I have decided to try to make another particle loop rule. This rule can easily be extended to be capable of universal computation.
...
The loop rule is almost complete -- the only things needed now are the "construction done" signal and a method to duplicate the construction cells.
...
That turned out to be quite easy. I simply changed signal 10 to duplicate the construction cell and made a new signal to turn the duplicator into a left reflector.

I like where you're going with this rule, it does have some peculiarities at the moment though - particularly trying to build a basic square loop (without considering the loop completion process). For reference:
x = 21, y = 18, rule = GoucherParticleLoop
.C$.B3.AB3.AB3.ABC$.A3$16.A$.B14.B$.A3$16.A$.B14.B$.A3$16.A$CBA3.BA3.
HA3.B3.E$16.F!

Firstly, due to the way the duplicator works it seems a loop would build it's child in a diagonally adjacent space, rather than directly adjacent.

Secondly, because of the spacing between signals, it's not even possible to store the program for a simple loop within the loop. While I was trying out a few ideas I changed the signal movement rules to the following:
0,p,i,c,d,e,f,g,o,p
0,p,3,i,j,e,l,m,1,p
0,p,1,i,m,e,k,j,4,p
0,p,6,i,m,e,j,n,1,p
0,p,1,i,k,e,n,m,6,p

I won't paste the whole rule to avoid confusion if you decide not to use this idea.

Most behaviour is still the same, e.g. here's my denser loop packing design which uses right and left turns (not optimal):
x = 21, y = 18, rule = GoucherParticleLoop
.C10.C$.B.AB.AB.C3.AB.AC$.A6.A3.B3.H$8.I3.A$.B3.D10.A$CA.IA3.AB.ABD2.
B$5.B2.D$5.A10.A$.C9.D.BA.B$.AB.ABD5.A3.C$12.B$.B7.D$.A2.DA.BA3.AB.AB
C$5.B3.H2.D$.H7.A6.A$.A3.A10.B$C.BA.B2.C11.E$5.C10.F!

However, the interaction with construction cells does change in some circumstances, which may be undesirable.
wildmyron
 
Posts: 1058
Joined: August 9th, 2013, 12:45 am

Re: Other Loop rules

Postby simsim314 » June 9th, 2014, 12:16 pm

wildmyron wrote:I really like your LoopParticle rule

Thx.

wildmyron wrote:To reuse part of the program to build a fractal shape


I was thinking a bit about this idea. And came up with alternative design: think of steps, that go in diagonal direction. Say Left->Right->Left->Right. So having (L>R)X8 we will advance in diagonal direction 8 units. Now we need to use special "turn operation" after 8 steps (8 circulations of the particle commands). So all we need is binary multiplier (something that pass every second signal, so placing three binary multipliers will pass every 8 signals). This will allow us to have linear capacity with only log(n) additional multipliers.

The only major disadvantage that I see to this approach is that if one want a huge capacity lets say million signals, so we can manage to place the multipliers and all, but the loop will need to make at least thousand circulations to build the whole loop, so it's very slow. On the other hand my quadratic approach will require about 4-8 thousand of operations to build the loop, and it will be free to build whatever else is needed.

Anyway I like this idea, just because it shows another approach to loop building mechanisms.
User avatar
simsim314
 
Posts: 1673
Joined: February 10th, 2014, 1:27 pm

Re: Other Loop rules

Postby dvgrn » June 9th, 2014, 1:41 pm

simsim314 wrote:
wildmyron wrote:To reuse part of the program to build a fractal shape


I was thinking a bit about this idea. And came up with alternative design: think of steps, that go in diagonal direction. Say Left->Right->Left->Right. So having (L>R)X8 we will advance in diagonal direction 8 units. Now we need to use special "turn operation" after 8 steps (8 circulations of the particle commands). So all we need is binary multiplier (something that pass every second signal, so placing three binary multipliers will pass every 8 signals). This will allow us to have linear capacity with only log(n) additional multipliers.

I haven't thought very seriously about whether this might really work, but another approach that occurred to me is to experiment with systems that use feedback to construct fractal, or even just pseudo-random-walk, paths.

Maybe during the loop-building stage, just a short "seed" segment of a loop would be constructed, but after that the next turn direction would be mutated depending on the direction of the last turn, plus some kind of feedback from bumping into previously constructed segments.

Then it would be a matter of trying lots of different initial "seed" segments and different mutation rules to find a system that wandered around for a good long time, but eventually happened to find its way back to bump into its starting point, to close the loop. No doubt most loops would fail to close (by heading off to infinity or getting stuck) or would close too soon -- but you only need one working seed+rule combination to make this work, and you could end up with a lot of cheap storage.

Maybe new arms would extend out from the loop-closing point to start a new copy, or copies -- there should be lots of room for custom construction code in a long enough loop.

... Even if this doesn't work, it would be interesting to see how simple the mutation rules could be made, while retaining the potential for complex loop outputs.
User avatar
dvgrn
Moderator
 
Posts: 5473
Joined: May 17th, 2009, 11:00 pm
Location: Madison, WI

Re: Other Loop rules

Postby c0b0p0 » June 9th, 2014, 10:11 pm

wildmyron wrote:Secondly, because of the spacing between signals, it's not even possible to store the program for a simple loop within the loop. While I was trying out a few ideas I changed the signal movement rules to the following:
0,p,i,c,d,e,f,g,o,p
0,p,3,i,j,e,l,m,1,p
0,p,1,i,m,e,k,j,4,p
0,p,6,i,m,e,j,n,1,p
0,p,1,i,k,e,n,m,6,p

I won't paste the whole rule to avoid confusion if you decide not to use this idea.

I noticed the problem as well, but I wanted to wait to solve it until I had finished everything else. For reference, here is the rule table applying your idea.
@RULE GoucherParticleLoop
#state 0 is blank
#state 1 is tail
#state 2 is head
#state 3 is right reflector
#state 4 is left reflector
#state 5 is construction cell
#state 6 is duplicator
#state 7 is special state
#state 8 is right turn
#state 9 is left turn
#state 10 is left and right duplicator constructor
#state 11 is pre-duplicator-deletor
#state 12 turns duplicator into left reflector
@TABLE
n_states:13
neighborhood:Moore
symmetries:rotate4
var a={0,1,2,3,4,5,6,7,8,9,10,11,12}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={0,3,4,5,6,7}
var j={i}
var k={i}
var l={i}
var m={i}
var n={i}
var o={i}
var p={2,8,9,10}
1,a,b,c,d,e,f,g,h,0
p,a,b,c,d,e,f,g,h,1
0,p,i,c,d,e,f,g,o,p
0,p,3,i,j,e,l,m,1,p
0,p,1,i,m,e,k,j,4,p
0,p,6,i,m,e,j,n,1,p
0,p,1,i,k,e,n,m,6,p
5,2,3,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,4,7
5,2,6,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,6,7
5,2,0,0,0,0,0,0,0,7
11,a,b,c,d,e,f,g,h,1
0,11,i,j,k,l,m,n,o,11
0,11,3,i,j,k,l,m,1,11
0,11,1,i,m,l,k,j,4,11
0,11,6,i,m,k,j,n,1,12
0,11,1,i,k,j,n,m,6,11
0,12,i,j,k,l,m,n,o,12
12,a,b,c,d,e,f,g,h,1
6,12,a,b,c,d,e,f,g,4
7,a,b,c,d,e,f,g,h,0
0,7,0,0,0,0,0,0,0,5
5,8,0,0,0,0,0,0,0,3
0,8,5,0,0,0,0,0,1,5
5,9,0,0,0,0,0,0,0,4
0,0,0,0,5,9,1,0,0,5
5,10,0,0,0,0,0,0,0,6
0,0,0,0,5,10,1,0,0,5
5,10,0,0,0,0,0,0,0,6
0,10,5,0,0,0,0,0,1,5
@COLORS
1 255 255 255 #white
2 0   0   255 #blue
3 255 0   0   #red
4 122 107 255 #lavender
5 0   255 255 #cyan
6 0   255 0   #green
8 255 128 128 #pale red
9 200 150 255 #pale lavender
10 200 255 255 #pale lavender-green
11 122 230 255 #lavender-green

wildmyron wrote:Firstly, due to the way the duplicator works it seems a loop would build it's child in a diagonally adjacent space, rather than directly adjacent.

That is not a coincidence; I figured that a duplicator working this way would be the easiest to program.
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Re: Other Loop rules

Postby simsim314 » June 15th, 2014, 10:17 am

dvgrn wrote: next turn direction would be mutated depending on the direction of the last turn, plus some kind of feedback from bumping into previously constructed segments.


I was thinking about this idea in direction of design (instead of trial and error), and although nothing fractal-ish came into my mind, I came up with some "quadratic loop" idea, although circular one.

We send particles call them A1 that push a construciton Block C1. When A1 hits C1 it becomes C2. Now we add a construction operation particle O1 at the end. When O1 Hits C1 it turns left, but when O1 hits C2 it creates a mutating state M1. Mutating state after hitting A1 Becomes M2 but it converts A1 to A2. A2 is also pushing C1 but it doesn't converts it to C2 like A1. M2 is transparent to A1 and A2 but come to be M1 again after O1 is passing through.

In the end having a signal of N push particles A1, and O1 in the end, we will create N mutating blocks M1 before we turn to left. Each M1 will convert each A1 to A2, so while we still have less than N, M1s we we will convert C1 to C2 and O1 will create another M1. Once we have all the particles "covered" with Ms, C1 will remain C1 and O1 will create a turn left block instead of M1. Notice that Each "batch" of signals is turning back M2s into M1s mutation state by the O1 in the end.

If this confusing I hope to create this loop case soon, but the idea is very "transparent", the same construction unit is used to create the mutation unit, and the turning unit. While a mutation is "acting" only on single "push" operation, so N push operations will require N mutating blocks before the turn can be allowed. Thus having N push operations, will require NxN pushes before the left turn.
User avatar
simsim314
 
Posts: 1673
Joined: February 10th, 2014, 1:27 pm

Re: Other Loop rules

Postby simsim314 » June 15th, 2014, 3:27 pm

Here is the implementation of this idea in my ParticleRule. But the idea can be implemented in any particle rule, and so solve the space problem which is common to all loop rules (this is N^2 efficiency, and can be implemented for any arbitrary large N).

@RULE QuadLoopParticles

@TABLE

# 0 dead
# 1 Tail
# 2 push constructor particle
# 3 create reflector particle
# 4 construction unit
# 5 reflection unit
# 6 duplication unit
# 7 special event state
# 8 special event state
# 9-11 states for closure

#13 - C2
#14 - A2
#15 - M1
#16 - M2

n_states:17
neighborhood:Moore
symmetries:rotate4reflect

var p={2,3}
var q={14,3}

var a = {0,1,2,3,4,5,6,7,8,9,14}
var b = {a}
var c = {a}
var d = {a}
var e = {a}
var f = {a}
var g = {a}
var h = {a}

var con1 = {0, 1, 4}
var con2 = {0, 1, 4, 5, 6}
var dup = {5,6}

#special case
1,0,8,0,0,0,0,0,0,8

#send particle 11
6,11,0,0,0,0,0,0,0,5


#particles move
0,p,0,con1,con2,a,b,0,0,p
p,a,b,c,d,e,f,g,h,1
1,a,b,c,d,e,f,g,h,0

#construction push

14,0,0,4,0,1,0,0,0,1


4,2,1,0,0,0,0,0,0,0
0,4,2,0,0,0,0,0,0,13

1,0,0,0,13,0,0,0,0,0
0,0,0,0,13,0,0,2,0,2
0,0,0,0,0,13,0,2,0,2
2,0,0,0,13,0,0,1,0,1

2,0,0,0,0,13,0,1,0,0
1,0,0,2,13,0,0,0,0,0
13,2,0,0,0,0,0,0,1,0
0,0,0,0,0,0,0,13,2,13

0,0,0,0,13,0,0,3,0,3
0,0,0,0,0,13,0,3,0,3
3,0,0,0,13,0,0,1,0,1

0,1,3,13,0,0,0,0,0,15
0,0,0,0,0,0,0,13,3,4
1,0,0,3,13,0,0,0,0,0
3,0,0,0,0,13,0,1,0,0
13,3,0,0,0,0,0,0,1,0

0,0,0,0,15,0,0,2,0,2

0,0,0,0,0,15,0,2,0,14
2,0,0,0,15,0,0,1,0,1
15,0,0,0,0,0,0,0,2,16
0,0,0,0,4,0,16,14,0,14
14,0,0,0,0,16,0,1,0,1
1,0,0,14,16,0,0,0,0,0
1,0,0,14,0,16,0,0,0,0
14,0,0,0,4,0,16,1,0,1
0,0,0,0,0,4,0,14,0,14
0,0,0,1,16,0,0,2,0,2
1,0,0,14,4,0,16,0,0,0
14,0,0,0,0,4,0,1,0,0
4,14,0,0,0,0,0,0,1,0
0,0,0,0,0,0,0,4,14,4

0,0,0,1,0,16,0,2,0,2
2,0,0,0,16,0,0,1,0,1
0,0,0,0,0,0,16,2,0,2
2,0,0,0,0,16,0,1,0,1
1,0,0,2,16,0,0,0,0,0
1,0,0,2,0,16,0,0,0,0
2,0,0,0,0,0,16,1,0,1
0,0,0,0,4,0,0,2,0,2
1,0,0,2,0,0,16,0,0,0
0,0,0,1,0,0,16,2,0,2

0,0,0,1,16,0,0,3,0,3
0,0,0,1,0,16,0,3,0,3
3,0,0,0,16,0,0,1,0,1

1,0,0,3,16,0,0,0,0,0
3,0,0,0,0,16,0,1,0,1
0,0,0,1,0,0,16,3,0,3
0,0,0,1,0,0,16,3,0,3
3,0,0,0,0,16,0,1,0,1
1,0,0,3,16,0,0,0,0,0
16,3,0,0,0,0,0,0,1,15
1,0,0,3,0,15,0,0,0,0
3,0,0,0,0,0,15,1,0,1
0,0,0,1,0,0,0,3,0,3
1,0,0,3,0,0,15,0,0,0
0,0,0,0,0,0,16,14,0,14

0,0,0,0,0,0,0,14,0,14
14,0,0,0,0,0,16,1,0,1
1,0,0,14,0,0,16,0,0,0
14,0,0,0,0,0,0,1,0,1
0,0,0,0,15,0,0,14,0,14

0,0,0,0,0,15,0,14,0,14
14,0,0,0,15,0,0,1,0,1
1,0,0,14,15,0,0,0,0,0
14,0,0,0,0,15,0,1,0,1
0,0,0,0,4,0,15,14,0,14

1,0,0,14,0,15,0,0,0,0
14,0,0,0,4,0,15,1,0,1
0,0,0,0,0,4,0,14,0,14
0,0,0,1,15,0,0,2,0,2
1,0,0,14,4,0,15,0,0,0
0,0,0,1,0,15,0,2,0,2

15,2,0,0,0,0,0,0,1,16
1,0,0,2,15,0,0,0,0,0
2,0,0,0,0,15,0,1,0,1
0,0,0,0,0,0,15,2,0,14

0,0,0,0,0,0,15,14,0,14
15,14,0,0,0,0,0,0,1,15

0,0,0,0,0,0,15,2,0,14
0,0,0,0,4,0,0,14,0,14
14,0,0,0,4,0,0,1,0,1
14,0,0,0,0,0,15,1,0,1
1,0,0,14,0,0,15,0,0,0
0,0,0,1,0,0,15,2,0,14
0,0,0,1,0,0,0,14,0,14
0,0,0,1,15,0,0,14,0,14
0,0,0,1,0,15,0,14,0,14
0,0,0,1,0,0,15,14,0,14

#construction reflect
4,3,1,0,0,0,0,0,0,5
0,4,3,1,0,0,0,0,0,7

#reflect
0,dup,0,p,1,0,a,b,c,p
0,p,dup,0,0,a,b,0,0,p

0,0,0,0,5,0,0,14,0,14
14,0,0,0,5,0,0,1,0,1
0,14,0,5,0,0,0,0,1,2
0,0,0,1,2,0,0,14,0,14
0,0,0,0,5,1,0,14,0,14
14,0,0,0,1,0,0,1,0,1
0,14,0,5,0,1,0,0,1,2

#duplicate

0,0,0,0,0,6,0,14,0,2
0,0,0,1,6,1,0,14,0,14
0,0,0,1,0,6,0,14,0,2
0,14,0,6,0,1,0,0,1,2

0,6,0,q,0,0,0,con1,0,q
0,5,7,0,0,0,0,0,0,8
7,5,1,0,0,0,0,0,0,8
0,8,5,8,0,0,0,0,0,7
8,5,8,7,0,0,0,0,0,0
0,7,8,0,0,0,0,0,0,7
7,7,7,0,0,0,0,0,0,0
7,7,0,7,0,0,5,0,0,0
0,7,7,7,0,0,0,0,0,4

0,0,0,0,6,0,0,14,0,14
0,14,0,6,0,0,0,0,1,2
0,0,0,0,0,6,0,14,0,2
14,0,0,0,6,0,0,1,0,1

#finish loop
0,4,14,0,1,14,0,0,0,8
8,1,14,0,0,0,1,0,0,0
1,0,8,0,0,0,0,0,0,8
0,8,3,0,0,0,0,0,0,9
0,1,3,0,0,9,8,0,0,9
0,9,9,8,0,0,0,0,0,7

0,2,0,0,0,4,14,0,1,8
8,1,2,0,0,0,1,0,0,0
14,8,0,0,0,1,0,0,0,0

#send particle 11
0,9,7,0,0,0,0,0,0,11
0,7,9,0,0,0,0,0,0,8
9,9,8,7,0,0,0,0,0,0
7,9,9,8,0,0,0,0,0,0
8,9,9,7,0,0,0,0,0,11
9,9,7,8,0,0,0,0,0,1
1,11,0,0,0,0,0,0,0,0
0,11,0,0,0,0,0,0,0,11
0,11,0,0,dup,0,0,0,0,11
11,1,0,0,0,0,0,0,0,1
0,11,0,dup,0,0,0,0,0,11
11,1,0,0,dup,0,0,0,0,1
0,11,8,0,0,0,0,0,0,5
8,11,0,0,0,0,0,0,0,0
11,8,0,0,0,0,0,0,0,1

#send particle with 6 back to 5
6,11,1,0,0,0,0,0,0,5
0,6,11,0,0,0,0,0,0,1
0,11,6,0,0,0,0,0,0,11
11,1,0,6,0,0,0,0,0,0
1,11,6,0,0,0,0,0,0,0
1,5,0,11,0,0,0,0,0,0
11,1,5,0,0,0,0,0,0,1
1,11,0,0,5,0,0,0,0,0
0,11,0,0,1,0,0,0,0,11

#particle 11 open gate
5,11,1,0,0,0,0,0,0,6
11,5,0,1,0,0,0,0,0,10
0,10,6,0,0,0,0,0,0,9
0,6,10,0,0,0,0,0,0,12
10,9,12,6,0,1,0,0,0,0
9,12,6,10,0,0,0,0,0,1
12,9,10,6,0,0,0,0,0,1
0,9,12,0,0,0,0,0,0,10
0,12,9,0,0,0,0,0,0,12

0,10,12,0,0,0,0,0,0,11
0,12,10,0,0,0,0,0,0,12
1,10,12,1,6,0,0,0,0,0
1,12,10,1,0,6,0,0,0,0
10,1,1,12,0,0,0,0,0,1
12,1,1,10,0,0,0,0,0,1
1,11,12,1,0,0,0,0,0,0
1,12,11,1,0,0,0,0,0,0
11,1,1,12,0,0,0,0,0,1
12,1,1,11,0,0,0,0,0,1
0,12,11,0,0,0,0,0,0,8
0,11,12,0,0,0,0,0,0,12
0,8,12,0,0,0,0,0,0,4
12,8,1,1,0,0,0,0,0,0
8,12,1,1,0,0,0,0,0,0
1,12,8,1,0,0,0,0,0,0
1,8,12,1,0,0,0,0,0,0

0,2,1,0,6,10,0,0,0,9
6,10,9,0,0,0,0,0,1,5
10,9,0,6,0,1,0,0,0,0
9,10,6,0,0,1,0,0,0,0

0,2,0,0,9,1,2,0,0,2
0,9,12,0,0,0,5,0,0,12

12,12,1,1,0,0,5,0,0,0
12,12,1,1,0,0,0,0,0,0
1,1,12,12,0,0,0,0,6,12
1,1,12,12,0,0,0,6,0,12

6,12,12,0,0,0,0,0,0,5
12,12,6,0,0,0,0,0,0,0
12,12,0,6,0,0,0,0,0,0

0,0,0,0,15,0,0,11,0,11
0,0,0,0,0,15,0,11,0,11
11,0,0,0,15,0,0,1,0,1

11,0,0,0,0,15,0,1,0,1
0,0,0,0,0,0,15,11,0,11
1,0,0,11,15,0,0,0,0,0

1,0,0,11,0,15,0,0,0,0
11,0,0,0,0,0,15,1,0,1
1,0,0,11,0,0,15,0,0,0


And here is an example of a loop:

x = 90, y = 85, rule = QuadLoopParticles
2.E$56.AC.AB.AB.AN.AN.AN.AN.AN.AN$11.O8.O8.O8.O8.O8.O8.O8.O9.F4.D8$2.
O$82.O8$2.O$82.O8$2.O$82.O8$2.O$82.O8$2.O$82.O8$2.O$82.O8$2.O$82.O8$
2.O$82.O8$E9.O8.O8.O8.O8.O8.O8.O8.O2$82.E!


An interesting question weather this concept can be improved, to something like exponential loop. That means having only N signals the system will construct itself in Exp(N) time. Currently it's only N^2.
User avatar
simsim314
 
Posts: 1673
Joined: February 10th, 2014, 1:27 pm

Re: Other Loop rules

Postby simsim314 » June 15th, 2014, 7:05 pm

I've build an exponential loop. That means that N particles will create a loop of size 2^N. Also because of the enormous size each "command" is taking 2^N time per single iteration. So in total in became O(4^N) ticks for replication.

@RULE ExpLoopParticles

@TABLE

# 0 dead
# 1 Tail
# 2 push constructor particle
# 3 create reflector particle
# 4 construction unit
# 5 reflection unit
# 6 duplication unit
# 7 special event state
# 8 special event state
# 9-11 states for closure

#13 - C2
#14 - A2
#15 - M1
#16 - M2

n_states:17
neighborhood:Moore
symmetries:rotate4reflect

var p={2,3}
var q={14,3}

var a = {0,1,2,3,4,5,6,7,8,9,14}
var b = {a}
var c = {a}
var d = {a}
var e = {a}
var f = {a}
var g = {a}
var h = {a}

var con1 = {0, 1, 4}
var con2 = {0, 1, 4, 5, 6}
var dup = {5,6}

0,0,0,0,0,0,15,14,0,2
0,0,0,0,4,0,15,14,0,2
1,0,0,2,0,15,0,0,0,0
2,0,0,0,4,0,15,1,0,1
1,0,0,2,4,0,15,0,0,0
0,0,0,0,13,0,0,14,0,14
14,0,0,0,13,0,0,1,0,1
0,0,0,0,0,13,0,14,0,14
0,0,0,0,0,0,0,13,14,13
14,0,0,0,0,13,0,1,0,0
13,14,0,0,0,0,0,0,1,0
1,0,0,14,13,0,0,0,0,0
2,1,0,0,0,0,0,0,15,1
1,0,0,0,0,2,0,0,15,0
0,14,0,0,0,1,16,0,0,14
14,1,0,0,0,0,16,0,0,1
0,14,0,0,0,1,0,16,0,14
0,14,0,0,0,1,0,0,16,14
0,0,0,0,0,6,0,2,0,2
0,0,0,1,0,6,0,2,0,2
0,0,0,1,0,0,15,14,0,2

1,0,0,0,16,0,0,0,0,0
0,0,0,0,16,3,0,0,0,3
#special case
1,0,8,0,0,0,0,0,0,8

#send particle 11
6,11,0,0,0,0,0,0,0,5


#particles move
0,p,0,con1,con2,a,b,0,0,p
p,a,b,c,d,e,f,g,h,1
1,a,b,c,d,e,f,g,h,0

#construction push

14,0,0,4,0,1,0,0,0,1


4,2,1,0,0,0,0,0,0,0
0,4,2,0,0,0,0,0,0,13

1,0,0,0,13,0,0,0,0,0
0,0,0,0,13,0,0,2,0,2
0,0,0,0,0,13,0,2,0,2
2,0,0,0,13,0,0,1,0,1

2,0,0,0,0,13,0,1,0,0
1,0,0,2,13,0,0,0,0,0
13,2,0,0,0,0,0,0,1,0
0,0,0,0,0,0,0,13,2,13

0,0,0,0,13,0,0,3,0,3
0,0,0,0,0,13,0,3,0,3
3,0,0,0,13,0,0,1,0,1

0,1,3,13,0,0,0,0,0,15
0,0,0,0,0,0,0,13,3,4
1,0,0,3,13,0,0,0,0,0
3,0,0,0,0,13,0,1,0,0
13,3,0,0,0,0,0,0,1,0

0,0,0,0,15,0,0,2,0,2

0,0,0,0,0,15,0,2,0,14
2,0,0,0,15,0,0,1,0,1
15,0,0,0,0,0,0,0,2,16
0,0,0,0,4,0,16,14,0,14
14,0,0,0,0,16,0,1,0,1
1,0,0,14,16,0,0,0,0,0
1,0,0,14,0,16,0,0,0,0
14,0,0,0,4,0,16,1,0,1
0,0,0,0,0,4,0,14,0,14
0,0,0,1,16,0,0,2,0,2
1,0,0,14,4,0,16,0,0,0
14,0,0,0,0,4,0,1,0,0
4,14,0,0,0,0,0,0,1,0
0,0,0,0,0,0,0,4,14,4

0,0,0,1,0,16,0,2,0,2
2,0,0,0,16,0,0,1,0,1
0,0,0,0,0,0,16,2,0,2
2,0,0,0,0,16,0,1,0,1
1,0,0,2,16,0,0,0,0,0
1,0,0,2,0,16,0,0,0,0
2,0,0,0,0,0,16,1,0,1
0,0,0,0,4,0,0,2,0,2
1,0,0,2,0,0,16,0,0,0
0,0,0,1,0,0,16,2,0,2

0,0,0,1,16,0,0,3,0,3
0,0,0,1,0,16,0,3,0,3
3,0,0,0,16,0,0,1,0,1

1,0,0,3,16,0,0,0,0,0
3,0,0,0,0,16,0,1,0,1
0,0,0,1,0,0,16,3,0,3
0,0,0,1,0,0,16,3,0,3
3,0,0,0,0,16,0,1,0,1
1,0,0,3,16,0,0,0,0,0
16,3,0,0,0,0,0,0,1,15
1,0,0,3,0,15,0,0,0,0
3,0,0,0,0,0,15,1,0,1
0,0,0,1,0,0,0,3,0,3
1,0,0,3,0,0,15,0,0,0
0,0,0,0,0,0,16,14,0,14

0,0,0,0,0,0,0,14,0,14
14,0,0,0,0,0,16,1,0,1
1,0,0,14,0,0,16,0,0,0
14,0,0,0,0,0,0,1,0,1
0,0,0,0,15,0,0,14,0,14

0,0,0,0,0,15,0,14,0,14
14,0,0,0,15,0,0,1,0,1
1,0,0,14,15,0,0,0,0,0
14,0,0,0,0,15,0,1,0,1
0,0,0,0,4,0,15,14,0,14

1,0,0,14,0,15,0,0,0,0
14,0,0,0,4,0,15,1,0,1
0,0,0,0,0,4,0,14,0,14
0,0,0,1,15,0,0,2,0,2
1,0,0,14,4,0,15,0,0,0
0,0,0,1,0,15,0,2,0,2

15,2,0,0,0,0,0,0,1,16
1,0,0,2,15,0,0,0,0,0
2,0,0,0,0,15,0,1,0,1
0,0,0,0,0,0,15,2,0,14

0,0,0,0,0,0,15,14,0,14
15,14,0,0,0,0,0,0,1,15

0,0,0,0,0,0,15,2,0,14
0,0,0,0,4,0,0,14,0,14
14,0,0,0,4,0,0,1,0,1
14,0,0,0,0,0,15,1,0,1
1,0,0,14,0,0,15,0,0,0
0,0,0,1,0,0,15,2,0,14
0,0,0,1,0,0,0,14,0,14
0,0,0,1,15,0,0,14,0,14
0,0,0,1,0,15,0,14,0,14
0,0,0,1,0,0,15,14,0,14

#construction reflect
4,3,1,0,0,0,0,0,0,5
0,4,3,1,0,0,0,0,0,7

#reflect
0,dup,0,p,1,0,a,b,c,p
0,p,dup,0,0,a,b,0,0,p

0,0,0,0,5,0,0,14,0,14
14,0,0,0,5,0,0,1,0,1
0,14,0,5,0,0,0,0,1,2
0,0,0,1,2,0,0,14,0,14
0,0,0,0,5,1,0,14,0,14
14,0,0,0,1,0,0,1,0,1
0,14,0,5,0,1,0,0,1,2

#duplicate

0,0,0,0,0,6,0,14,0,2
0,0,0,1,6,1,0,14,0,14
0,0,0,1,0,6,0,14,0,2
0,14,0,6,0,1,0,0,1,2

0,6,0,q,0,0,0,con1,0,q
0,5,7,0,0,0,0,0,0,8
7,5,1,0,0,0,0,0,0,8
0,8,5,8,0,0,0,0,0,7
8,5,8,7,0,0,0,0,0,0
0,7,8,0,0,0,0,0,0,7
7,7,7,0,0,0,0,0,0,0
7,7,0,7,0,0,5,0,0,0
0,7,7,7,0,0,0,0,0,4

0,0,0,0,6,0,0,14,0,14
0,14,0,6,0,0,0,0,1,2
0,0,0,0,0,6,0,14,0,2
14,0,0,0,6,0,0,1,0,1

#finish loop
0,4,14,0,1,14,0,0,0,8
8,1,14,0,0,0,1,0,0,0
1,0,8,0,0,0,0,0,0,8
0,8,3,0,0,0,0,0,0,9
0,1,3,0,0,9,8,0,0,9
0,9,9,8,0,0,0,0,0,7

0,2,0,0,0,4,14,0,1,8
8,1,2,0,0,0,1,0,0,0
14,8,0,0,0,1,0,0,0,0

#send particle 11
0,9,7,0,0,0,0,0,0,11
0,7,9,0,0,0,0,0,0,8
9,9,8,7,0,0,0,0,0,0
7,9,9,8,0,0,0,0,0,0
8,9,9,7,0,0,0,0,0,11
9,9,7,8,0,0,0,0,0,1
1,11,0,0,0,0,0,0,0,0
0,11,0,0,0,0,0,0,0,11
0,11,0,0,dup,0,0,0,0,11
11,1,0,0,0,0,0,0,0,1
0,11,0,dup,0,0,0,0,0,11
11,1,0,0,dup,0,0,0,0,1
0,11,8,0,0,0,0,0,0,5
8,11,0,0,0,0,0,0,0,0
11,8,0,0,0,0,0,0,0,1

#send particle with 6 back to 5
6,11,1,0,0,0,0,0,0,5
0,6,11,0,0,0,0,0,0,1
0,11,6,0,0,0,0,0,0,11
11,1,0,6,0,0,0,0,0,0
1,11,6,0,0,0,0,0,0,0
1,5,0,11,0,0,0,0,0,0
11,1,5,0,0,0,0,0,0,1
1,11,0,0,5,0,0,0,0,0
0,11,0,0,1,0,0,0,0,11

#particle 11 open gate
5,11,1,0,0,0,0,0,0,6
11,5,0,1,0,0,0,0,0,10
0,10,6,0,0,0,0,0,0,9
0,6,10,0,0,0,0,0,0,12
10,9,12,6,0,1,0,0,0,0
9,12,6,10,0,0,0,0,0,1
12,9,10,6,0,0,0,0,0,1
0,9,12,0,0,0,0,0,0,10
0,12,9,0,0,0,0,0,0,12

0,10,12,0,0,0,0,0,0,11
0,12,10,0,0,0,0,0,0,12
1,10,12,1,6,0,0,0,0,0
1,12,10,1,0,6,0,0,0,0
10,1,1,12,0,0,0,0,0,1
12,1,1,10,0,0,0,0,0,1
1,11,12,1,0,0,0,0,0,0
1,12,11,1,0,0,0,0,0,0
11,1,1,12,0,0,0,0,0,1
12,1,1,11,0,0,0,0,0,1
0,12,11,0,0,0,0,0,0,8
0,11,12,0,0,0,0,0,0,12
0,8,12,0,0,0,0,0,0,4
12,8,1,1,0,0,0,0,0,0
8,12,1,1,0,0,0,0,0,0
1,12,8,1,0,0,0,0,0,0
1,8,12,1,0,0,0,0,0,0

0,2,1,0,6,10,0,0,0,9
6,10,9,0,0,0,0,0,1,5
10,9,0,6,0,1,0,0,0,0
9,10,6,0,0,1,0,0,0,0

0,2,0,0,9,1,2,0,0,2
0,9,12,0,0,0,5,0,0,12

12,12,1,1,0,0,5,0,0,0
12,12,1,1,0,0,0,0,0,0
1,1,12,12,0,0,0,0,6,12
1,1,12,12,0,0,0,6,0,12

6,12,12,0,0,0,0,0,0,5
12,12,6,0,0,0,0,0,0,0
12,12,0,6,0,0,0,0,0,0

0,0,0,0,15,0,0,11,0,11
0,0,0,0,0,15,0,11,0,11
11,0,0,0,15,0,0,1,0,1

11,0,0,0,0,15,0,1,0,1
0,0,0,0,0,0,15,11,0,11
1,0,0,11,15,0,0,0,0,0

1,0,0,11,0,15,0,0,0,0
11,0,0,0,0,0,15,1,0,1
1,0,0,11,0,0,15,0,0,0


Here is four bit loop, It replicates in about 20K ticks:

x = 89, y = 84, rule = ExpLoopParticles
2.E2$7.O4.O4.O4.O4.O4.O4.O4.O4.O4.O4.O4.O4.O4.O4.O5.F4.D4$2.O$81.O4$
2.O$81.O4$2.O$81.O4$2.O$81.O4$2.O$81.O4$2.O$81.O4$2.O$81.O4$2.O$81.O
4$2.O$81.O4$2.O$81.O4$2.O$81.O3$.B$.AO$81.O$.N$.A2$.BP$.A79.O2$.B$.A$
2.P$.C79.O$.A3$2.O$81.O4$E5.O4.O4.O4.O4.O4.O4.O4.O4.O4.O4.O4.O4.O4.O
4.O2$81.E!


And here is 8 bit loop, it replicated in about 9.5M ticks:

x = 2313, y = 2308, rule = ExpLoopParticles
2.E$935.AC.AB.AN.AN.AB.AN.AB.AN.AB$11.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.P8.P8.P8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O
8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O9.F4.D8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$
2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$
2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.
O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$2.O$2305.O8$E9.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.
O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O8.O2$2305.E!


NOTE This trick can be done with any loop rule. I've modified ParticleLoop rule, mainly because I know it best.

The next challenge would be to introduce this modification into existing rules, add some new states for extra "building" and "calculating" capabilities. Notice that perrier loops, that contains a universal computation is pretty ugly (don't contain the computational information inside the loop itself), because of the limited space caused by the annoying limitation of loops. This approach with cost of 3 extra states allows exponential container inside the loop.

NOTE 2 This is by the way the same technology as the quadratic loop, but it modified a little bit to address the n particles as n bits, and only if all the bits are 1's the turn operation is activated. The mutation operation is just a binary adder, that always increase the "flowing" bits by 1. This is why it turns after 2^N - 1 signals (i.e. 4 bits will have 2^4 - 1 = 15 mutation blocks, and 8 bits will have 2^8 - 1 = 255 mutation blocks).
User avatar
simsim314
 
Posts: 1673
Joined: February 10th, 2014, 1:27 pm

Re: Other Loop rules

Postby c0b0p0 » June 15th, 2014, 10:25 pm

@simsim314: I can't see a backwards operation for that, so apparently it does not use the same technology as the quadratic loop.

I added a "construction done" signal to my rule, and to make the rule less bulky, I also made a "left and right left- turn constructor".
@RULE GoucherParticleLoop
#state 0 is blank
#state 1 is tail
#state 2 is head
#state 3 is right reflector
#state 4 is left reflector
#state 5 is construction cell
#state 6 is duplicator
#state 7 is special state
#state 8 is right turn
#state 9 is left turn
#state 10 is left and right duplicator constructor
#state 11 is left and right left-turn constructor
#state 12 is "construction done" signal
@TABLE
n_states:13
neighborhood:Moore
symmetries:rotate4
var a={0,1,2,3,4,5,6,7,8,9,10,11,12}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={0,3,4,5,6,7}
var j={i}
var k={i}
var l={i}
var m={i}
var n={i}
var o={i}
var p={2,8,9,10,11}
p,1,a,b,c,12,d,e,f,12
12,p,a,b,c,d,e,f,g,0
p,4,0,0,0,1,0,12,0,12
p,3,0,12,0,1,0,0,0,12
1,a,b,c,d,e,f,g,h,0
p,a,b,c,d,e,f,g,h,1
0,p,i,c,d,e,f,g,o,p
0,p,3,i,j,e,l,m,1,p
0,p,1,i,m,e,k,j,4,p
0,p,6,i,m,e,j,n,1,p
5,2,3,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,4,7
5,2,6,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,6,7
5,2,0,0,0,0,0,0,0,7
7,a,b,c,d,e,f,g,h,0
0,7,0,0,0,0,0,0,0,5
5,8,0,0,0,0,0,0,0,3
0,8,5,0,0,0,0,0,1,5
5,9,0,0,0,0,0,0,0,4
0,0,0,0,5,9,1,0,0,5
5,10,0,0,0,0,0,0,0,6
0,0,0,0,5,10,1,0,0,5
5,10,0,0,0,0,0,0,0,6
0,10,5,0,0,0,0,0,1,5
5,11,0,0,0,0,0,0,0,4
0,0,0,0,5,11,1,0,0,5
5,11,0,0,0,0,0,0,0,6
0,11,5,0,0,0,0,0,1,5
@COLORS
1 255 255 255 #white
2 0   0   255 #blue
3 255 0   0   #red
4 122 107 255 #lavender
5 0   255 255 #cyan
6 0   255 0   #green
8 255 128 128 #pale red
9 200 150 255 #pale lavender
10 200 255 255 #pale lavender-green
11 122 230 255 #lavender-green
12 133 99  99  #light wood
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Re: Other Loop rules

Postby simsim314 » June 16th, 2014, 4:01 am

c0b0p0 wrote: I can't see a backwards operation for that, so apparently it does not use the same technology as the quadratic loop.


Yes. It's a logical continuation of some other proposal, from wildmyron and dvgrn.

The problem we were trying to solve, is that the naive loops have very significant space limitations, so the construction operations take about 3/4 of the loop space. So we were looking at some way to overcome it. I suggested some sort of universal construction arm that will make quadratic container in linear time. This would require step back operation.

But wildmyron and dvgrn have explored the idea of having more "circulations" for copy. Initial the thought was to have some fractal structure, dvgrn suggested to add mutation states, and trial and error approach. My implementation is modificaion of their suggestions, in a particular way, which is not fractal based but still very efficient.

c0b0p0 wrote:I added a "construction done" signal to my rule...


Can you please post a loop, even if it's not yet fully working, just to have a taste of the rule.
User avatar
simsim314
 
Posts: 1673
Joined: February 10th, 2014, 1:27 pm

Re: Other Loop rules

Postby c0b0p0 » June 16th, 2014, 4:56 pm

simsim314 wrote:
c0b0p0 wrote:I added a "construction done" signal to my rule...


Can you please post a loop, even if it's not yet fully working, just to have a taste of the rule.


I'm not sure exactly what the loop will look like, but here are the codons for the rule. (Note: use the updated rule table to run this.)
x = 9, y = 21, rule = GoucherParticleLoop
AB6.E5$AH6.E5$AI6.E5$AJ6.E5$AK6.E!


I fixed a bug with the behavior of the duplicator, and I also changed the behavior of the "construction done" cell.
@RULE GoucherParticleLoop
#state 0 is blank
#state 1 is tail
#state 2 is head
#state 3 is right reflector
#state 4 is left reflector
#state 5 is construction cell
#state 6 is duplicator
#state 7 is special state
#state 8 is right turn
#state 9 is left turn
#state 10 is left and right duplicator constructor
#state 11 is left and right left-turn constructor
#state 12 is "construction done" signal
@TABLE
n_states:13
neighborhood:Moore
symmetries:rotate4
var a={0,1,2,3,4,5,6,7,8,9,10,11,12}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={0,3,4,5,6,7}
var j={i}
var k={i}
var l={i}
var m={i}
var n={i}
var o={i}
var p={2,8,9,10,11}
p,1,a,b,c,12,d,e,f,12
12,p,a,b,c,d,e,f,g,0
p,4,0,0,0,1,0,12,0,12
p,3,0,12,0,1,0,0,0,12
3,p,a,b,c,d,e,f,12,0
4,p,12,b,c,d,e,f,a,0
1,a,b,c,d,e,f,g,h,0
p,a,b,c,d,e,f,g,h,1
0,p,i,c,d,e,f,g,o,p
0,p,3,i,j,e,l,m,1,p
0,p,1,i,m,e,k,j,4,p
0,p,6,i,m,e,j,n,1,p
0,p,1,i,m,e,j,n,6,p
5,2,3,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,4,7
5,2,6,0,0,0,0,0,1,7
5,2,1,0,0,0,0,0,6,7
5,2,0,0,0,0,0,0,0,7
7,a,b,c,d,e,f,g,h,0
0,7,0,0,0,0,0,0,0,5
5,8,0,0,0,0,0,0,0,3
0,8,5,0,0,0,0,0,1,5
5,9,0,0,0,0,0,0,0,4
0,0,0,0,5,9,1,0,0,5
5,10,0,0,0,0,0,0,0,6
0,0,0,0,5,10,1,0,0,5
5,10,0,0,0,0,0,0,0,6
0,10,5,0,0,0,0,0,1,5
5,11,0,0,0,0,0,0,0,4
0,0,0,0,5,11,1,0,0,5
5,11,0,0,0,0,0,0,0,6
0,11,5,0,0,0,0,0,1,5
@COLORS
1 255 255 255 #white
2 0   0   255 #blue
3 255 0   0   #red
4 122 107 255 #lavender
5 0   255 255 #cyan
6 0   255 0   #green
8 255 128 128 #pale red
9 200 150 255 #pale lavender
10 200 255 255 #pale lavender-green
11 122 230 255 #lavender-green
12 133 99  99  #light wood
c0b0p0
 
Posts: 645
Joined: February 26th, 2014, 4:48 pm

Next

Return to Other Cellular Automata

Who is online

Users browsing this forum: No registered users and 3 guests