Resu wrote: ↑May 29th, 2025, 12:59 pm
How is it known that all the used 2xN patterns are synthesisable?
If we use a long line of blocks and blinkers to generate the xWSSes used to build the universal constructor, this reaction from the first post can be used:
Code:
Select all
x = 21, y = 3, rule = B3/S23
2bo$obo3b3o2b2o6b2o$b2o8b2o6b2o!
At generation 11, the pattern fits into a 2xN bounding box. Since the tape used is made up of well-seperated blocks and blinkers, it is certainly glider constructible. My idea for the other tape (which will send xWSSes back to the constructor) uses blocks which are 12 cells apart, and this is also certainly glider constructible.
For creating the xWSSes, I've written another Python script:
Code: Select all
from random import randint
import golly as g
#This is a script to find potential 'tapes', or arrangements of a traffic light predecessor, blocks, and blinkers, that evolve into xWSSes that can be used
#to build a universal constructor and a spaceship/rake salvo to read data from a long line of blocks.
soups = int(g.getstring('How many potential tapes do you want to search?', '10000'))
def maketape(objects):
#This function assembles an rle for a potential tape.
row1 = 'bbobb'
row2 = 'ooooo'
#row1 and row2 use a 2x5 traffic light predecessor that can be formed by a collision between a blinker and glider.
#This ensures that the tape can be 'activated' into a 2xN form.
for x in range(objects):
spacing = randint(2,3)
#Randomising the spacing means there are more results to find.
row1 = row1 + 'b'*spacing
row2 = row2 + 'b'*spacing
objectused = randint(1,4)
#objectused is used to randomly place objects in a 2xN bounding box. 1 and 2 represent a block, while 3 and 4 represent the two possible blinker positions.
if objectused == 1 or objectused == 2:
row1 = row1 + 'oo'
row2 = row2 + 'oo'
elif objectused == 3:
row1 = row1 + 'ooo'
row2 = row2 + 'bbb'
else:
row1 = row1 + 'bbb'
row2 = row2 + 'ooo'
rle = 'x = 0, y = 0, rule = B3/S23\n'+row1+'$'+row2+'!'
return rle
fullrle = ''
rles = []
for x in range(soups):
rles.append(maketape(randint(5,20)))
for x in rles:
fullrle = fullrle + x
f = open('tapes.txt', 'w')
#Saving the tapes to a file ensures that they can be looked through later, either by apgsearch or a custom program.
f.write(fullrle)
f.close()
interestingrles = []
g.new('Potential tapes')
def searchsoup(rle):
global interestingrles
g.reset()
if g.getpop() != '0':
g.select(g.getrect())
g.clear(0)
g.setclipstr(rle)
g.paste(0, 0, 'xor')
g.run(2000)
if g.getpop() != '0':
bbox = g.getrect()
width = bbox[2]
height = bbox[3]
if int(width) > 700 and int(height) < 100 and int(g.getpop()) < 250
#Checking for width > 700 ensures there is a sideways xWSS that forms within 600 generations, since sideways xWSSes will be used to create a universal constructor.
#Checking for height < 100 ensures there are no excess gliders, as if any escape, the 'spaceship' will become a rake instead.
#Checking for population < 150 ensures that the result will be fairly small, since the ash will likely be cleaned up with xWSS salvos.
g.reset()
g.select(g.getrect())
g.copy()
interestingrles.append(g.getclipstr())
for x in range(soups//100):
for y in range(100):
searchsoup(rles[100*x+y])
g.show(str((x+1)*100)+' potential tapes have been examined, of which '+str(len(interestingrles))+' have been deemed interesting.')
for x in range(len(interestingrles)):
g.setclipstr(interestingrles[x])
g.paste(300*x, 0, 'or')
g.show('Done. Look out for results with no ash blocking the xWSS lane and/or a traffic light produced on the right.')
Again, I am currently unable to test it, but I should be able to within 24 hours. Ideally, you want to look for results which:
- Are transparent - there should be no ash blocking the output xWSS's lane.
- Are chainable - a traffic light or other suitable reaction should be produced at the end to ensure chainability, so that we only need to trigger the reaction with gliders once.
- Are easily cleanable - to minimise rake usage, the ash should ideally be made up of patterns that can be destroyed by MWSSes and HWSSes.
The rake I proposed can be constructed in 17 gliders, but building a seed for it, along with designing and synthesising a universal constructor which can interpret a p48 binary xWSS stream, is probably far too difficult.
Code:
Select all
x = 215, y = 186, rule = B3/S23
213bo$212bo$212b3o10$200bobo$200b2o$201bo3$53bo$51bobo$52b2o37$95bo$
93b2o$94b2o7$147bo$147bobo$147b2o11$82bobo$82b2o$83bo8$59bo$60bo$58b3o
2$52bo$53b2o$52b2o2$65bo$66bo$64b3o8$68b3o$70bo$69bo5$54b2o$55b2o$54bo
29$3o$2bo5b3o$bo8bo$9bo6$200bo$199b2o$199bobo12$34b2o$35b2o$34bo3$148b
2o$148bobo$148bo9$161bo$160b2o$160bobo!
However, the reaction from the start of this thread seems much more promising. Creating two MWSSes close together might be slightly difficult, but the construction efficiency with the secondary tape will be worth it. Assuming we can convert the gliders released into xWSSes, we can create xWSS streams with gaps of any multiple of 4 greater than or equal to 32.
Code:
Select all
x = 86, y = 23, rule = B3/S23
b6o$o5bo$6bo$o4bo$2b2o2$41b6o$40bo5bo$46bo$40bo4bo$42b2o2$52b2o6b2o6b
2o6b2o6b2o$52b2o6b2o6b2o6b2o6b2o3$10bo$8bo3bo30b5o$13bo22bo5bo4bo$8bo
4bo20bo3bo8bo$9b5o25bo2bo3bo$34bo4bo4bo$35b5o!
I strongly suspect that a single channel glider stream with the same restrictions might be capable of universal construction. There is no need to duplicate the recipe, so if glider streams with gaps of 4N+32 (or maybe slightly higher) are proven universal and we find a simple xWSS-based c/2 G-to-MWSS converter, then the constructor could simply be a
135-degree MWSS-to-G and elbow block, which should be easy to construct and destruct.
Alternatively, if that turns out to be impossible, then we could make a constructor which works with a binary p120 stream, which should be easier than p48 to design and synthesise as we can use p30 technology and Simkin glider guns.
