H-to-G and H-to-Gn converter collection

[dvgrn]

The last reminders finally came in to put together organized collections of H-to-G and H-to-G(n) converters -- meaning, stable circuitry that takes a Herschel as input and produces unidirectional glider output, either a single glider or two or more gliders on parallel lanes.

EDIT0: Here's the link for the glider pair adjustment toolkit.

EDIT1: Updated 4 June 2014, after a complete scan of Hunting of the New Herschel Conduits thread, with some composite conduits included -- mostly H-to-X-to-G for non-Herschel X. Added and fixed everything from simeks' review (thanks again!)

EDIT2: Updated collection from chris_c, 13 October 2015 -- 50 new H-to-Gs, mostly combinations of elementary conduits, plus simeks' new SE30T14.

EDIT3: Updated collection based on simeks' notes.

EDIT4: Annual October update for 2016 -- added everything I found in this thread and the Hunting of the New Herschel Conduits thread.

H-to-G-21Oct2016.rle.gz

H-to-G stamp collection as of 21 Oct 2016

(98.26 KiB) Downloaded 253 times

-----------------------------------------------

Please post links or patterns for Herschel-to-glider or Herschel-to-2-parallel-glider converters that aren't in the respective collections yet. The pattern below is the template for the H-to-G stamp collection, to be updated from time to time here in this first post. I'll fill in the forty or fifty known ones sometime this week, and then will be looking for pointers to other H-to-Gs that I've missed.

See the next post for a similar stamp collection for H-to-G(n).

Canonical orientations for gliders:

Code: Select all

x = 27, y = 30, rule = LifeHistory
D3.D.D3.D5.D3.D.5D$2D2.D.D3.D5.2D2.D.D$D.D.D.D3.D5.D.D.D.D$D2.2D.D.D.
D5.D2.2D.3D$D3.D.D.D.D5.D3.D.D$D3.D.2D.2D5.D3.D.D$D3.D.D3.D5.D3.D.5D
4$4.3C13.3C$4.C17.C$5.C15.C5$5.C15.C$4.C17.C$4.3C13.3C4$.3D2.D3.D6.3D
2.5D$D3.D.D3.D5.D3.D.D$D5.D3.D5.D5.D$.3D2.D.D.D6.3D2.3D$4.D.D.D.D9.D.
D$D3.D.2D.2D5.D3.D.D$.3D2.D3.D6.3D2.5D!
#C [[ VIEWONLY THUMBNAIL ]]

If a canonical-phase glider is centered on the cell (N, 0) then it's on Lane N -- that is, if you run a lane-N glider forwards or backwards in time, there should be a pont where the canonical orientation of the glider is centered around (N,0). This is slightly different from the old NW and SE lane numbers from the 2006 collection, but the same for the old NE and SW lanes.

Script to identify H-to-Gs:

H-to-Gstats16November2015.py -- edited to remove dependency on make_text in glife module, for more reliability when running from clipboard:

Code: Select all

import golly as g
from time import sleep
import itertools
from string import *

# Mono-spaced ASCII font
__mfont = dict()
__mfont[' '] = g.parse("")
__mfont['!'] = g.parse("2bo$2bo$2bo$2bo$2bo2$2bo!")
__mfont['"'] = g.parse("bobo$bobo$bobo!")
__mfont['#'] = g.parse("bobo$bobo$5o$bobo$5o$bobo$bobo!")
__mfont['$'] = g.parse("b3o$obobo$obo$b3o$2bobo$obobo$b3o!")
__mfont['%'] = g.parse("2o2bo$2o2bo$3bo$2bo$bo$o2b2o$o2b2o!")
__mfont['&'] = g.parse("b2o$o2bo$o2bo$b2o$o2bo$o2bo$b2obo!")
__mfont['\''] = g.parse("2bo$2bo$2bo!")
__mfont['('] = g.parse("3bo$2bo$2bo$2bo$2bo$2bo$3bo!")
__mfont[')'] = g.parse("bo$2bo$2bo$2bo$2bo$2bo$bo!")
__mfont['*'] = g.parse("$obobo$b3o$5o$b3o$obobo!")
__mfont['+'] = g.parse("$2bo$2bo$5o$2bo$2bo!")
__mfont[','] = g.parse("6$2bo$2bo$bo!")
__mfont['-'] = g.parse("3$5o!")
__mfont['.'] = g.parse("6$2bo!")
__mfont['/'] = g.parse("3bo$3bo$2bo$2bo$2bo$bo$bo!")
__mfont['0'] = g.parse("b3o$o3bo$o2b2o$obobo$2o2bo$o3bo$b3o!")
__mfont['1'] = g.parse("2bo$b2o$2bo$2bo$2bo$2bo$b3o!")
__mfont['2'] = g.parse("b3o$o3bo$4bo$3bo$2bo$bo$5o!")
__mfont['3'] = g.parse("b3o$o3bo$4bo$2b2o$4bo$o3bo$b3o!")
__mfont['4'] = g.parse("3bo$2b2o$bobo$o2bo$5o$3bo$3bo!")
__mfont['5'] = g.parse("5o$o$o$b3o$4bo$o3bo$b3o!")
__mfont['6'] = g.parse("b3o$o$o$4o$o3bo$o3bo$b3o!")
__mfont['7'] = g.parse("5o$4bo$3bo$2bo$bo$o$o!")
__mfont['8'] = g.parse("b3o$o3bo$o3bo$b3o$o3bo$o3bo$b3o!")
__mfont['9'] = g.parse("b3o$o3bo$o3bo$b4o$4bo$4bo$b3o!")
__mfont[':'] = g.parse("2$2bo4$2bo!")
__mfont[';'] = g.parse("2$2bo4$2bo$2bo$bo!")
__mfont['<'] = g.parse("$3bo$2bo$bo$2bo$3bo!")
__mfont['='] = g.parse("2$5o2$5o!")
__mfont['>'] = g.parse("$bo$2bo$3bo$2bo$bo!")
__mfont['?'] = g.parse("b3o$o3bo$4bo$2b2o$2bo2$2bo!")
__mfont['@'] = g.parse("b3o$o3bo$ob3o$obobo$ob2o$o$b3o!")
__mfont['A'] = g.parse("b3o$o3bo$o3bo$5o$o3bo$o3bo$o3bo!")
__mfont['B'] = g.parse("4o$o3bo$o3bo$4o$o3bo$o3bo$4o!")
__mfont['C'] = g.parse("b3o$o3bo$o$o$o$o3bo$b3o!")
__mfont['D'] = g.parse("4o$o3bo$o3bo$o3bo$o3bo$o3bo$4o!")
__mfont['E'] = g.parse("5o$o$o$3o$o$o$5o!")
__mfont['F'] = g.parse("5o$o$o$3o$o$o$o!")
__mfont['G'] = g.parse("b3o$o3bo$o$o2b2o$o3bo$o3bo$b3o!")
__mfont['H'] = g.parse("o3bo$o3bo$o3bo$5o$o3bo$o3bo$o3bo!")
__mfont['I'] = g.parse("b3o$2bo$2bo$2bo$2bo$2bo$b3o!")
__mfont['J'] = g.parse("2b3o$3bo$3bo$3bo$3bo$o2bo$b2o!")
__mfont['K'] = g.parse("o3bo$o2bo$obo$2o$obo$o2bo$o3bo!")
__mfont['L'] = g.parse("o$o$o$o$o$o$5o!")
__mfont['M'] = g.parse("o3bo$2ob2o$obobo$obobo$o3bo$o3bo$o3bo!")
__mfont['N'] = g.parse("o3bo$2o2bo$obobo$o2b2o$o3bo$o3bo$o3bo!")
__mfont['O'] = g.parse("b3o$o3bo$o3bo$o3bo$o3bo$o3bo$b3o!")
__mfont['P'] = g.parse("4o$o3bo$o3bo$4o$o$o$o!")
__mfont['Q'] = g.parse("b3o$o3bo$o3bo$o3bo$obobo$o2bo$b2obo!")
__mfont['R'] = g.parse("4o$o3bo$o3bo$4o$o2bo$o3bo$o3bo!")
__mfont['S'] = g.parse("b3o$o3bo$o$b3o$4bo$o3bo$b3o!")
__mfont['T'] = g.parse("5o$2bo$2bo$2bo$2bo$2bo$2bo!")
__mfont['U'] = g.parse("o3bo$o3bo$o3bo$o3bo$o3bo$o3bo$b3o!")
__mfont['V'] = g.parse("o3bo$o3bo$o3bo$o3bo$o3bo$bobo$2bo!")
__mfont['W'] = g.parse("o3bo$o3bo$o3bo$obobo$obobo$2ob2o$o3bo!")
__mfont['X'] = g.parse("o3bo$o3bo$bobo$2bo$bobo$o3bo$o3bo!")
__mfont['Y'] = g.parse("o3bo$o3bo$bobo$2bo$2bo$2bo$2bo!")
__mfont['Z'] = g.parse("5o$4bo$3bo$2bo$bo$o$5o!")
__mfont['['] = g.parse("2b2o$2bo$2bo$2bo$2bo$2bo$2b2o!")
__mfont['\\'] = g.parse("bo$bo$2bo$2bo$2bo$3bo$3bo!")
__mfont[']'] = g.parse("b2o$2bo$2bo$2bo$2bo$2bo$b2o!")
__mfont['^'] = g.parse("2bo$bobo$o3bo!")
__mfont['_'] = g.parse("6$5o!")
__mfont['`'] = g.parse("o$bo!")
__mfont['a'] = g.parse("2$b4o$o3bo$o3bo$o3bo$b4o!")
__mfont['b'] = g.parse("o$o$4o$o3bo$o3bo$o3bo$4o!")
__mfont['c'] = g.parse("2$b4o$o$o$o$b4o!")
__mfont['d'] = g.parse("4bo$4bo$b4o$o3bo$o3bo$o3bo$b4o!")
__mfont['e'] = g.parse("2$b3o$o3bo$5o$o$b4o!")
__mfont['f'] = g.parse("2b2o$bo2bo$bo$3o$bo$bo$bo!")
__mfont['g'] = g.parse("2$b3o$o3bo$o3bo$o3bo$b4o$4bo$b3o!")
__mfont['h'] = g.parse("o$o$ob2o$2o2bo$o3bo$o3bo$o3bo!")
__mfont['i'] = g.parse("$2bo2$2bo$2bo$2bo$2b2o!")
__mfont['j'] = g.parse("$3bo2$3bo$3bo$3bo$3bo$o2bo$b2o!")
__mfont['k'] = g.parse("o$o$o2bo$obo$3o$o2bo$o3bo!")
__mfont['l'] = g.parse("b2o$2bo$2bo$2bo$2bo$2bo$2b2o!")
__mfont['m'] = g.parse("2$bobo$obobo$obobo$o3bo$o3bo!")
__mfont['n'] = g.parse("2$4o$o3bo$o3bo$o3bo$o3bo!")
__mfont['o'] = g.parse("2$b3o$o3bo$o3bo$o3bo$b3o!")
__mfont['p'] = g.parse("2$4o$o3bo$o3bo$o3bo$4o$o$o!")
__mfont['q'] = g.parse("2$b4o$o3bo$o3bo$o3bo$b4o$4bo$4bo!")
__mfont['r'] = g.parse("2$ob2o$2o2bo$o$o$o!")
__mfont['s'] = g.parse("2$b4o$o$b3o$4bo$4o!")
__mfont['t'] = g.parse("$2bo$5o$2bo$2bo$2bo$3b2o!")
__mfont['u'] = g.parse("2$o3bo$o3bo$o3bo$o3bo$b4o!")
__mfont['v'] = g.parse("2$o3bo$o3bo$o3bo$bobo$2bo!")
__mfont['w'] = g.parse("2$o3bo$o3bo$obobo$2ob2o$o3bo!")
__mfont['x'] = g.parse("2$o3bo$bobo$2bo$bobo$o3bo!")
__mfont['y'] = g.parse("2$o3bo$o3bo$o3bo$o3bo$b4o$4bo$b3o!")
__mfont['z'] = g.parse("2$5o$3bo$2bo$bo$5o!")
__mfont['{'] = g.parse("3bo$2bo$2bo$bo$2bo$2bo$3bo!")
__mfont['|'] = g.parse("2bo$2bo$2bo$2bo$2bo$2bo$2bo!")
__mfont['}'] = g.parse("bo$2bo$2bo$3bo$2bo$2bo$bo!")
__mfont['~'] = g.parse("2$bo$obobo$3bo!")

orientations=[[1,0,0,1],[0,-1,1,0],[-1,0,0,-1],[0,1,-1,0],[1,0,0,-1],[0,1,1,0],[0,-1,-1,0],[-1,0,0,1]]
herschel=([[-1,-2],[-1,-1],[-1,0],[1,-1],[1,0],[1,1]],0) # plus [0,0] makes a Herschel
# arrange for pre-Herschels to be recognizable also
hminus3=([[-5,-1],[-5,1],[-5,2],[-4,-2],[-4,-1],[-4,0],[-4,1],[-4,2],[-3,-2],[-3,-1],[-3,0],[-3,1],[-1,-1],[-1,0],[-1,1],[0,-1],[0,1],[1,0]],-3)
hminus4=([[-5,1],[-4,-2],[-4,-1],[-4,0],[-4,1],[-4,2],[-3,-3],[-1,-2],[-1,2],[0,-1],[0,1],[0,1]],-4)
hminus5=([[-4,0],[-4,1],[-4,2],[-3,-3],[-3,-2],[-3,-1],[-3,1],[-2,-2],[-2,-1],[-2,1],[-2,2],[-1,-2],[-1,-1],[-1,1],[-1,2],[-1,2]],-5)
hminus6=([[-5,1],[-4,-3],[-4,1],[-3,-2],[-3,1],[-2,-2],[-2,-1],[-2,1],[-2,2],[-1,-1],[-1,1],[-1,1]],-6)
# the duplicate cell at end of hminus6 is a cheap kludge
#   to allow a multistate version of the cell list to have an odd number of items...

# quick recognition patterns and offsets for all phases -- add [0,0] to make a complete glider
gliders=[([[1,0],[2,0],[0,1],[1,2]],(-1,-1),"NW",0),
         ([[-1,1],[0,1],[-1,2],[1,2]],(0,-2),"NW",1),
         ([[1,0],[0,1],[2,1],[0,2]],(-1,-2),"NW",2),
         ([[1,0],[-1,1],[0,1],[1,2]],(-1,-2),"NW",3),
         ([[1,0],[2,0],[2,1],[1,2]],(-1,-1),"NE",0),
         ([[0,1],[1,1],[-1,2],[1,2]],(0,-2),"NE",1),
         ([[1,0],[-1,1],[1,1],[1,2]],(0,-2),"NE",2),
         ([[1,0],[1,1],[2,1],[0,2]],(0,-2),"NE",3),
         ([[1,1],[-1,2],[0,2],[1,2]],(0,-1),"SE",0),
         ([[2,0],[1,1],[2,1],[1,2]],(-1,0),"SE",1),
         ([[-2,1],[0,1],[-1,2],[0,2]],(1,0),"SE",2),
         ([[1,1],[2,1],[0,2],[1,2]],(0,0),"SE",3),
         ([[-1,1],[-1,2],[0,2],[1,2]],(0,-1),"SW",0),
         ([[2,0],[0,1],[1,1],[1,2]],(-1,0),"SW",1),
         ([[0,1],[2,1],[0,2],[1,2]],(-1,0),"SW",2),
         ([[-2,1],[-1,1],[-1,2],[0,2]],(0,0),"SW",3)]
RUNTIME = 1024

def make_text(string, font='Mono'):
    p,x = [], 0
    for c in string:
        if not __mfont.has_key (c): c = "_"
        p += g.transform(__mfont[c],x,0)
        x += 6
    return p
   
def groupcells(c):
  return [c[pos:pos+2] for pos in range(0, len(c)-1, 2)]

def findHerschels(c, hv):
  h=hv[0]
  count,foundmatch,final=0,0,[]
  while count<8:
    ora,orb,orc,ord=orientations[count]
    count+=1
    cnew=groupcells(g.transform(c,0,0,ora,orb,orc,ord))
    for cell in cnew:
      sleep(0)
      ptr,match=0,1
      while ptr<len(h):
        if [cell[0]+h[ptr][0],cell[1]+h[ptr][1]] not in cnew:
          match=0
          break
        ptr+=1
      if match==1:
        final=g.transform(c,0,0,ora,orb,orc,ord)
        final=g.transform(final,-cell[0],-cell[1])
        foundmatch+=1
        # break ## faster, but doesn't check for multiple Herschels
    # if foundmatch==1: break
  return foundmatch, final, hv

# input time run so far
# return list of spacetime locations of canonical gliders in current universe:
#   [["NW",X0,Y0,T0],["NW",X1,Y1,T1],[["SE",X2,Y2,T2],["NE",X3,Y3,T3]]
def findgliders(t):
  outlist=[]
  clist=groupcells(g.getcells(g.getrect()))
  while clist!=[]:
    cx,cy = clist[0][0],clist[0][1]
    match=1
    for glider in gliders:
      match = 1
      for item in glider[0]:
        if g.getcell(item[0]+cx,item[1]+cy)==0:
          match=0
          break

      if match==1:
        g.setcell(cx,cy,0)
        for item in glider[0]:
          g.setcell(item[0]+cx,item[1]+cy, 0)
        outlist+=[[cx-glider[1][0],cy-glider[1][1],glider[2],glider[3]]]
        # make new list of remaining ON cells and continue
        clist=groupcells(g.getcells(g.getrect()))
        break
    # if we try all gliders and none of them match, report the problem
    if match==0: g.exit("Top remaining cell doesn't look like a glider.")
 
  #  g.note(str(clist)+"\n"+str(outlist))
  return outlist

cells,altcells=g.getcells(g.getselrect()),[]
if cells==[]:
  cells=g.getcells(g.getrect())
  if cells==[]:
    g.exit("Please open or select H-to-nG converter pattern to retrieve glider statistics.")

altcells2, altflatcells2 = [], []
if len(cells)%2==1:
  # convert to two-state list
  # cells = ON cells only (will find Herschels with some cells marked)
  # altcells = marked ON and marked OFF cells
  # altcells2 = any ON and marked OFF cells
  newcells=[cells[i:i+2] for i in range(0,len(cells)-1,3) if cells[i+2] in [1,3,5]]
  flatcells=list(itertools.chain.from_iterable(newcells)) # sum(newcells,[]) is shorter but slower
#  altcells=[cells[i:i+2] for i in range(0,len(cells)-1,3) if cells[i+2] in [3,4,5]]
#  altflatcells=list(itertools.chain.from_iterable(altcells))
  altcells2=[cells[i:i+2] for i in range(0,len(cells)-1,3) if cells[i+2] in [1,3,4,5]]
  altflatcells2=list(itertools.chain.from_iterable(altcells2))
  cells=newcells
else:
  flatcells=cells
foundmatch, final, hvariant = findHerschels(flatcells, herschel)
if foundmatch==0:
  foundmatch, final, hvariant = findHerschels(flatcells, hminus3)
if foundmatch==0:
  foundmatch, final, hvariant = findHerschels(flatcells, hminus4)
if foundmatch==0:
  foundmatch, final, hvariant = findHerschels(flatcells, hminus5)
if foundmatch==0:
  foundmatch, final, hvariant = findHerschels(flatcells, hminus6)
if foundmatch==0:
  if altcells2!=[]:
    foundmatch, final, hvariant = findHerschels(altflatcells2, herschel)
  if foundmatch==0:
    foundmatch, final, hvariant = findHerschels(altflatcells2, hminus3)
  if foundmatch==0:
    foundmatch, final, hvariant = findHerschels(altflatcells2, hminus4)
  if foundmatch==0:
    foundmatch, final, hvariant = findHerschels(altflatcells2, hminus5)
  if foundmatch==0:
    foundmatch, final, hvariant = findHerschels(altflatcells2, hminus6)
  if foundmatch==0:  g.exit("No match found.")
if foundmatch>1: g.exit("Found multiple Herschels ("+str(foundmatch)+")" )
hcells=[[0,0]]+hvariant[0]
# hcellsflat=list(itertools.chain.from_iterable(hcells))

g.addlayer()
g.new("LifeHistory version")
g.setrule("LifeHistory")
g.putcells(final)
rfinal=g.getrect()
g.run(RUNTIME)
# g.putcells(list(itertools.chain.from_iterable([c+[3] for c in groupcells(hcellsflat)])))
g.putcells(list(itertools.chain.from_iterable([c+[3] for c in hcells])))
finalLH=g.getcells([rfinal[0]-8,rfinal[1]-8,rfinal[2]+16,rfinal[3]+16])

g.new("start@H"+str(hvariant[1]))
# g.setalgo("QuickLife")
g.setrule("B3/S23")
g.putcells(final)

g.run(RUNTIME)
for c in hcells:
  if g.getcell(c[0],c[1])!=0: g.exit("Herschel site is contaminated.")
for c in hcells: g.setcell(c[0],c[1],1)
for c in groupcells(final):
  if g.getcell(c[0],c[1])==0: g.exit("Conduit has been damaged.")
  g.setcell(c[0],c[1],0)
glist = findgliders(RUNTIME)

count=0
g.setrule("LifeHistory")
for item in glist:
  if item[2]=="NW":
    lane = item[0]-item[1]
    out="NW"+str(lane)+"T"+str(RUNTIME-item[3]+4*item[1]+hvariant[1]+4*lane)     # tested
  elif item[2]=="NE":
    lane = item[0]+item[1]
    out="NE"+str(lane)+"T"+str(RUNTIME-item[3]+4*item[1]+hvariant[1]-4*lane)     # tested
  elif item[2]=="SE":
    lane = item[0]-item[1]
    out="SE"+str(lane)+"T"+str(RUNTIME-item[3]-4*item[1]+hvariant[1]-4*lane)     # tested
  elif item[2]=="SW":
    lane = item[0]+item[1]
    out="SW"+str(lane)+"T"+str(RUNTIME-item[3]-4*item[1]+hvariant[1]+4*lane)     # tested
  else:
    g.note("A new diagonal direction has been discovered...!")
  t = make_text(out, "mono")
  tstate4=[c+[4] for c in groupcells(t)]
  ts4flat = list(itertools.chain.from_iterable(tstate4))
  if len(ts4flat)%2==0:  ts4flat+=[0]
  g.putcells(ts4flat, 0, count*10)
  count+=1

g.putcells(finalLH,0,count*10+50)
g.setgen("0")
g.fit()

EDIT: Golly will fail to load the make_text module on a first run, unless the above script is saved in Golly's Scripts/Python directory (I think). Otherwise Python doesn't know where to find the glife module. Because Golly keeps modules loaded after their first use, you can dodge the problem by running another script such as pop-plot.py that loads make_text, and then the above script works fine after that (!).

Please report any remaining bugs. Versions of this script that recognize R, B, C, D, P, and Q inputs have been written. Will post an updated version of the above when they've all been successfully combined into one script...!

[dvgrn]

Here's what I have so far for H-to-G(N). Lots more to come, no doubt, especially for larger N. There are any number of H-to-H-to-G combinations that will create tandem gliders 25-75 lanes apart -- but I wanted to get this base collection published first. I'll change the update stamp here whenever I add more converters.

Updated 13 October 2015:
13 June: added chris_c's G1, simeks' G7 and G11, and new timings for G(10+2N)
19 September: Updated from simsim314's September 19 contribution, plus Sphenocorona's G1 and simeks' G21 and G23.
Also added minimum Snark turn for two crossing glider lanes (G17) and minimum Snark turn for two parallel glider lanes (G18).

H-to-Gn-13Oct2015.rle.gz

H-to-G(n) tandem glider converter collection, updated 13 October 2015

(34.07 KiB) Downloaded 344 times

----------------------------------

People are certainly welcome to post other types of H-to-2Gs (and H-to-3Gs, etc.) as well, with outputs in different directions. They could be categorized by the direction and lane of the output -- NW, NE, SE, SW, Any reasonably compact converter might happen to come in handy somewhere, in some type of circuitry, especially now that we have Snarks and syringes, making glider-based stable circuits a bit less unwieldy.

So elementary or compact composite circuits are okay; eventually I'd like to get a complete set of H-to-G(n) for reasonable N. Maybe the non-parallel H-to-2Gs will get their own stamp collection -- especially if someone else does the work. Other collectors should post early to claim a spot near the top of the thread...!

[Sokwe]

Here's a reduction of the still lifes for the H/G-to-G18:

Code: Select all

x = 57, y = 48, rule = B3/S23
39bob2ob2o$37b3obo3bo$36bo5b2o$37bob2obob4o$36b2ob2obobo2bo$27b2o14bo$
28bo$28bobo$18bo10b2o$16b3o$8bo6bo$9b2o4b2o$2o6b2o$bo$bob2o$2bo2bo$3b
2o$18b2o$18b2o5$26bo3b2o$25bobo3bo$21b2obobo3bo22b2o$21b2obo4bo23b2o$
25b5obo$20bob2obo4b2o2bob2o$20b2o2bo3bo3b3ob2o$10b2o11bo4b2obo$10b2o8b
3o9b3ob2o$20bo13bobo$34bobo$35bo10$53b2o$53bobo$55bo$55b2o!

[biggiemac]

Here's the result of a cursory search of pointers to H-to-2Gs in my memory:

Code: Select all

x = 356, y = 732, rule = LifeHistory
3$188.2B$186.5B$185.7B$185.8B$184.9B$183.10B$183.A8B$182.ABA8B$182.AB
A10B$182.BA14B2.2B2.B$183.23B$183.24B2.B$185.19B2AB.B2A$185.19B2A3B2A
$186.B2.19B.B$196.4B.7B$197.4B.7B$198.12B$199.11B$200.9B.3B$201.12B$
198.2B.11B2A$197.2A13B2A$197.2AB.10B.B$88.2B4.2A102.B2.10B$86.5B2.A.A
105.9B$85.8B2A105.10B$85.7B.B105.11B$85.6B.B105.11B$86.2BA5B103.13B$
86.BABA5B101.15B73.8B$86.BABA4B101.19B71.8B$87.BA5B100.19B2A71.8B$84.
3B.6B3.2A94.4B.15B2A72.8B$81.13B2.B2A2B91.4B.17B33.2A39.8B$81.10B.B4.
4B90.19B38.A14.2A24.8B$78.14B6.4B88.19B39.A.AB10.B2AB8.2A14.8B$78.14B
5.6B86.20B40.2AB.2B7.4B7.B2A2B13.8B$77.16B2.B.5B86.20B43.5B6.4B8.4B
14.8B$20.B2.B14.2B2.B2.B31.28B82.24B40.7B4.5B5.6B5.2A8.8B$20.B2.B7.B
5.B2.B.B2.B31.30B63.A15.4B.20B40.7B3.7B.8B.2B2.B2AB8.8B$20.B2.B8.B4.B
4.B2.B33.30B61.3A5.2A5.4B3.20B33.A.2A2.7B.22B2.2B10.8B$20.4B3.7B3.B.
2B2.3B33.32B62.A3.B2AB3.4B3.22B32.2A.A35B12.8B$20.B2.B8.B4.B2.B4.B33.
33B60.2A4.3B2.4B2.24B37.36B11.8B$20.B2.B7.B5.B2.B4.B31.B.33B60.5B2.B
2.30B39.32B2A2B11.8B$20.B2.B14.2B5.B29.36B63.29B.10B37.32B2A3B11.8B$
75.23BD14B60.2A21B.7B2.2B4.2A29.2A2.2A.B.35B13.8B$74.2A22BDBD4B.3B2.
2A60.2A21B2.3B.B4.B4.A30.A2.A.A38B14.8B$74.2AB.20B3D4B2.B3.A62.B.20B
4.2B2A3.2A4.3A28.A.A.B.30B.7B14.8B14.2A$75.B3.21BD4B7.3A61.19B4.BA2.A
4.A6.A27.2A.2A23B3.B2.4B.6B15.8B14.A$83.21B10.A62.6B.4B12.3A4.A39.B.
21B3.3B2.9B17.8B13.A.AB$82.21B73.6B.4B20.2A40.20B3.B2AB3.8B18.8B13.2A
B.2B$82.22B72.10B14.2A.A46.13B.4B5.2A5.8B18.8B14.5B$81.10BD12B71.10B
8.A6.A.2A47.11B3.2B3.B10.7B19.8B13.5B$81.9B3D11B70.10B7.3A54.14B3.3B.
B2A10.6B20.8B11.7B$80.9BD2B2D11B69.9B7.A56.15B4.A3B2A10.7B20.8B9.8B$
79.2AB3.21B68.10B6.2A55.14B4.A.AB.B11.7B21.8B9.8B$78.A.AB6.9B2.8B65.
13B2.5B55.12B5.A.AB14.8B.2B18.8B9.7B$78.A10.7B4.8B61.2B.18B57.B3D4B.
2B6.A17.12B18.8B5.11B$77.2A8.8B6.8B59.2A19B2A56.2BD4B9.2A17.14B17.10B
.12B$102.8B58.2AB.17B2A56.2B3D2B28.15B17.22B.B$103.8B58.B.17B.B57.6B
30.14B18.24B$104.8B60.16B58.7B33.11B19.25B$105.8B58.16B58.4B.B34.13B
2.2B15.24B$106.8B56.6B2.8B58.4B36.19B8.2A5.22B2A$107.8B54.6B3.7B58.4B
35.B.21B6.A.A4.20B.B2A$168.6B3.11B54.4B32.2A.2A22B7.AB3.19B4.B$167.6B
4.12B52.4B34.A.A.B.21B5.2B3.21B12.2A$166.6B5.12B51.4B34.A2.A.A23B.B2.
25B8.B3.A.A$165.6B7.11B50.4B35.2A2.2A.B.19B.29B4.6B.B2A$164.6B6.4B.4B
3DB50.3B44.51B2.8B.B$163.6B7.2A4.4BD2B50.2B45.53B.6B.2B$162.6B9.A4.2B
3D2B50.B45.65B$174.3A6.6B91.2A.A59B2A6B$174.A8.7B90.A.2A2.7B.17B.4B.
25BA2BA5B$185.B.4B95.7B3.7B.12B2.23B.B2A5B$188.4B94.7B4.5B4.8B4.24B.
7B$189.4B93.5B6.4B5.6B6.24B4.3B$190.4B90.2AB.2B7.4B6.4B8.23B$191.4B
88.A.AB10.B2AB18.22B$192.4B87.A14.2A19.5B.16B$193.4B85.2A33.5B3.16B$
317.2AB5.14B$318.A6.14B$315.3A8.4B4.5B$315.A11.4B3.3B$326.4B$325.B2A
2B$326.2A22$145.4B.4B$146.4B.4B$147.4B.4B$148.4B.4B$149.4B.4B$150.4B.
4B$151.4B.4B$152.4B.4B$153.4B.4B$154.4B.4B$88.A66.4B.4B$88.3A65.4B.4B
$91.A65.4B.4B$90.2A4.B61.4B.4B24.A$90.8B61.4B.4B16.B4.3A$92.8B5.2A53.
4B.4B14.4B.A$91.9B6.A52.11B12.5BA.A$90.12B.3A52.13B10.4B.2BAB$89.14BA
53.15B8.4B3.2B$88.15B55.10B.4B6.4B3.2B$87.15B56.16B4.4B3.B2AB$86.5BD
11B52.20B2.4B5.2A$85.6BDBD10B50.2A15B.8B$84.4B.2B3D4B.B2AB2A49.2A14B
3.6B$83.4B.5BD4B2.A3.A50.2B.10B6.4B.6B$82.4B.10B4.3A53.9B.18B8.A$81.
4B.4B67.8B.20B5.3A$25.B2.B14.2B2.4B29.4B.4B12.3A53.8B.19B.B3.A$25.B2.
B7.B5.B2.B.B32.3B.4B12.A3.A51.9B.13B3D6B2.2A$25.B2.B8.B4.B4.B32.2B.4B
13.2A.2A50.24BD8B.3B$25.4B3.7B3.B.2B.3B30.B.4B65.B2.22B.B3D9B$25.B2.B
8.B4.B2.B4.B30.4B65.2AB.19B4.14B$25.B2.B7.B5.B2.B.B2.B30.3B66.2A19B6.
13B$25.B2.B14.2B3.2B101.B.17B7.13B$154.17B7.14B$154.17B8.14B$155.14B.
B2A5.15B$156.10B4.BA.A4.16B$156.8B9.A5.14B$157.8B8.2A4.14B$157.8B13.B
.10B$157.7B13.13B$154.2B.6B14.6B.3B$153.2A8B14.5BAB$153.2AB.7B13.4BAB
AB$154.B2.7B12.5BABAB$158.7B12.5BA2B$160.6B12.B.6B$159.2BA3B12.B.7B$
158.2BABA2B11.2A8B$158.2BABAB11.A.A2.5B$159.2BAB12.2A4.2B$161.2B9$87.
4B$88.4B$86.B2.4B$86.2B2.4B$86.3B2.4B$86.4B2.4B$87.4B2.4B$88.4B2.4B$
89.4B2.4B$90.4B.4B$91.9B.B$92.12B$93.11B$94.9B2A$93.10B2A$92.10B.B$
82.2A8.10B$83.A9.8B$83.A.AB5.9B$84.2AB.3B.10B$86.17B$86.17B$87.15B$
86.16B.B$84.19B2A$82.21B2A$25.B2.B14.2B3.2B32.2BD16B.2B$25.B2.B7.B5.B
2.B.B2.B30.3BDBD4B.10B$25.B2.B8.B4.B4.B34.2B3D4B2.8B$25.4B3.7B3.B.2B.
3B31.5BD4B2.9B$25.B2.B8.B4.B2.B.B2.B29.10B4.8B$25.B2.B7.B5.B2.B.B2.B
28.4B11.8B$25.B2.B14.2B3.2B29.3B13.5B.B2A$79.2B12.5B3.BA.A$79.B11.A.
2A9.A$89.3AB2A9.2A$88.A4.B$89.3A.2A$91.A.A$91.A.A$92.A16$81.4B3.4B$
82.4B3.4B$83.4B3.4B$84.4B3.4B$85.4B3.4B$86.4B3.4B$87.4B3.4B5.2A$88.4B
3.4B3.B2AB$89.4B3.4B2.3B$90.4B3.4B2.B.B$91.4B3.8B$92.4B3.7B$93.4B2.7B
$94.4B.7B$95.12B4.2A$96.11B3.A.A$95.13B2.BA$94.17B$94.17B$86.2A6.18B.
3B$87.A6.23B$87.A.AB4.23B$88.2AB.27B$90.30B$90.31B$91.32B$90.34B$88.
36B$86.39B$86.2BD35B2A$25.B2.B14.2B2.4B34.3BDBD4B.28B2A$25.B2.B7.B5.B
2.B4.B35.2B3D4B.29B$25.B2.B8.B4.B6.B35.5BD4B.8B3.15B$25.4B3.7B3.B.2B
2.B35.10B.9B4.3B.9B$25.B2.B8.B4.B2.B.B35.4B6.10B.2B3.B3.7B$25.B2.B7.B
5.B2.B.B34.4B5.14B2A$25.B2.B14.2B2.B33.4B5.15B2A$81.3B5.17B$81.2B7.
13B$93.10B$93.11B$93.10B$94.8B$97.3B$98.4B$100.2A$100.A$101.3A$103.A
14$107.B$95.2BD11B$95.DBD12B2.B$95.3D9B2AB.B2A$95.D11B2A3B2A$95.16B.B
$99.4B.7B$100.4B.7B$101.12B$102.11B$103.9B.3B$104.12B$101.2B.11B2A$
100.2A13B2A$100.2AB.10B.B$101.B2.10B$104.9B$103.10B$102.11B$101.11B$
100.13B$99.15B$98.19B$97.19B2A$96.4B.15B2A$95.4B.17B$94.19B$93.19B$
25.B2.B14.2B3.2B42.20B$25.B2.B7.B5.B2.B.B2.B40.20B$25.B2.B8.B4.B4.B2.
B39.24B$25.4B3.7B3.B.2B2.2B39.4B.20B$25.B2.B8.B4.B2.B.B2.B37.4B3.20B$
25.B2.B7.B5.B2.B.B2.B36.4B3.22B$25.B2.B14.2B3.2B36.4B2.24B$85.4B.25B$
84.4B2.2BD13B.10B$83.4B2.3BDBD4B.7B2.2B4.2A$82.4B4.2B3D4B2.3B.B4.B4.A
$81.4B4.5BD4B4.2B2A3.2A4.3A$80.4B4.10B4.BA2.A4.A6.A$79.4B4.4B12.3A5.A
.A$78.4B4.4B22.2A$77.4B4.4B14.3A$76.4B4.4B15.A2.A$75.4B4.4B18.2A$74.
4B4.4B$73.4B4.4B$73.3B4.4B$73.2B4.4B$73.B4.4B$77.4B$76.4B$75.4B24$
142.4B5.4B$141.4B5.4B$140.4B5.4B$139.4B5.4B$138.4B5.4B$137.4B5.4B$
136.4B5.4B$135.4B5.4B$118.2A14.4B5.4B$119.A13.4B5.4B$119.A.AB9.4B5.4B
$120.2AB.2A5.4B5.4B$122.2B2AB3.4B5.4B$105.2A15.4B3.13B$106.A8.B6.13BD
5B$106.A.AB5.2B6.12B3D2B$107.2AB.2A2.3B5.7B.4BDBD3B$109.2B2AB.4B3.15B
D2B$109.4B3.4B.19B$109.6B2.21B$107.B2.26B$106.2AB.25B$106.2A28B$107.
2B.26B$110.19B2.3B.B2A$72.2AB34.20B6.BA.A$70.BA2BA2B31.7B.14B8.A$69.
3B2A3B30.23B8.2A$67.12B27.12B4.10B$66.14B25.12B5.6B2.2A$66.13B25.4B.
7B8.B.B3.A$65.14B24.4B2.6B8.3B5.3A$65.15B22.4B2.7B8.B2AB6.A$66.14B21.
4B3.7B9.2A$67.13B20.6B.8B$68.3B.8B19.16B$73.7B18.17B$13.B2.B14.2B3.2B
35.7B17.18B$13.B2.B7.B5.B2.B.B2.B35.6B16.18B$13.B2.B8.B4.B4.B2.B35.7B
14.4B.11B$13.4B3.7B3.B.2B2.3B35.8B5.2A5.4B.13B$13.B2.B8.B4.B2.B4.B36.
8B3.B2AB3.20B$13.B2.B7.B5.B2.B4.B36.9B2.3B3.21B.B$13.B2.B14.2B2.3B36.
6B.4B2.B3.23B2A.2A$74.7B.30B.B.A.A$75.38BA.A2.A$75.35B.B.2A2.2A$74.3B
2A32B$75.2B2A32B$76.36B$78.35BA.2A$77.2B2.22B.7B2.2A.A$76.B2AB2.2B.8B
.7B3.7B$77.2A5.6B5.5B4.7B$84.4B8.4B6.5B$84.2B2AB7.4B7.2B.B2A$86.2A8.B
2AB10.BA.A$97.2A14.A$113.2A44$83.4B6.4B$84.4B6.4B$85.4B6.4B$86.4B6.4B
$87.4B6.4B$88.4B6.4B$89.4B6.4B$90.4B6.4B$91.4B6.4B$92.4B6.4B$93.4B6.
4B$94.4B6.4B$92.7B6.4B$90.9B7.4B$89.11B7.4B$90.13B5.4B$90.14B5.4B$89.
16B5.4B$88.17B6.4B$88.18B6.4B$87.19B7.4B$87.20B7.4B$80.A7.20B7.4B$80.
3A3.21B9.4B$83.A2.21B10.4B$82.2A2.19B13.4B$82.4B.17B15.4B$15.B2.B14.
2B5.2B4.2B36.20B16.4B$15.B2.B7.B5.B2.B3.B.B3.B2.B35.20B17.4B$15.B2.B
8.B4.B8.B3.B2.B33.21B19.4B$15.4B3.7B3.B.2B5.B3.B2.B33.2BD18B20.4B$15.
B2.B8.B4.B2.B5.B3.B2.B32.3BDBD14B23.4B$15.B2.B7.B5.B2.B5.B3.B2.B33.2B
3D13B25.4B$15.B2.B14.2B4.5B2.2B33.5BD13B26.4B$80.20B27.4B$79.4B4.13B
28.4B$79.3B5.3B2.8B21.2A6.4B$77.4B4.2AB5.8B20.A8.4B$77.2A5.A.AB6.6B
18.BA.A9.4B12.A$78.A5.A8.6B17.B.B2A11.4B9.3A$75.3A5.2A8.7B15.4B14.4B
7.A$75.A16.9B14.4B15.4B6.2A$93.9B12.5B8.2A6.4B2.5B$93.10B11.6B8.A7.8B
$91.19B2.8B8.A.AB5.8B$89.B.2B2A26B8.2AB.3B2.8B$88.2A3B2A25B11.16B$88.
2A21B.7B12.18B$89.31B12.17B$87.5B2.B2.2B2.19B11.16B.B2A$87.2A4.3B8.
17B8.17B2.BA.A$88.A3.B2AB10.15B.2B2.20B5.A$85.3A5.2A12.38B6.2A$85.A
21.8B.20B.7B$105.8B3.2B2A16B2.6B$105.2A3.B5.2B2A16B3.6B$106.A10.18B6.
4B$103.3A12.B.3B.4B12.B2A2B$103.A20.3B14.2A.B2A$122.4B18.BA.A$122.2A
23.A$123.A23.2A$120.3A$120.A56$128.4B8.4B$127.4B8.4B$126.4B8.4B$125.
4B8.4B$124.4B8.4B$123.4B8.4B$122.4B8.4B$121.4B8.4B$120.4B8.4B$119.4B
8.4B$118.4B8.4B$117.4B8.4B$116.4B8.4B$115.4B8.4B6.2A3.2A$114.4B8.4B6.
B2AB.B2AB$113.4B8.4B4.B3.3B2.2B$112.4B8.4B3.4B.3B.3B$111.4B8.13B.7B5.
2A$91.2A.A15.4B7.23B5.A$91.A.2A14.4B4.8B.19B.BA.A$86.2A20.4B4.29B.B2A
$87.A4.3A12.4B.35B$79.A6.A4.A2.AB4.47B$79.3A4.2A3.2A2B4.48B$82.A4.B4.
B.3B2.47B$81.2A4.2B2.7B.45B$81.10B.54B$83.30B3.25B3.2A$82.24B2.4B4.B
4.20B3.A$82.22B3.4B4.2A7.15B6.3A$83.20B3.4B5.A12.11B8.A$84.20B.4B7.A
10.13B$84.24B7.2A9.15B$87.20B18.16B$86.20B18.17B$86.19B20.16B$85.19B
22.13B$81.17B.4B23.5B2A2B.4B$80.2A15B.4B26.3B2A2B2.3B$10.B2.B14.2B4.B
4.2B39.2A19B27.8B3.B2A$10.B2.B7.B5.B2.B2.2B3.B2.B39.19B27.4BD3B4.BA.A
$10.B2.B8.B4.B4.B.B6.B42.15B28.3B3D2B7.A$10.4B3.7B3.B.2B3.B6.B43.13B
29.3B3DB8.2A$10.B2.B8.B4.B2.B3.B5.B45.11B30.7B$10.B2.B7.B5.B2.B3.B4.B
45.11B32.B4DB$10.B2.B14.2B2.5B.4B43.10B33.B4D$85.9B35.BDB2D$84.10B2.B
32.6B$82.B.10B.B2A30.6B$81.2A13B2A30.7B$81.2A11B.2B32.6B$82.12B35.6B$
82.3B.9B$85.11B$85.12B$86.7B.4B$87.7B.4B$85.B.19B2.B$84.2A3B2A19B$84.
2AB.B2A19B$85.B2.24B$89.23B$90.B2.2B2.14BAB$100.10BABA$102.8BABA$103.
8BA$102.10B$102.9B$102.8B$103.7B$104.5B$105.2B22$87.2A$88.A5.2B11.A$
88.A.AB.3B.B7.3A$89.2AB.6B5.A$91.8B5.2A$91.9B.5B$85.B4.14B$84.2AB.19B
$84.2A22B$85.24B$88.22B$87.22B$88.20B$89.19B$88.21B$86.2AB.15B.4B$85.
A.AB3.10B5.4B$85.A6.10B6.4B$84.2A5.13B5.4B$90.15B5.4B$89.16B6.4B$88.
17B7.4B$89.16B8.4B$90.13B11.3B$10.B2.B14.2B4.B2.4B49.5B2A2B.4B11.2B$
10.B2.B7.B5.B2.B2.2B2.B2.B51.3B2A2B2.4B11.B$10.B2.B8.B4.B4.B.B2.B54.
8B2.4B$10.4B3.7B3.B.2B3.B2.3B51.4BD3B4.4B$10.B2.B8.B4.B2.B3.B5.B50.3B
3D2B5.4B$10.B2.B7.B5.B2.B3.B5.B50.3B3DB7.4B$10.B2.B14.2B2.4B.3B51.7B
8.4B$92.B4DB9.4B$92.B5D10.4B$93.BDB2D11.4B$93.6B11.4B$92.6B13.4B$92.
7B13.4B$93.6B14.4B$93.6B15.3B$93.6B16.2B$92.8B16.B$91.8B$91.9B!


Some are composite but I figure it's worth including the best we know of for each.

[simsim314]

Here is a collection of 8 H->xG (including G12 and G28):

Code: Select all

x = 686, y = 40, rule = LifeHistory
106.C86.C88.2C$105.C.C84.C.C87.2C$105.C.C84.C.C$106.C86.C$366.2C94.2C
$2.C299.2C62.2C94.2C$2.3C297.C359.2C$5.C15.2C75.2C85.2C113.C.C360.C$
4.2C15.C76.2C85.2C113.2C361.C.C$19.C.C364.2C94.2C180.2C$19.2C161.C
203.C95.C$182.3C199.C.C93.C.C$118.2C65.C19.2C72.2C103.2C94.2C200.2C$
2C116.C65.2C19.C73.2C296.C104.C$2C114.C.C84.C.C98.C257.2C11.3C102.C.C
$116.2C85.2C97.2C259.C10.C11.C93.2C$23.C277.2C61.C95.C102.C.C8.2C8.3C
$21.2C277.C62.C.C93.C.C102.2C17.C$20.2C279.5C58.C23.C71.C23.C98.2C$
19.C76.C205.C83.2C94.2C$2.2C16.5C70.C.C287.2C94.2C$2.2C17.C74.C23.C
86.C176.C95.C203.C$118.2C85.2C178.5C91.5C196.2C$117.2C85.2C180.C95.C
198.2C$3.2C111.C86.C384.C91.C$2.C.C112.5C82.5C83.2C292.2C93.5C$2.C
115.C86.C86.C.C290.2C95.C$.2C7.2C274.2C6.C182.C106.C80.2C$10.C276.C6.
2C180.C.C91.2C13.5C74.C.C4.2C$11.3C270.3C190.C93.C14.C77.C6.C$13.C99.
C170.C82.2C199.3C92.2C7.3C$112.C.C252.2C199.C105.C$113.C$194.2C182.2C
94.2C$194.C183.C.C93.C.C$195.3C182.C95.C$110.2C85.C182.2C94.2C$110.C.
C$112.C$112.2C!


Found using CatForce (yet unpublished version - but the results for herschel can be found here)

EDIT Kinda big for a single glider, and yet what I could find with the current search:

Code: Select all

x = 41, y = 45, rule = LifeHistory
20.C$18.3C$17.C$7.2C8.2C$7.2C2$25.2C$24.C.C$25.C4$2.2C$.C.C$.C$2C2$
39.2C$39.C$37.C.C$6.2C29.2C$7.C$7.C.C$8.2C4$38.C$36.C.C$36.3C$36.C5$
34.C$33.C.C$34.C$20.2C$20.2C2$31.2C$31.C.C$33.C$33.2C!


[simeks]

Kinda big for a single glider, and yet what I could find with the current search:

This already very useful H-to-G can be reduced in size:

Code: Select all

x = 33, y = 39, rule = LifeHistory
17.2A$16.A.A$17.A6$2A$2A2$31.2A$31.A$29.A.A$29.2A$2A$2A5$30.A$28.A.A$
28.3A$28.A$3.2A$4.A$.3A$.A$26.A$25.A.A$26.A$12.2A$12.2A2$23.2A$23.A.A
$25.A$25.2A!


[simsim314]

Another pretty tricky one (hope it's as helpful as my previous - thx simeks for the feedback):

Code: Select all

x = 28, y = 29, rule = LifeHistory
14.2C$14.C.C$15.C7$26.2C$26.2C$2C$.C$.C.C$2.2C5$23.C$22.C.C$2.C20.C$
2.C.C$2.3C$4.C3$19.2C$19.2C!


EDIT Just noticed it's an edge shooter.

[dvgrn]

Another pretty tricky one (hope it's as helpful as my previous - thx simeks for the feedback)...
EDIT Just noticed it's an edge shooter.

That one is a variant of H-to-G#3 (and it also shows up as part of H-to-G#17, with the glider blocked off). Here it is compared with the old standard form -- it sticks out a little more to the east, but saves two rows at the top:

Code: Select all

x = 75, y = 34, rule = LifeHistory
20.A$19.A.A39.2A$19.A.A39.A.A$20.A41.A4$27.2A$27.2A2$73.2A$73.2A$7.2A
38.2A$8.A39.A$8.A.A37.A.A$9.2A38.2A4$30.2A$30.2A38.A$69.A.A$9.A39.A
20.A$9.A.A37.A.A$9.3A37.3A$11.A39.A3$26.2A38.2A$26.2A38.2A$2.2A38.2A$
3.A39.A$3A37.3A$A39.A!

It's not exactly an edge shooter, because the Herschel has to come from somewhere. I think the best you can say for it is that it's "potentially transparent" -- Guam used it as part of a transparent tandem-glider circuit at one point, for example.

[Sphenocorona]

Just realized that there's a TWIT version of the near-edgeshooting H->FNG I posted, with a somewhat different reaction envelope:

Code: Select all

x = 43, y = 20, rule = LifeHistory
9.2B$8.4B17.B$8.4B16.3B$6.6B16.5B$5.7B16.7B7.A$4.10B12.9B5.3A$5.9B12.
9B4.A$5.9B4.A7.9B4.2A$6.8B2.3A8.8B2.4B$4.10B.A8.15B$3.11BA.A6.11B2A2B
2A$3.9B.2BAB6.11B2A.B2A$3.9B2.2B7.12B3.B$3.B3C4B2.2B8.B3C5B$3.2BC4B2.
B2AB7.2BC5B$3.2B3C2B3.2A8.2B3C2B$3.6B14.6B$2.7B13.7B$.4B.B14.4B.B$4B
16.4B!

[chris_c]

HtoG SE on lane 63

Code: Select all

x = 64, y = 34, rule = B3/S23
50bo$50b3o$53bo8b2o$27b2o23b2o8bo$28bo31bobo$28bobo29b2o$21b2o6b2o$12b
2o7b2o$13bo$13bobo$14b2o2$7b2o$8bo$8bobo$9b2o7$9bo$9bobo$9b3o31b2o$11b
o31b2o2$21b2o8b2o$21b2o2b2o5bo$25bobob3o$2b2o23bobo$3bo23b2o$3o$o!


[dvgrn]

Okay, everything seems to be working. Please try out the H-to-G recognizer script on any H-to-Gs that you think are new. Select an H-to-G conduit and run the script. As long as the conduit is stable, the input is a Herschel in any orientation (or a pre-Herschel at T=-3 or T=-6) and the output is nothing but gliders, the script will normalize the conduit and generate a label.

The input can be a two-state pattern, or a LifeHistory pattern with the Herschel shown either in live cells or in marked OFF cells (state 4). Live-cell Herschels are checked first.

Once you have a label, you can look it up in the stamp collection (attached to the first post -- same link above) and see if it's a new lane, or a new timing for a known lane. I've reviewed everything that has shown up so far in this thread.

Eventually I'll add to the first post a list of all the known labels, so that we can do a simple text search to check for a new H-to-G -- and also use those same statistics to set up Hersrch-type searches automatically.

I'm going to be fighting my way through the Hunting of the New Herschel Conduits thread over the next week or so, and will update the stamp collection with any H-to-Gs that have been missed. A new labeled edition of the elementary-conduits stamp collection is also in the works.

One slightly odd detail is that the script only matches on ON cells -- so it will happily find a Herschel in any 3x4 or larger block of all-ON cells, for example. In practice I don't think this should be a problem, since any such conduit will be disqualified as unstable at a later step. I might add OFF-cell masks to each pattern at some point, especially if I get around to upgrading the script to recognize pi, B, R, BG, C, etc., since an R is a subset of a B...!

Please let me know if you find any bugs in the script. It should work fine for H-to-2G, H-to-3G, etc.

[simsim314]

@dvgrn I was wondering what is the fastest recovery spartan conduit for H->Gn and Gn->H? I mean H->G4 and G4->H is now working with recovery time of 118 ticks, is there any faster Gn mechanism?

And many thanks for the glider project you're conducting.

[chris_c]

Please try out the H-to-G recognizer script on any H-to-Gs that you think are new.

The script seems to work well, thanks. The only thing I am worried about is that we choose the best definition for timing before too much work is done on cataloguing these things.

At the moment it seems that the timing is defined as the time at which the glider returns to the line y=0 and has canonical form. Since Herschels naturally travel from left to right I was thinking it might be better if the timing was based on the line x=0 instead. For example, if you had a HtoG NE with timing T and you prepended a F117 conduit you would always end up with a HtoG NE with timing T-43 since the Herschel advances by 40 cells eastward in 117 generations.

Another thing I think would be good is if the canonical form of the gliders were related by reflection instead of rotation. At the moment, for example, the canonical orientations of glider NE and SE are as follows:

Code: Select all

x = 13, y = 3, rule = B3/S23
b2o8bo$obo9bo$2bo7b3o!


If, instead, the canonical gliders were reflections of one another then you would always know that a HtoG NE with timing T prepended with an Fx77 conduit would give a HtoG SE of timing T-23 (the Herschel advances 25 cells in 77 generations). With the current canonical orientations I don't think the story is so simple.

My opinions here are heavily biased by my experience in working out this fast G->LWSS converter. So am I making things simpler for one use case but making it significantly harder in other cases? Quite possibly... but I thought it would be good to discuss before the formula for the timing is set in stone.

[dvgrn]

@dvgrn I was wondering what is the fastest recovery spartan conduit for H->Gn and Gn->H? I mean H->G4 and G4->H is now working with recovery time of 118 ticks, is there any faster Gn mechanism?

Yes, but they're all in the same general range. We can pretty much count the old G5 transceiver as Spartan, now that we have a nice recipe for a dead spark coil. That's 117-tick recovery. The newer G6 transmitter allows 110-tick recovery.

Code: Select all

x = 231, y = 74, rule = LifeHistory
188.2A$187.B2AB$187.4B$188.2B$187.3B2A$185.5B2A$184.8B11.2A$88.A95.6B
5.2B6.A$88.3A91.9B.6B2.BA.A$71.2A18.A88.17B.B.B2A$72.A17.2A4.B80.24B
4.2A$59.A11.A18.8B77.27B2.B2AB$59.3A9.2A19.8B5.2A67.28B2.3B$62.A9.B
18.9B6.A65.31B2.B.B$49.2A10.2A9.3B15.12B.3A50.B.7B5.39B$50.A10.5B5.6B
12.14BA46.B.13B5.4B.34B$50.A.AB9.4B3.10B8.15B42.21BD10BD33B$51.2AB.3B
4.6B2.11B3.2B.15B41.D21BD10B2D2B2.29B$53.7B.13B2A15BC11B39.B3D18B2D
11B2DB4.8B2A16B$53.21B2A15BCBC10B39.DBD15B2A2B2D13B6.6B2A17B$54.37B3C
4B.B2AB2A40.D15B2A3BD12B8.12B2A9B$53.40BC4B2.A3.A42.2B2.2B3.19B2.B10.
10BA2BA4B.B$51.46B4.3A53.10B2.B3.2B15.9B2A6B$49.18B.B3.13B.4B70.6B6.B
A17.12B.4B$49.2BC13B7.7B.4B.4B12.3A58.3B7.A.A17.12B.4B$48.3BCBC4B.6B
14.4B.4B12.A3.A59.B8.2A19.11B.4B$49.2B3C4B2.B.5B11.4B.4B13.2A.2A59.2A
29.11B.4B$48.5BC4B7.2A10.4B.4B79.A31.10B.4B$47.10B8.A10.4B.4B79.A33.B
.B3.4B.4B$46.4B16.3A6.4B.4B80.2A33.3B3.4B.4B$45.4B19.A5.4B.4B115.B2AB
4.4B.5B$44.4B25.4B.4B117.2A6.4B.B3DB$44.2A26.4B132.4B.D4B$45.A25.4B
134.4B.D4B$42.3A25.4B136.4B2.4B$42.A26.4B138.4B2.4B$68.4B140.4B2.4B$
67.4B.B140.4B2.4B$66.4B.B142.4B2.4B$57.2A6.4B.4B141.4B.4B$56.B2AB4.4B
.4B143.9B.B$22.2A33.3B3.4B.4B145.12B$22.A33.B.B3.4B.4B147.11B$23.A31.
10B.4B149.9B2A$22.2A29.11B.4B149.10B2A$22.B8.2A19.11B.4B149.10B.B$20.
3B7.A.A17.12B.4B140.2A8.10B$18.6B6.BA17.12B.4B123.2A17.A9.8B$15.10B2.
B3.2B15.9B2A6B125.A17.A.AB5.9B$5.2B2.2B3.19B2.B10.10BA2BA4B.B111.A11.
A19.2AB.3B.10B$3.D15B2A3BD12B8.12B2A9B109.3A9.2A20.17B$.DBD15B2A2B2D
13B6.6B2A17B111.A9.B20.17B$B3D18B2D11B2DB4.8B2A16B99.2A10.2A9.3B19.
15B$.D21BD10B2D2B2.29B99.A10.5B5.6B16.16B.B$3.21BD10BD33B99.A.AB9.4B
3.10B8.22B2A$8.B.13B5.4B.34B102.2AB.3B4.6B2.11B3.2B.23B2A$14.B.7B5.
39B104.7B.13B2A15BC16B.2B$30.31B2.B.B105.21B2A15BCBC4B.10B$32.28B2.3B
107.37B3C4B2.8B$33.27B2.B2AB105.40BC4B2.9B$35.24B4.2A104.46B4.8B$38.
17B.B.B2A106.18B.B17.4B11.8B$40.9B.6B2.BA.A105.ABC2B2A9B20.4B13.5B.B
2A$42.6B5.2B6.A104.BABDAC2BAB.6B19.4B12.5B3.BA.A$42.8B11.2A104.2BD2C
2BAB2.B.5B17.2AB11.A.2A9.A$43.5B2A116.2B2ABDABAB7.2A18.A10.3AB2A9.2A$
45.3B2A115.10B8.A16.3A10.A4.B$46.2B116.4B16.3A13.A13.3A.2A$45.4B114.
4B19.A29.A.A$45.B2AB167.A.A$46.2A114.2A53.A$163.A$160.3A$160.A!
#C [[ VIEWONLY HEIGHT 240 ZOOM 2 ]]

Both of those are painfully limited to one orientation, but the newer G6 transmitter combined with the newer G6/G13 receiver is ambidextrous, with recovery time 110 ticks in one orientation and 130 ticks in the other.

It's too bad it's not 128 ticks -- that would be a nice round number from Golly's point of view -- but it's all in the same ballpark anyway. For example, in practice we might end up sending signals at p256+/-63, which is safe for 130-tick-recovery conduits.

I don't think there are any reasonable Spartan transmitters with recovery time under 110. The old absolute limit used to be 111 ticks, and that was incredibly awkward and significantly non-Spartan.

[dvgrn]

The script seems to work well, thanks. The only thing I am worried about is that we choose the best definition for timing before too much work is done on cataloguing these things.

At the moment it seems that the timing is defined as the time at which the glider returns to the line y=0 and has canonical form. Since Herschels naturally travel from left to right I was thinking it might be better if the timing was based on the line x=0 instead... Another thing I think would be good is if the canonical form of the gliders were related by reflection instead of rotation.
...
My opinions here are heavily biased by my experience in working out this fast G->LWSS converter. So am I making things simpler for one use case but making it significantly harder in other cases? Quite possibly... but I thought it would be good to discuss before the formula for the timing is set in stone.

Definitely all good points to bring up.

Here are my reasons for the choices I made -- such as they are!

• Gliders related by rotation are all the same color, whereas gliders related by reflection are different colors. So with the current canonical form, you can tell what color any glider is, based on whether the lane number is even or odd. For even-lane H-to-Gs, for example, the glider will be the same color as the upper left cell of the Hershel's '4' shape, and the opposite color for odd lanes. I like that -- maybe for no particularly good reason.
  
• I chose the canonical form of the glider from my arbitrary stamp collection of signal objects' canonical forms. They're all "heavy in the southeast" if possible, and hopefully that will make the canonical forms easier to memorize. But the Herschel doesn't really follow that -- it's just the traditional Hersrch orientation, which is also the one that the canonical R and B naturally transform into.
  
• Just by the way, lane numbers are chosen to line up with the numbering system I used for the original H-to-G collection in 2006. If I were doing it all again, I'd definitely make the first natural glider be SW lane 0 -- or maybe SW lane -1, see below -- but really it's mostly just the difference between lane numbers that matters, so it doesn't seem to make sense to change that old convention at this late date.
  
• For the T values, my choice of y=0 was fairly arbitrary. It was easy for me to check that all of the numbers were coming out right, by placing a canonical glider on the y=0 line in the output lane at T={my T value}, in an empty copy of the converter -- then continuing to run both copies and checking that the two eventually converge to the same state.

Now, I can invent composite H-to-Gs where this last test doesn't work (because the glider hits a catalyst) but usually the elementary H-to-Gs seem to be fine. The T number is reasonably intuitive with the y=0 rule.

So let's try a sample statistic for the x=0 line. For what I'm currently calling "SE21T80", we can calculate what time the glider would be at X=0, and where it would be:

Code: Select all

x = 157, y = 45, rule = LifeHistory
.3D2.5D2.3D4.D3.5D2.3D3.3D21.3D2.5D2.3D4.D3.5D26.3D$D3.D.D5.D3.D2.2D
5.D3.D3.D.D3.D19.D3.D.D5.D3.D2.2D5.D27.D3.D$D5.D9.D3.D5.D3.D3.D.D2.2D
19.D5.D9.D3.D5.D2.D3.D7.5D8.D3.D$.3D2.3D6.D4.D5.D4.3D2.D.D.D20.3D2.3D
6.D4.D5.D3.D.D15.5D2.3D$4.D.D7.D5.D5.D3.D3.D.2D2.D23.D.D7.D5.D5.D4.D
9.5D8.D3.D$D3.D.D6.D6.D5.D3.D3.D.D3.D19.D3.D.D6.D6.D5.D3.D.D21.D3.D$.
3D2.5D.5D2.3D4.D4.3D3.3D21.3D2.5D.5D2.3D4.D2.D3.D2.2D17.3D$95.D2.D$
95.D2.D$95.D2.D$96.2D$68.3B57.3B$68.3BD56.3BC$69.B.CD56.B.BC$70.3DB
56.3CB$71.4B56.4B$72.4B56.4B$73.4B56.4B$74.3B57.3B$75.2B58.2B2$18.A
59.A59.D$18.3A57.3A57.3D$9.A11.A47.A11.A47.A11.D$9.3A8.2A5.4B38.3A8.
2A5.4B38.3A8.2D5.4B$12.A7.11B41.A7.11B41.A7.3B2.6B$11.2A3.B5.11B38.2A
3.B5.11B38.2A3.B5.B2.8B$11.8B2.11B2A37.8B2.11B2A37.8B2.11B2A$13.19B2A
39.19B2A39.19B2A$13.20B40.20B40.20B$12.20B40.20B40.20B$10.21B39.21B
39.21B$8.24B36.24B36.24B$8.2BD14B4.4B35.2BA14B4.4B35.2BD14B4.4B$7.3BD
BD4B.6B6.3BD33.3BABA4B.6B6.4B33.3BDBD4B.6B6.4B$8.2BDCD4B2.B.5B5.2BCD
33.2BACA4B2.B.5B5.4B33.2BDCD4B2.B.5B5.4B$7.5BD4B7.2A6.3DB31.5BA4B7.2A
6.4B31.5BD4B7.2A6.4B$6.10B8.A8.4B29.10B8.A8.4B29.10B8.A8.4B$5.4B16.3A
6.3B28.4B16.3A6.3B28.4B16.3A6.3B$5.3B19.A7.2B28.3B19.A7.2B28.3B19.A7.
2B$3.4B56.4B56.4B$3.2A58.2A58.2A$4.A59.A59.A$.3A57.3A57.3A$.A59.A59.A!
#C [[ VIEWONLY HEIGHT 240 ZOOM 2.5 ]]

Turns out to be Tx0=-8 -- you just have to take the T value as currently calculated and subtract four times the lane-plus-one, I believe. In other words, move the SE canonical glider lane+1 cells to the northwest.

(Yes, again it would have been better if I'd chosen a slightly different lane numbering system in 2006, to get rid of that ugly +1. Water under the bridge... Or we could have the "canonical point" of the Herschel be the one with three orthogonal neighbors, I suppose, but again there's too much history with Hersrch defining the cell with five neighbors as the canonical center of a Herschel.)

So, Tx0=-8... ugh, a negative number. Yes, there are a few of those in the current H-to-G collection, especially the ubiquitous NW32T-4, but they're pretty rare. I think they'd be much more common among the Tx0 numbers, and for pretty much any non-transparent conduit, the canonical glider would hit catalysts if it were allowed to run from time=Tx0.

Therefore: if there's a specific use case for switching Tx0, I can trivially adjust the script to report both Tx0 and Ty0... but since it's really pretty easy to calculate the Tx0 metric from the currently reported lane and T values, I'm very tempted to leave things just as they are.

Thoughts, ideas, suggestions?

[chris_c]

Here are my reasons for the choices I made -- such as they are!

Thoughts, ideas, suggestions?

All of your reasoning sounds good. Note that I am not suggesting any change to the lane numbers and I definitely wouldn't suggest changing the base coordinate of the Herschel.

The reason I prefer the return time to x=0 is because it works best with an arbitrary sequence of prepended F and Fx conduits. These are the only types of conduit that can be chained together indefinitely so in my opinion it makes sense to favour this case over anything else.

Also note what happens if you use Tx=0 but keep the canonical gliders as rotations of each other:

Code: Select all

x = 204, y = 168, rule = LifeHistory
4.3D2.5D2.3D4.D3.5D29.3D$3.D3.D.D5.D3.D2.2D5.D30.D3.D74.D3.D.5D2.3D3.
3D2.5D26.3D3.3D$3.D5.D9.D3.D5.D2.D3.D7.5D11.D3.D74.2D2.D.D5.D3.D.D3.D
3.D27.D3.D.D3.D$4.3D2.3D6.D4.D5.D3.D.D18.5D2.3D75.D.D.D.D9.D.D3.D3.D
2.D3.D7.5D12.D.D3.D$7.D.D7.D5.D5.D4.D9.5D11.D3.D74.D2.2D.3D5.2D3.4D3.
D3.D.D15.5D4.D3.4D$3.D3.D.D6.D6.D5.D3.D.D24.D3.D74.D3.D.D9.D5.D3.D4.D
9.5D10.D7.D$4.3D2.5D.5D2.3D4.D2.D3.D2.2D20.3D75.D3.D.D5.D3.D5.D3.D3.D
.D22.D8.D$38.D2.D97.D3.D.5D2.3D3.3D4.D2.D3.D2.2D16.5D2.3D$38.D2.D132.
D2.D$38.D2.D132.D2.D$39.2D133.D2.D$175.2D17$165.A$165.3A$29.A138.A$
29.3A135.2A$20.A11.A$20.3A8.2A115.A42.A$23.A124.3A38.3A$22.2A127.A36.
A$43.2A105.2A11.2A23.2A$43.2A118.2A5$21.A$21.A.A125.A$21.3A125.A.A44.
2A$23.A11.2A112.3A44.2A$35.A115.A23.2A$36.3A137.A$38.A134.3A8.2A$173.
A11.A$14.2A166.3A$15.A126.2A38.A$12.3A128.A20.2A$12.A127.3A21.A.A$
140.A25.A$166.2A55$138.3D2.5D2.3D3.3D2.5D26.3D3.3D$137.D3.D.D5.D5.D3.
D3.D27.D3.D.D3.D$137.D5.D5.D9.D3.D2.D3.D7.5D12.D.D2.2D$2.D3.D.5D2.3D
3.3D2.5D19.5D83.3D2.3D3.4D5.D4.D3.D.D15.5D4.D2.D.D.D$2.2D2.D.D5.D3.D.
D3.D3.D21.D90.D.D5.D3.D3.D5.D4.D9.5D10.D3.2D2.D$2.D.D.D.D9.D.D2.2D3.D
2.D3.D7.5D2.D86.D3.D.D5.D3.D2.D6.D3.D.D22.D4.D3.D$2.D2.2D.3D5.2D2.D.D
.D3.D3.D.D16.3D84.3D2.5D2.3D2.5D3.D2.D3.D2.2D16.5D2.3D$2.D3.D.D9.D.2D
2.D3.D4.D9.5D6.D117.D2.D$2.D3.D.D5.D3.D.D3.D3.D3.D.D15.D3.D117.D2.D$
2.D3.D.5D2.3D3.3D4.D2.D3.D2.2D11.3D118.D2.D$37.D2.D132.2D$37.D2.D$37.
D2.D$38.2D15$32.A127.A$30.3A127.3A36.A$29.A133.A33.3A$18.A10.2A131.2A
32.A$17.A.A176.2A$17.A.A123.A42.A$15.3A.2A20.A101.3A38.3A$14.A24.3A
104.A36.A$8.A6.3A.2A17.A106.2A11.2A23.2A$8.3A6.A.2A17.2A118.2A$11.A$
10.2A$35.2A$34.A2.A$35.2A$144.A50.2A$144.A.A47.A2.A$144.3A48.2A$9.A
136.A23.2A$9.A.A159.A$9.3A156.3A6.A.2A17.2A$11.A11.2A143.A6.3A.2A17.A
$23.A150.A24.3A$24.3A110.2A36.3A.2A20.A$26.A111.A20.2A16.A.A$36.2A97.
3A21.A.A15.A.A$2.2A32.A98.A25.A16.A10.2A$3.A33.3A121.2A26.A$3A36.A
150.3A$A191.A!


It looks like if you add Fx77 before an SE HtoG then the x0 timing changes by 21 but if you add Fx77 before a NE HtoG then the x0 timing changes by 25. That's a little bit weird for my taste. All I am suggesting is to change two of the canonical gliders by 2 modulo 4 so that the difference would be 23 in both cases --- you shouldn't need to change the lane numbers.

[dvgrn]

It looks like if you add Fx77 before an SE HtoG then the x0 timing changes by 21 but if you add Fx77 before a NE HtoG then the x0 timing changes by 25. That's a little bit weird for my taste. All I am suggesting is to change two of the canonical gliders by 2 modulo 4 so that the difference would be 23 in both cases --- you shouldn't need to change the lane numbers.

Okay, I'll look into that. It's a fairly trivial change to the script, but also the kind of thing that's easy to get wrong. I agree that it would be nice if adding F and Fx conduits only changed the lane number (by a predictable amount) but didn't affect the T rating.

My objection about glider color doesn't really hold -- the offset-by-two gliders will still be the same color, it's just a little harder to tell (because the easy test for glider color requires picking four rotationally equivalent gliders to test with.)

[simeks]

H-to-G3:

Code: Select all

x = 55, y = 53, rule = LifeHistory
50.C$48.3C$47.C$43.B.B.2C$42.7B$34.2C6.5B$35.C5.8B$35.C.CB.9B$36.2CB.
8B$38.9B6.2C$29.2C7.10B5.C$30.C7.10B2.BC.C$30.C.CB4.11B.B2C$31.2CB.
16B$33.18B$33.17B$34.15B$33.16B$31.20B$29.21B2C$29.2BE16B.BC.C$28.3BE
BE4B.9B4.C$29.2B3E4B2.7B5.2C$28.5BE4B3.5B$27.10B5.3B$26.7B7.7B$25.7B
8.2C.B.2C$24.7B10.C3.C$23.7B8.3C5.3C$22.4BD2B9.C9.C$21.3B2D2B$20.4B.
2D$19.4B$18.4B$17.4B$16.4B$15.4B$14.4B$13.4B$12.4B$11.4B$10.4B$9.4B$
8.4B$7.4B$6.4B$5.4B$4.4B$3.4B$2.4B$.D3B$D3B$3D!


[A for awesome]

What I think is a new R-to-G:

Code: Select all

x = 18, y = 18, rule = LifeHistory
2.C$2.3C$5.C$4.2C10.2C$4.5B7.C$6.5B2.BC.C$6.6B.B2C$2.12B$.2C11B$.2C
11B$2.12B$5.10B$4.4BC6B$3.4B3C5B$2.5BC7B$.D3B.8B$D3B$3D!


[Kazyan]

Non-Spartan H-to-2G. At least one new lane here; the script identifies the other as matching a dependent conduit, but visual inspection suggests otherwise (unless I'm just misidentifying something).

EDIT: Oh, that's a negative sign, not a dash. Yep, both lanes are new.

Code: Select all

x = 30, y = 30, rule = LifeHistory
19.4B$18.4B3.A$17.4B3.A.A$16.4B4.A.A$15.4B3.2A.A.2A$14.4B3.A3.A3.A$
14.4B3.A.2A.2A.A$13.5B4.A.A.A.A$13.6B5.4B$11.7B5.4B$10.8B3.7B$9.20B$
8.21B$7.14BD6B$6.15BDBD4B$5.16B3D4B$4.4B.14BD4B$3.4B3.19B$2.4B9.14B$.
4B10.14B$4B12.12B$3B14.9B$2B17.B2A4B$B19.2A4B$21.3B.B2A$19.5B.BA.A$
19.2A7.A$20.A7.2A$17.3A$17.A!

[dvgrn]

Non-Spartan H-to-2G. At least one new lane here; the script identifies the other as matching a dependent conduit, but visual inspection suggests otherwise (unless I'm just misidentifying something).

Hmm. Let's put this one in the Future Hopefuls group rather than the main collection, since that input Herschel is so far inside the reaction envelope that I can't see how much of anything could connect to it.

It's not totally impossible, since the F171 does connect to it, in a rather entertaining self-destructive kind of way:

Code: Select all

x = 39, y = 39, rule = LifeHistory
28.4B$27.4B3.A$26.4B3.A.A$25.4B4.A.A$10.A13.4B3.2A.A.2A$10.3A10.4B3.A
3.A3.A$13.A9.4B3.A.2A.2A.A$12.2A8.5B4.A.A.A.A$22.6B5.4B$20.7B5.4B$19.
8B3.7B$18.20B$17.21B$16.14BC6B$4.2A9.15BCBD4B$5.A8.16B3C4B$5.A.A5.4B.
14BC4B$6.2A4.4B3.19B$11.4B9.14B$10.4B10.14B$A8.4B12.12B$3A6.3B14.9B$
3.A5.2B17.B2A4B$2.2A5.B19.2A4B$30.3B.B2A$28.5B.BA.A$28.2A7.A$29.A7.2A
$26.3A$26.A$.E$.E.E$.3E$3.E2$10.2A$11.A$8.3A$8.A!
#C [[ THUMBNAIL AUTOSTART STEP 2 ZOOM 12 LOOP 500 ]]

So maybe for some future conduit with an extra H output, that interior glider might be just what's needed to clean up some junk. Or are there any of Guam's more speculative conduits that can survive being attached to this thing?

[Kazyan]

It would probably be kept on the shelf for use on those conduit-hunting cases where you almost get a clean output, but there's a boat left somewhere deep in the reaction envelope. (It's always a boat. I'm not the only one that keeps happening to, right?)

[dvgrn]

Okay, here's my latest attempt at H-to-G recognizer code:

HtoGstats26May2015:

Code: Select all

import golly as g
from time import sleep
import itertools
from glife.text import make_text

g.warn("Don't use this version -- use the version posted in the first message in the H-to-G thread.")

orientations=[[1,0,0,1],[0,-1,1,0],[-1,0,0,-1],[0,1,-1,0],[1,0,0,-1],[0,1,1,0],[0,-1,-1,0],[-1,0,0,1]]
herschel=([[-1,-2],[-1,-1],[-1,0],[1,-1],[1,0],[1,1]],0) # plus [0,0] makes a Herschel
# arrange for pre-Herschels to be recognizable also
hminus3=([[-5,-1],[-5,1],[-5,2],[-4,-2],[-4,-1],[-4,0],[-4,1],[-4,2],[-3,-2],[-3,-1],[-3,0],[-3,1],[-1,-1],[-1,0],[-1,1],[0,-1],[0,1],[1,0]],-3)
# TODO:  add hminus4 and hminus5, mostly for testing purposes
hminus6=([[-5,1],[-4,-3],[-4,1],[-3,-2],[-3,1],[-2,-2],[-2,-1],[-2,1],[-2,2],[-1,-1],[-1,1]],-6)
# quick recognition patterns and offsets for all phases -- add [0,0] to make a complete glider
gliders=[([[1,0],[2,0],[0,1],[1,2]],(-1,-1),"NW",0),
         ([[-1,1],[0,1],[-1,2],[1,2]],(0,-2),"NW",1),
         ([[1,0],[0,1],[2,1],[0,2]],(-1,-2),"NW",2),
         ([[1,0],[-1,1],[0,1],[1,2]],(-1,-2),"NW",3),
         ([[1,0],[2,0],[2,1],[1,2]],(-1,-1),"NE",0),
         ([[0,1],[1,1],[-1,2],[1,2]],(0,-2),"NE",1),
         ([[1,0],[-1,1],[1,1],[1,2]],(0,-2),"NE",2),
         ([[1,0],[1,1],[2,1],[0,2]],(0,-2),"NE",3),
         ([[1,1],[-1,2],[0,2],[1,2]],(0,-1),"SE",0),
         ([[2,0],[1,1],[2,1],[1,2]],(-1,0),"SE",1),
         ([[-2,1],[0,1],[-1,2],[0,2]],(1,0),"SE",2),
         ([[1,1],[2,1],[0,2],[1,2]],(0,0),"SE",3),
         ([[-1,1],[-1,2],[0,2],[1,2]],(0,-1),"SW",0),
         ([[2,0],[0,1],[1,1],[1,2]],(-1,0),"SW",1),
         ([[0,1],[2,1],[0,2],[1,2]],(-1,0),"SW",2),
         ([[-2,1],[-1,1],[-1,2],[0,2]],(0,0),"SW",3)]
RUNTIME = 1024

def groupcells(c):
  return [c[pos:pos+2] for pos in range(0, len(c)-1, 2)]

def findHerschels(c, hv):
  h=hv[0]
  count,foundmatch,final=0,0,[]
  while count<8:
    ora,orb,orc,ord=orientations[count]
    count+=1
    cnew=groupcells(g.transform(c,0,0,ora,orb,orc,ord))
    for cell in cnew:
      sleep(0)
      ptr,match=0,1
      while ptr<len(h):
        if [cell[0]+h[ptr][0],cell[1]+h[ptr][1]] not in cnew:
          match=0
          break
        ptr+=1
      if match==1:
        final=g.transform(c,0,0,ora,orb,orc,ord)
        final=g.transform(final,-cell[0],-cell[1])
        foundmatch+=1
        # break ## faster, but doesn't check for multiple Herschels
    # if foundmatch==1: break
  return foundmatch, final, hv

# input time run so far
# return list of spacetime locations of canonical gliders in current universe:
#   [["NW",X0,Y0,T0],["NW",X1,Y1,T1],[["SE",X2,Y2,T2],["NE",X3,Y3,T3]]
def findgliders(t):
  outlist=[]
  clist=groupcells(g.getcells(g.getrect()))
  while clist!=[]:
    cx,cy = clist[0][0],clist[0][1]
    match=1
    for glider in gliders:
      match = 1
      for item in glider[0]:
        if g.getcell(item[0]+cx,item[1]+cy)==0:
          match=0
          break

      if match==1:
        g.setcell(cx,cy,0)
        for item in glider[0]:
          g.setcell(item[0]+cx,item[1]+cy, 0)
        outlist+=[[cx-glider[1][0],cy-glider[1][1],glider[2],glider[3]]]
        # make new list of remaining ON cells and continue
        clist=groupcells(g.getcells(g.getrect()))
        break
    # if we try all gliders and none of them match, report the problem
    if match==0: g.exit("Top remaining cell doesn't look like a glider.")
 
  #  g.note(str(clist)+"\n"+str(outlist))
  return outlist

# TODO:  fix case where 4-state H overlaps ON H-3 or H-6
#        I think this will need a third run with cells[i+2] in [4,5]
cells,altcells=g.getcells(g.getselrect()),[]
if cells==[]:
  cells=g.getcells(g.getrect())
  if cells==[]:
    g.exit("Please open or select H-to-nG converter pattern to retrieve glider statistics.")
if len(cells)%2==1:
  # convert to two-state list
  # cells = ON cells only (will find Herschels with some cells marked)
  # altcells = marked ON and marked OFF cells
  # altcells2 = any ON and marked OFF cells
  newcells=[cells[i:i+2] for i in range(0,len(cells)-1,3) if cells[i+2] in [1,3,5]]
  flatcells=list(itertools.chain.from_iterable(newcells)) # sum(newcells,[]) is shorter but slower
#  altcells=[cells[i:i+2] for i in range(0,len(cells)-1,3) if cells[i+2] in [3,4,5]]
#  altflatcells=list(itertools.chain.from_iterable(altcells))
  altcells2=[cells[i:i+2] for i in range(0,len(cells)-1,3) if cells[i+2] in [1,3,4,5]]
  altflatcells2=list(itertools.chain.from_iterable(altcells2))
  cells=newcells
else:
  flatcells=cells
foundmatch, final, hvariant = findHerschels(flatcells, herschel)
if foundmatch==0:
  foundmatch, final, hvariant = findHerschels(flatcells, hminus3)
if foundmatch==0:
  foundmatch, final, hvariant = findHerschels(flatcells, hminus6)
#if foundmatch==0:
#  if altcells!=[]:
#    foundmatch, final, hvariant = findHerschels(altflatcells2, herschel)
#  if foundmatch==0:
#    foundmatch, final, hvariant = findHerschels(altflatcells2, hminus3)
#  if foundmatch==0:
#    foundmatch, final, hvariant = findHerschels(altflatcells2, hminus6)
if foundmatch==0:
  if altcells2!=[]:
    foundmatch, final, hvariant = findHerschels(altflatcells2, herschel)
  if foundmatch==0:
    foundmatch, final, hvariant = findHerschels(altflatcells2, hminus3)
  if foundmatch==0:
    foundmatch, final, hvariant = findHerschels(altflatcells2, hminus6)
  if foundmatch==0:  g.exit("No match found.")
if foundmatch>1: g.note("Found multiple Herschels ("+str(foundmatch)+")" )
g.addlayer()
g.new("Test - Herschel"+str(hvariant[1]))
hcells=[[0,0]]+hvariant[0]
# g.setalgo("QuickLife")
g.setrule("B3/S23")
g.putcells(final)

g.run(RUNTIME)
for c in hcells:
  if g.getcell(c[0],c[1])!=0: g.exit("Herschel site is contaminated.")
for c in hcells: g.setcell(c[0],c[1],1)
for c in groupcells(final):
  if g.getcell(c[0],c[1])==0: g.exit("Conduit has been damaged.")
  g.setcell(c[0],c[1],0)
glist = findgliders(RUNTIME)

count=0
g.setrule("LifeHistory")
for item in glist:
  if item[2]=="NW":
    lane = item[0]-item[1]+1
    out="NW"+str(lane)+"T"+str(RUNTIME-item[3]+4*item[1]+hvariant[1]+4*(lane-1)) # tested
  elif item[2]=="NE":
    lane = item[0]+item[1]
    out="NE"+str(lane)+"T"+str(RUNTIME-item[3]+4*item[1]+hvariant[1]-4*lane)     # tested
  elif item[2]=="SE":
    lane = item[0]-item[1]-1
    out="SE"+str(lane)+"T"+str(RUNTIME-item[3]-4*item[1]+hvariant[1]-4*(lane+1)) # tested
  elif item[2]=="SW":
    lane = item[0]+item[1]
    out="SW"+str(lane)+"T"+str(RUNTIME-item[3]-4*item[1]+hvariant[1]+4*lane)     # tested
  else:
    g.note("A new diagonal direction has been discovered...!")
  t = make_text(out, "mono")
  tstate4=[c+[4] for c in groupcells(t)]
  ts4flat = list(itertools.chain.from_iterable(tstate4))
  if len(ts4flat)%2==0:  ts4flat+=[0]
  g.putcells(ts4flat, 0, count*10)
  count+=1

g.putcells(final,0,count*10+50)
g.setgen("0")
g.fit()

Here's the test pattern I used:

Code: Select all

x = 177, y = 393, rule = LifeHistory
5.3D2.D3.D3.D4.3D2.5D2.3D2.5D67.D3.D.D3.D4.D5.D2.5D2.3D2.5D4.D$4.D3.D
.D3.D2.2D3.D3.D3.D3.D3.D5.D67.2D2.D.D3.D3.2D4.2D4.D3.D3.D5.D3.2D$4.D
5.D3.D3.D3.D2.2D3.D3.D3.D4.D68.D.D.D.D3.D2.D.D3.D.D4.D7.D4.D3.D.D$5.
3D2.D.D.D3.D3.D.D.D3.D4.4D3.D69.D2.2D.D.D.D.D2.D2.D2.D4.D6.D4.D3.D2.D
$8.D.D.D.D3.D3.2D2.D3.D7.D2.D70.D3.D.D.D.D.5D.5D3.D5.D4.D4.5D$4.D3.D.
2D.2D3.D3.D3.D3.D7.D.D71.D3.D.2D.2D4.D5.D4.D4.D4.D8.D$5.3D2.D3.D2.3D
3.3D4.D4.3D2.D71.D3.D.D3.D4.D5.D4.D3.5D.D8.D10$27.A$25.3A$7.2A15.A$8.
A15.2A$8.A.A$9.2A140.A$151.3A$135.A18.A$28.2A105.3A15.2A7.2A$28.2A
108.A23.A$137.2A21.A.A$160.2A$9.C108.A$9.C.C106.3A$9.3C109.A39.2A$11.
C14.2A92.2A11.2A11.D14.2A$26.2A105.2A9.3D$144.D.D$144.D$25.2A$2.2A21.
A.A$3.A23.A135.2A$3A15.2A7.2A90.C43.2A$A18.A99.C.C$16.3A100.3C$16.A
104.C22.2A$143.A.A$143.A15.2A$142.2A15.A$160.3A$112.2A48.A$113.A20.2A
$110.3A21.A.A$110.A25.A$136.2A29$3.D3.D.D3.D3.D4.3D2.5D3.D4.3D3.3D73.
3D2.D3.D2.3D5.D2.5D2.3D3.3D2.5D$3.2D2.D.D3.D2.2D3.D3.D3.D4.2D3.D3.D.D
3.D71.D3.D.D3.D.D3.D3.2D4.D3.D3.D.D3.D5.D$3.D.D.D.D3.D3.D3.D3.D3.D5.D
7.D.D2.2D71.D5.D3.D5.D2.D.D4.D7.D.D2.2D4.D$3.D2.2D.D.D.D3.D4.3D4.D5.D
5.2D2.D.D.D72.3D2.D.D.D3.2D2.D2.D4.D5.2D2.D.D.D3.D$3.D3.D.D.D.D3.D3.D
3.D3.D5.D7.D.2D2.D75.D.D.D.D5.D.5D3.D7.D.2D2.D2.D$3.D3.D.2D.2D3.D3.D
3.D3.D5.D3.D3.D.D3.D71.D3.D.2D.2D.D3.D4.D4.D3.D3.D.D3.D.D$3.D3.D.D3.D
2.3D3.3D4.D4.3D3.3D3.3D73.3D2.D3.D2.3D5.D4.D4.3D3.3D2.D7$27.2A$27.A
107.A$25.A.A107.3A$25.2A9.A101.A12.A$34.3A100.2A12.3A7.2A$33.A120.A6.
A$7.2A24.2A83.A34.2A4.A.A$8.A109.3A38.2A$8.A.A110.A$9.2A109.2A11.2A
11.D$133.2A9.3D$144.D.D$144.D4$9.C109.C$9.C.C107.C.C$9.3C107.3C$11.C
109.C22.2A$143.A.A$24.2A117.A$18.2A4.A.A115.2A24.2A$19.A6.A141.A$2.2A
12.3A7.2A84.2A55.3A$3.A12.A96.A20.2A24.2A9.A$3A107.3A21.A.A23.A.A$A
109.A25.A25.A$136.2A24.2A28$D3.D.D3.D3.D3.5D.5D3.D4.3D3.3D$2D2.D.D3.D
2.2D7.D3.D4.2D3.D3.D.D3.D$D.D.D.D3.D3.D6.D4.D5.D3.D2.2D.D3.D64.3D2.D
3.D2.3D3.3D2.5D2.3D3.3D2.5D$D2.2D.D.D.D3.D5.D5.D5.D3.D.D.D2.3D64.D3.D
.D3.D.D3.D.D3.D3.D3.D3.D.D3.D.D$D3.D.D.D.D3.D4.D6.D5.D3.2D2.D.D3.D63.
D5.D3.D5.D5.D3.D7.D.D3.D.D$D3.D.2D.2D3.D3.D7.D5.D3.D3.D.D3.D64.3D2.D.
D.D3.2D4.2D4.D6.D3.3D3.3D$D3.D.D3.D2.3D2.D7.D4.3D3.3D3.3D68.D.D.D.D5.
D5.D3.D5.D3.D3.D5.D$110.D3.D.2D.2D.D3.D.D3.D3.D4.D4.D3.D.D3.D$111.3D
2.D3.D2.3D3.3D4.D3.5D2.3D3.3D7$135.A$135.3A$138.A$137.2A12.A$151.3A$
118.A35.A$118.3A32.2A$121.A35.2A$120.2A11.2A11.D10.2A$23.2A108.2A9.3D
$23.2A119.D.D$144.D2$31.A132.2A$29.3A132.2A$7.2A19.A90.C$8.A19.2A89.C
.C$8.A.A108.3C$9.2A110.C22.2A$143.A.A$143.A19.2A$142.2A19.A$29.2A133.
3A$29.2A81.2A52.A$113.A20.2A$9.C100.3A21.A.A$9.C.C98.A25.A21.2A$9.3C
124.2A20.2A$11.C10.2A$22.2A$18.2A$19.A$16.3A$2.2A12.A$3.A$3A$A21$106.
D3.D.D3.D2.3D3.3D2.5D3.D4.3D3.3D$106.2D2.D.D3.D.D3.D.D3.D3.D4.2D3.D3.
D.D3.D$.3D2.D3.D8.3D2.5D2.3D4.D67.D.D.D.D3.D5.D5.D3.D5.D3.D3.D.D3.D$D
3.D.D3.D7.D3.D3.D3.D3.D2.2D67.D2.2D.D.D.D3.2D5.D4.D5.D4.4D2.3D$D5.D3.
D11.D3.D7.D3.D67.D3.D.D.D.D5.D3.D5.D5.D7.D.D3.D$.3D2.D.D.D.5D4.D4.D6.
D4.D67.D3.D.2D.2D.D3.D2.D6.D5.D7.D.D3.D$4.D.D.D.D9.D5.D5.D5.D67.D3.D.
D3.D2.3D2.5D3.D4.3D3.3D3.3D$D3.D.2D.2D8.D6.D4.D6.D$.3D2.D3.D7.5D3.D3.
5D2.3D10$118.A$118.3A$121.A$120.2A11.2A11.D$133.2A9.3D$144.D.D$20.A
123.D$19.A.A133.A$19.A.A132.A.A$20.A133.A.A$9.C109.C35.A$9.C.C107.C.C
$9.3C107.3C$11.C109.C5$112.2A$113.A20.2A$110.3A21.A.A$110.A25.A$136.
2A14$3.3D2.5D2.3D4.D3.5D8.3D$2.D3.D.D5.D3.D2.2D5.D9.D3.D$2.D5.D9.D3.D
5.D9.D3.D65.D3.D.5D2.3D3.3D2.5D8.3D4.D$3.3D2.3D6.D4.D5.D3.5D2.3D66.2D
2.D.D5.D3.D.D3.D3.D9.D3.D2.2D$6.D.D7.D5.D5.D9.D3.D65.D.D.D.D9.D.D3.D
3.D13.D3.D$2.D3.D.D6.D6.D5.D9.D3.D65.D2.2D.3D5.2D3.4D3.D3.5D3.2D4.D$
3.3D2.5D.5D2.3D4.D10.3D66.D3.D.D9.D5.D3.D13.D3.D$108.D3.D.D5.D3.D5.D
3.D9.D3.D3.D$108.D3.D.5D2.3D3.3D4.D10.3D3.3D11$135.A$135.3A$138.A$17.
A119.2A$17.3A$8.A11.A97.A42.A$8.3A8.2A97.3A38.3A$11.A109.A36.A$10.2A
108.2A11.2A11.D11.2A$31.2A100.2A9.3D$31.2A111.D.D$144.D4$9.C109.C$9.C
.C107.C.C44.2A$9.3C107.3C44.2A$11.C11.2A96.C23.2A$23.A122.A$24.3A116.
3A8.2A$26.A116.A11.A$152.3A$2.2A108.2A38.A$3.A109.A20.2A$3A107.3A21.A
.A$A109.A25.A$136.2A25$117.3D2.5D2.3D3.3D2.5D8.3D3.3D$D3.D.5D2.3D3.3D
2.5D2.3D82.D3.D.D5.D5.D3.D3.D9.D3.D.D3.D$2D2.D.D5.D3.D.D3.D3.D3.D3.D
81.D5.D5.D9.D3.D13.D.D2.2D$D.D.D.D9.D.D2.2D3.D7.D82.3D2.3D3.4D5.D4.D
3.5D4.D2.D.D.D$D2.2D.3D5.2D2.D.D.D3.D5.2D86.D.D5.D3.D3.D5.D11.D3.2D2.
D$D3.D.D9.D.2D2.D3.D7.D81.D3.D.D5.D3.D2.D6.D10.D4.D3.D$D3.D.D5.D3.D.D
3.D3.D3.D3.D82.3D2.5D2.3D2.5D3.D9.5D2.3D$D3.D.5D2.3D3.3D4.D4.3D8$32.A
$30.3A$29.A$18.A10.2A104.A$17.A.A115.3A36.A$17.A.A118.A33.3A$15.3A.2A
20.A95.2A32.A$14.A24.3A129.2A$8.A6.3A.2A17.A79.A42.A$8.3A6.A.2A17.2A
78.3A38.3A$11.A109.A36.A$10.2A108.2A11.2A11.D11.2A$35.2A96.2A9.3D$34.
A2.A106.D.D$35.2A107.D4$9.C109.C50.2A$9.C.C107.C.C47.A2.A$9.3C107.3C
48.2A$11.C11.2A96.C23.2A$23.A122.A$24.3A116.3A6.A.2A17.2A$26.A116.A6.
3A.2A17.A$36.2A111.A24.3A$2.2A32.A75.2A36.3A.2A20.A$3.A33.3A73.A20.2A
16.A.A$3A36.A70.3A21.A.A15.A.A$A109.A25.A16.A10.2A$136.2A26.A$165.3A$
167.A!

Select each H-to-G in turn and run the script (I assigned a keyboard shortcut) to see if you get the same label. This seems to indicate that prepending an Fx77 will add a delta-T of +177 for a NW or SW conduit, and -23 for a NE or SE conduit.

Also, changing a NE conduit to a SE conduit using an Fx77 adds 32 lanes, SE to NE adds 18 lanes, SW to NW adds 34 lanes, and NW to SW adds 16 lanes. That doesn't seem quite so good. I think I can fix that to 33 lanes (NE->SE or SW->NW) and 17 lanes (SE->NE or NW->SW), still adding to 50 of course... by changing the lane numbers that I arbitrarily assigned in 2006.

I think that that's almost certainly worth doing. Nobody uses that silly old lane numbering system, do they? It would only have to change for the NW and SE converters -- notice that those are the ones that need arbitrary +1 and -1 and (lane+1) and (lane-1) adjustments in the above script.

If I get rid of those, then it's possible to find the lane easily by counting up or down along the Y axis (assuming 0,0 is the center of the Herschel). That will allow the lane to be found manually using the same exact rule for any glider direction:

If a canonical-phase glider is centered on the cell (0, N) then it's on NewLane N.
EDIT: or chris_c's version is good --
If the glider passes through (N, 0) then it is on lane N.
-- as long as you remember that the timing is calculated from the X=0 point, i.e., (0, N).

Simple as that (now that the update below is done).

EDIT: Updated the script in the first post to use the calculations described above. So an Fx77 now "officially" adds 33 lanes (NE->SE or SW->NW) and 17 lanes (SE->NE or NW->SW), with a delta-T of 177 (NW/SW) and -23 (NE/SE).

Notice that an Fx77 moves the Herschel by (dx=25, dy=-8). 33=25-(-8) and 17=25+(-8). Also the delta-Ts are (77+4*dx) and (77-4*dx). Other Fx conduits should work the same way.

[chris_c]

So... any objections to this radical one-time lane renumbering? Or does anyone see any discrepancies besides the lane-related ones, in the numbers that this script is putting out?

No, the lane numbering seems good. I wasn't expecting you to go to the trouble of changing all the lane numbers but it does seem to be worth it. The only quibble I have at the moment is that the simple rule should be "if the glider passes through (N, 0) then it is on lane N" rather than (0, N) as is written at the moment.

Timings can be specified for other pieces of circuitry as well. For example, the syringe has T=23 and the snark has T=4 so that this composite of syringe + NE8T3 + snark delays the input glider by 23 + 3 + 4 = 30 ticks in the eastward direction:

Code: Select all

x = 71, y = 117, rule = LifeHistory
4.A$5.A$3.3A66$55.2A$55.A.A$57.A4.2A$53.4A.2A2.A2.A$53.A2.A.A.A.A.2A$
55.BABABA.A$56.B2ABA.A$57.2B.BA$56.3B$47.2A6.4B$48.A6.B2A3B$48.A.AB3.
B2A3B$49.2AB.10B$51.13B$51.14B$51.15B$53.8B2.4B$53.6B5.4B$37.A14.9B4.
4B$37.3A11.4B4.2A5.4B$40.A9.4B5.A7.4B$39.2A8.3DB7.3A5.3B$4.A22.2A10.
6B3.3BD10.A6.2B$5.A22.A12.5B.3BD$3.3AB21.A.AB7.11B$4.4B10.A10.2AB.3B
3.13B$5.4B7.3A12.20B2A$6.4B5.A15.20B2A$7.4B4.2A15.20B$2A6.9B14.21B$.A
7.6B14.20B$.A.2A5.6B3.B2.2B2.22B$2.A2.A4.19BD15B.4B$3.2AB3.20BDBD4B.
7B4.2A$4.14B2A9B3D4B2.6B4.A$5.13B2A11BD4B3.6B4.3A$6.29B6.4B6.A$6.17B.
B.2B12.B2A2B$7.15B4.3B12.2A.B2A$7.15B5.A2B.2A11.BA.A$8.13B5.A.A2B.A
14.A$10.13B2.A.AB2.A15.2A$9.8B4.2A.A.A3.A$9.6B6.2ABA2.4A.A$9.5B8.B2.A
.A3.A.A$9.B.B9.2A.2A2.A2.A.A$10.3B9.A.A2.2A3.A$9.B2AB9.A.A$10.2A11.A!


[dvgrn]

The only quibble I have at the moment is that the simple rule should be "if the glider passes through (N, 0) then it is on lane N" rather than (0, N) as is written at the moment.

Ah, of course -- much better. I was thinking of changing it to "(0, N) or (0,-N), depending on..." but that stops being so simple.

The reason I was stuck looking at the x=0 line is that those locations are handy for visualizing the output glider's spacetime location. To draw in a glider equivalent to the output glider for a given conduit:

1) locate (0, -N) for NW or SE outputs, or (0, N) for NE or SW ones.
2) Drop in a canonical glider at (0, +/-N) as appropriate.
3) If T is positive, run only the Herschel for T ticks, else run only the glider for -T ticks.

If the conduit is transparent, or usually if T is big-enough positive, a version with only the Herschel input will eventually produce the same exact configuration as one with only the dropped-in glider.

-- Speaking of which, do we happen to have a transparent H-to-G yet that has a lucky early spark that can kill off an incoming glider at exactly the same lane and T-value as the output? Seems as if one will probably turn up eventually. This would allow a direct simple ETM (exact-timing merge, or OR circuit).