Serizawa - Linear Self Replicator.

[simsim314]

OK here is the "verdict". First of all OGC recipes work with 3 glider pairs for both colors of input lanes.

But the only effective same color lane available, is 4hd, and it has some "holes". There is no good recipe for WHITE gliders on both edges (there is such good recipe for BLACK gliders):

Here is the recipes for this case:

Code: Select all

x = 1177, y = 1181, rule = LifeHistory
1176.A$1174.2A$1175.2A66$1108.A$1106.2A$1107.2A67$1038.A.A$1038.2A$
1039.A68$968.A.A$968.2A$969.A65$901.A.A$901.2A$902.A75$824.A.A$824.2A
$825.A78$744.A$744.A.A$744.2A48$695.A$693.2A$694.2A74$618.A.A$618.2A$
619.A59$561.2A$560.A.A$562.A68$491.2A$490.A.A$492.A68$421.A$421.2A$
420.A.A68$351.2A$350.A.A$352.A68$281.2A$280.A.A$282.A68$211.A$211.2A$
210.A.A68$141.2A$140.A.A$142.A68$71.2A$70.A.A$72.A68$.A$.2A$A.A!

On the other hand for 3hd there are much more successful recipes that work well on both edges:

Code: Select all

x = 1628, y = 1881, rule = LifeHistory
1627.A$1625.2A$1626.2A72$1552.A.A$1552.2A$1553.A71$1479.A.A$1479.2A$
1480.A74$1403.A.A$1403.2A$1404.A27$1624.A$1623.A$1623.3A33$1340.A$
1338.2A$1339.2A39$1549.A$1547.2A$1548.2A29$1267.A$1267.A.A$1267.2A35$
1480.A$1480.A.A$1480.2A20$1208.A$1207.A$1207.3A47$1410.A$1408.2A$
1409.2A29$1129.A$1127.2A$1128.2A43$1333.A.A$1333.2A$1334.A22$1059.A$
1059.A.A$1059.2A41$1266.A$1266.A.A$1266.2A38$976.A$976.A.A$976.2A35$
1189.A.A$1189.2A$1190.A26$911.A$911.A.A$911.2A32$1127.A$1126.A$1126.
3A29$847.A$845.2A$846.2A34$1060.A$1059.A$1059.3A41$770.3A$772.A$771.A
38$977.A$976.A$976.3A28$700.3A$702.A$701.A28$917.A$917.A.A$917.2A37$
631.A$631.2A$630.A.A30$846.A$846.A.A$846.2A37$560.3A$562.A$561.A38$
770.3A$772.A$771.A28$490.3A$492.A$491.A37$701.A$701.2A$700.A.A29$420.
3A$422.A$421.A38$630.3A$632.A$631.A28$350.3A$352.A$351.A37$561.A$561.
2A$560.A.A28$281.A$281.2A$280.A.A38$491.A$491.2A$490.A.A29$210.3A$
212.A$211.A38$420.3A$422.A$421.A28$140.3A$142.A$141.A38$350.3A$352.A$
351.A28$70.3A$72.A$71.A38$280.3A$282.A$281.A28$3A$2.A$.A38$210.3A$
212.A$211.A68$140.3A$142.A$141.A67$71.A$71.2A$70.A.A68$.A$.2A$A.A!

So preferably OGC-RU should have different color output gliders, unless there could be something that can compensate for about 10-15 tracks lost on the edge of WHITE glider in the same color output case.

And for references and improvements here is the script I wrote to search for OGC-RU recipes:

Code: Select all

import golly as g 
from glife import *
from string import *
from copy import copy, deepcopy

# Snakial font
__sfont = dict ()
__sfont['0'] = pattern ("2b2obo$2bob2o$2o4b2o$o5bo$bo5bo$2o4b2o$o5bo$bo5bo$2o4b2o$o5bo$bo5bo$2o4b2o$2b2obo$2bob2o!", 0, -14)
__sfont['0'].width = 10
__sfont['1'] = pattern ("2o$bo$o$2o2$2o$bo$o$2o2$2o$bo$o$2o!", 1, -14)
__sfont['1'].width = 6
__sfont['2'] = pattern ("2b2obo$2bob2o$6b2o$6bo$7bo$6b2o$2b2obo$2bob2o$2o$o$bo$2o$2b2obo$2bob2o!", 0, -14)
__sfont['2'].width = 10
__sfont['3'] = pattern ("2obo$ob2o$4b2o$4bo$5bo$4b2o$2obo$ob2o$4b2o$4bo$5bo$4b2o$2obo$ob2o!", 0, -14)
__sfont['3'].width = 8
__sfont['4'] = pattern ("2o3b2o$2o3b2o2$2o3b2o$obobobo$2bobo$b2obo$5b2o$6bo$5bo$5b2o$6bo$5bo$5b2o!", 0, -14)
__sfont['4'].width = 9
__sfont['5'] = pattern ("2b2obo$2bob2o$2o$o$bo$2o$2b2obo$2bob2o$6b2o$6bo$7bo$6b2o$2b2obo$2bob2o!", 0, -14)
__sfont['5'].width = 10
__sfont['6'] = pattern ("2b2obo$2bob2o$2o$o$bo$2o$2b2obo$2bob2o$2o4b2o$o5bo$bo5bo$2o4b2o$2b2obo$2bob2o!", 0, -14)
__sfont['6'].width = 10
__sfont['7'] = pattern ("ob2o$2obo$4b2o$5bo$4bo$4b2o$2b2o$3bo$2bo$2b2o$2o$bo$o$2o!", 0, -14)
__sfont['7'].width = 8
__sfont['8'] = pattern ("2b2obo$2bob2o$2o4b2o$o5bo$bo5bo$2o4b2o$2b2obo$2bob2o$2o4b2o$o5bo$bo5bo$2o4b2o$2b2obo$2bob2o!", 0, -14)
__sfont['8'].width = 10
__sfont['9'] = pattern ("2b2obo$2bob2o$2o4b2o$o5bo$bo5bo$2o4b2o$2b2obo$2bob2o$6b2o$6bo$7bo$6b2o$2b2obo$2bob2o!", 0, -14)
__sfont['9'].width = 10
__sfont['-'] = pattern ("2obo$ob2o!", 0, -8)
__sfont['-'].width = 6
__sfont[' '] = pattern ("8b!", 0, -8)
__sfont[' '].width = 8

def make_text (string):
	p = pattern ()
	x = 0
	for c in string:
		if not __sfont.has_key (c):
			c = ' '
		
		symbol = __sfont[c]
		
		
		p += symbol (x, 0)
		x += symbol.width
	return p

def PlaceGliders(dat, inc, d):
	for data in dat:

		g.putcells(gld, -d, d)
		
		d += 145 + 2 * inc
		
		if data[1] == 1:
			gldj = gld
		if data[1] == 0:
			gldj = g.evolve(gld,1)
		if data[1] > 1: 
			gldj = g.evolve(gld,5 - data[1])
			data[0] -= 1
		
		g.putcells(gldj, -d + data[0], d - data[0])

		d += 145

	
	return d
	
def PlaceGld(dy, d, stat, toText, dx):
	
	gldj = g.parse("3A$2.A$.A!")
	gld = g.parse("3A$2.A$.A!")
	
	if stat[1] > 0:
		gldj = g.evolve(gldj, stat[1])
	
	if stat[2] == 1: 
		gld = g.evolve(gld, 1)
		
	g.putcells(gld, -d, -dx + d)		
	
	g.putcells(gldj, d + stat[0], - dx - dy - d - stat[0], -1,0,0,-1)
	
	if toText:

		periodText = make_text (str(dy) +  "   " + str(stat[0]) + "   " + str(stat[1]) + "   " + str(stat[2]))
		g.putcells(periodText,  70 + d + stat[0], - dx - dy - d - stat[0]) 
		
	
gld = g.parse("3A$2.A$.A!")

ij = [(-9,3),(-8,1),(-8,3),(-7,3),(-6,1),(-6,2),(-6,3),(-5,2),(-4,3),(-2,3),(-1,2),(0,1),(0,2),(0,3),(1,1),(2,1),(2,3),(3,0),(3,1)]

#ijstat = [(2,3,[-6,0]),(2,1,[-4,2]),(1,1,[-9,2]), (1,1,[-7,0]), (-1,2,[1,3]), (-5,2,[0,1]), (-7,3,[10,2]), (-7,3,[7,0]), (-8,3,[-6,0]), (-8,1,[-4,2])]
#ijstat = [(-7,3,[[0,0],[7,0],[4,1]]), (-7,3,[[10,2],[5,3],[0,-10]])]
#ijstat = [(-7,3,[[0,0],[7,0],[4,1]]), (-7,3,[[0,0],[10,2],[5,3],[20,2]])]

ij = [(-8,1)]
potential=[[-4,3,0],[-3,3,0],[-4,3,1],[-5,3,1],[-5,3,0],[-6,3,1],[-5,3,0],[-7,3,0],[-14,3,1],[-16,3,1],[-4,2,1],[-4,2,0],[-5,2,0],[-6,2,1],[-6,2,0],[-16,2,0],[-6,1,1],[-6,1,0],[-3,0,0],[-4,0,1],[-4,0,0],[-5,0,1],[-6,0,1,],[-6,0,0],[-7,0,1],[-8,0,1],[-11,0,0]]

dx = 0 
'''
datW = [[0,0],[7,0],[4,1]]
datB = [[0,0],[10,2],[5,3],[20,2]]
d = 0
#inc = 12 (datW)
#inc = -6(datW)
#inc = 12 (datB)
#inc = 0 (datB)
inc = 0

d = PlaceGliders(datW, 12, d)
datW = [[0,0],[7,0],[4,1]]
datB = [[0,0],[10,2],[5,3],[20,2]]
d = PlaceGliders(datW, -6, d)
d = PlaceGliders(datB, 12, d)
datW = [[0,0],[7,0],[4,1]]
datB = [[0,0],[10,2],[5,3],[20,2]]
d = PlaceGliders(datB, 0, d)


def PlaceGld(i, j, d, stat, toText):
	
	gldj = g.parse("3A$2.A$.A!")
	
	if j + stat[1] > 0:
		gldj = g.evolve(gldj, j + stat[1])
	
	g.putcells(gld, -d, -dx + d)		
	
	g.putcells(gldj, 10 + d + stat[0], -10 - dx - i - d - stat[0], -1,0,0,-1)
	
	if toText:
		periodText = make_text (str(i) + "    " + str(j) +  "   " + str(stat[0]) + "   " + str(stat[1]) )
		g.putcells(periodText,  70 + 10 + d + stat[0], -10 - dx - i - d - stat[0]) 
dk = 0 	
du = 0 
for p in ijstat:
	#for m in xrange(0, 4): 
	#	for n in xrange(-15,15): 
	i = p[0]
	j = p[1]
	
	for k in xrange(0,len(p[2])):
		p[2][k][0] += du
		PlaceGld(i,j, dk + k * 20, p[2][k], False)
	
	dk +=130
	du = -10
	#dx += 100


for p in ijstat:
	
	i = p[0]
	j = p[1]
			
	PlaceGld(i,j, 20, [0,0], False)
	PlaceGld(i,j, 40, p[2], False)
	PlaceGld(i,j, 60, [0,0], False)
	PlaceGld(i,j, 90, p[2], True)
	dx += 250
'''

def PlaceResults(results, dy, dx):
	g.new("")
	
	for p in results:
		
		glds = p[0]
		
		step = 40 
		
		for gld in glds:
			
			PlaceGld(dy, step, gld, False, dx)
			step += 70
			
		dx += 250
	
result = []

def AnalyzeState(maxPop, maxWidth):
	
	g.step()
	
	pop = int(g.getpop())
	
	if pop == 0:
		return [0]
		
	if pop > maxPop:
		return [-1]
	
	g.run(2)
	
	pop1 = int(g.getpop())
	
	if not pop1 == pop:
		return [-2]
	
	#Search Glider Shoots 
	rect = g.getrect()
		
	g.run(16)
	rect1 = g.getrect()
	
	gld = []
	
	if int(g.getpop()) == 5 and rect[0] - rect[1] == rect1[0] - rect1[1] and rect[0] - rect1[0]  != 0 and rect[2] == 3 and rect[3] == 3:
		
		w = rect1[0] 
		rectx = g.getrect()
		step  = 1
		
		while rectx[0] == w:
			g.run(1)
			rectx = g.getrect()
			step  += 1
		
		g.run(1)
		rectx = g.getrect()
		
		gld = [rectx[0] + rectx[2] - 3, rectx[1] + rectx[3] - 1, rectx[0] - w, rectx[0] - w,  int(g.getgen())]
		
		if step % 2 == 1:
			g.run(1)
			
		return [1, gld, 0]
	
	if rect[0] == rect1[0] and rect[1] == rect1[1] and rect1[2] - rect[2] == 4 and rect1[3] - rect[3] == 4:
		
		w = rect1[3] 
		rectx = g.getrect()
		step  = 1
		
		while rectx[3] == w:
			g.run(1)
			rectx = g.getrect()
			step  += 1
			
		g.run(1)
		rectx = g.getrect()
		
		gld = [rectx[0] + rectx[2] - 3, rectx[1] + rectx[3] - 1, 1, 1,  int(g.getgen())]
		
		for i in xrange(0, 3):
			for j in xrange(0, 3):
				g.setcell(gld[0] + i, gld[1] - j,0)
		
		if step % 2 == 1:
			g.run(1)
			
	#g.show(str(rect) + "," + str(rect1))
	
	if rect1[2] - rect[2] == 4 and rect1[3] - rect[3] == 4 and rect[0] - rect1[0] == 4 and rect[1] - rect1[1] == 4:
	
		x = rect1[0] 
		rectx = g.getrect()
		
		step  = 1
		
		while rectx[0] == x:
			g.run(1)
			rectx = g.getrect()
			step += 1
			
		g.run(1)
		
		rectx = g.getrect()
		
		gld = [rectx[0] + 2, rectx[1], -1, -1,  int(g.getgen())]
		
		for i in xrange(0, 3):
			for j in xrange(0, 3):
				g.setcell(gld[0] - i, gld[1] + j,0)
		
		if step % 2 == 1:
			g.run(1)
			
	if gld == [] and not(rect[0] == rect1[0] and rect[1] == rect1[1] and rect[2] == rect1[2] and rect[3] == rect1[3]):
		return [-3]
	
	#Search Single Block
	
	rect = g.getrect()
	g.run(4)
	rect1 = g.getrect()
	
	if rect[2] > maxWidth or  rect[3] > maxWidth:
		return [-5]
		
	if not(rect[0] == rect1[0] and rect[1] == rect1[1] and rect[2] == rect1[2] and rect[3] == rect1[3]):
		return [-4]
	
	rect = g.getrect()
	g.run(1)
	rect1 = g.getrect()
	g.run(1)
	
	if rect[2] >  rect1[2]:
		rect = rect1
	
	block = []
	
	if rect[2] == 7 and rect[3] == 7 and int(g.getpop()) == 12:
		block = [rect[0], rect[1]]
	
	return [1, gld, block]
	
	
def Analyze(curState, dy, maxStep, toCreateList):
	idx = 0 
	global x
	global result 
	
	newState = []
	total = len(curState)
	for pn in curState:
		p = pn[1]
		idx += 1
		
		for m in xrange(0, 4):
			for n in xrange(-maxStep, maxStep + 1):
				for s in xrange(0,2):
					
					g.new("")
					g.setstep(4)
					g.show(str(len(result)) + " , " + str(idx) + " / " + str(total) + " , " + str(len(newState))+ " , " + str(x))
					
					step = 40
					
					for gld in p:
						PlaceGld(dy,step, gld, False, 0)
						step += 70
						
					PlaceGld(dy,step, [n,m,s], False, 0)
					
					stp = AnalyzeState(18, 14)
					
					if stp[0] > 0:
						if stp[2] == 0: 
							#if len([t for t in result if (t[1] == stp[1][2] and t[2] == (stp[1][0] + stp[1][1])%2)]) == 0:
							px = deepcopy(p)
							px.append([n,m,s])
							result.append([px,stp[1][2],(stp[1][0] + stp[1][1])%2, stp[1][0] - stp[1][1]])
						else: 
							
							if toCreateList:
								
								strW = GetStr()
								g.run(1)
								strB = GetStr()
								g.run(1)
								
								if  len([t for t in newState if (t[0] == strW or t[0] == strB)]) == 0:							
									px = deepcopy(p)
									px.append([n,m,s])
									newState.append([strW, px])
						g.update()
					
						'''
						g.step()
						g.update()
						
						if int(g.getpop()) == 5:
							rect = g.getrect()
							g.run(4)
							rectCur = g.getrect()
							
							if rect[2] == rectCur[2] and rect[3] == rectCur[3] and  rect[0] != rectCur[0] and rect[1] != rectCur[1]:
								result.append((i,j,[[0,0,0], p, [n,m,s]]))
								
						'''
						
	return newState

def PrepareResults(result):
	bUp = [t for t in result if (t[1] == 1 and t[2] == 1)]
	wUp = [t for t in result if (t[1] == 1 and t[2] == 0)]
	
	bDown = [t for t in result if (t[1] == -1 and t[2] == 1)]
	wDown = [t for t in result if (t[1] == -1 and t[2] == 0)]
	
	curRes = []
	
	if len(bUp) > 0 and len(wUp) > 0:
		
		rbMin = min([t for t in result if (t[1] == 1 and t[2] == 1)], key=lambda w: w[3])
		rbMax = max([t for t in result if (t[1] == 1 and t[2] == 1)], key=lambda w: w[3])
		
		rwMin = min([t for t in result if (t[1] == 1 and t[2] == 0)], key=lambda w: w[3])
		rwMax = max([t for t in result if (t[1] == 1 and t[2] == 0)], key=lambda w: w[3])
		
		rwMin[0].extend(rwMax[0])
		rwMin[0].extend(rbMin[0])
		rwMin[0].extend(rbMax[0])
		
		curRes.append([rwMin[0]])
		
	
	if len(bDown) > 0 and len(wDown) > 0: 
		rbMin = min([t for t in result if (t[1] == -1 and t[2] == 1)], key=lambda w: w[3])
		rbMax = max([t for t in result if (t[1] == -1 and t[2] == 1)], key=lambda w: w[3])
		
		rwMin = min([t for t in result if (t[1] == -1 and t[2] == 0)], key=lambda w: w[3])
		rwMax = max([t for t in result if (t[1] == -1 and t[2] == 0)], key=lambda w: w[3])
		
		rwMin[0].extend(rwMax[0])
		rwMin[0].extend(rbMin[0])
		rwMin[0].extend(rbMax[0])
		
		curRes.append([rwMin[0]])
	
	return curRes
	
def GetStr():
	rect = g.getrect()
							
	#strW  = str(rect[1] + rect[0])
	strW  = str(rect[1]) + ":" + str(rect[0]) 
	
	for mi in xrange(rect[0], rect[0] + rect[2] + 1):
		strW += "$"
		for mj in xrange(rect[1], rect[1] + rect[3] + 1):
			strW += str(g.getcell(mi,mj))
			
	return strW

#dy = 1 #3hd	
#dy = 1 #4hd
dy = 2 #5hd

cur = [["",[]]] 
x = 0 
full = []

for x in xrange(0, 3): 
	temp = [] 
	
	if x == 0:			
		temp = Analyze(cur,dy, 2, x < 2)
	else: 
		temp = Analyze(cur,dy, 12, x < 2)
	
	cur = temp
		
PlaceResults(PrepareResults(result), dy, 0)				

[dvgrn]

But the only effective same color lane available, is 4hd, and it has some "holes". There is no good recipe for WHITE gliders on both edges (there is such good recipe for BLACK gliders...

A side note on another minor detail of terminology: strangely, when 4hd lanes have gliders coming in opposite directions, the gliders are on different colored lanes (!).

Just try stringing Snarks together (i.e., color-preserving reflectors) and you'll see that you can get from a given input glider to either one end or the other of any output glider lane -- but not both. So 4hd lanes are actually different colors when they're in opposition, and the same color (of course) when they're parallel.

I understand the verdict, though, and will go through my growing odd-hd R.U. collection again and see what turns up. Here's a 40sL odd-hd armless R.U. (i.e., the colliding gliders are the same color) that appears to have enough range to be universal:

Code: Select all

#C corrected from 39sL -- need an extra blinker-suppressing eater
x = 229, y = 223, rule = B3/S23
184b2o$184b2o12$152bo$152b3o6b2o$155bo5b2o$154b2o3$155b2o$155b2o3b2o
13b2o$160b2o13b2o$215b2o$215b2o2$142bo7bo$130bo11b3o5b3o46b2o23b2o$
128b3o14bo7bo45b2o22bobo$112bo14bo16b2o6b2o19b2o49bo$112b3o12b2o43bobo
$115bo56bo$114b2o55b2o26b2o17b2o$199b2o17b2o$185b2o$115b2o67bobo38b2o$
115b2o17b2o48bo40bobo$134b2o47b2o8b2o32bo$193bo18b2o13b2o$194b3o16bo$
196bo13b3o6b2o$210bo8b2o2$131b2o$131bo$132b3o$134bo$128b2o$128bo$129b
3o$131bo6$137b2o$137bo$118b2o15bobo$118b2o15b2o12$117b2o$116bobo$116bo
$115b2o9$127b2o$127b2o6$116b2o$117bo19b2o17b2o$117bobo17bo18bo$118b2o
15bobo16bobo$130bo4b2o17b2o$129bobo$129bobo7b2o$118b2o4b3o3bo8b2o$117b
obo6bo$117bo7bo$116b2o38b2o$131b2o16b2o5b2o$131bo17b2o$132b3o$134bo9bo
$143bobo$143b2o6b2o$151bo$152b3o$154bo112$2o$b2o$o!

However, I'm kind of thinking that the really interesting applications of this technology will use Herschel signals, or multiple channels and no period doublers -- maybe along the lines of the "Demonoid" design. The Demonoid's serial-switching mechanism is one way of avoiding signal-crossing problems for multiple channels; this might work well especially for a design along the lines of the linear Life replicator, where there's only one replicator unit.

It's a little harder to avoid signal crossings when the exact same signal has to come in to both replicator units in a Gemini-style spaceship, but even then the problem can be minimized... That link also has some discussion of a diamond-shaped Geminoid spaceship, which I think may actually be significantly easier to design with this new "armless" construction idea.

[simsim314]

: strangely, when 4hd lanes have gliders coming in opposite directions, the gliders are on different colored lanes (!).

I get it it's just confusing. this color issue really makes simple things harder than they should...


----

A design I was thinking about: All we need for the "extended arm" (the "body" of the armless replicator can be considered as a giant arm) is some "far away" 180 degree reflector.

So we place all the "logic" and wiring and self destruct seeds etc. at one place, and then extend the "arm" as much as we like with very small "180 reflector". So the only thing that really needs to be built with "slow" salvo is this 180 degree reflector (or the part that lays outside of the construction zone, which could be even few blocks).

Now this design has obvious advantages (infinitely extendable). But it has also fallback. First of all the signal calculation could be a bit tricky (having a large delay between the opposite collision can be a small annoyance). It's also obviously requires more SLs. The question is how much?

I think eventually, this design will "win" due to flexibility. Adding more to the circuit will force to enlarge the area more and more, it would be pain to redesign the UC time after time for each "addition" in the circuitry.

---------

Coming a little bit back to Serizawa. I was thinking to do the same extendable "armless" design there. But only with two armless units. In Serizawa there is an option to make some "slow salvo construction" although not as powerful as in Life, but for construction of 180 reflector that lays outside the construction zone it would suffice.

Anyway I've discovered (or rediscovered?) some destruction seeds in Serizawa (for the self destruct circuitry):

Code: Select all

x = 179, y = 215, rule = Serizawa
14$45.A3$43.A.A12.A$57.B$45.A12.A16$47.A2$43.A.A12.A$57.B$45.A12.A16$
46.A19$45.A2$21.A$45.A10.A$55.B$42.A2.A10.A14$46.A6$46.A.A$47.B11$43.
A2.A2$47.A$45.A19$72.A21.A21.A21.A19$134.A2.A10.A$147.B$112.A2.A21.A
10.A2$90.A2.A21.A$137.A$48.A19.A2.A21.A$115.A$44.A.A24.A$93.A$46.A$
71.A17$44.A28.A2.A2$46.A.A24.A21.A2.A2$46.A48.A21.A2.A$73.A$117.A21.A
2.A$95.A54.A$139.A$117.A2$139.A10.A17$73.A21.A21.A21.A!

[dvgrn]

A design I was thinking about: All we need for the "extended arm" (the "body" of the armless replicator can be considered as a giant arm) is some "far away" 180 degree reflector.

I've been thinking somewhat along the same lines. Currently the cheapest slow-salvo-constructible 180-degree reflector is still a 20-still-life Silver reflector. It's now theoretically possible to slow-construct either a boojum reflector or a rectifier -- or a couple of Snarks, for that matter -- but the eater2 or eater3 or Snark still lifes aren't really worth the extra construction expense.

But it may well be worth getting rid of the semi-Snark period doublers along with the 180-degree reflector, and simply feed each side of the shooting range with a separate glider stream. Along the lines of the "Demonoid" design, the circuitry could be set up so that the first half of a long glider stream gets sent to the faraway side of the shooting range, and then that circuit is shut off and the second half of the same stream feeds the near side.

There was some discussion at one point about having nearby copies of replicators each contribute half of the information needed to create a new copy nearby (between them? off to one side, equidistant from each?) I never figured out how there would really be an advantage to this design over keeping all the information in one place. But it might be worth thinking about this again with the armless R.U. design in mind. Calcyman has gone a little farther with the idea of cooperating groups of replicators simulating various rules to get a very wide variety of population growth rates and patterns. No working model of that yet, though...!

I think eventually, this design will "win" due to flexibility. Adding more to the circuit will force to enlarge the area more and more, it would be pain to redesign the UC time after time for each "addition" in the circuitry.

There's also the orientation problem. The linear Life replicator, following the pattern set by the Gemini, builds each child replicator unit in the same orientation as the parent. It seems like there are relatively few ways to use a child R.U. that's oriented 90 degrees from its parent... but one possibility is a spiral-growth pattern, and another is a diamond-shaped 2D quadratic-growth replicator.

I think the right balance will still be to fit as much of a construction as possible into the "shooting range" of some replicator unit, or even better, inside the intersection of two shooting ranges. There's no need to worry if some significant pieces fall outside those ranges; we have the technology to reach around corners whenever it's necessary -- but the armless design should make it necessary much less often.

[simsim314]

Currently the cheapest slow-salvo-constructible 180-degree reflector is still a 20-still-life Silver reflector.

Well we don't need full 180 degree reflector, only a 180 "half" reflector. Here is sample of this concept, requiring only the semi snark to be constructed with slow salvos:

Code: Select all

x = 97, y = 162, rule = LifeHistory
35.A$35.3A$38.A$37.2A6.2A$44.A.A$45.A3$32.2A$32.2A6.2A$40.2A2$49.2A$
49.2A2$34.2A$33.A.A$33.A$32.2A45$68.A$66.3A$42.A22.A$30.A11.3A20.2A$
28.3A14.A$12.A14.A16.2A$12.3A12.2A$15.A$14.2A3$15.2A$15.2A17.2A$34.2A
6$31.2A32.2A$31.A20.2A11.2A$32.3A18.A$34.A15.3A$28.2A20.A$28.A$29.3A
45.2A$31.A46.A$75.3A$75.A2$12.2A$11.A.A$11.A25.2A46.2A$10.2A25.A42.2A
3.2A$18.2A15.A.A42.2A$18.2A15.2A2$79.2A12.2A$80.A5.2A5.A$77.3A6.2A6.
3A$77.A18.A7$17.2A$16.A.A$16.A$15.2A9$27.2A$27.2A$39.2A$39.A.A$41.A$
41.2A2$16.2A$17.A19.2A$17.A.A17.A$18.2A15.A.A$30.A4.2A$29.A.A$29.A.A$
18.2A10.A$17.A.A$17.A$16.2A$31.2A$31.A$32.3A$34.A16$.2A$A.A$2.A!

Now the diagonal troweling, can be achieved constructing a copy of itself diagonally, and then self destruct the parent. So the stream will reach the child without intersecting the parent (or for starter self destruct can utilize only the parts that stay on the stream path). Also it's possible to travel "almost diagonally", having "holes" in the design that allow the stream "pass" through the parent, although this concept will require more SLs to be constructed with slow salvo, still not the whole silver will need to be slow salved.

There's no need to worry if some significant pieces fall outside those ranges...

Well I was trying to calculate the ratio between slow salvo construction, and two armless unit construction in Serizawa. The slow salvo is traveling one cell per glider shoot. If the size of the RU is around 100 cells so the new copy will be placed 100 cells apart, so there is a need to travel 100 cells with slow salvo, i.e. 100 shoots. So each cell outside the shooting range is around the same cost as 100 inside. Having even 6 cells outside will give us 600 cells inside. Which is about the size of the whole replicator including the self destruct circuitry. I think I will go for it because there is no choice, but some special design to cut the amount of cells on the edge is a good idea (I've a concept that allows 6 "edge cells" for 180 reflector in Serizawa, in cost of about 10-15 inside cells).

Now in Life the slow salvo is not so awkward, but still comparing to up to 3 shoots to construct anything inside (many of the SL can be constructed with only one pair), while having many time around 20-30 shoots to construct the SLs outside the shooting range, it's a factor of 10 at least (I guess the same goes for slow salvo single armless UC as well - 1 to 10 ratio). So the posted pattern has 27 SL inside and 6 outside, which can be count as total 9 outside SLs. Of course it's all goes for same orientation design.

[dvgrn]

Well we don't need full 180 degree reflector, only a 180 "half" reflector. Here is sample of this concept, requiring only the semi snark to be constructed with slow salvos...

True enough. Also some parts of the semi-Snark can be constructed from inside the shooting range:

Code: Select all

x = 313, y = 333, rule = LifeHistory
10.A$10.3A$13.A$12.2A6.2A$19.A.A$20.A3$7.2A$7.2A6.2A$15.2A2$24.2A$24.
2A2$2E7.2D$2E6.D.D$8.D$7.2D82$110.A$110.3A$113.A$112.2A6.2A$119.A.A$
120.A3$107.2A$107.2A6.2A$115.2A2$124.2A$124.2A2$109.2A$108.A.A$108.A$
107.2A2$100.3A$100.A$101.A28$127.3A$127.A$128.A28$150.3A$150.A$151.A
28$183.2A$182.2A$184.A28$207.3A$207.A$208.A28$253.2A$252.2A$254.A28$
280.2A$279.2A$281.A28$311.2A$310.2A$312.A!

At least two of the three blocks are also within reach, I think, using known reactions from the block-move table. It's quite possible that even recipes for the eater and boat can be found with that much lateral offset, but that might be another challenge for oblique's sscs search program.

[simsim314]

It seems like there are relatively few ways to use a child R.U. that's oriented 90 degrees from its parent

I was checking the geometrical option of using the new "rotated" copy. The point is not only to rotate but also reflect, thus creating a steps pattern instead of full circle. the only problem with that approach is to feed the new "rotate+reflect" copy from the "other side" (the far side from the feeding initial stream). Now one solution could be to place "smartly" the lower copy, and "alternate" between "big step" in stream and "small step" in stream in the upper and lower sides. The other solution would be some additional wiring to the interpreter from few side (like adding extra silvers on the others side that carry the stream back to the original feeding point).

----

each contribute half of the information needed to create a new copy nearby

I think that this "near diagonal traveling" can also use the "two stream design" as well. The only thing that missing for that design is a reflector that has a "wide glider traveling range from it's edge" that can include most of itself inside the shooting range (like shooting from the side that is on the further edge of a reflector, see the design I came up with in previous message, just without the semi snark, and instead of 180 degree we need only 90). EDIT Looking at the first OGC-UC with 39SL it is actual a reflector that does include almost everything "inside" the glider stream, except of single beehive. So I really leaning toward this two streams two "nice reflectors". The only issue I see now with this approach is the "lower part design". or we simply place two silvers there with slow salvo?

A "schematics" of the general concept is attached.

[dvgrn]

The only issue I see now with this approach is the "lower part design". or we simply place two silvers there with slow salvo?

A "schematics" of the general concept is attached.

Another alternative I've been thinking about is building two semi-Snarks, and adding circuitry in the upper part to turn each single glider into four. Somehow I doubt that that will work out very well -- it probably either increases the spacing between signals too much, or else takes too much circuitry -- but there are a couple of possibilities I'd like to look at there.

EDIT: The smallest G-to-4Gs I can think of aren't too bad, but as we suspected they probably won't win any prizes for efficiency. It's interesting that you get a second 4G stream for free, though:

Code: Select all

#C two different Herschel tracks that can "amplify" a signal stream
#C so that it can be run through one or more semi-Snarks.
#C Requires fairly long spacing between signals --
#C  517 for the left-hand version (and that's too tight for one phase
#C   of a semi-Snark) and 995 for the right-hand circuit, because
#C   the Rx140 conduit has an unusually slow recovery time.
x = 743, y = 337, rule = B3/S23
2o385b2o$bo385bo$bobo381bobo$2b2o381b2o$460b2o$461bo$461bobo$462b2o$
20b2o$9b3o8bo356b3o5b2o$9bo8bobo44bo313bo5b2o$8b3o7b2o45b3o310b3o15bo
36b2o$68bo325b3o37bo$67b2o324bo39bo$393b2o38b2o$48bo42bo$29b2o17b3o38b
3o269bo$22b2o6bo20bo36bo9bo262b3o$22bo6bo20b2o11b2o23b2o6b3o265bo$20bo
bo6b2o32b2o30bo267b2o43b2o70b2o$20b2o73b2o311b2o26b2o42bo$99b2o335b2o
40bobo$99bo378b2o$7b2o88bobo$6bobo88b2o$6bo25b2o$5b2o25b2o360b2o$394bo
bo9b2o$75b2o23bo295bo8bobo38b2o5b2o$76bo22bobo294b2o7bo41bo5b2o$9b2o
62b3o8b2o14bo303b2o25b2o11b3o$8bobo62bo11bo345b2o11bo$8bo4b2o67b3o395b
2o$7b2o5bo27b2o38bo397b2o$11b3o5bo23bo334b2o37b2o$11bo6bobo19b3o20b2o
314bo38bo$19bo20bo22bo312b3o10b2o24b3o39b2o$64b3o309bo12b2o24bo40bobo
11b2o$66bo360b2o27bo13bo$81bob2o342bo27b2o14b3o$81b2obo343b3o42bo$430b
o$90b2o$90b2o3$475bo$473b3o$472bo$472b2o$100b2o$100bo362b2o$98bobo362b
2o$98b2o5$80b2o398b2o$81bo398bo$81bobo394bobo$82b2o394b2o9$482b2o$482b
obo$484bo$83b2o15b2o382b2o$83b2o15bobo371b2o$75b2o25bo371b2o$76bo25b2o
351bob2o$76bobo376b2obo$77b2o$464b2o$464b2o3$95b2o$95bo$93bobo44bo$93b
2o45b3o332b2o$143bo331bo$142b2o329bobo$473b2o$123bo42bo$104b2o17b3o38b
3o380b2o$97b2o6bo20bo36bo9bo374bo$97bo6bo20b2o11b2o23b2o6b3o374bobo$
95bobo6b2o32b2o30bo378b2o$95b2o73b2o$174b2o296b2o$174bo297b2o$82b2o88b
obo308bo36b2o$81bobo88b2o307b3o37bo$81bo25b2o371bo39bo$80b2o25b2o371b
2o38b2o2$150b2o23bo272bo$151bo22bobo271b3o$84b2o62b3o8b2o14bo275bo$83b
obo62bo11bo289b2o43b2o70b2o$83bo4b2o67b3o335b2o26b2o42bo$82b2o5bo27b2o
38bo365b2o40bobo$86b3o5bo23bo446b2o$86bo6bobo19b3o20b2o$94bo20bo22bo$
139b3o$141bo339b2o$156bob2o321bobo9b2o$156b2obo323bo8bobo38b2o5b2o$
483b2o7bo41bo5b2o$165b2o324b2o25b2o11b3o$165b2o351b2o11bo$567b2o$567b
2o$465b2o37b2o$466bo38bo$463b3o10b2o24b3o39b2o$463bo12b2o24bo40bobo11b
2o$175b2o337b2o27bo13bo$175bo338bo27b2o14b3o$173bobo339b3o42bo$173b2o
342bo5$155b2o$156bo404bo$156bobo400b3o$157b2o399bo$558b2o$550b2o$550b
2o6$567b2o$567bo$565bobo$158b2o15b2o388b2o$158b2o15bobo$150b2o25bo$
151bo25b2o$151bobo$152b2o4$569b2o$170b2o397bobo$170bo400bo$168bobo44bo
355b2o$168b2o45b3o343b2o$218bo342b2o$217b2o323bob2o$542b2obo$198bo42bo
$179b2o17b3o38b3o309b2o$172b2o6bo20bo36bo9bo302b2o$172bo6bo20b2o11b2o
23b2o6b3o$170bobo6b2o32b2o30bo$170b2o73b2o$249b2o$249bo$157b2o88bobo$
156bobo88b2o312b2o$156bo25b2o377bo$155b2o25b2o375bobo$559b2o$225b2o23b
o383b2o$226bo22bobo383bo$159b2o62b3o8b2o14bo384bobo$158bobo62bo11bo
400b2o$158bo4b2o67b3o$157b2o5bo27b2o38bo326b2o$161b3o5bo23bo365b2o$
161bo6bobo19b3o20b2o355bo36b2o$169bo20bo22bo354b3o37bo$214b3o350bo39bo
$216bo350b2o38b2o$231bob2o$231b2obo300bo$535b3o$240b2o296bo$240b2o295b
2o43b2o70b2o$582b2o26b2o42bo$610b2o40bobo$652b2o4$250b2o316b2o$250bo
317bobo9b2o$248bobo319bo8bobo38b2o5b2o$248b2o320b2o7bo41bo5b2o$578b2o
25b2o11b3o$605b2o11bo$654b2o$654b2o$230b2o320b2o37b2o$231bo321bo38bo$
231bobo316b3o10b2o24b3o39b2o$232b2o316bo12b2o24bo40bobo11b2o$601b2o27b
o13bo$601bo27b2o14b3o$602b3o42bo$604bo5$649bo$647b3o$646bo$233b2o15b2o
394b2o$233b2o15bobo$225b2o25bo384b2o$226bo25b2o383b2o$226bobo$227b2o4$
654b2o$245b2o407bo$245bo406bobo$243bobo44bo361b2o$243b2o45b3o$293bo$
292b2o2$273bo42bo$254b2o17b3o38b3o$247b2o6bo20bo36bo9bo$247bo6bo20b2o
11b2o23b2o6b3o$245bobo6b2o32b2o30bo335b2o$245b2o73b2o334bobo$324b2o
332bo$324bo333b2o$232b2o88bobo323b2o$231bobo88b2o324b2o$231bo25b2o370b
ob2o$230b2o25b2o370b2obo2$300b2o23bo312b2o$301bo22bobo311b2o$234b2o62b
3o8b2o14bo$233bobo62bo11bo$233bo4b2o67b3o$232b2o5bo27b2o38bo$236b3o5bo
23bo$236bo6bobo19b3o20b2o359b2o$244bo20bo22bo360bo$289b3o355bobo$291bo
355b2o$306bob2o$306b2obo411b2o$722bo$315b2o405bobo$315b2o406b2o2$646b
2o$646b2o$657bo36b2o$655b3o37bo$654bo39bo$325b2o327b2o38b2o$325bo$323b
obo296bo$323b2o297b3o$625bo$624b2o43b2o70b2o$669b2o26b2o42bo$697b2o40b
obo$739b2o4$655b2o$655bobo9b2o$657bo8bobo38b2o5b2o$657b2o7bo41bo5b2o$
665b2o25b2o11b3o$692b2o11bo$741b2o$312b2o427b2o$311bo2bo324b2o37b2o$
312b2o326bo38bo$637b3o10b2o24b3o39b2o$637bo12b2o24bo40bobo11b2o$688b2o
27bo13bo$688bo27b2o14b3o$689b3o42bo$691bo6$735bo$733b3o$732bo$732b2o$
724b2o$724b2o13$740b2o$740b2o6$733b2o$733bo$734b3o$736bo!

Maybe there's a case for a just G-to-2G, with pairs of Herschels going to it. With two semi-Snarks on each stream, you'd get alternating outputs, but you could bounce the gliders into opposition, and I think have the shooting range as wide as you wanted (and bidirectional):

Code: Select all

#C G-to-2G versions need shorter delays -- 185 and 467 respectively.
x = 569, y = 163, rule = B3/S23
2o385b2o$bo385bo$bobo381bobo$2b2o381b2o$460b2o$461bo$461bobo$462b2o$
20b2o$9b3o8bo356b3o5b2o$9bo8bobo44bo313bo5b2o$8b3o7b2o45b3o310b3o15bo
39bo$68bo325b3o37b3o26b2o$67b2o324bo39bo29b2o$393b2o38b2o$48bo42bo$29b
2o17b3o38b3o269bo$22b2o6bo20bo36bo9bo262b3o$22bo6bo20b2o11b2o23b2o6b3o
265bo$20bobo6b2o24b2o6b2o30bo267b2o43b2o70b2o$20b2o30b2ob3o37b2o311b2o
26b2o42bo$52b2o3b2o40b2o335b2o40bobo$54bobo2bo39bo378b2o$7b2o45b3o2b2o
36bobo$6bobo45bobob2o37b2o366b2o$6bo25b2o24bo406b2o$5b2o25b2o14bo345b
2o69b2o$47bo346bobo9b2o$47b3o25b2o23bo295bo8bobo38b2o5b2o11bo2b2o$76bo
22bobo294b2o7bo41bo5b2o12b3o$9b2o62b3o8b2o14bo303b2o25b2o11b3o21bo$8bo
bo62bo11bo345b2o11bo$8bo4b2o67b3o395b2o$7b2o5bo27b2o38bo397b2o$11b3o5b
o23bo334b2o37b2o$11bo6bobo19b3o20b2o314bo38bo$19bo20bo22bo312b3o10b2o
24b3o39b2o4b2o$64b3o309bo12b2o24bo40bobo4b2o5b2o$66bo360b2o27bo13bo$
81bob2o342bo27b2o14b3o$81b2obo343b3o42bo$430bo51bobo$90b2o391b2o$90b2o
391bo2$462b2o$461bo2bo10bo$39bo422bobo8b3o$40bo422bo8bo$38b3o422b2o7b
2o$100b2o361b2o$100bo362b2o$98bobo$98b2o$462bo$460b2o$460b2o2b3o$460b
2o3b2o$80b2o384bo13b2o$81bo381bob2o13bo$81bobo379b3o12bobo$82b2o380bo
13b2o9$482b2o$482bobo$484bo$83b2o15b2o382b2o$83b2o15bobo371b2o$75b2o
25bo371b2o$76bo25b2o353b2o$76bobo377bobo$77b2o377bo$455b2o7b2o$464b2o
3$95b2o$95bo$93bobo44bo$93b2o45b3o332b2o$143bo331bo$142b2o329bobo$473b
2o$123bo42bo$104b2o17b3o38b3o380b2o$97b2o6bo20bo36bo9bo374bo$97bo6bo
20b2o11b2o23b2o6b3o374bobo$95bobo6b2o32b2o30bo378b2o$95b2o73b2o$174b2o
296b2o$174bo297b2o$82b2o88bobo308bo39bo$81bobo88b2o307b3o37b3o$81bo25b
2o371bo39bo$80b2o25b2o371b2o38b2o2$150b2o23bo272bo$151bo22bobo271b3o$
84b2o62b3o8b2o14bo275bo$83bobo62bo11bo289b2o43b2o70b2o$83bo4b2o67b3o
335b2o26b2o42bo$82b2o5bo27b2o38bo365b2o40bobo$86b3o5bo23bo446b2o$86bo
6bobo19b3o20b2o$94bo20bo22bo$139b3o$141bo339b2o$156bob2o321bobo9b2o$
156b2obo314bobo6bo8bobo38b2o5b2o$475b2o6b2o7bo41bo5b2o$165b2o308bo15b
2o25b2o11b3o$165b2o351b2o11bo$567b2o$567b2o$465b2o37b2o$466bo38bo$463b
3o10b2o24b3o39b2o$463bo12b2o24bo40bobo11b2o$175b2o337b2o27bo13bo$175bo
338bo27b2o14b3o$173bobo339b3o42bo$173b2o342bo6$561bo$559b3o$558bo$558b
2o$550b2o$550b2o5$162b2o$161bo2bo402b2o$162b2o403bo$565bobo$565b2o4$
566b2o$566b2o6$559b2o$559bo$560b3o$562bo!

For the schematic, I think I've fallen several steps behind your thinking. A few labels might help, to make sure I have the right ideas. What are the circles -- just plain reflectors, not semi-Snarks? Are the green squares the parent half-R.U.s, and the red ones are the child? Is the diagonal blue line a Herschel signal split off from the memory loop? [Since the other signals are all presumably gliders, I kind of expected a diagonal line to be an *WSS.]

Seems like it might be a bit tricky to build the lower red rectangles (reflectors) while signals are passing right through the area -- I think you mentioned that earlier. In a pinch it could be done by building freeze-dried slow salvos in the empty space between the two halves, and then triggering it at the right moment. In an extreme case, this could completely tear down and rebuild a piece of circuitry in a new location in a few thousand ticks instead of a few million.

In some situations it might even be worth working out how to build two freeze-dried salvos 90 degrees from each other, and then trigger them simultaneously -- ending up with a Gemini-style construction by colliding the two "synchronized slow" 90-degree streams together. Not in this case, though, I think -- the salvo seed objects would have to be constructed near the circulating signal gliders again, which is basically the same as the original construction problem.

[simsim314]

I've been thinking about is building two semi-Snarks, and adding circuitry in the upper part to turn each single glider into four

Well although I see the advantage of using semi snark as reflector, and can also think of a design: split the H Gemini style, and then shoot the glider onto the same lane, also Gemini like (which is I think originally spartan UC?). But it seems just too inefficient. I liked the way the first 39SL "reflected" a glider, there was a lot of space there, so probably something along those line will be much more efficient.

A few labels might help

Yep sorry, I was more or less using the same color code as LifeHistory. The circles just indicate that the reflected glider are from the "further side", and will need to be build with "extra slow" salvo falling outside the building range. It might be beehive or Semi snark I don't know. Yes the green color is the static parent part, the red is the child, the gray arrows is the construction direction, and the blue is glider stream path. The blue I meant is the blue of LifeHistory. The diagonal is probably the split H (or anything else it's just a signal pass mark). I think you got it all correctly. The only detail I should point , is that the reflected glider should get "outside of the reflector path", or as much as possible. The key detail is that the upper part and the lower part are on different "x" locations (in the schematics), so they all can be built by the slow salvo, but they exchange signals (reflect them in circle) so the need to be pretty close in the x direction.

Seems like it might be a bit tricky to build the lower red rectangles (reflectors) while signals are passing right through the area

.

Well the only problematic part is the "left" side of the lower left reflector (and right part of the right reflector). Which is again a design challenge to minimize that area, but it's just a small area having few SLs, that needs to be "dried". Although using a dried slow salvo it's might be necessary to "cut out" some extra SLs to "clear the path".

Another solution, is to move the child a bit to the right and make a "hole" in that area (kinda hole the silver has that allows glider path through). Of course this will cost in more "out of range" SLs, but it's definitely an option, considering we need to move it few lanes just enough not to "touch" the "input lane" of the lower child reflector.

Another note to notice: This design can work only with self destruct mechanism (at least partial).

I'm also not concerned with the details in the schematics (like, H, G, WSS or whatever - they all signals, and can be implemented differently), much more I'm concerned with the geometrical properties and limitations (in timing, and in placement etc).

------

Attached another schematics. The triangle represent the RU. It's longest edge is the shooting range. It's triangular so that it would be easy to follow the orientation. A detail to notice that entry point cannot be changed, but it's possible to "wire" the design in different ways. 1-2-3 of the triangles is the history, 1 grandparent, 2 parent, 3 child. Blues is the signal stream. The main idea of this schematics is to show the possibility of 90 degree stepping. It's operation is rotate clockwise and flip x. It's easy to see that 1 to 2 is oriented exactly as 2 to 3 and that 1-3 is just a translation.

[simsim314]

Here is a recipe in Serizawa, for slow salvo RU "edge" 180 degree reflector.

Code: Select all

x = 159, y = 54, rule = Serizawa
14$3.A39.A39.A$4.B39.B39.B$3.A39.A39.A5$135.A$136.B12.A$135.A17.A$
146.A6$133.A15.A$134.B6.A9.A$133.A8.B$18.A39.A39.A42.A$19.B39.B39.B
53.A$18.A39.A39.A50.A7$9.A39.A39.A$10.B39.B39.B$9.A39.A39.A!

And here is a much nicer 4G->G with much less components, and p40 recovery.

Code: Select all

x = 48, y = 205, rule = Serizawa
10$30.A2$14.A$29.A.A$35.A$13.A.A$9.A7$13.A7.A.A7.A$10.A23.A$13.A17.A
4$14.A15.A3$30.A2$14.A$29.A.A$35.A$13.A.A$9.A7$13.A7.A.A7.A$10.A23.A$
13.A17.A4$14.A15.A$22.B$21.A.A19$22.B$21.A.A19$22.B$21.A.A19$22.B$21.
A.A19$22.B$21.A.A17$22.B$21.A.A19$22.B$21.A.A19$22.B$21.A.A!

It's very close to optimal in recovery time (the regular duplicator/reflector is p28).

EDIT* It's funny an idea taken from Serizawa adapted into life, made me to rethink the approach again and "re-adapt" it back into Serizawa in different way. As I mentioned the "outside blocks" that should be built with slow salvo are very expensive in Serizawa, so we want to avoid this as much as we can (with cost of 1 to 100). So here is 4G->G reflector from a single block.

Code: Select all

x = 9, y = 23, rule = Serizawa
2.A11$.B$A.A$5.A$4.ABA$4.A.A2$7.A$6.ABA$6.A.A$2.A$.ABA$.A.A!

This is not "cheap", creating a well timed low separation salvo of 4 gliders will cost around 50x4 = 200 blocks (or 2 outside cells).

So another interaction I've found requires two blocks and it uses 3 well timed gliders to create a 90 degree reflector from a block.

Code: Select all

x = 47, y = 131, rule = Serizawa
9$30.A4$29.A30$28.A$27.ABA$27.A.A3$33.A$32.ABA$32.A.A3$34.B$33.A.A3$
28.B$27.A.A3$35.B$34.A.A21$30.A$29.ABA$29.A.A18$10.B$9.A.A10$9.A$8.AB
A$8.A.A6$18.A$17.ABA$17.A.A!

It looks cheaper, but creating well timed salvo even once, is not an easy task in Serizawa. The "simple" dried salvo approach doesn't allow low separation and good timing, some additional "tricks" are needed. But this approach is definitely less expensive (say 50 for the dry salvo + 2 outside blocks, is 250).

Finally here is 5 gliders single block reflector. It's has more than the 4 glider reflector, but it has a much better separation.

Code: Select all

x = 7, y = 57, rule = Serizawa
6.A10$4.B$3.A.A14$3.A$2.ABA$2.A.A2$5.B$4.A.A12$2.A$.ABA$.A.A11$.B$A.A!

[simsim314]

My Serizawa method for handling the edge made me thinking: if we go for the design of "all at the same place with single 180 degree reflector", we don't need a real reflector, we can send a glider cluster (Gemini style), and get one glider back. Here is an example (3G->G single block 180 reflector):

Code: Select all

x = 32, y = 31, rule = B3/S23
7$8b2o$8b2o8$21b2o$15b3o2b2o$15bo6bo$16bo3$19bo$18b2o$18bobo!

Now for the cost analysis: there is a need of G->3G cluster interpreter, taking average Gemini components is about 50-70 SLs per extra well timed glider, getting to 150 (3G) components, which is of a price of about 15 SLs outside the construction zone (assuming 1 to 10 ratio). So it's probably not worth it unless either we will find a better G->3G interpreter, or 1 to 10 ratio is also optimistic. If we use let's say 1 to 30, it will already get us to 5 SLs outside the construction zone, which can compete with the previous design with 27 inside and 4-5 outside the zone (in this design we also have 1 block outside the zone). But's it's still another (elegant) option in our disposal.

EDIT Similar approach could be used for the lower reflector in two separate stream Geminoid, instead the "two semi snarks" with 12 SLs. If we already go for G->NG approach and dried salvo, I think some more elegant glider salvo could reflect 180 degree with single block (maybe 2?). My current 3 gliders can't work in parallel, but it should be not so hard to find, and it shouldn't be too expensive.

EDIT2 I liked your design of G->4G, it is very elegant, and although I'm not so sure about using it in the current design (mostly because 2 dried semi snarks + some extra 130+SLs, is a bit high price, you can get a dried block + around 200 SLs, to have a nice reflector and much less "work" with the dried salvo), I do think it's a good piece of circuitry to have in the arsenal.

EDIT3 I've found a reflectable (from a block) 180 glider salvo (of 8 gliders - two 4 gliders salvos). Looking to improve...

Code: Select all

x = 320, y = 312, rule = LifeHistory
2A$2A9$14.3A$14.A$15.A4$21.2A$21.A.A$21.A6$29.2A$28.2A$30.A8$39.2A$
39.A.A$39.A3$46.3A$46.A$47.A4$53.2A$52.2A$54.A6$60.3A$60.A$61.A2$66.A
$65.2A$65.A.A14$77.3A$77.A$78.A4$84.2A$84.A.A$84.A6$92.2A$91.2A$93.A
8$102.2A$102.A.A$102.A3$109.3A$109.A$110.A4$116.2A$115.2A$117.A6$123.
3A$123.A$124.A2$129.A$128.2A$128.A.A14$140.3A$140.A$141.A4$147.2A$
147.A.A$147.A6$155.2A$154.2A$156.A8$165.2A$165.A.A$165.A3$172.3A$172.
A$173.A4$179.2A$178.2A$180.A6$186.3A$186.A$187.A2$192.A$191.2A$191.A.
A14$203.3A$203.A$204.A4$210.2A$210.A.A$210.A6$218.2A$217.2A$219.A8$
228.2A$228.A.A$228.A3$235.3A$235.A$236.A4$242.2A$241.2A$243.A6$249.3A
$249.A$250.A2$255.A$254.2A$254.A.A14$266.3A$266.A$267.A4$273.2A$273.A
.A$273.A6$281.2A$280.2A$282.A8$291.2A$291.A.A$291.A3$298.3A$298.A$
299.A4$305.2A$304.2A$306.A6$312.3A$312.A$313.A2$318.A$317.2A$317.A.A!

EDIT4

Here is an improvement to 5 gliders salvo:

Code: Select all

x = 249, y = 250, rule = LifeHistory
2A$2A9$5.3A$5.A$6.A4$15.A$14.2A$14.A.A12$26.A$25.2A$25.A.A5$32.3A$32.
A$33.A8$47.A$46.2A$46.A.A11$55.3A$55.A$56.A4$65.A$64.2A$64.A.A12$76.A
$75.2A$75.A.A5$82.3A$82.A$83.A8$97.A$96.2A$96.A.A11$105.3A$105.A$106.
A4$115.A$114.2A$114.A.A12$126.A$125.2A$125.A.A5$132.3A$132.A$133.A8$
147.A$146.2A$146.A.A11$155.3A$155.A$156.A4$165.A$164.2A$164.A.A12$
176.A$175.2A$175.A.A5$182.3A$182.A$183.A8$197.A$196.2A$196.A.A11$205.
3A$205.A$206.A4$215.A$214.2A$214.A.A12$226.A$225.2A$225.A.A5$232.3A$
232.A$233.A8$247.A$246.2A$246.A.A!

For reference here is the script I used to find all the above patterns:

Code: Select all

import golly as g
import random 

gld = g.parse("3o$o$bo!")
block = g.parse("2o$2o!")

def SetRandGliderParallelStream(dist,num):
	g.new("")
	g.setstep(3)
	curdist = 5
	g.putcells(gld, 0, 0)
	
	total = 1
	while total < num: 
		
		x = random.randint(0,dist - 1)
		j = random.randint(0,3)
		k = random.randint(-4,4)
		gldj = gld
		
		if j > 0:
			gldj = g.evolve(gld,j)
		
		g.putcells(gldj, curdist + x + k, curdist + x)
		
		curdist += 5 + x
		total += 1 
		
	g.setmag(1)

	
def SetRandGliderStream(maxX,maxY,num):
	g.new("")
	
	g.setstep(3)
	g.putcells(gld, maxX + 100, maxY + 100)
	
	total = 0 
	while total < num: 
		
		x = random.randint(0,maxX - 1)
		y = random.randint(0,maxY - 1)
		j = random.randint(0,3)
		
		gldj = gld
		
		if j > 0:
			gldj = g.evolve(gld,j)
		
		g.reset()
		g.run(4)
		
		g.putcells(gldj, x - 1, y - 1)
		
		rect = g.getrect()
		p0 = g.getpop()
		g.step()
		
		rectStep = g.getrect()
		p512 = g.getpop()
		if rectStep == [] or p512 != p0:
			continue 
		
		if rect[0] - 128 == rectStep[0] and rect[1] - 128 == rectStep[1] and rect[2] == rectStep[2] and  rect[3] == rectStep[3]:
			g.reset()
			g.putcells(gldj, x, y)
			
			total += 1
	
	g.select([maxX + 100, maxY + 100, 4, 4])
	g.clear(0)
	g.select([])
	
	
maxX = 10 
maxY = 10
num = 3
len = 15
total = 0
dxy = [(0,0),(1,0),(0,1),(1,1)]

#SetRandGliderParallelStream(4,num)
#g.putcells(block, -10, -10)

while True: 
	total += 1
	SetRandGliderParallelStream(len,num)
	
	for i in xrange(-17, -3):
		g.reset()
		g.run(1)
		g.putcells(block, i, -10)
		#g.putcells(block, -7 + i, -5)
		g.step()
		
		rect = g.getrect()
		
		    
		if rect == []:
			continue
		
		if total % 100 == 0:
			g.show(str(total))
			
		'''
		#if rect[0] == -6 + i  and rect[1] == 0 and int(g.getpop()) == 4:
		if rect[0] == -6 + i  and rect[1] == 0:
			
			bl = True
			for xy in dxy:
				if g.getcell(rect[0] + xy[0], rect[1] + xy[1]) == 0:
					bl = False
			
			if bl: 
			
			g.reset()
			g.putcells(block, -7 + i, -5)
			g.exit("success")
		'''
		'''and int(g.getpop()) == 5 + 4'''
		
		if rect[0] == i  and rect[1] == -10  and rect[2] > 70 and rect[3] > 70 and int(g.getpop()) <= 19:
			
			if abs((rect[0] +  rect[2]) - (rect[1] + rect[3])) <=6: 
				continue
			
			bl = True
			for xy in dxy:
				if g.getcell(rect[0] + xy[0], rect[1] + xy[1]) == 0:
					bl = False
			
			if bl: 
				g.reset()
				g.putcells(block, i, -10)
				g.exit("success")
				
			
		

[simsim314]

In Serizawa it's impossible to do a lot of operations with only single glider (Life style slow salvo). I've showed that there is a universal set of operation as construction arm with single glider, and it can be used to move block around as well, but there is no "splitter" so each block would have to be placed from scratch.

So Here is a two glider pairs salvo solutions in Serizawa. They have much more operations, and although a bit more complex to construct than single glider shoot, they have a lot of nice splitters and other operations, that can easily compensate for the complexity.

Code: Select all

x = 229, y = 90, rule = Serizawa
20.A18$144.A9.A9.A9.A9.A9.A9.A9.A9.A$31.A3$5.A3$30.A.A$39.A2$4.A.A$A
37.A.A$44.A6$142.A10.A9.A9.A9.A11.A7.A9.A9.A$141.ABA8.ABA7.ABA7.ABA7.
ABA9.ABA5.ABA7.ABA7.ABA$141.A.A8.A.A7.A.A7.A.A7.A.A2.B6.A.A5.A.A7.A.A
7.A.A$156.B29.A.A18.A$155.A.A9.B7.B30.ABA$166.A.A5.A.A15.B13.A.A18.A$
144.B46.A.A23.A8.ABA$143.A.A70.ABA7.A.A$216.A.A13$31.A$30.ABA$30.A.A$
5.B$4.A.A6$39.B$38.A.A19$19.A$18.ABA$18.A.A!

At the left is an example of well separated stream that creates a very "packed" glider pair. At the right there is a recipe collection of glider pair operations.

Another point, is that with this technology, it's now possible to create single armless unit, with two stream and use the design that I've build for separate streams linear replicator in Life.

[dvgrn]

Here are a few more possible applications of Serizawa-style armless construction to Conway's Life problems.

First of all, I had forgotten the numbers for recovery time of the smallest Spartan Herschel splitters -- had to go look them up. Here are the most reasonable ones that I know about:

Code: Select all

#C maybe-Spartan Herschel splitter, recovery time 251 ticks
x = 197, y = 91, rule = B3/S23
106bo$104b3o$103bo$84bo18b2o7b2o3b2o$84b3o25b2o3b2o$87bo$86b2o$124b2o$
56bo67bo$55bobo64bobo$55bobo64b2o$56bo$67bo15b2o$67bo15b2o$65b3o$65bo
2$119b2o$119bo$90b2o28b3o$73b2o15bo31bo$73bo17b3o$74b3o16bo$76bo4$106b
2o$106b2o7$129b2o$129b2o$2bo164bo$obo162b3o$b2o161bo$164b2o$155b2o$
155bobo37bo$156bo37bobo$129b2o63bobo$128bo2bo63bo$129b2o36b2o15bo$136b
2o29b2o15bo$104b2o30b2o46b3o$95b2o7b2o80bo$96bo$96bobo$97b2o2$177b2o$
123b2o53bo$123b2o50b3o$127b2o46bo$96bo29bobo$33b2o61b3o27bo$33b2o52bo
11bo25b2o$71bo15b3o8b2o14bo23b2o$69b3o18bo22bobo22b2o$68bo20b2o23bo$
68b2o$32bo26b2o79b2o$33bo25bobo78b2o$31b3o26bo50b2o$111bobo$113bo$71b
2o15bo24b2o$40b2o29b2o15bobo18b2o$40b2o46b3o18bo$90bo11b2o6b3o$102bo9b
o$103b3o$105bo2$81b2o$27b2o53bo$27b2o50b3o$31b2o46bo$30bobo$30bo$29b2o
$42b2o$42b2o3$44b2o$44b2o!

The two closely-spaced eaters in the key L156 variant are buildable with slow salvos in all orientations, but it may be a bit of a pain in some cases. Moving to a design with better still-life spacing costs you just a few ticks:

Code: Select all

#C Spartan Herschel splitter, recovery time 262 ticks
x = 143, y = 107, rule = B3/S23
99b2o$98bo2bo$99b2o8$94b2o$95bo$95b3o6$88b2o$87bobo$87bo47b2o$86b2o46b
o2bo$135b2o6$96b2o$96b2o7b2o$105bo24b2o$103bobo25bo$103b2o26b3o7$101bo
$100bobo$101b2o7$132b2o$132b2o7b2o$141bo$139bobo$139b2o$2bo$obo$b2o74b
2o42b2o$77b2o43bo$81b2o39bobo$81b2o40b2o$95b2o$95b2o$137b2o$137bobo$
139bo$139b2o2$107b2o$107b2o$85b2o$86bo$83b3o$83bo50b2o$87b2o45bo$87b2o
46b3o$137bo$33b2o$33b2o52bo$71bo15b3o$69b3o18bo$28bobo37bo20b2o11b2o$
29b2o37b2o32b2o$29bo29b2o$59bobo$60bo3$71b2o15bo21b2o21b2o$40b2o29b2o
15bobo18bobo21b2o$40b2o46b3o18bo17b2o$90bo17b2o17b2o3$129b2o$122b2o5b
2o$81b2o39b2o$27b2o53bo$27b2o50b3o20b2o$31b2o46bo22bo$30bobo70b3o$30bo
74bo$29b2o$42b2o$42b2o3$44b2o$44b2o!

If you really had to, you could build a Spartan Herschel splitter with a recovery time of 117 ticks (the limit for a standard Herschel transceiver). Even all the way down to 69 is theoretically possible, but that would require a horrible multi-state and multi-stage recovery system. Here are a couple of samples of two-state recovery systems:

Code: Select all

#C three parallel gliders, two semi-Snarks, and a Herschel receiver --
#C   two-state Herschel splitters with recovery times 334 (left) and 364
x = 641, y = 251, rule = LifeHistory
A$.2A$2A3$432.2A$431.A2.A$432.2A8$427.2CD$428.C$428.3C6$421.2A$420.A.
A$420.A$419.2A6$446.A$429.2A15.3A$429.2A7.2A9.A$438.A9.2A6.2A$436.A.A
16.A.A$436.2A18.A3$443.2A$443.2A6.2A$451.2A2$434.A25.2A$433.A.A24.2A$
434.2A$445.2A$444.A.A$444.A$443.2A10$410.2A$410.2A$414.2A$414.2A$428.
2A$428.2A5$431.A$430.A.A7.2A$430.A.A7.2A$418.2A11.A$419.A$25.A390.3A$
26.A389.A$24.3A393.2A$420.2A6$83.C.C$84.2C$84.C2$401.2A8.A$401.2A6.3A
$408.A$393.2A13.2A$394.A$394.A.A$395.2A2$402.2A$402.2A3$397.A$396.A.A
13.2C$396.2A13.2C$413.C2$405.2A$405.2A33$501.C$500.2C$500.C.C6$50.A$
51.2A$50.2A10$109.C$107.C.C$108.2C2$605.A$603.3A$602.A$602.2A$590.A$
590.3A$593.A$592.2A$273.A$254.A18.3A$254.3A19.A329.2A11.A$257.A17.2A
11.2A11.C304.2A11.3A$256.2A30.2A9.3C212.A44.2A7.2A52.A$299.C.D210.3A
44.2A7.A52.2A$299.C211.A54.A.A14.2C$310.A200.2A53.2A15.C.C$309.A.A
271.C$309.A.A$191.2A117.A319.C$191.2A55.2A271.A106.3C$249.A271.3A87.
2A15.C.D$249.A.A272.A58.2A26.2A15.C$200.2A48.2A247.C23.2A11.2A45.2A
54.A$199.A.A295.3C36.2A100.A.A$200.A296.C.C138.A.A$244.A252.C141.A$
225.A18.3A$194.2A29.3A19.A360.2A$194.2A32.A17.2A40.2A318.A$227.2A59.A
320.3A$201.2A86.3A319.A$201.A.A87.A219.2A$203.A294.2A11.2A$188.2A13.
2A294.A$189.A306.3A$186.3A6.2A299.A$186.A8.2A22.2A336.2A$220.A294.2A
41.A$220.A.A293.A38.3A$221.2A290.3A20.2A17.A$254.2A257.A22.A$161.2A
92.A281.3A$161.2A52.A36.3A284.A$199.A15.3A34.A$197.3A18.A$196.A20.2A$
196.2A$187.2A$187.A.A$188.A$161.2A$160.A2.A$161.2A36.2A$168.2A29.2A$
168.2A3$225.2A$226.A$223.3A$209.2A12.A$155.2A53.A$155.2A50.3A$159.2A
46.A$158.A.A$158.A$157.2A$170.2A$133.C.C34.2A$134.2C10.2A$134.C11.A$
144.A.A25.2A$144.2A26.2A2$129.2A$129.2A2$138.2A$138.2A6.2A$146.2A3$
134.A$133.A.A$133.2A6.2A$141.A$142.3A$144.A!

With shorter delays allowed between signals, it gets easier to collect extra gliders from short stretches of Herschel track, and get workable armless constructors out:

Code: Select all

x = 302, y = 581, rule = LifeHistory
C$.2C$2C73$25.C$26.C$24.3C7$83.C.C$84.2C$84.C61$50.C$51.2C$50.2C10$
109.C$107.C.C$108.2C20$191.2A$191.2A3$200.2A$199.A.A$200.A3$194.2A$
194.2A2$201.2A$201.A.A$203.A$188.2A13.2A$189.A$186.3A6.2A$186.A8.2A3$
281.A$279.3A$161.2A76.2A14.A22.A$161.2A51.2A24.A14.3A20.2A$199.A15.A
13.2A6.3A18.A$197.3A15.A.A11.2A6.A19.2A$196.A19.2A$196.2A$187.2A$187.
A.A$188.A$161.2A$160.A2.A83.2A$161.2A36.2A46.2A51.A$168.2A29.2A98.A.A
$168.2A129.A.A$300.A3$244.2A32.2A$244.A20.2A11.2A$225.2A3.2A13.3A18.A
$155.2A40.2A27.A3.A16.A15.3A$155.2A40.2A24.3A5.3A29.A$159.2A62.A9.A$
158.A.A$158.A29.2A$157.2A29.A.A$170.2A17.A$133.C.C34.2A$134.2C10.2A$
134.C11.A$144.A.A25.2A18.2A$144.2A26.2A18.2A$187.2A$129.2A55.A.A$129.
2A55.A$185.2A13.2A$138.2A60.A$138.2A6.2A45.2A6.3A$146.2A45.2A8.A3$
134.A$133.A.A$133.2A6.2A$141.A$142.3A$144.A16$231.2A$232.A$232.A.A$
233.2A2$248.2A$248.2A2$239.2A$231.2A6.2A$231.2A3$244.A$243.A.A$236.2A
6.2A$237.A$234.3A$234.A4$C$.2C$2C73$25.C$26.C$24.3C7$83.C.C$84.2C$84.
C61$50.C$51.2C$50.2C10$109.C$107.C.C$108.2C20$191.2A$191.2A3$200.2A$
199.A.A$200.A3$194.2A26.A$194.2A26.3A$225.A$201.2A21.2A$201.A.A$203.A
$188.2A13.2A$189.A$186.3A6.2A$186.A8.2A5$161.2A$161.2A$199.A$197.3A
12.A$196.A15.3A$196.2A17.A$187.2A25.2A$187.A.A$188.A$161.2A$160.A2.A$
161.2A36.2A$168.2A29.2A$168.2A5$243.A9.A$217.2A24.3A5.3A$155.2A40.2A
19.A27.A3.A16.A$155.2A40.2A16.3A27.2A3.2A13.3A$159.2A54.A48.A$158.A.A
103.2A$158.A29.2A$157.2A29.A.A104.A$170.2A17.A35.2A67.A.A$133.C.C34.
2A48.2A3.2A67.A.A$134.2C10.2A72.2A73.A$134.C11.A120.2A$144.A.A25.2A
18.2A73.2A$144.2A26.2A18.2A25.2A$187.2A31.A5.2A$129.2A55.A.A28.3A6.2A
$129.2A55.A30.A$185.2A13.2A$138.2A60.A35.2A$138.2A6.2A45.2A6.3A31.A.A
11.2A6.A$146.2A45.2A8.A31.A13.2A6.3A$234.2A24.A$259.2A$134.A$133.A.A$
133.2A6.2A$141.A$142.3A$144.A24$232.2A$233.A$233.A.A$234.2A2$249.2A$
249.2A2$240.2A$232.2A6.2A$232.2A3$245.A$244.A.A$237.2A6.2A$238.A$235.
3A$235.A!

I've looked a little more at the idea of sending signals in two separate streams, and not using period-doublers at all. One way of doing this is while still avoiding signal-crossing problems is to send the two streams in series. It's nice that the serial switching circuitry is so trivial: all you have to do is stop the first circuit's output with an eater. When gliders start coming from both directions, you only need one or two pairs of gliders to cleanly knock out the eater... and when the gliders stop coming from the first circuit, a backstop eater can take care of the unmatched gliders from the second circuit:

Code: Select all

#C unblocking an "armless" circuit --
#C moving the two ends farther apart creates as much room you want
#C for more colliding glider pairs.
x = 377, y = 488, rule = LifeHistory
35.2A$35.2A$56.A$54.3A11.A$53.A14.3A$53.2A16.A14.A$70.2A12.3A$83.A$
83.2A3$82.2A$63.2A17.2A$63.2A2$25.2A$25.2A3$66.2A$46.2A19.A$46.A.A15.
3A$48.A15.A$48.2A19.2A$70.A$67.3A$67.A6$60.2A$61.A$61.A.A15.2A$62.2A
15.2A12$80.2A$80.A.A$82.A$82.2A9$70.2A$70.2A6$53.D.D25.2A$53.2D5.2A
19.A$54.D6.A17.A.A$61.A.A15.2A$62.2A4.A$67.A.A$67.A.A$68.A10.2A$50.C
28.A.A$48.3C30.A$47.C33.2A$47.2C17.2A$67.A$64.3A$64.A8$13.2A20.2D$13.
2A19.D.D$36.D$46.A$46.3A$49.A14.A$48.2A12.3A$61.A$61.2A3$60.2A$41.2A
17.2A$41.2A2$3.2A$3.2A3$44.2A$24.2A19.A$24.A.A15.3A$26.A15.A$26.2A19.
2A$48.A$45.3A$45.A3$2.2A$.A.A$.A$2A36.2A$39.A$39.A.A15.2A$40.2A15.2A
12$58.2A$58.A.A$60.A$60.2A9$48.2A$48.2A$36.2A$35.A.A$35.A$34.2A2$59.
2A$38.2A19.A$39.A17.A.A$39.A.A15.2A$40.2A4.A$45.A.A$45.A.A2.2C$46.A3.
C.C4.2A$50.C6.A.A$59.A$59.2A$44.2A$45.A$42.3A$42.A31$334.2A$334.A$
332.A.A$290.A37.2A2.2A$264.A9.A15.3A35.2A$264.3A5.3A18.A$267.A3.A20.
2A11.2A$266.2A3.2A32.2A8$280.2A52.2A$280.2A34.2A16.A.A$268.2A45.A.A
18.A$267.A2.A44.A20.2A$262.2A4.2A44.2A4.2A$261.A.A55.A.A$261.A57.A$
246.2A12.2A56.2A7.2A$246.A23.2A33.2A20.2A$244.A.A23.A34.A$202.A37.2A
2.2A25.3A32.3A$176.A9.A15.3A35.2A31.A34.A$176.3A5.3A18.A$179.A3.A20.
2A11.2A$178.2A3.2A32.2A$337.2A$274.D62.A$272.2D61.A.A$273.2D60.2A3$
265.2C$192.2A52.2A17.C51.A$192.2A34.2A16.A.A14.C.C51.3A$180.2A45.A.A
18.A14.2C55.A$179.A2.A44.A20.2A69.2A$174.2A4.2A44.2A4.2A$173.A.A55.A.
A$173.A57.A$172.2A56.2A7.2A$182.2A33.2A20.2A$182.A34.A$183.3A32.3A$
185.A34.A$190.2A$191.A58.3D86.2A$188.3A61.D86.2A$188.A62.D7$229.A$
229.3A92.2A$232.A91.2A$231.2A10$251.2A$251.2A9$236.2A$222.2A12.2A$
223.A$220.3A$220.A200$374.3C$374.C$375.C!

This is just a sample -- notice that the timing doesn't come out right in the southeast R.U. For that to work, the two Silver reflectors in each R.U. would have to be lined up with each other diagonally... which means you'd need semi-Snarks to get the output gliders to line up again... which means, depending on how many semi-Snarks you used, that half, or three quarters or whatever, of the gliders would be "non-coding", sent only to feed the semi-Snarks.

In some designs there are big advantages to having non-coding gliders, though! Different gliders can be coding and non-coding in different replicator units...

What I'm really looking forward to is a four-cornered Geminoid, just because Golly should be able to run a diamond-shaped spaceship so much faster than the antiparallel straight-line designs. Each corner of the diamond would have three semi-Snarks attached to each of two glider outputs, turning the gliders onto a collision course to produce an armless constructor. Each corner is different, so four different construction recipes would be interleaved in the glider stream in groups of eight -- four corners, four pairs of gliders.

Time to start a new forum thread for the diamond Geminoid, I think!

[simsim314]

Here are the most reasonable ones that I know about:

Well this is nice!

The original Gemini splitter recovery is 290 ticks:

Code: Select all

#Gemini Herschel splitter with 290 ticks recovery 
x = 152, y = 109, rule = LifeHistory
106.2A$105.A2.A$106.2A19$92.2A$91.A.A50.2A$91.A51.A2.A$90.2A52.2A4$
103.2A$103.2A2$110.A$110.3A$113.A$112.2A5$108.A$107.A.A$108.2A4$A$.2A
$2A3$141.2A$141.2A2$148.A$148.3A$84.2A65.A$84.2A64.2A$88.2A40.2A$88.
2A41.A$102.2A27.A.A$102.2A28.2A3$146.2A$146.A.A$148.A$114.2A32.2A$
104.A9.2A$92.2A$93.A$90.3A$90.A$94.2A$94.2A47.2A$30.A.A110.A$31.2A
111.3A$31.A114.A$42.2A$42.2A52.A$80.A15.3A$78.3A18.A$77.A20.2A11.2A$
77.2A32.2A$68.2A$68.A.A$69.A3$80.2A15.A21.2A21.2A$49.2A29.2A15.A.A18.
A.A21.2A$49.2A46.3A18.A17.2A$99.A17.2A17.2A3$138.2A$131.2A5.2A$90.2A
39.2A$36.2A53.A$36.2A50.3A20.2A$40.2A46.A22.A$39.A.A70.3A$39.A74.A$
38.2A$51.2A$51.2A3$53.2A$53.2A!

It's possible that all those splitters can be useful because each of them has it's own timing and placement of Hersch.

all you have to do is stop the first circuit's output with an eater..

Hmm why not to use your "key" mechanism? we pass all the Herschels through a "lockable" herschel track, and use a key to open it when we need it.

Anyway I really didn't get what exactly the problem you're trying to solve here. Why you open the tracks at some point? And have them close on other?

What I'm really looking forward to is a four-cornered Geminoid

Well for starters it's not obvious it's even possible. You have four corners, so your stream size is limited to the size of your diamond edge. Of course you could increase the diamond edge, but this will require more command because the further unit will be more far away, and you'll need some extra commands to get the construction block there. So increasing the edge will increase the required command length.

So one possibility is to have separate circuit for "pushing the blocks far away" and when it's far away enough, we "turn on" the circulating construction commands, and "turn off" the pushing commands. Once again just pointing out it's more complex than it seems.

Another complexity with "four copies" is proximity alerting mechanism, which should be triggered on "stage two", so the copy will not work to direction where some other unit wants to copy, or where there is already a copy.

Anyway it's nice project, and the armless design definitely has some useful potential there (let's say instead of diamond we use long and thin, so we have 2 copies instead of four, but they fully "fit" inside the construction area.

[dvgrn]

all you have to do is stop the first circuit's output with an eater..

Hmm why not to use your "key" mechanism? we pass all the Herschels through a "lockable" herschel track, and use a key to open it when we need it.

Anyway I really didn't get what exactly the problem you're trying to solve here. Why you open the tracks at some point? And have them close on other?

The "key" mechanism would work, but it's not needed here. No need to add dozens of still lifes when two eaters will do everything that's needed.

The idea here is to have construction data in a single glider stream, just as in the linear Life replicator or in your new armless R.U.s ... but instead of sending gliders in pairs and decoding them with semi-Snarks or other period doublers, you send the information serially: first send all of the gliders that will come from the northeast (in this example). They pass harmlessly through the first reflector -- let's call that "Reflector A" -- then through a very long delay loop, and they start to reach the second reflector, B, at the same time as the gliders that they're supposed to be paired with are finally reaching Reflector A.

With gliders from both directions, you can easily get rid of the single eater that's blocking Reflector A's extra output, and then start an "armless" construction using colliding gliders from Reflectors A and B. When all the gliders have gone through the A reflector, they'll also get processed by the B reflector, but with no gliders coming from A to oppose them, they'll pass harmlessly through and get cleaned up by an eater on the far side of Reflector A.

One advantage to this is that the construction can happen twice as fast (once the circuits are "loaded") because there aren't any period doublers to slow things down. Another big advantage might be that you can include singleton gliders in your "armless" recipes if you need them. Not sure if those will outweigh the disadvantages, but it's another possible tool for the collection.

[dvgrn]

What I'm really looking forward to is a four-cornered Geminoid

Well for starters it's not obvious it's even possible. You have four corners, so your stream size is limited to the size of your diamond edge. Of course you could increase the diamond edge, but this will require more command because the further unit will be more far away, and you'll need some extra commands to get the construction block there. So increasing the edge will increase the required command length.

Yes, people keep saying things like that... but in B3/S23 there are good workarounds available. As you say, we could run a "block pusher" for one full trip around the diamond, then do the construction on the next cycle, then the data copying on the next cycle.

But what looks more interesting to me at the moment is to set up synchronized "seed constellations" at the two corners closest to where we want the blocks. One seed is triggered to form an LWSS, and the other creates a glider at the same moment. Then we can start a slow construction salvo immediately following that first glider, because we know it will eventually hit the LWSS and provide a nice target at an appropriate distance.

Once we have distant blocks perpendicular to two corners, at a diamond-edge length away, we can build new LWSS and glider seeds at that distance and trigger those to reach two diamond-edge lengths, if we want to. There are certainly some tricky synchronization problems to solve there, but it doesn't seem impossible.

Another complexity with "four copies" is proximity alerting mechanism, which should be triggered on "stage two", so the copy will not work to direction where some other unit wants to copy, or where there is already a copy.

This shouldn't be terribly difficult. There are lots of possible mechanisms, but basically you build a "test spark" near the location in question. If a replicator copy is already present, then one of its still lifes (an eater or even a single block would be enough) can catalyze an otherwise clean spark at a good offset, to send a glider back toward the source constructor. That glider can then be used to trigger a seed constellation that permanently shuts off the constructor.

The switching could be done with a re-usable key / latch mechanism, but single-use devices are a lot cheaper. At least for the simplest replicator designs, there's no reason to worry about re-testing periodically or turning the circuit back on again.

It's fairly straightforward to adjust the design so that two replicators will never be simultaneously attempting to build in the same location. I had two or three different designs that looked like they might be workable. Last time I was looking at the problem, the big difficulty was that it was necessary to build the faraway corners of the next diamond first -- otherwise the near corners got in the way of constructing the far corners.

But with the old constructor-arm design there was no way to leave an elbow at the near corners, to quickly start construction there when the faraway corners were complete. Would have had to do some kind of trick with a returning glider from the far corner, or maybe an LWSS seed triggered at another corner again. With an "armless" design this becomes a non-issue -- just use a slightly narrower shooting range to construct the far corners, then pick up a near-corner elbow from the edge of the range and start working with that.

Anyway, maybe this is a topic for a separate thread...!

Anyway it's nice project, and the armless design definitely has some useful potential there (let's say instead of diamond we use long and thin, so we have 2 copies instead of four, but they fully "fit" inside the construction area.

The main reason that I'd really like to try out a diamond design is that if it's designed right, it should run much faster in Golly than any long thin design. Since the construction data is fairly random, doubling it back on itself gives the Hashlife algorithm big headaches -- too many different large hashtiles. If diamond replicators build their copies at one diamond-edge length away or more, most large hashtiles have gliders traveling in only one direction, so you use the same set of hashtiles over and over, and only alter them at the corners instead of all along the line.

You can see an equivalent speed improvement if you run a Gemini spaceship gun for a while: the base signal travels in a big loop, very quickly, and only slows down when the signal gets doubled over and folded into the first Gemini spaceship.

This is maybe kind of a silly reason to invent a whole new design, but I'd love to be able to turn up the speed on a quadratic replicator pattern and have Golly be able to really run away with it, instead of having to slow to a crawl.

[simsim314]

That glider can then be used to trigger a seed constellation that permanently shuts off the constructor.

For long time I was thinking this is a "clean" solution to the "proximity alert" issue. The problem is as follows: Actually the RU is pretty large, so pretty far away RU can "damage" other RU at a pretty big distance. Let's say you made 5-10 copies, and one of the RU sends a test glider into "empty space" that glider can come to some other RU on unknown time and ruin it completely. Now you could say it's not "that bad" because we still have many other working RU copies, but it's definitely ugly solution that could destroy eventually the whole replication process.

So we need a solution for "clean" testing probe. Not a glider that goes into empty space and could not return, but something like an "arm" that reaches the neighbor RUs and check out its presence.

Yet again it's all possible and not a "big deal", but it's all small details that make the design more and more complex that you naively think.

Another solution would be to store an information and have some "prediction" of local RUs, say those at radius 2 RUs. So after one copy, each RU knows only it's neighbors (radius 1), and this is enough not to send "void gliders". After exchanging between themselves and information of their neighbors, each RU once again could know radius 2 state, so it can once again replicate. It's of course a much more complex mechanism, on the other hand it's nice to have some basic "computational properties" inside the RU. And it shouldn't be too complex, maybe twice more complex.

Anyway I do agree it should be discussed in new thread. This thread "suppose" to be Serizawa oriented, which by the way has all the needed ingredients now, to build the "first" armless Linear RU. Because we call this approach "Serizawa style" but until now the Serizawa replicator was using a construction arm like Gemini. This armless approach "born" in this discussion, while trying to adapt and think of the benefits of the OGC approach in GOL.

My current design of the Linear RU for Serizawa, is to use the glider pair slow salvo to build the far away two reflectors. Turns out that the cost for slow salvo builds has drop very rapidly, due to new slow salvo glider pairs recipes, and now it's actually not so "worth it" to use a lot of "inner" geometry to optimize the outside blocks.