LifeWiki - User contributions [en]

User:77topaz/Forum handles table

2025-01-05T02:27:58Z

Snacked: hyperlinked my user page

To make referencing patterns and other discoveries easier, I've decided to start compiling a table noting which forum handle corresponds to which real name used on this wiki. Feel free to add to this table if you want.

{| class="wikitable sortable"
!Preferred name for credits
!Forum handle
!Discord handle
!Discord nickname
!LifeWiki username
!Catagolue handle
|-
|[[Adam P. Goucher]]
|calcyman
|apgoucher
|apgoucher
|[[User:Calcyman|Calcyman]]
|apgoucher@gmx.com
|-
|[[Dylan Chen]]
|Dylan Chen
|inspirehep
|inspirehep
|[[User:Dylan Chen|Dylan Chen]]
|inspirehep@gmail.com{{refn|group=note|also Cloud_Bach}}
|-
|[[Jiahao Yu]]
|yujh
|yujhtheyujh
|#4 se fan: ihateswitchengines<ref name="changes_often" group="note" />
|[[User:Yujh|Yujh]]
|Yujh{{refn|group=note|also Yujh2}}
|-
|[[Caleb R. Hilton]]
|C_R_116
|c_r_116
|C_R_116
|[[User:C R 116|C R 116]]
|cc.nan.315@gmail.com
|-
|
|Cyclotrons
|Cyclotrons
|Cyclotrons
|[[User:Cyclotrons|Cyclotrons]]
|Cyclotrons
|-
|
|dani
|danielle{{refn|group=note|formerly moose}}
|danielle<ref name="changes_often" group="note">changes often</ref>
|[[User:Dani|Dani]]
|dani
|-
|[[Dave Greene]]
|dvgrn
|dvgrn
|dvgrn
|[[User:Dvgrn|Dvgrn]]
|-
|[[David Raucci]]
|hotdogPi
|hotdogPi
|hotdogPi
|[[User:HotdogPi|HotdogPi]]
|-
|[[Dongook Lee]]
|Scorbie
|
|Scorbie
|[[User:Scorbie|Scorbie]]
|-
|[[Evin]]
|EvinZL
|wait262144what
|#NaN switch engine fan<ref name="changes_often" group="note" />
|[[User:Evin|Evin]]
|-
|[[Entity Valkyrie]]
|Entity Valkyrie 2
|valkyriver
|Entity Valkyrie 2
|[[User:Entity Valkyrie 2|Entity Valkyrie 2]]
|-
|
|H. H. P. M. P. Cole
|
|
|[[User:H. H. P. M. P. Cole|H. H. P. M. P. Cole]]
|-
|
|Ian07
|Ian07
|Ian07
|[[User:Ian07|Ian07]]
|Ian07
|-
|[[Ignacy Jackl]]
|IgnacyJ
|jiqci
|ua w wae strh az
|[[User:IgnacyJ|IgnacyJ]]
|IgnacyJ
|-
|[[Ivan Fomichev]]
|codeholic
|codeholic
|codeholic
|[[User:Codeholic|Codeholic]]
|-
|[[Jacob]]
|moonsheep
|
|
|[[User:Moonsheep|Moonsheep]]
|-
|[[Jeremy Tan]]
|Freywa
|Parcly Taxel
|Parcly Taxel
|[[User:Freywa|Freywa]]
|-
|[[John Winston Garth]]
|winston
|winston
|Christristiax
|
|winstax
|-
|[[Kalan Warusa]]
|ihatecorderships
|Ball Lightning
|Ihatecorderships
|[[User:Ihatecorderships|Ihatecorderships]]
|-
|[[Matthias Merzenich]]
|Sokwe
|Sokwe
|Matthias Merzenich
|[[User:Sokwe|Sokwe]]
|-
|[[Mitchell Riley]]
|mvr
|mvr
|mvr
|-
|
|Moosey
|Moooosey
|ought to do CA again<ref name="changes_often" group="note" />
|[[User:Moosey|Moosey]]
|Moosey
|-
|[[Connor Steppie]]
|muzik
|muzikbike
|Партин Моляков
|[[User:Muzik|Muzik]]
|muzikbike
|-
|
|wwei47{{refn|group=note|formerly wwei23}}
|xp3_xggk171z8e82
|
|[[User:Prime Raptor21|Prime Raptor21]]{{refn|group=note|formerly Wwei23}}
|ilovecoding23@gmail.com
|-
|[[Alex Greason]]
|AGreason
|Exa
|Exa
|-
|
|bubblegum
|sonata «pathétique»
|sonata
|[[User:Bubblegum|Bubblegum]]
|-
|
|cvojan
|cq
|$$$
|[[User:Cvojan|Cvojan]]
|-
|
|goldenratio
|phiisnotcoolanymore<ref name="changes_often" group="note" />
|goldenratio<ref name="changes_often" group="note" />
|[[User:Goldenratio|Goldenratio]]
|onepoint618
|-
|
|iNoMed
|iNoMed
|iNoMed
|[[User:INoMed|INoMed]]
|-
|[[James Pascua]]
|JP21
|Jam11
|
|[[User:JP21|JP21]]
|-
|[[Mark Niemiec]]
|mniemiec
|StrongAxe
|Mark D. Niemiec
|-
|[[Daniel Vargas]]
|MathAndCode
|Danny2197
|MathAndCode
|[[User:MathAndCode|MathAndCode]]
|-
|[[Nico Brown]]
|glider_rider
|turingcomplete30
|Nico (glider_rider)
|-
|[[Nikola K.]]
|andrewph33
|andrewthediscorder
|andrewthediscorder
|-
|[[Oscar Cunningham]]
|Macbi
|Macbi
|Macbi
|Macbi
|Macbi
|-
|[[Pavel Grankovskiy]]
|Pavgran
|Pavgran
|Pavgran
|-
|
|Saka
|Droseraman
|Saka
|[[User:Saka|Saka]]
|-
|[[Tanner Jacobi]]
|Kazyan
|Kazyan
|Kazyan
|-
|[[praosylen]]
|praosylen<ref name="4A4A" group="note">formerly A for awesome</ref>
|praosylen
|<ref name="changes_often" group="note" />
|[[User:Praosylen|Praosylen]]<ref name="4A4A" group="note" />
|0x6ef79077fbb
|-
|
|83bismuth38
|Dui Mauris Football
|gbrldvs<ref name="changes_often" group="note" />
|-
|
|AforAmpere
|AforAmpere
|Ampere
|-
|[[Andrew J. Wade]]
|mscibing
|mscibing
|-
|[[Arie Paap]]
|wildmyron
|wildmyron
|-
|
|Blinkerspawn
|AxiomaticSystem
|Blinkerspawn
|-
|[[Brett Berger]]
|biggiemac
|biggiemac42
|-
|
|M. I. Wright
|caramel<ref name="wright" group="note">formerly Wright</ref>
|caramel<ref name="wright" group="note" />
|-
|
|cgoler2
|cgoler2
|just red
|[[User:Cgoler2|Cgoler2]]
|-
|
|confocaloid
|
|
|[[User:Confocal|Confocal]]
|
|-
|
|gameoflifemaniac
|Illuminati65
|Illuminati65
|-
|[[John Goodman]]
|John Goodman
|
|
|
|John Goodman
|-
|
|KittyTac
|KittyTac
|FOOF + ClF3
|-
|[[Luke Kiernan]]
|yoleo
|ljkiernan1
|ljkiernan1
|-
|[[Mateusz Naściszewski]]
|
|Mateon1
|Mateon1
|-
|
|Redstoneboi
|Redstoneboi
|RS BOB
|-
|[[Rob Liston]]
|rliston
|
|
|
|rliston@gmail.com
|-
|
|Sarp
|Sarperen
|Sarp
|-
|
|_zM
|_zM
|bird<ref name="changes_often" group="note" />
|-
|[[Alexey Nigin]]
|Alexey_Nigin
|-
|[[Andrzej Okrasinski]]
|ohennel
|-
|[[Avery Feingold]]
|NimbleRogue
|-
|[[Chris Cain]]
|chris_c
|-
|[[Chris Rowett]]
|rowett
|rowett
|rowett
|[[User:Rowett|Rowett]]
|-
|[[Darren Li]]
|testitemqlstudop
|gchromodynamics<ref group="note">formerly Dandan and ascendantDreamweaver, display name gradiometricChromodynamics</ref>
|very
|[[User:Testitemqlstudop|Testitemqlstudop]]
|TechnobladeNeverDies
|-
|[[David Bell]]
|dbell
|-
|[[David S. Miller]]
|dsmiller
|-
|[[Dean Hickerson]]
|Dean Hickerson
|-
|[[Ed Pegg Jr]]
|EdPeggJr
|-
|[[Emerson J. Perkins]]
|knightlife
|-
|[[Frank Everdij]]
|dexter1
|-
|[[Hartmut Holzwart]]
|HartmutHolzwart
|-
|[[Heinrich Koenig]]
|hkoenig
|-
|[[Jason Summers]]
|Jason Summers
|-
|[[Josh Ball]]
|velcrorex
|-
|[[Haycat Durnak]]
|Haycat2009
|
|
|[[User:Haycat2009|Haycat2009]]
|Durnakoic acid
|-
|[[Karel Suhajda]]
|Kasuha
|-
|[[Keith Amling]]
|amling
|-
|[[Kiran Linsuain]]
|Kiran
|-
|[[Lewis Patterson]]
|Lewis
|-
|[[Louis-François Handfield]]
|Jormungant
|-
|[[Luka Okanishi]]
|AbhpzTa
|-
|[[Martin Grant]]
|Extrementhusiast
|-
|[[Matti Ward]]
|mattiward
|-
|[[Michael Simkin]]
|simsim314
|-
|[[Mike Playle]]
|MikeP
|-
|[[Nick Gotts]]
|NickGotts
|-
|[[Park Shinhwan]]
|Dannyu NDos/David
|-
|[[Paul Callahan]]
|pcallahan
|-
|[[Paul Chapman]]
|igblan
|-
|[[Paul Tooke]]
|Paul Tooke
|-
|[[Rich Holmes]]
|Rich Holmes
|-
|[[Richard Schank]]
|flipper77
|-
|[[Sergey Petrov]]
|Guam
|-
|[[Shannon Omick]]
|skomick
|-
|[[Scot Ellison]]
|scote
|-
|[[Simon Ekström]]
|simeks
|-
|[[Stephen Silver]]
|SAS
|-
|[[Szymon Bartosiewicz]]
|lifeisawesome
|-
|[[Tim Coe]]
|moebius
|-
|[[Tim Hutton]]
|Tim Hutton
|-
|[[Tomas Rokicki]]
|rokicki
|-
|[[Wojciech Kęsy]]
|Game of Life Fun
|-
|[[Yoel Matveyev]]
|Yoel
|-
|[[Lucy D'Agostino]]
|C28
|thevillageidiot0476
|C28
|[[User:C28|C28]]
|-
|Phil Bookman
|Book
|Book
|Book
|-
|Maia Karpovich
|thunk
|thunkii
|maia thunkies
|-
|Zhenqian Peng
|pzq_alex
|pzq_alex
|#!/usr/bin/pzq
|[[User:Pzq_Alex|Pzq Alex]]
|pzq_alex
|-
|[[Dmitry Maitak]]
|May13
|-
|Tommy Ziblis
|tommyaweosme
|
|
|tommyaweosme
|tommyaweosme
|-
|
|unname4798
|
|
|[[User:Unname4798|Unname4798]]
|-
|Chenxiao Zhou
|islptng
|islptng
|islptng
|[[User:I am islptng|I am islptng]]
|islptng
|-
|
|get_Snacked
|.aoeuidhtns
|#1 ethnomusicology fan<ref name="changes_often" group="note" />
|[[User:Snacked|Snacked]]
|get_snacked
|}
==Notes==
<references group="note" />

__NOINDEX__

User:77topaz/Forum handles table

2025-01-05T02:27:27Z

Snacked: added myself

To make referencing patterns and other discoveries easier, I've decided to start compiling a table noting which forum handle corresponds to which real name used on this wiki. Feel free to add to this table if you want.

{| class="wikitable sortable"
!Preferred name for credits
!Forum handle
!Discord handle
!Discord nickname
!LifeWiki username
!Catagolue handle
|-
|[[Adam P. Goucher]]
|calcyman
|apgoucher
|apgoucher
|[[User:Calcyman|Calcyman]]
|apgoucher@gmx.com
|-
|[[Dylan Chen]]
|Dylan Chen
|inspirehep
|inspirehep
|[[User:Dylan Chen|Dylan Chen]]
|inspirehep@gmail.com{{refn|group=note|also Cloud_Bach}}
|-
|[[Jiahao Yu]]
|yujh
|yujhtheyujh
|#4 se fan: ihateswitchengines<ref name="changes_often" group="note" />
|[[User:Yujh|Yujh]]
|Yujh{{refn|group=note|also Yujh2}}
|-
|[[Caleb R. Hilton]]
|C_R_116
|c_r_116
|C_R_116
|[[User:C R 116|C R 116]]
|cc.nan.315@gmail.com
|-
|
|Cyclotrons
|Cyclotrons
|Cyclotrons
|[[User:Cyclotrons|Cyclotrons]]
|Cyclotrons
|-
|
|dani
|danielle{{refn|group=note|formerly moose}}
|danielle<ref name="changes_often" group="note">changes often</ref>
|[[User:Dani|Dani]]
|dani
|-
|[[Dave Greene]]
|dvgrn
|dvgrn
|dvgrn
|[[User:Dvgrn|Dvgrn]]
|-
|[[David Raucci]]
|hotdogPi
|hotdogPi
|hotdogPi
|[[User:HotdogPi|HotdogPi]]
|-
|[[Dongook Lee]]
|Scorbie
|
|Scorbie
|[[User:Scorbie|Scorbie]]
|-
|[[Evin]]
|EvinZL
|wait262144what
|#NaN switch engine fan<ref name="changes_often" group="note" />
|[[User:Evin|Evin]]
|-
|[[Entity Valkyrie]]
|Entity Valkyrie 2
|valkyriver
|Entity Valkyrie 2
|[[User:Entity Valkyrie 2|Entity Valkyrie 2]]
|-
|
|H. H. P. M. P. Cole
|
|
|[[User:H. H. P. M. P. Cole|H. H. P. M. P. Cole]]
|-
|
|Ian07
|Ian07
|Ian07
|[[User:Ian07|Ian07]]
|Ian07
|-
|[[Ignacy Jackl]]
|IgnacyJ
|jiqci
|ua w wae strh az
|[[User:IgnacyJ|IgnacyJ]]
|IgnacyJ
|-
|[[Ivan Fomichev]]
|codeholic
|codeholic
|codeholic
|[[User:Codeholic|Codeholic]]
|-
|[[Jacob]]
|moonsheep
|
|
|[[User:Moonsheep|Moonsheep]]
|-
|[[Jeremy Tan]]
|Freywa
|Parcly Taxel
|Parcly Taxel
|[[User:Freywa|Freywa]]
|-
|[[John Winston Garth]]
|winston
|winston
|Christristiax
|
|winstax
|-
|[[Kalan Warusa]]
|ihatecorderships
|Ball Lightning
|Ihatecorderships
|[[User:Ihatecorderships|Ihatecorderships]]
|-
|[[Matthias Merzenich]]
|Sokwe
|Sokwe
|Matthias Merzenich
|[[User:Sokwe|Sokwe]]
|-
|[[Mitchell Riley]]
|mvr
|mvr
|mvr
|-
|
|Moosey
|Moooosey
|ought to do CA again<ref name="changes_often" group="note" />
|[[User:Moosey|Moosey]]
|Moosey
|-
|[[Connor Steppie]]
|muzik
|muzikbike
|Партин Моляков
|[[User:Muzik|Muzik]]
|muzikbike
|-
|
|wwei47{{refn|group=note|formerly wwei23}}
|xp3_xggk171z8e82
|
|[[User:Prime Raptor21|Prime Raptor21]]{{refn|group=note|formerly Wwei23}}
|ilovecoding23@gmail.com
|-
|[[Alex Greason]]
|AGreason
|Exa
|Exa
|-
|
|bubblegum
|sonata «pathétique»
|sonata
|[[User:Bubblegum|Bubblegum]]
|-
|
|cvojan
|cq
|$$$
|[[User:Cvojan|Cvojan]]
|-
|
|goldenratio
|phiisnotcoolanymore<ref name="changes_often" group="note" />
|goldenratio<ref name="changes_often" group="note" />
|[[User:Goldenratio|Goldenratio]]
|onepoint618
|-
|
|iNoMed
|iNoMed
|iNoMed
|[[User:INoMed|INoMed]]
|-
|[[James Pascua]]
|JP21
|Jam11
|
|[[User:JP21|JP21]]
|-
|[[Mark Niemiec]]
|mniemiec
|StrongAxe
|Mark D. Niemiec
|-
|[[Daniel Vargas]]
|MathAndCode
|Danny2197
|MathAndCode
|[[User:MathAndCode|MathAndCode]]
|-
|[[Nico Brown]]
|glider_rider
|turingcomplete30
|Nico (glider_rider)
|-
|[[Nikola K.]]
|andrewph33
|andrewthediscorder
|andrewthediscorder
|-
|[[Oscar Cunningham]]
|Macbi
|Macbi
|Macbi
|Macbi
|Macbi
|-
|[[Pavel Grankovskiy]]
|Pavgran
|Pavgran
|Pavgran
|-
|
|Saka
|Droseraman
|Saka
|[[User:Saka|Saka]]
|-
|[[Tanner Jacobi]]
|Kazyan
|Kazyan
|Kazyan
|-
|[[praosylen]]
|praosylen<ref name="4A4A" group="note">formerly A for awesome</ref>
|praosylen
|<ref name="changes_often" group="note" />
|[[User:Praosylen|Praosylen]]<ref name="4A4A" group="note" />
|0x6ef79077fbb
|-
|
|83bismuth38
|Dui Mauris Football
|gbrldvs<ref name="changes_often" group="note" />
|-
|
|AforAmpere
|AforAmpere
|Ampere
|-
|[[Andrew J. Wade]]
|mscibing
|mscibing
|-
|[[Arie Paap]]
|wildmyron
|wildmyron
|-
|
|Blinkerspawn
|AxiomaticSystem
|Blinkerspawn
|-
|[[Brett Berger]]
|biggiemac
|biggiemac42
|-
|
|M. I. Wright
|caramel<ref name="wright" group="note">formerly Wright</ref>
|caramel<ref name="wright" group="note" />
|-
|
|cgoler2
|cgoler2
|just red
|[[User:Cgoler2|Cgoler2]]
|-
|
|confocaloid
|
|
|[[User:Confocal|Confocal]]
|
|-
|
|gameoflifemaniac
|Illuminati65
|Illuminati65
|-
|[[John Goodman]]
|John Goodman
|
|
|
|John Goodman
|-
|
|KittyTac
|KittyTac
|FOOF + ClF3
|-
|[[Luke Kiernan]]
|yoleo
|ljkiernan1
|ljkiernan1
|-
|[[Mateusz Naściszewski]]
|
|Mateon1
|Mateon1
|-
|
|Redstoneboi
|Redstoneboi
|RS BOB
|-
|[[Rob Liston]]
|rliston
|
|
|
|rliston@gmail.com
|-
|
|Sarp
|Sarperen
|Sarp
|-
|
|_zM
|_zM
|bird<ref name="changes_often" group="note" />
|-
|[[Alexey Nigin]]
|Alexey_Nigin
|-
|[[Andrzej Okrasinski]]
|ohennel
|-
|[[Avery Feingold]]
|NimbleRogue
|-
|[[Chris Cain]]
|chris_c
|-
|[[Chris Rowett]]
|rowett
|rowett
|rowett
|[[User:Rowett|Rowett]]
|-
|[[Darren Li]]
|testitemqlstudop
|gchromodynamics<ref group="note">formerly Dandan and ascendantDreamweaver, display name gradiometricChromodynamics</ref>
|very
|[[User:Testitemqlstudop|Testitemqlstudop]]
|TechnobladeNeverDies
|-
|[[David Bell]]
|dbell
|-
|[[David S. Miller]]
|dsmiller
|-
|[[Dean Hickerson]]
|Dean Hickerson
|-
|[[Ed Pegg Jr]]
|EdPeggJr
|-
|[[Emerson J. Perkins]]
|knightlife
|-
|[[Frank Everdij]]
|dexter1
|-
|[[Hartmut Holzwart]]
|HartmutHolzwart
|-
|[[Heinrich Koenig]]
|hkoenig
|-
|[[Jason Summers]]
|Jason Summers
|-
|[[Josh Ball]]
|velcrorex
|-
|[[Haycat Durnak]]
|Haycat2009
|
|
|[[User:Haycat2009|Haycat2009]]
|Durnakoic acid
|-
|[[Karel Suhajda]]
|Kasuha
|-
|[[Keith Amling]]
|amling
|-
|[[Kiran Linsuain]]
|Kiran
|-
|[[Lewis Patterson]]
|Lewis
|-
|[[Louis-François Handfield]]
|Jormungant
|-
|[[Luka Okanishi]]
|AbhpzTa
|-
|[[Martin Grant]]
|Extrementhusiast
|-
|[[Matti Ward]]
|mattiward
|-
|[[Michael Simkin]]
|simsim314
|-
|[[Mike Playle]]
|MikeP
|-
|[[Nick Gotts]]
|NickGotts
|-
|[[Park Shinhwan]]
|Dannyu NDos/David
|-
|[[Paul Callahan]]
|pcallahan
|-
|[[Paul Chapman]]
|igblan
|-
|[[Paul Tooke]]
|Paul Tooke
|-
|[[Rich Holmes]]
|Rich Holmes
|-
|[[Richard Schank]]
|flipper77
|-
|[[Sergey Petrov]]
|Guam
|-
|[[Shannon Omick]]
|skomick
|-
|[[Scot Ellison]]
|scote
|-
|[[Simon Ekström]]
|simeks
|-
|[[Stephen Silver]]
|SAS
|-
|[[Szymon Bartosiewicz]]
|lifeisawesome
|-
|[[Tim Coe]]
|moebius
|-
|[[Tim Hutton]]
|Tim Hutton
|-
|[[Tomas Rokicki]]
|rokicki
|-
|[[Wojciech Kęsy]]
|Game of Life Fun
|-
|[[Yoel Matveyev]]
|Yoel
|-
|[[Lucy D'Agostino]]
|C28
|thevillageidiot0476
|C28
|[[User:C28|C28]]
|-
|Phil Bookman
|Book
|Book
|Book
|-
|Maia Karpovich
|thunk
|thunkii
|maia thunkies
|-
|Zhenqian Peng
|pzq_alex
|pzq_alex
|#!/usr/bin/pzq
|[[User:Pzq_Alex|Pzq Alex]]
|pzq_alex
|-
|[[Dmitry Maitak]]
|May13
|-
|Tommy Ziblis
|tommyaweosme
|
|
|tommyaweosme
|tommyaweosme
|-
|
|unname4798
|
|
|[[User:Unname4798|Unname4798]]
|-
|Chenxiao Zhou
|islptng
|islptng
|islptng
|[[User:I am islptng|I am islptng]]
|islptng
|-
|
|get_Snacked
|.aoeuidhtns
|#1 ethnomusicology fan<ref name="changes_often" group="note" />
|Snacked
|get_snacked
|}
==Notes==
<references group="note" />

__NOINDEX__

Cloverleaf interchange

2024-09-26T17:18:54Z

Snacked: wording

{{Stilllife
|name = Cloverleaf interchange
|pname = cloverleafinterchange
|type = strict
|c = 56
|bx = 13
|by = 13
|symmetry = *c
|discoverer = Adam P. Goucher
|discoveryear = 2016
|rulemin = B/S23
|rulemax = B378/S012345678
|rulespecial = [[Conway's Game of Life|Conway Life]]
|isorulemin = B/S2cik
|isorulemax = B2ikn34-inw5-ry6-i78/S012345678
|synthesis = 9
|plaintext = true
|rle = true
|viewerconfig = #C [[ THUMBSIZE 2 HEIGHT 480 ]]
|apgcode = xs56_g8861u0u1688gz8ll55o0o55ll8zx3430343
}}
{{for|other uses of cloverleaf|Cloverleaf (disambiguation)}}

'''Cloverleaf interchange''' (or '''fourfold [[racetrack]]-[[weld]]-racetrack''') is a {{slcells|56|text=56-cell}} [[still life]] exhibiting D8_1 [[symmetry]].

While known for many years beforehand due to its ability to be [[hassle]]d, it is notable due to a natural occurrence being found in the [[ash]] of a random [[asymmetric]] [[soup]] by [[Adam P. Goucher]] on August 12, {{year|2016}}.<ref name="haul10a1c7a48df686717596631e275383a5" /><ref name="post34242" /> This made it the single largest known still life to occur completely [[natural]]ly, surpassing the previous record holder, the 46-cell [[professor]]; it had previously arisen semi-naturally in various higher symmetries, including C2_1, C4_1, D2_+1, D4_+1, D4_+2 and D4_x1. It has since been tied in C1 by another, unnamed 56-cell still life found by [[John Goodman]] in September {{year|2021}}.<ref name="post135613" />

[[BlinkerSpawn]] found a {{gliders|12}} [[Glider synthesis|synthesis]] on August 12, 2016.<ref name="post34243" /> [[GUYTU6J]] improved this to {{gliders|10|text=10 gliders}} on February 5, 2020.<ref name="post88936" /> [[KtT]] further reduced the cost to {{gliders|9|text=9 gliders}} on September 23, 2024.<ref name="post194679" />

A cloverleaf interchange can be hassled by [[carnival shuttle]]s:

{{EmbedViewer
|pname = p12cloverleafhassler
|viewerconfig = #C [[ AUTOSTART THUMBSIZE 2 ZOOM 8 WIDTH 600 HEIGHT 600 GPS 6 LOOP 12 ]]
|position = center
}}

== References ==
<references>
<ref name="haul10a1c7a48df686717596631e275383a5">{{citeCatagolue
|page = haul/b3s23/C1/10a1c7a48df686717596631e275383a5
|title = Haul
|author = Adam P. Goucher
|work = Catagolue
|date = August 12, 2016
|accessdate = August 12, 2016
}}</ref>
<ref name="post34242">{{LinkForumThread
|format = ref
|title = Re: Soup search results
|p = 34242
|author = Apple Bottom
|date = August 12, 2016
}}</ref>
<ref name="post135613">{{LinkForumThread
|format = ref
|title = Re: Soup search results
|p = 135613
|author = dani
|date = September 8, 2021
}}</ref>
<ref name="post34243">{{LinkForumThread
|format = ref
|title = Re: Soup search results
|f = 2
|t = 1452
|p = 34243
|author = BlinkerSpawn
|date = August 12, 2016
}}</ref>
<ref name="post88936">{{LinkForumThread
|format = ref
|title = Re: Thread for your unsure discoveries
|p = 88936
|author = GUYTU6J
|date = February 5, 2020
}}</ref>
<ref name="post194679">{{LinkForumThread
|format = ref
|title = Re: Still Life Synthesis Thread
|f = 2
|t = 3267
|p = 194679
|author = KtT
|date = September 23, 2024
}}</ref>
</references>

== External links ==
* {{LinkWikipedia|Cloverleaf_interchange}}
* {{LinkCatagolue|xs56_g8861u0u1688gz8ll55o0o55ll8zx3430343}}

{{natural}}

Cloverleaf interchange

2024-09-26T17:18:31Z

Snacked: added new 9G synthesis. I don't know why the "2020" on the 10G synthesis had a hyperlink so I removed it

{{Stilllife
|name = Cloverleaf interchange
|pname = cloverleafinterchange
|type = strict
|c = 56
|bx = 13
|by = 13
|symmetry = *c
|discoverer = Adam P. Goucher
|discoveryear = 2016
|rulemin = B/S23
|rulemax = B378/S012345678
|rulespecial = [[Conway's Game of Life|Conway Life]]
|isorulemin = B/S2cik
|isorulemax = B2ikn34-inw5-ry6-i78/S012345678
|synthesis = 9
|plaintext = true
|rle = true
|viewerconfig = #C [[ THUMBSIZE 2 HEIGHT 480 ]]
|apgcode = xs56_g8861u0u1688gz8ll55o0o55ll8zx3430343
}}
{{for|other uses of cloverleaf|Cloverleaf (disambiguation)}}

'''Cloverleaf interchange''' (or '''fourfold [[racetrack]]-[[weld]]-racetrack''') is a {{slcells|56|text=56-cell}} [[still life]] exhibiting D8_1 [[symmetry]].

While known for many years beforehand due to its ability to be [[hassle]]d, it is notable due to a natural occurrence being found in the [[ash]] of a random [[asymmetric]] [[soup]] by [[Adam P. Goucher]] on August 12, {{year|2016}}.<ref name="haul10a1c7a48df686717596631e275383a5" /><ref name="post34242" /> This made it the single largest known still life to occur completely [[natural]]ly, surpassing the previous record holder, the 46-cell [[professor]]; it had previously arisen semi-naturally in various higher symmetries, including C2_1, C4_1, D2_+1, D4_+1, D4_+2 and D4_x1. It has since been tied in C1 by another, unnamed 56-cell still life found by [[John Goodman]] in September {{year|2021}}.<ref name="post135613" />

[[BlinkerSpawn]] found a {{gliders|12}} [[Glider synthesis|synthesis]] on August 12, 2016.<ref name="post34243" /> [[GUYTU6J]] improved this to {{gliders|10|text=10 gliders}} on February 5, 2020.<ref name="post88936" /> [[KtT]] further reduced its cost to {{gliders|9|text=9 gliders}} on September 23, 2024.<ref name="post194679" />

A cloverleaf interchange can be hassled by [[carnival shuttle]]s:

{{EmbedViewer
|pname = p12cloverleafhassler
|viewerconfig = #C [[ AUTOSTART THUMBSIZE 2 ZOOM 8 WIDTH 600 HEIGHT 600 GPS 6 LOOP 12 ]]
|position = center
}}

== References ==
<references>
<ref name="haul10a1c7a48df686717596631e275383a5">{{citeCatagolue
|page = haul/b3s23/C1/10a1c7a48df686717596631e275383a5
|title = Haul
|author = Adam P. Goucher
|work = Catagolue
|date = August 12, 2016
|accessdate = August 12, 2016
}}</ref>
<ref name="post34242">{{LinkForumThread
|format = ref
|title = Re: Soup search results
|p = 34242
|author = Apple Bottom
|date = August 12, 2016
}}</ref>
<ref name="post135613">{{LinkForumThread
|format = ref
|title = Re: Soup search results
|p = 135613
|author = dani
|date = September 8, 2021
}}</ref>
<ref name="post34243">{{LinkForumThread
|format = ref
|title = Re: Soup search results
|f = 2
|t = 1452
|p = 34243
|author = BlinkerSpawn
|date = August 12, 2016
}}</ref>
<ref name="post88936">{{LinkForumThread
|format = ref
|title = Re: Thread for your unsure discoveries
|p = 88936
|author = GUYTU6J
|date = February 5, 2020
}}</ref>
<ref name="post194679">{{LinkForumThread
|format = ref
|title = Re: Still Life Synthesis Thread
|f = 2
|t = 3267
|p = 194679
|author = KtT
|date = September 23, 2024
}}</ref>
</references>

== External links ==
* {{LinkWikipedia|Cloverleaf_interchange}}
* {{LinkCatagolue|xs56_g8861u0u1688gz8ll55o0o55ll8zx3430343}}

{{natural}}

Template:GliderNavbox

2023-12-17T15:29:19Z

Snacked: Snark64 added

{{Navbox
|name = Glider-accepting Devices Navbox
|state = {{{state|autocollapse}}}
|title = <big>[[Glider]]-accepting devices in stationary [[signal]] [[circuitry]]</big> ([[Template_talk:GliderNavbox|Talk]] · [https://conwaylife.com/w/index.php?title=Template:GliderNavbox&action=edit Edit] · [[Special:WhatLinksHere/Template:GliderNavbox|Links]])
|image = [[File:Glider.png|64px]]
|group1 = [[Stable]]
|list1 = {{Navbox
|group1 = [[Reflector]]s
|list1 = {{Navbox
|group1 = [[Elementary]]
|list1 = {{Navbox
|group1 = 90-degree
|list1 = [[Snark]] · [[Snark64]]
|group2 = 180-degree
|list2 = [[Boojum reflector]] · [[Rectifier]]
|group3 = 0-degree
|list3 = [[Bandersnatch]] · [[0-degree colour-preserving reflector (March 2023)]]
|group4 = Others
|list4 = [[Rephaser]] · [[Glider-block cycle]] · [[Three-block shifter]]
}}
|group2 = [[Composite]]
|list2 = [[Silver's reflector]] · [[487-tick reflector]] · [[Scorbie Splitter]] · [[Highway robber]] for glider · [[stable pseudo-Heisenburp]] for glider · stable [[speed booster]] (advancer) · [[Trombone slide]]
}}
|group2 = [[Pulse divider]]s{{br}}([[Period multiplier]]s)
|list2 = {{Navbox
|group1 = 2×
|list1 = [[Semi-Snark]] ([[CC semi-Snark]] · [[CP semi-Snark]]) · [[Semi-cenark]] ([[CC semi-cenark]] · [[CP semi-cenark]])
|group2 = 3×
|list2 = [[Tremi-Snark]]
|group3 = 4×
|list3 = [[Quadri-Snark]]
|group4 = Adjustable
|list4 = p-even [[crystal]]lization-and-decay devices
}}
|group3 = G-to-X (mostly{{br}}[[glider-to-Herschel]])
|list3 = {{Navbox
|group1 = Elementary
|list1 = {{Navbox
|group1 = Single input
|list1 = [[Syringe]] · [[Bronco]] · [[Speed tunnel]] · [[G-to-X (November 2023)]] · [[G-to-pi catalyst (August 2023)]] · [[G-to-LWSS (2023)]]
|group2 = [[Asynchronous]] double input
|list2 = [[Callahan G-to-H]] · [[Herschel receiver]] · [[G4 receiver]]
|group3 = [[Synchronized]] double input
|list3 = [[Jormungant's G-to-H]] · [[BFx59H injector]]
}}
|group2 = Composite
|list2 = [[Silver G-to-H]]
}}
|group4 = [[Memory cell]]s / [[Factory|Factories]]
|list4 = [[Glider stopper]] · [[Beehive stopper]] · [[Bistable switch]] · [[Boat-bit]] · [[Honeybit]] · [[Glider to block]] · [[Glider to 2 blocks]]
|group5 = [[Eater]]s
|list5 = [[Eater 1]] · [[Eater 2]] · [[Eater 3]] · [[Tub-with-tail eater]] · [[Sidesnagger]] · [[Sparking eater]]
}}
|group2 = [[Periodic]]
|list2 = {{Navbox
|group1 = Reflectors
|list1 = {{Navbox
|group1 = 90-degree
|list1 = {{Navbox
|group1 = [[Bumper]]s
|list1 = [[p3 bumper|p3]] · [[p4 bumper|p4]] · [[p5 bumper|p5]] · [[p6 bumper|p6]] · [[p7 bumper|p7]] · [[p8 bumper|p8]] · [[p9 bumper|p9]] · [[p11 bumper|p11]] · [[p15 bumper|p15]]
|group2 = [[Bouncer]]s
|list2 = p3 · [[p4 bouncer|p4]] · [[p5 bouncer|p5]] · [[p6 bouncer|p6]] · [[p7 bouncer|p7]] · [[p8 bouncer|p8]] · [[p9 bouncer|p9]] · [[p11 bouncer|p11]] · [[p15 bouncer|p15]]
|group3 = [[Duoplet]] emitters
|list3 = [[34P14 shuttle]] · [[Merzenich's p31]] · [[44P38]] · [[Twin bees shuttle]] · [[p50 traffic jam]] · [[Centinal]]
|group4 = Other
|list4 = [[p4 reflector]] · [[p4 CC cenark]] · [[p4 CP cenark]] · [[Buckaroo]] · [[PD-pair reflector]]{{br}}[[Beluchenko's other p37]] · [[Karel's p177]]
}}
|group2 = 180-degree
|list2 = [[Pentadecathlon]](s) (as in [[6 bits]]) · 3-block-1-tub reflector (as in [[Ocellus]] or [[Gallus]]) · Pre-pond reflector · [[Hotcrystal0 reaction]] · [[p8 glider reflector]]{{br}}5× pulse divider: [[Quinti-Snark]] ([[p5 quinti-Snark]])
|group3 = 0-degree
|list3 = [[Glider pusher]] · [[Inline inverter]]
}}
|group2 = G-to-H
|list2 = [[p4 syringe]] · [[Two blockers hassling R-pentomino]] (as in [[gunstar]]) · TO BE DONE
}}
|group3 = Concepts
|list3 = [[Speed]] · [[Color]] · [[Parity]] · [[Phase]] · [[Lane]] ([[Half-diagonal]] · [[Quarter-diagonal]] · [[Full-diagonal]] · [[Gn]])
}}<noinclude>[[Category:Navbox templates]]</noinclude>

G-to-X (November 2023)

2023-11-20T22:11:35Z

Snacked: category added

{{stub}}
A stable "glider-to-chaos" mechanism was discovered in November {{year|2023}}, based on a [[partial result]] by Mitchell Riley.<ref name="post171229" />
The base reaction involves a [[Transparent object|transparent]] [[block]], a transparent [[beehive]], an [[eater 1]] and a large catalyst, and produces a certain "pi+block" collision as output (with a leftover beehive that can be suppressed).

Shortly after discovery, several [[stable reflector]]s<ref name="post171229" /><ref name="post171215" /><ref name="post171277" /><ref name="post171279" /><ref name="post171256" /><ref name="post171309" /> and [[conduit]]s<ref name="post171229" /><ref name="post171328" /><ref name="post171279" /><ref name="post171242" /><ref name="post171287" /> were completed with this mechanism as the first stage.

The "instant disappearance" [[repeat time]] (assuming the output pi+block is removed as soon as it forms) is 90 ticks; several known completions keep the same repeat time.

== Modifications ==

{{EmbedViewer
|rle = x = 105, y = 33, rule = B3/S23
7b2o38b2o38b2o$6bo2bo36bo2bo36bo2bo$7b2o38b2o38b2o3$103b2o$103b2o3$59b
2o$o39bo18bo20bo$b2o38b2o17b3o18b2o$2o38b2o20bo17b2o6$20b2o38b2o38b2o$
18bo2bo36bo2bo36bo2bo$18b3o37b3o37b3o2$8b2o8b2obob2o23b2o8b2obob2o23b
2o8b2obob2o$8b2o9bob2obo23b2o9bob2obo23b2o9bob2obo$2b2o15bo22b2o15bo
22b2o15bo$3bo7b2o3b2obo23bo7b2o3b2obo23bo7b2o3b2obo$3o7bo2bo3bob2o19b
3o7bo2bo3bob2o19b3o7bo2bo3bob2o$o8bob2o3bo23bo8bob2o3bo23bo8bob2o3bo$
9bo5bo33bo5bo33bo5bo$10b6obo32b6obo32b6obo$12bo3bobo33bo3bobo33bo3bobo
$15bo2bo36bo2bo36bo2bo$16b2o38b2o38b2o!
|viewerconfig = #C [[ HEIGHT 500 WIDTH 1000 THUMBSIZE 2 ZOOM 8 X 0 Y -10 GPS 20 AUTOSTART T 0 PAUSE 2 T 108 PAUSE 1 T 137 PAUSE 1 LOOP 138 ]]
|position = center
|caption = Left: the base reaction; middle: beehive suppressed with an eater 1;<ref name="post171328" /> right: beehive suppressed with a block<ref name="post171229" />
|style = width:300px;
}}

=== Beehive factory ===

If the transparent beehive is removed, what is left is a glider-to-beehive factory with high clearance and toggle functionality.<ref name="post171223" />

{{EmbedViewer
|rle = x = 65, y = 30, rule = B3/S23
47bo$46bobo$46bobo$47bo4$o39bo$b2o38b2o$2o38b2o6$20b2o38b2o$18bo2bo36b
o2bo$18b3o37b3o2$8b2o8b2obob2o23b2o8b2obob2o$8b2o9bob2obo23b2o9bob2obo
$2b2o15bo22b2o15bo$3bo7b2o3b2obo23bo7b2o3b2obo$3o7bo2bo3bob2o19b3o7bo
2bo3bob2o$o8bob2o3bo23bo8bob2o3bo$9bo5bo33bo5bo$10b6obo32b6obo$12bo3bo
bo33bo3bobo$15bo2bo36bo2bo$16b2o38b2o!
|viewerconfig = #C [[ HEIGHT 500 WIDTH 800 THUMBSIZE 2 ZOOM 10 GPS 20 AUTOSTART T 0 PAUSE 2 T 122 PAUSE 1 LOOP 123 ]]
|position = center
|caption = A beehive factory with toggle functionality<ref name="post171223" />
|style = width:300px;
}}

== Completions ==

=== Reflectors ===
{{gallery top}}
{{gallery item|{{EmbedViewer
|rle = x = 41, y = 58, rule = B3/S23
11bo17bo$10bobo15bobo$11bo5b2o3b2o5bo$16bo2bobo2bo$17b2o3b2o8b2o$32b2o
8$37b2o$37bobo$39bo$39b2o8$bo$2bo15b2o$3o14bo2bo$18b2o3$34b2o$34b2o10$
34bo$32b3o$31bo$29bo2bo$29b4o2$19b2o8b2o$19b2o9bo$13b2o15bob2o$14bo7b
2o3b2obo2bo$11b3o7bo2bo3bob2o$11bo8bob2o3bo$20bo5bo$21b6obo$23bo3bobo$
26bo2bo$27b2o!
|viewerconfig = #C [[ HEIGHT 700 WIDTH 600 THUMBSIZE 2 ZOOM 8 GPS 20 ]]
|position = center
|caption = 180-degree reflector<ref name="post171215" /><ref name="post171309" />
|style = width:300px;
}}}}
{{gallery item|{{EmbedViewer
|rle = x = 40, y = 53, rule = B3/S23
11b2o26bo$11b2o24b3o$36bo$11b4o21b2o$10bo3bo$9bob2o$6bo2bobo$5bobobobo
$5bobob2o$6bobo$8bo$8b2o8$bo$2bo15b2o$3o14bo2bo$18b2o3$34b2o$34b2o10$
34bo$32b3o$31bo$29bo2bo$29b4o2$19b2o8b2o$19b2o9bo$13b2o15bob2o$14bo7b
2o3b2obo2bo$11b3o7bo2bo3bob2o$11bo8bob2o3bo$20bo5bo$21b6obo$23bo3bobo$
26bo2bo$27b2o!
|viewerconfig = #C [[ HEIGHT 700 WIDTH 600 THUMBSIZE 2 ZOOM 8 GPS 20 ]]
|position = center
|caption = 180-degree reflector<ref name="post171256" />
|style = width:300px;
}}}}
{{gallery item|{{EmbedViewer
|rle = x = 38, y = 58, rule = B3/S23
25bo$23b3o$22bo$12b2o8b2o$12b2o18b2o$32bo$34bo$30b5o$30bo4b2o$33b2o2bo
$34bob2o$34bo$33b2o3$9b2o$8bobo$8bo$7b2o6$bo$2bo15b2o$3o14bo2bo$18b2o
3$34b2o$34b2o10$34bo$32b3o$31bo$29bo2bo$29b4o2$19b2o8b2o$19b2o9bo$13b
2o15bob2o$14bo7b2o3b2obo2bo$11b3o7bo2bo3bob2o$11bo8bob2o3bo$18b3o5bo$
17bo4b5obo$17b2o4bo3bobo$21bo4bo2bo$21b2o4b2o!
|viewerconfig = #C [[ HEIGHT 700 WIDTH 600 THUMBSIZE 2 ZOOM 8 GPS 20 ]]
|position = center
|caption = 90-degree reflector<ref name="post171229" />
|style = width:300px;
}}}}
{{gallery item|{{EmbedViewer
|rle = x = 37, y = 75, rule = B3/S23
19b2o$19bobo$21bo2b2o$20b2obobo$23bo$23b2o7$29bo$27b3o$26bo$26b2o6$29b
2o$29b2o8$33b2o$33bobo$35bo$35b2o3$12b2o$7b2o3b2o$6bobo$6bo$5b2o$bo$2b
o15b2o$3o14bo2bo$18b2o3$34b2o$34b2o10$34bo$32b3o$31bo$29bo2bo$29b4o2$
19b2o8b2o$19b2o9bo$13b2o15bob2o$14bo7b2o3b2obo2bo$11b3o7bo2bo3bob2o$
11bo8bob2o3bo$18b3o5bo$17bo4b5obo$17b2o4bo3bobo$21bo4bo2bo$21b2o4b2o!
|viewerconfig = #C [[ HEIGHT 700 WIDTH 600 THUMBSIZE 2 ZOOM 8 GPS 20 ]]
|position = center
|caption = 90-degree reflector<ref name="post171279" />
|style = width:300px;
}}}}
{{gallery item|{{EmbedViewer
|rle = x = 44, y = 73, rule = B3/S23
37bo$35b3o$34bo$34b2o3$bo$b3o$4bo$3b2o2$7b2o$7b2o2$2o$2o4$3b2o$4bo$b3o
$bo9$37b2obo$37b2ob3o$43bo$37b2ob3o$38bobo$38bobo$39bo2$5bo$6bo15b2o$
4b3o14bo2bo$22b2o3$38b2o$38b2o10$38bo$36b3o$35bo$33bo2bo$33b4o2$23b2o
8b2o$23b2o9bo$17b2o15bob2o$18bo7b2o3b2obo2bo$15b3o7bo2bo3bob2o$15bo8bo
b2o3bo$24bo5bo$25b6obo$27bo3bobo$30bo2bo$31b2o!
|viewerconfig = #C [[ HEIGHT 700 WIDTH 600 THUMBSIZE 2 ZOOM 8 GPS 20 ]]
|position = center
|caption = G → 2G ([[glider duplicator]])<ref name="post171277" />
|style = width:300px;
}}}}
{{gallery bottom}}

=== Other ===
{{gallery top}}
{{gallery item|{{EmbedViewer
|rle = x = 38, y = 67, rule = B3/S23
13b2o$13bo$11b3o7$25bo$23b3o$22bo$13b2o7b2o$13b2o3$4b2o$4b2o3$36bo$35b
obo$5b2o29bo$6bo$3b3o3b2o$3bo4bobo$8bo$7b2o6$bo$2bo15b2o$3o14bo2bo$18b
2o3$34b2o$34b2o10$34bo$32b3o$31bo$29bo2bo$29b4o2$19b2o8b2o$19b2o9bo$
13b2o15bob2o$14bo7b2o3b2obo2bo$11b3o7bo2bo3bob2o$11bo8bob2o3bo$18b3o5b
o$17bo4b5obo$17b2o4bo3bobo$21bo4bo2bo$21b2o4b2o!
|viewerconfig = #C [[ HEIGHT 700 WIDTH 600 THUMBSIZE 2 ZOOM 8 GPS 20 ]]
|position = center
|caption = G → H<ref name="post171229" />
|style = width:300px;
}}}}
{{gallery item|{{EmbedViewer
|rle = x = 37, y = 72, rule = B3/S23
18bo$17bobo$17bob2o3$24b2o$24b2o$10b2o$10b2o$29bo$27b3o$26bo$26b2o6$
29b2o$29b2o8$33b2o$33bobo$35bo$35b2o3$12b2o$7b2o3b2o$6bobo$6bo$5b2o$bo
$2bo15b2o$3o14bo2bo$18b2o3$34b2o$34b2o10$34bo$32b3o$31bo$29bo2bo$29b4o
2$19b2o8b2o$19b2o9bo$13b2o15bob2o$14bo7b2o3b2obo2bo$11b3o7bo2bo3bob2o$
11bo8bob2o3bo$18b3o5bo$17bo4b5obo$17b2o4bo3bobo$21bo4bo2bo$21b2o4b2o!
|viewerconfig = #C [[ HEIGHT 700 WIDTH 600 THUMBSIZE 2 ZOOM 8 GPS 20 ]]
|position = center
|caption = G → B<ref name="post171279" />
|style = width:300px;
}}}}
{{gallery item|{{EmbedViewer
|rle = x = 45, y = 81, rule = B3/S23
32b2o$33bo$33b3o16$34b2o$34b2o2$41bob2o$41b2obo5$16b2o5b2o$16b2o5b2o$
39bo$38bobo$39b2o5$6b2o$5bobo$5bo$4b2o4$13b2o$14bo$11b3o$11bo$bo$2bo
15b2o$3o14bo2bo$18b2o7$30b2o$30bo$31b3o$33bo6$31b2o$29bo2bo$29b3o2$19b
2o8b2obob2o$19b2o9bob2obo$13b2o15bo$14bo7b2o3b2obo$11b3o7bo2bo3bob2o$
11bo8bob2o3bo$20bo5bo$21b6obo$23bo3bobo$26bo2bo$27b2o!
|viewerconfig = #C [[ HEIGHT 700 WIDTH 600 THUMBSIZE 2 ZOOM 8 GPS 20 ]]
|position = center
|caption = G → R+G<ref name="post171328" /> (followed by [[RF28B]] [[BFx59H]])
|style = width:300px;
}}}}
{{gallery item|{{EmbedViewer
|rle = x = 37, y = 60, rule = B3/S23
12bo15bo$12b3o11b3o$15bo9bo$6bo7b2o9b2o$5bobo10bo3bo$5bobo9bobobobo$3b
3ob2o8bobobobo$2bo15bo3bo$3b3ob2o$5bob2o5$5b2o$4bo$5b2o26b2o$6bo26bobo
$35bo$35b2o7$bo$2bo15b2o$3o14bo2bo$18b2o3$34b2o$34b2o10$34bo$32b3o$31b
o$29bo2bo$29b4o2$19b2o8b2o$19b2o9bo$13b2o15bob2o$14bo7b2o3b2obo2bo$11b
3o7bo2bo3bob2o$11bo8bob2o3bo$20bo5bo$21b6obo$23bo3bobo$26bo2bo$27b2o!
|viewerconfig = #C [[ HEIGHT 700 WIDTH 600 THUMBSIZE 2 ZOOM 8 GPS 20 ]]
|position = center
|caption = G → B<ref name="post171242" />
|style = width:300px;
}}}}
{{gallery item|{{EmbedViewer
|rle = x = 36, y = 43, rule = B3/S23
11b2o$10bobo20bo$10bo21bobo$9b2o20b3o$31b3o5$bo$2bo15b2o$3o14bo2bo$18b2o3$34b2o$34b2o10$34bo$32b3o$31bo$29bo2bo$29b4o2$19b2o8b2o$19b2o9bo$13b
2o15bob2o$14bo7b2o3b2obo2bo$11b3o7bo2bo3bob2o$11bo8bob2o3bo$20bo5bo$21b6obo$23bo3bobo$26bo2bo$27b2o!
|viewerconfig = #C [[ HEIGHT 700 WIDTH 600 THUMBSIZE 2 ZOOM 8 GPS 20 ]]
|position = center
|caption = G → [[U-turner]]<ref name="post171287" /><ref name="post171382" />
|style = width:300px;
}}}}
{{gallery bottom}}

== See also ==
* [[Snark]]
* [[Bronco]]
* [[Syringe]]
* [[Speed tunnel]]

== References ==
<references>
<ref name="post171215">{{LinkForumThread
|format = ref
|p = 171215
|title = Re: The Hunting of the Elementary Conduits
|author = iNoMed
|date = November 15, 2023
}}</ref>
<ref name="post171223">{{LinkForumThread
|format = ref
|p = 171223
|title = Re: Still-life 'factories'
|author = Jormungant
|date = November 15, 2023
}}</ref>
<ref name="post171229">{{LinkForumThread
|format = ref
|p = 171229
|title = Re: The Hunting of the Elementary Conduits
|author = AlbertArmStain
|date = November 15, 2023
}}</ref>
<ref name="post171242">{{LinkForumThread
|format = ref
|p = 171242
|title = Re: Thread for your speculative elementary conduits
|author = squareroot12621
|date = November 15, 2023
}}</ref>
<ref name="post171256">{{LinkForumThread
|format = ref
|p = 171256
|title = Re: Thread for your speculative elementary conduits
|author = C28
|date = November 16, 2023
}}</ref>
<ref name="post171277">{{LinkForumThread
|format = ref
|p = 171277
|title = Re: The Hunting of the Elementary Conduits
|author = iNoMed
|date = November 16, 2023
}}</ref>
<ref name="post171279">{{LinkForumThread
|format = ref
|p = 171279
|title = Re: The Hunting of the Elementary Conduits
|author = AlbertArmStain
|date = November 16, 2023
}}</ref>
<ref name="post171287">{{LinkForumThread
|format = ref
|p = 171287
|title = Re: Thread for your speculative elementary conduits
|author = EvinZL
|date = November 16, 2023
}}</ref>
<ref name="post171309">{{LinkForumThread
|format = ref
|p = 171309
|title = Re: Thread for your speculative elementary conduits
|author = Period1GliderGun
|date = November 16, 2023
}}</ref>
<ref name="post171328">{{LinkForumThread
|format = ref
|p = 171328
|title = Re: The Hunting of the Elementary Conduits
|author = AlbertArmStain
|date = November 16, 2023
}}</ref>
<ref name="post171382">{{LinkForumThread
|format = ref
|p = 171382
|title = Re: Still-life 'factories'
|author = C28
|date = November 17, 2023
}}</ref>
</references>

[[Category:Stable reflectors]]
[[Category:Stable conduits]]
[[Category:Reactions]]
[[Category:Partial results]]
[[Category:Glider conduits]]
[[Category:Patterns found in 2023]]
[[Category:Patterns found by Mitchell Riley]]

{{GliderNavbox}}

O(sqrt(log(t)))

2023-11-12T17:46:18Z

Snacked: Category added

{{Pattern
|name = O(sqrt(log(t)))
|pname = osqrt
|c =
|bx =
|by =
|discoverer = Adam P. Goucher
|discoveryear = 2010
|nofile = true
}}
'''O(sqrt(log(''t'')))''' is a pattern constructed by [[Adam P. Goucher]] in {{year|2010}}<ref name="ref1">{{LinkGoLNews|2011/01/|title=Game of Life News 1/30/11}}</ref> which uses an unbounded triangular region as [[memory]] for a [[binary counter]]. [[Empty space]] is read as a zero, and a [[boat]] as a one, as shown below:

{{EmbedViewer
|pname = memorycell
|viewerconfig = #C [[ THEME 6 GRID THUMBLAUNCH THUMBSIZE 2 HEIGHT 400 WIDTH 640 ZOOM 12 GPS 16 AUTOSTART T 0 PAUSE 5 T 100 PAUSE 1 LOOP 110 ]]
|position = center
|style = width:300px;
}}

The pattern's diametric growth rate is Θ(sqrt(log(''t''))), which is the slowest possible for any [[Life]] pattern,<ref>[[Conway's Game of Life: Mathematics and Construction]], 9.7.2</ref> or indeed any 2D Euclidean cellular automaton. Since the population returns infinitely often to its initial minimum value (during carry operations from 11111...1 to 100000...0, it can be considered to be an unusual form of [[sawtooth]].

==Pattern file==
To get the very large pattern file for this pattern, open [[Golly]] and then click Help > Online Archives > Very Large Patterns.

==Also see==
* [[Memory cell]]
* [[APGsembly]]

==References==
<references>
</references>

==External links==
* {{LinkLexicon|lex_o.htm#osqrtlogt}}

[[Category:Patterns]]
[[Category:Infinite growth]]
[[Category:Patterns with between 100,000 and 999,999 cells]]

__NOTOC__

User:Snacked/DiPiWiki/Di-Pi

2023-08-28T01:32:42Z

Snacked: Created page with "{{Rule |name = Di-Pi |char = Somewhat explosive |b = 3-e5n |s = 2-cn3-y4i |ruleinteger = 4 |reversal = B0123e45-n678/S012cn3y4-i5678 }}"

{{Rule
|name = Di-Pi
|char = Somewhat explosive
|b = 3-e5n
|s = 2-cn3-y4i
|ruleinteger = 4
|reversal = B0123e45-n678/S012cn3y4-i5678
}}

User:Snacked/DiPiWiki

2023-08-28T01:24:04Z

Snacked: Created page with "welcome to low effort (for now) wiki woohoo"

welcome to low effort (for now) wiki woohoo

Period-16 honey farm hasslers

2023-04-05T23:37:04Z

Snacked: 588p16? lol

{{OscListP/HF|p=16}}

{|style="margin:auto;width:300px;"
|{{EmbedViewer
|rle = x = 20, y = 22, rule = B3/S23
4bo7bo$3bobo4b3o$4bo4bo$9b2o2$6b3o$2o3bo3bo$2o2bo5bo$5bo3bo$6b3o3$11b
3o$10bo3bo$9bo5bo2b2o$10bo3bo3b2o$11b3o2$9b2o$10bo4bo$7b3o4bobo$7bo7bo!
|viewerconfig = #C [[ THUMBLAUNCH THUMBSIZE 2 THEME Book ZOOM 10 HEIGHT 500 WIDTH 500 GPS 8 AUTOSTART STOP 16 ]]
|position = center
|caption = 44P16,<ref name="oldid114513" /> found by [[Dongook Lee]] on January 7, {{year|2016}}<ref name="post26519" />
|apgcode = xp16_g8gx33z01gg02dd4y5g0s4z4701y54mm8011gzyaoox121
}}
|{{EmbedViewer
|rle = x = 28, y = 32, rule = B3/S23
4b2o7b2o$4bo2b2ob2o2bo$5b2obobob2o$6bo5bo$6bob3obo$7bo3bo2$7bo3bo$7bo
3bo2$8b3o$23b2o$23b3o$9bo13b2obo$8b3o7bo6bobo$b2o4bo3bo5b3o4bo2bo$o2bo
4b3o5bo3bo4b2o$obo6bo7b3o$bob2o13bo$2b3o$3b2o$17b3o2$16bo3bo$16bo3bo2$
16bo3bo$15bob3obo$15bo5bo$14b2obobob2o$13bo2b2ob2o2bo$13b2o7b2o!
|viewerconfig = #C [[ THUMBLAUNCH THUMBSIZE 2 THEME Book ZOOM 10 HEIGHT 500 WIDTH 500 GPS 8 AUTOSTART STOP 16 ]]
|position = center
|caption = 112P16,<ref name="oldid114513" /> stabilized by [[mold]]s and [[T-nosed p4]]s, found by [[Jason Summers]] on August 2, {{year|2004}}<ref name="jslife" />
|apgcode = xp16_ggy969lqoz1cba24o0goy2g81pzojd5421w1y166421y5g8ozy8s2hb3y1s80s21llmzy8ss8gy612269czy92543
}}
|-
|{{EmbedViewer
|rle = x = 25, y = 20, rule = B3/S23
10b2o2b3o2b2o$10bo2b5o2bo$11b9o$8b3o9b3o$8bo2bo7bo2bo$9b2o9b2o2$15bo$
14bobo$13bo3bo$13bo3bo$b2ob2obo5bo3bo$2o2b2ob2o5bobo$8bo6bo$2o16b2obo$
2o5b2o10bob3o$7b2o8bobo4bo$o15bob2o3b2o$2ob2o2b2o7bo$bob2ob2o7b2o!
|viewerconfig = #C [[ THUMBLAUNCH THUMBSIZE 2 THEME Book ZOOM 10 HEIGHT 500 WIDTH 500 GPS 8 AUTOSTART STOP 16 ]]
|position = center
|caption = 92P16,<ref name="oldid114513" /> found by [[David Raucci]] on March 10, {{year|2022}}<ref name="post142634" /> and reduced by James Pascua<ref name="post142665" />
|apgcode = xp16_ckgg0s4871y2ae12032b4zx1011gcc4oy02d4c04875zxggx3j3xggzw32ql4988894lq23
}}
|{{EmbedViewer
|rle = x = 16, y = 21, rule = B3/S23
b2o$b2o2$bo7b2o$obo5bo2bo$o2bo4bobobo$bo2bo4bob3o$11b3o$bo2bo$b2o2$7b
3o$6bo3bo$b2o2bo5bo2b2o$b2o3bo3bo3b2o$7b3o2$10b2o$5bo4bo$4bobo4b3o$5bo7bo!
|viewerconfig = #C [[ THUMBLAUNCH THUMBSIZE 2 THEME Book ZOOM 10 HEIGHT 500 WIDTH 500 GPS 8 AUTOSTART STOP 16 ]]
|position = center
|caption = 56P16,<ref name="oldid114513" /> a monomer
|apgcode = xp16_y0252xca23z066x6dhe4x66z422sy1g8ssz3jg1y03452z011
}}
|-
|{{EmbedViewer
|rle = x = 39, y = 29, rule = B3/S23
8bo3bo$7bobobobo$8b2ob2o3$4b5o3b5o13bo3bo$4bob4ob4obo12bobobobo$4b2obo
bobobob2o13b2ob2o$5bobobobobobo$6b3o3b3o12bo9bo$7bo5bo12bo11bo$26bo3b
2ob2o3bo$18b3o6b3obobob3o$17bo3bo6b2obobob2o$3b2o3b2o6bo5bo6b2o3b2o$2b
2obobob2o6bo3bo$b3obobob3o6b3o$o3b2ob2o3bo$o11bo12bo5bo$bo9bo12b3o3b3o
$23bobobobobobo$4b2ob2o13b2obobobobob2o$3bobobobo12bob4ob4obo$4bo3bo
13b5o3b5o3$26b2ob2o$25bobobobo$26bo3bo!
|viewerconfig = #C [[ THUMBLAUNCH THUMBSIZE 2 THEME Book ZOOM 10 HEIGHT 500 WIDTH 500 GPS 8 AUTOSTART STOP 16 ]]
|position = center
|caption = 158P16,<ref name="oldid114513" /> found by [[Carson Cheng]] on August 28, {{year|2022}}<ref name="post150280" />
|apgcode = xp16_y32560652zy03diiie0eiiid3y6g025606520gzy0gxgy4ok4ooy03498ie0ei8943zci914707419icy011221wgggxgggzx4a606a4y8cb444707444bczyl4a606a4
}}
|{{EmbedViewer
|rle = x = 35, y = 25, rule = B3/S23
5bo3bo$4bobobobo$5b2ob2o2$2b3o5b3o6bo$bo4bobo4bo5bobo$o5bobo5bo3bobo$b
o4bobo4bo6bo$b2o3bobo3b2o$17bo6bo$3b3o3b3o4bobo4bobo$15bo3bo4bo$15bo3b
o$10bo4bo3bo$9bobo4bobo4b3o3b3o$10bo6bo$21b2o3bobo3b2o$14bo6bo4bobo4bo
$14bobo3bo5bobo5bo$13bobo5bo4bobo4bo$15bo6b3o5b3o2$25b2ob2o$24bobobobo
$25bo3bo!
|viewerconfig = #C [[ THUMBLAUNCH THUMBSIZE 2 THEME Book ZOOM 10 HEIGHT 500 WIDTH 500 GPS 8 AUTOSTART STOP 16 ]]
|position = center
|caption = 98P16,<ref name="oldid114513" /> found by James Pascua on January 30, {{year|2022}}<ref name="post140952" />
|apgcode = xp16_x2560652y4gz3diiie0eiiid3y02161wgzy4g8gx69ricx121zy51wgcg8y0om999e0e999mozya1y48kc0ck8
}}
|-
|{{EmbedViewer
|rle = x = 55, y = 30, rule = B3/S23
3b2o3b2o$2bo2bo2b2o$2bo10b6o$2bo2bo6bo2bo3bo$2b2ob2o6bo5bo15bo$2bo2bo
3b2o3b3obo14b3o$2bobo4b2o4bo16bo$3bo28b2o$18b2o$5b2o6b2o3b2o9b3o$2o3b
2o6b2o13bo3bo5b2o3b2o$2o25bo5bo3bo2bo2b2o$16bo11bo3bo4bo10b6o$4bo4b2o
4bobo11b3o5bo2bo6bo2bo3bo$bob3o3b2o3bo2bo19b2ob2o6bo5bo$o5bo6b2ob2o19b
o2bo3b2o3b3obo$o3bo2bo6bo2bo5b3o11bobo4b2o4bo$b6o10bo4bo3bo11bo$10b2o
2bo2bo3bo5bo25b2o$10b2o3b2o5bo3bo13b2o6b2o3b2o$23b3o9b2o3b2o6b2o$35b2o
$21b2o28bo$22bo16bo4b2o4bobo$19b3o14bob3o3b2o3bo2bo$19bo15bo5bo6b2ob2o
$35bo3bo2bo6bo2bo$36b6o10bo$45b2o2bo2bo$45b2o3b2o!
|viewerconfig = #C [[ THUMBLAUNCH THUMBSIZE 2 THEME Book ZOOM 10 HEIGHT 500 WIDTH 500 GPS 8 AUTOSTART STOP 16 ]]
|position = center
|caption = 174P16,<ref name="oldid114513" /> found by David Raucci on April 3, {{year|2022}}<ref name="post143748" />
|apgcode = xp16_oowg8cx33xj3zooxjx31whh032zw8o0hhwgoxpx33zxopxoox621wj3y0ggzydgpgw643zy5o01agw1ag03zy1o4cw1j1zy011y0opwg8cx33xj3zy6ooxjx31whh032zy88o0hhwgoxpx33zy9opxoox621w33
}}
|{{EmbedViewer
|rle = x = 52, y = 30, rule = B3/S23
3b2o3b2o5b2o$bo2bo3b2o3bo4bo6b2o4b2o4b2o$13bo10bo2bobo4bobo2bo$o5bo5bo
6bo4b3o10b3o$o6bo5bo4b2o7b2o6b2o$6bo2b2o2bo12bo2b6o2bo$b2ob2o3b2o3bobo
9b2o8b2o$3bo11bo$18b2o$5b2o6b2o3b2o$2o3b2o6b2o20b2o3b2o5b2o$2o27bo3bo
2bo3b2o3bo4bo$4bo11bo10b2obo14bo$3bobo3b2o3b2ob2o8bo2bobo5bo5bo6bo$6bo
2b2o2bo13b3o2bo6bo5bo4b2o$2o4bo5bo6bo2b3o13bo2b2o2bo$o6bo5bo5bobo2bo8b
2ob2o3b2o3bobo$6bo14bob2o10bo11bo$bo4bo3b2o3bo2bo3bo27b2o$3b2o5b2o3b2o
20b2o6b2o3b2o$32b2o3b2o6b2o$32b2o$36bo11bo$14b2o8b2o9bobo3b2o3b2ob2o$
14bo2b6o2bo12bo2b2o2bo$15b2o6b2o7b2o4bo5bo6bo$12b3o10b3o4bo6bo5bo5bo$
12bo2bobo4bobo2bo10bo$13b2o4b2o4b2o6bo4bo3b2o3bo2bo$35b2o5b2o3b2o!
|viewerconfig = #C [[ THUMBLAUNCH THUMBSIZE 2 THEME Book ZOOM 10 HEIGHT 500 WIDTH 500 GPS 8 AUTOSTART STOP 16 ]]
|position = center
|caption = 244P16,<ref name="oldid114513" /> found by David Raucci on April 3, {{year|2022}}<ref name="post143748" />
|apgcode = xp16_y93jx33xc8gwoozy8230hhw13xjxooz0o4s0ggx33xpxogwhh0o8zw10vspx33w126xooxpozwg0v7jx37wode2y4ggz0347011y2oocwgy06is343zxccxccw1h2x33xfvvzw8c244w4cw1d2w33x643siczccx62y246x33zccw4bow32w22431zy633x33
}}
|-
|{{EmbedViewer
|pname = p16honeyfarmhassler2
|viewerconfig = #C [[ THUMBLAUNCH THUMBSIZE 2 THEME Book ZOOM 16 HEIGHT 500 WIDTH 500 GPS 8 AUTOSTART STOP 16 ]]
|position = center
|caption = 58P16, found by [[Carson Cheng]] on January 19, {{year|2023}} and reduced by [[James Pascua]] on January 26, {{year|2023}} <ref name="post156480" />
|apgcode = xp16_0gbjy5ggoz01qg1ay232zggy233566wo8gz1cr0rby732zw121
}}
|}

==References==
<references>
<ref name="oldid114513">RLE extracted from https://conwaylife.com/w/index.php?title=RLE:P16honeyfarmhasslers&oldid=114513</ref>
<ref name="jslife">{{CiteSummersPattern|name=jslife|accessdate=June 7, 2021}}</ref>
<ref name="post26519">{{LinkForumThread
|format = ref
|title = Re: Oscillator Discoveries Thread
|p = 26519
|author = Dongook Lee
|date = January 7, 2016
}}</ref>
<ref name="post140952">{{LinkForumThread
|format = ref
|title = Re: Oscillator Discussion Thread
|p = 140952
|author = James Pascua
|date = January 30, 2022
}}</ref>
<ref name="post142634">{{LinkForumThread
|format = ref
|title = Re: Oscillator Discussion Thread
|p = 142634
|author = David Raucci
|date = March 10, 2022
}}</ref>
<ref name="post142665">{{LinkForumThread
|format = ref
|title = Re: Oscillator Discussion Thread
|p = 142665
|author = James Pascua
|date = March 11, 2022
}}</ref>
<ref name="post143748">{{LinkForumThread
|format = ref
|title = Re: Oscillator Discussion Thread
|p = 143748
|author = David Raucci
|date = April 3, 2022
}}</ref>
<ref name="post150280">{{LinkForumThread
|format = ref
|title = Re: Oscillator Discussion Thread
|p = 150280
|author = David Raucci
|date = August 28, 2022
}}</ref>
<ref name="post156480">{{LinkForumThread
|format = ref
|title = Re: Oscillator Discussion Thread
|p = 156480
|author = James Pascua
|date = January 26, 2023
}}</ref>
</references>
__NOTOC__

Octagon 4

2023-03-14T19:50:35Z

Snacked: link added

{{Oscillator
|name = Octagon 4
|pname = octagon4
|c = 40
|bx = 16
|by = 16
|p = 4
|m = 4
|h = 48
|v = 0.83
|sv = 0.67
|discoverer = Robert Wainwright
|discoveryear = 1979
|rulemin = B3/S23
|rulemax = B378/S0238
|rulespecial = [[Conway's Game of Life|Conway Life]]
|isorulemin = B3ijn/S2-ae3anqy
|isorulemax = B2cin34-aew5-r6-kn78/S0234-qr5-ijn6-ae7e8
|synthesis = 18
|synthesisRLE = true
|plaintext = true
|rle = true
|animated = true
|viewerconfig = #C [[ THUMBSIZE 3 GPS 4 ZOOM 24 HEIGHT 500 WIDTH 600 ]]
|apgcode = xp4_y1g8bb8gzcc0u1y21u0cczy0124kk421zy311
|pentadecathlonid = 40P4.19
}}
'''Octagon 4''' is a {{period|4}} [[oscillator]], discovered in January {{year|1979}} by [[Robert Wainwright]].<ref>{{CiteHickersonOscillators|accessdate=March 14, 2020}}</ref> It consists of a regular octagon with sides four cells long and of four [[block]]s.

In August {{year|2004}} [[Jason Summers]] and [[Mark Niemiec]] found a {{gliders|34}} [[synthesis]] of this oscillator,<ref>{{CiteSummersPattern|name=jslife}}</ref> which was improved to {{gliders|18|text=18 gliders}} by [[Jeremy Tan]] on May 17, {{year|2019}}.<ref name="post76303"/>

The oscillator first appeared [[semi-natural]]ly in October {{year|2014}} in a [[soup]] found by [[Matthias Merzenich]] using [[apgsearch]].<ref name="post13599" /> Almost exactly 3 in 100000 (within the margin of error) even-width eightfold (D8_4) symmetric soups will form an octagon 4 in the centre.

Without the blocks, the octagon will become 4 [[Pond|ponds]].

==See also==
* [[Octagon 2]]
* [[List of common oscillators]]

==References==
<references>
<ref name="post13599">{{LinkForumThread
|format = ref
|title = Re: Soup search results
|p = 13599
|author = Matthias Merzenich
|date = October 2, 2014
}}</ref>
<ref name="post76303">{{LinkForumThread
|format = ref
|title = Re: Synthesising Oscillators
|p = 76303
|author = Jeremy Tan
|date = May 17, 2019
}}</ref>
</references>

==External links==
* {{LinkLexicon|lex_o.htm#octagoniv}}
* {{LinkPentadecathlonObject|40P4.19}}
* {{LinkCatagolue|xp4_y1g8bb8gzcc0u1y21u0cczy0124kk421zy311}}

{{Symmetry|full}}
{{seminatural}}

P4 syringe

2023-01-03T20:57:21Z

Snacked: grammar moment

{{Conduit
|name = p4 syringe
|pname = p4syringe
|type = converter
|conduitfor = Glider
|convertsto = Herschel
|recovery = 44
|c = 109
|bx = 29
|by = 35
|spartan = no
|discoverer = David Raucci
|discoverer2 = Louis-François Handfield
|discoveryear = 2021
|rulemin = B3/S23
|rulemax = B38/S23
|rulespecial = [[Conway's Game of Life|Conway Life]]
|isorulemin = B3/S23
|isorulemax = B34c7c8/S234c5e6ei
|plaintext = true
|rle = true
|viewerconfig = #C [[ THUMBNAIL THUMBSIZE 2 Z 16 WIDTH 600 HEIGHT 600 GPS 12 AUTOSTART PAUSE 2 T 96 PAUSE 2 LOOP 140 ]]
}}{{DISPLAYTITLE: p4 syringe}}

'''p4 syringe''' is a [[periodic]] [[glider-to-Herschel converter]] that was found by [[David Raucci]] and [[Louis-François Handfield]] in November {{year|2021}}.<ref name="post138076" /> It consists of a [[bait]] [[block]], an [[eater 1]], a [[block on table]] (originally [[mold]]), and a large {{period|4}} [[oscillator]] that is a [[weld]] of a high-[[clearance]] [[heavyweight emulator]] variant and a [[tub-with-tail eater]] (eater 5) variant. The input [[glider]] hitting the block triggers a [[honey farm]] explosion, which is perturbed by stable [[catalyst]]s and ''two'' [[domino]] sparks to give a [[B-heptomino]], releasing a [[Herschel]] and restoring the block.

The transient [[spark]] from honey farm reaction fades away before another glider 42 ticks behind the first one enters, but considering periodicity and removal of output's [[first natural glider]], the infobox form of this device works for gliders separated by (60+4''n'') ticks. For lower periods, a suitable [[sparker]] should be welded in place of the eater 5, like an [[53P13]] for p52.<ref name="post138098" />

== References ==
<references>
<ref name="post138076">{{LinkForumThread
|format = ref
|p = 138076
|title = Re: The Hunting of the Periodic Herschel Conduits
|author = David Raucci
|date = November 25, 2021
}}</ref>
<ref name="post138098">{{LinkForumThread
|format = ref
|p = 138098
|title = Re: The Hunting of the Periodic Herschel Conduits
|author = cvojan
|date = November 26, 2021
}}</ref>
</references>

{{GliderNavbox}}

Talk:Catagolue

2022-12-20T23:37:13Z

Snacked: /* picture */ new section

__TOC__

==4x64, 2x128, 1x256, 32x32==
I did that. -wwei23 2:54PM 6/23/2017 NY time

:Would you share your version of apgsearch that you used for these? [[User:Apple Bottom|Apple Bottom]] ([[User talk:Apple Bottom|talk]]) 21:19, 23 June 2017 (UTC)

::Sure, this is modified because I had it use my key, here it uses "#anon". These modifications are trivial(I use JS, not PY!). Also, won't apgsearch eventually run out of soups to search?
<pre>
# *************************************
# * Ash Pattern Generator (apgsearch) *
# *************************************
# * Version: v1.1 (beta release) *
# *************************************
#
# -- Processes roughly 100 soups per (second . core . GHz), using caching
# and machine-learning to optimise itself during runtime.
#
# -- Can perfectly identify oscillators with period < 1000, well-separated
# spaceships of low period, and certain infinite-growth patterns (such
# guns and puffers, including both naturally-occurring types of switch
# engine).
#
# -- Separates most pseudo-objects into their constituent parts, including
# all pseudo-still-lifes of 18 or fewer live cells (which is the maximum
# theoretically possible, given there is a 19-cell pseudo-still-life
# with two distinct decompositions).
#
# -- Correctly separates non-interacting standard spaceships, irrespective
# of their proximity. In particular, a LWSS-on-LWSS is registered as two
# LWSSes, whereas an LWSS-on-HWSS is registered as a single spaceship
# (since they interact by suppressing sparks).
#
# -- At least 99.9999999999% reliable at identifying objects in asymmetrical
# soups in B3/S23 (based on the fact that out of over 10^12 objects that
# have appeared, there are no errors).
#
# -- Scores soups based on the total excitement of the ash objects.
#
# -- Support for other outer-totalistic rules, including detection and
# classification of various types of infinite growth.
#
# -- Support for symmetrical soups.
#
# -- Uploads results to the server at http://catagolue.appspot.com (which
# currently has collected over 2.7 * 10^12 objects).
#
# -- Peer-reviews others' contributions to ensure data integrity for the
# asymmetrical B3/S23 census.
#
# By Adam P. Goucher, with contributions from Andrew Trevorrow, Tom Rokicki,
# Nathaniel Johnston, Dave Greene and Richard Schank.

import golly as g
from glife import rect, pattern
import time
import math
import operator
import hashlib
import datetime
import os
import urllib2
import RANDOM

def get_server_address():
# Should be 'http://catagolue.appspot.com' for the released version,
# and 'http://localhost:8080' for the development version:
return 'http://catagolue.appspot.com'

# Engages with Catagolue's authentication system ('payment over SHA-256',
# affectionately abbreviated to 'payosha256'):
#
# The payosha256_key can be obtained from logging into Catagolue in your
# web browser and visiting http://catagolue.appspot.com/payosha256
def authenticate(payosha256_key, operation_name):

g.show("Authenticating with Catagolue via the payosha256 protocol...")

payload = "payosha256:get_token:"+payosha256_key+":"+operation_name

req = urllib2.Request(get_server_address() + "/payosha256", payload, {"Content-type": "text/plain"})
f = urllib2.urlopen(req)

if (f.getcode() != 200):
return None

resp = f.read()

lines = resp.splitlines()

for line in lines:
parts = line.split(':')

if (len(parts) < 3):
continue

if (parts[1] != 'good'):
continue

target = parts[2]
token = parts[3]

g.show("Token " + token + " obtained from payosha256. Performing proof of work with target " + target + "...")

for nonce in xrange(100000000):

prehash = token + ":" + str(nonce)
posthash = hashlib.sha256(prehash).hexdigest()

if (posthash < target):
break

if (posthash > target):
continue

g.show("String "+prehash+" is sufficiently valuable ("+posthash+" < "+target+").")

payload = "payosha256:pay_token:"+prehash+"\n"

return payload

return None

# Sends the results to Catagolue:
def catagolue_results(results, payosha256_key, operation_name, endpoint="/apgsearch", return_point=None):

try:

payload = authenticate("#anon", operation_name)

if payload is None:
return 1

payload += results

req = urllib2.Request(get_server_address() + endpoint, payload, {"Content-type": "text/plain"})

f = urllib2.urlopen(req)

if (f.getcode() != 200):
return 2

resp = f.read()

try:
f2 = open(g.getdir("data")+"catagolue-response.txt", 'w')
f2.write(resp)
f2.close()

if return_point is not None:
return_point[0] = resp

except:
g.warn("Unable to save catagolue response file.")

return 0

except:

return 1

# Takes approximately 350 microseconds to construct a 16-by-16 soup based
# on a SHA-256 cryptographic hash in the obvious way.
def hashsoup(instring, sym):

s = hashlib.sha256(instring).digest()

thesoup = []

if sym in ['D2_x', 'D8_1', 'D8_4']:
d = 1
elif sym in ['D4_x1', 'D4_x4']:
d = 2
else:
d = 0

for j in xrange(32):

t = ord(s[j])

for k in xrange(8):

if (sym == '8x32'):

x = k + 8*(j % 4)
y = int(j / 4)

elif (sym == '4x64'):

x = k + 8*(j % 8)
y = int(j / 8)

elif (sym == '2x128'):

x = k + 8*(j % 16)
y = int(j / 16)

elif (sym == '1x256'):

x = k + 8*(j % 32)
y = int(j / 32)

else:

x = k + 8*(j % 2)
y = int(j / 2)

if (t & (1 << (7 - k))):

if ((d == 0) | (x >= y)):

thesoup.append(x)
thesoup.append(y)

if (sym == '32x32'):

thesoup.append(x+16)
thesoup.append(y)
thesoup.append(x)
thesoup.append(y+16)
thesoup.append(x+16)
thesoup.append(y+16)

elif (sym == 'D4_x1'):

thesoup.append(y)
thesoup.append(-x)

elif (sym == 'D4_x4'):

thesoup.append(y)
thesoup.append(-x-1)

if ((sym == 'D4_x1') & (x == y)):

thesoup.append(y)
thesoup.append(-x)

if ((sym == 'D4_x4') & (x == y)):

thesoup.append(y)
thesoup.append(-x-1)

# Checks for diagonal symmetries:
if (d >= 1):
for x in xrange(0, len(thesoup), 2):
thesoup.append(thesoup[x+1])
thesoup.append(thesoup[x])
if d == 2:
if (sym == 'D4_x1'):
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x+1])
thesoup.append(-thesoup[x])
else:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x+1] - 1)
thesoup.append(-thesoup[x] - 1)
return thesoup

# Checks for orthogonal x symmetry:
if sym in ['D2_+1', 'D4_+1', 'D4_+2']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(thesoup[x])
thesoup.append(-thesoup[x+1])
elif sym in ['D2_+2', 'D4_+4']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(thesoup[x])
thesoup.append(-thesoup[x+1] - 1)

# Checks for orthogonal y symmetry:
if sym in ['D4_+1']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x])
thesoup.append(thesoup[x+1])
elif sym in ['D4_+2', 'D4_+4']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x] - 1)
thesoup.append(thesoup[x+1])

# Checks for rotate2 symmetry:
if sym in ['C2_1', 'C4_1', 'D8_1']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x])
thesoup.append(-thesoup[x+1])
elif sym in ['C2_2']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x])
thesoup.append(-thesoup[x+1]-1)
elif sym in ['C2_4', 'C4_4', 'D8_4']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x]-1)
thesoup.append(-thesoup[x+1]-1)

# Checks for rotate4 symmetry:
if (sym in ['C4_1', 'D8_1']):
for x in xrange(0, len(thesoup), 2):
thesoup.append(thesoup[x+1])
thesoup.append(-thesoup[x])
elif (sym in ['C4_4', 'D8_4']):
for x in xrange(0, len(thesoup), 2):
thesoup.append(thesoup[x+1])
thesoup.append(-thesoup[x]-1)

return thesoup

# Obtains a canonical representation of any oscillator/spaceship that (in
# some phase) fits within a 40-by-40 bounding box. This representation is
# alphanumeric and lowercase, and so much more compact than RLE. Compare:
#
# Common name: pentadecathlon
# Canonical representation: 4r4z4r4
# Equivalent RLE: 2bo4bo$2ob4ob2o$2bo4bo!
#
# It is a generalisation of a notation created by Allan Weschler in 1992.
def canonise(duration):

representation = "#"

# We need to compare each phase to find the one with the smallest
# description:
for t in xrange(duration):

rect = g.getrect()
if (len(rect) == 0):
return "0"

if ((rect[2] <= 40) & (rect[3] <= 40)):
# Fits within a 40-by-40 bounding box, so eligible to be canonised.
# Choose the orientation which results in the smallest description:
representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0], rect[1], 1, 0, 0, 1))
representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0]+rect[2]-1, rect[1], -1, 0, 0, 1))
representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0], rect[1]+rect[3]-1, 1, 0, 0, -1))
representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0]+rect[2]-1, rect[1]+rect[3]-1, -1, 0, 0, -1))
representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0], rect[1], 0, 1, 1, 0))
representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0]+rect[2]-1, rect[1], 0, -1, 1, 0))
representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0], rect[1]+rect[3]-1, 0, 1, -1, 0))
representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0]+rect[2]-1, rect[1]+rect[3]-1, 0, -1, -1, 0))

g.run(1)

return representation

# A subroutine used by canonise:
def canonise_orientation(length, breadth, ox, oy, a, b, c, d):

representation = ""

chars = "0123456789abcdefghijklmnopqrstuvwxyz"

for v in xrange(int((breadth-1)/5)+1):
zeroes = 0
if (v != 0):
representation += "z"
for u in xrange(length):
baudot = 0
for w in xrange(5):
x = ox + a*u + b*(5*v + w)
y = oy + c*u + d*(5*v + w)
baudot = (baudot >> 1) + 16*g.getcell(x, y)
if (baudot == 0):
zeroes += 1
else:
if (zeroes > 0):
if (zeroes == 1):
representation += "0"
elif (zeroes == 2):
representation += "w"
elif (zeroes == 3):
representation += "x"
else:
representation += "y"
representation += chars[zeroes - 4]
zeroes = 0
representation += chars[baudot]
return representation

# Compares strings first by length, then by lexicographical ordering.
# A hash character is worse than anything else.
def compare_representations(a, b):

if (a == "#"):
return b
elif (b == "#"):
return a
elif (len(a) < len(b)):
return a
elif (len(b) < len(a)):
return b
elif (a < b):
return a
else:
return b

# Finds the gradient of the least-squares regression line corresponding
# to a list of ordered pairs:
def regress(pairlist):

cumx = 0.0
cumy = 0.0
cumvar = 0.0
cumcov = 0.0

for x,y in pairlist:

cumx += x
cumy += y

cumx = cumx / len(pairlist)
cumy = cumy / len(pairlist)

for x,y in pairlist:

cumvar += (x - cumx)*(x - cumx)
cumcov += (x - cumx)*(y - cumy)

return (cumcov / cumvar)

# Analyses a pattern whose average population follows a power-law:
def powerlyse(stepsize, numsteps):

g.setalgo("HashLife")
g.setbase(2)
g.setstep(stepsize)

poplist = [0]*numsteps

poplist[0] = int(g.getpop())

pointlist = []

for i in xrange(1, numsteps, 1):

g.step()
poplist[i] = int(g.getpop()) + poplist[i-1]

if (i % 50 == 0):

g.fit()
g.update()

if (i > numsteps/2):

pointlist.append((math.log(i),math.log(poplist[i]+1.0)))

power = regress(pointlist)

if (power < 1.10):
return "unidentified"
elif (power < 1.65):
return "zz_REPLICATOR"
elif (power < 2.05):
return "zz_LINEAR"
elif (power < 2.8):
return "zz_EXPLOSIVE"
else:
return "zz_QUADRATIC"

# Gets the period of an interleaving of degree-d polynomials:
def deepperiod(sequence, maxperiod, degree):

for p in xrange(1, maxperiod, 1):

good = True

for i in xrange(maxperiod):

diffs = [0] * (degree + 2)
for j in xrange(degree + 2):

diffs[j] = sequence[i + j*p]

# Produce successive differences:
for j in xrange(degree + 1):
for k in xrange(degree + 1):
diffs[k] = diffs[k] - diffs[k + 1]

if (diffs[0] != 0):
good = False
break

if (good):
return p
return -1

# Analyses a linear-growth pattern, returning a hash:
def linearlyse(maxperiod):

poplist = [0]*(3*maxperiod)

for i in xrange(3*maxperiod):

g.run(1)
poplist[i] = int(g.getpop())

p = deepperiod(poplist, maxperiod, 1)

if (p == -1):
return "unidentified"

difflist = [0]*(2*maxperiod)

for i in xrange(2*maxperiod):

difflist[i] = poplist[i + p] - poplist[i]

q = deepperiod(difflist, maxperiod, 0)

moments = [0, 0, 0]

for i in xrange(p):

moments[0] += (poplist[i + q] - poplist[i])
moments[1] += (poplist[i + q] - poplist[i]) ** 2
moments[2] += (poplist[i + q] - poplist[i]) ** 3

prehash = str(moments[1]) + "#" + str(moments[2])

# Linear-growth patterns with growth rate zero are clearly errors!
if (moments[0] == 0):
return "unidentified"

return "yl" + str(p) + "_" + str(q) + "_" + str(moments[0]) + "_" + hashlib.md5(prehash).hexdigest()

# This explodes pseudo-still-lifes and pseudo-oscillators into their
# constituent parts.
#
# -- Requires the period (if oscillatory) and graph-theoretic diameter
# to not exceed 4096.
# -- Never mistakenly separates a true object.
# -- Correctly separates most pseudo-still-lifes, including the famous:
# http://www.conwaylife.com/wiki/Quad_pseudo_still_life
# -- Works perfectly for all still-lifes of up to 17 bits.
# -- Doesn't separate 'locks', of which the smallest example has 18
# bits and is unique:
#
# ** **
# ** **
#
# * *** *
# ** * **
#
# To use this function (standalone), merely copy it into a script of
# the following form:
#
# import golly as g
#
# def pseudo_bangbang():
#
# [...]
#
# pseudo_bangbang()
#
# and execute it in Golly with a B3/S23 universe containing any still-
# lifes or oscillators you want to separate. Pure objects correspond to
# connected components in the final state of the universe.
#
# This has dependencies on the rules ContagiousLife, PercolateInfection
# and EradicateInfection.
#
# Not to be confused with the Unix shell instruction for repeating the
# previous instruction as a superuser (sudo !!), or indeed with any
# parodies of this song: https://www.youtube.com/watch?v=YswhUHH6Ufc
#
# Adam P. Goucher, 2014-08-25
def pseudo_bangbang(alpharule):

g.setrule("APG_ContagiousLife_" + alpharule)
g.setbase(2)
g.setstep(12)
g.step()

celllist = g.getcells(g.getrect())

for i in xrange(0, len(celllist)-1, 3):

# Only infect cells that haven't yet been infected:
if (g.getcell(celllist[i], celllist[i+1]) <= 2):

# Seed an initial 'infected' (red) cell:
g.setcell(celllist[i], celllist[i+1], g.getcell(celllist[i], celllist[i+1]) + 2)

prevpop = 0
currpop = int(g.getpop())

# Continue infecting until the entire component has been engulfed:
while (prevpop != currpop):

# Percolate the infection to every cell in the island:
g.setrule("APG_PercolateInfection")
g.setbase(2)
g.setstep(12)
g.step()

# Transmit the infection across any bridges.
g.setrule("APG_ContagiousLife_" + alpharule)
g.setbase(2)
g.setstep(12)
g.step()

prevpop = currpop
currpop = int(g.getpop())

g.fit()
g.update()

# Red becomes green:
g.setrule("APG_EradicateInfection")
g.step()

# Counts the number of live cells of each degree:
def degreecount():

celllist = g.getcells(g.getrect())
counts = [0,0,0,0,0,0,0,0,0]

for i in xrange(0, len(celllist), 2):

x = celllist[i]
y = celllist[i+1]

degree = -1

for ux in xrange(x - 1, x + 2):
for uy in xrange(y - 1, y + 2):

degree += g.getcell(ux, uy)

counts[degree] += 1

return counts

# Counts the number of live cells of each degree in generations 1 and 2:
def degreecount2():

g.run(1)
a = degreecount()
g.run(1)
b = degreecount()

return (a + b)

# If the universe consists only of disjoint *WSSes, this will return
# a triple (l, w, h) giving the quantities of each *WSS. Otherwise,
# this function will return (-1, -1, -1).
#
# This should only be used to separate period-4 moving objects which
# may contain multiple *WSSes.
def countxwsses():

degcount = degreecount2()
if (degreecount2() != degcount):
# Degree counts are not period-2:
return (-1, -1, -1)

# Degree counts of each standard spaceship:
hwssa = [1,4,6,2,0,0,0,0,0,0,0,0,4,4,6,1,2,1]
mwssa = [2,2,5,2,0,0,0,0,0,0,0,0,4,4,4,1,2,0]
lwssa = [1,2,4,2,0,0,0,0,0,0,0,0,4,4,2,2,0,0]
hwssb = [0,0,0,4,4,6,1,2,1,1,4,6,2,0,0,0,0,0]
mwssb = [0,0,0,4,4,4,1,2,0,2,2,5,2,0,0,0,0,0]
lwssb = [0,0,0,4,4,2,2,0,0,1,2,4,2,0,0,0,0,0]

# Calculate the number of standard spaceships in each phase:
hacount = degcount[17]
macount = degcount[16]/2 - hacount
lacount = (degcount[15] - hacount - macount)/2
hbcount = degcount[8]
mbcount = degcount[7]/2 - hbcount
lbcount = (degcount[6] - hbcount - mbcount)/2

# Determine the expected degcount given the calculated quantities:
pcounts = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: hacount*x, hwssa))
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: macount*x, mwssa))
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: lacount*x, lwssa))
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: hbcount*x, hwssb))
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: mbcount*x, mwssb))
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: lbcount*x, lwssb))

# Compare the observed and expected degcounts (to eliminate nonstandard spaceships):
if (pcounts != degcount):
# Expected and observed values do not match:
return (-1, -1, -1)

# Return the combined numbers of *WSSes:
return(lacount + lbcount, macount + mbcount, hacount + hbcount)

# Generates the helper rules for apgsearch, given a base outer-totalistic rule.
class RuleGenerator:

def __init__(self):

# Unless otherwise specified, assume standard B3/S23 rule:
self.bee = [False, False, False, True, False, False, False, False, False]
self.ess = [False, False, True, True, False, False, False, False, False]
self.alphanumeric = "B3S23"
self.slashed = "B3/S23"

# Save all helper rules:
def saveAllRules(self):

self.saveClassifyObjects()
self.saveCoalesceObjects()
self.saveExpungeObjects()
self.saveExpungeGliders()
self.saveIdentifyGliders()
self.saveHandlePlumes()
self.savePercolateInfection()
self.saveEradicateInfection()
self.saveContagiousLife()

# Set outer-totalistic rule:
def setrule(self, rulestring):

mode = 0
s = [False]*9
b = [False]*9

for c in rulestring:

if ((c == 's') | (c == 'S')):
mode = 0

if ((c == 'b') | (c == 'B')):
mode = 1

if (c == '/'):
mode = 1 - mode

if ((ord(c) >= 48) & (ord(c) <= 56)):
d = ord(c) - 48
if (mode == 0):
s[d] = True
else:
b[d] = True

prefix = "B"
suffix = "S"

for i in xrange(9):
if (b[i]):
prefix += str(i)
if (s[i]):
suffix += str(i)

self.alphanumeric = prefix + suffix
self.slashed = prefix + "/" + suffix
self.bee = b
self.ess = s

# Save a rule file:
def saverule(self, name, comments, table, colours):

ruledir = g.getdir("rules")
filename = ruledir + name + ".rule"

results = "@RULE " + name + "\n\n"
results += "*** File autogenerated by saverule. ***\n\n"
results += comments
results += "\n\n@TABLE\n\n"
results += table
results += "\n\n@COLORS\n\n"
results += colours

# Only create a rule file if it doesn't already exist; this avoids
# concurrency issues when booting an instance of apgsearch whilst
# one is already running.
if not os.path.exists(filename):
try:
f = open(filename, 'w')
f.write(results)
f.close()
except:
g.warn("Unable to create rule table:\n" + filename)

# Defines a variable:
def newvar(self, name, vallist):

line = "var "+name+"={"
for i in xrange(len(vallist)):
if (i > 0):
line += ','
line += str(vallist[i])
line += "}\n"

return line

# Defines a block of equivalent variables:
def newvars(self, namelist, vallist):

block = ""

for name in namelist:
block += self.newvar(name, vallist)

block += "\n"

return block

def scoline(self, chara, charb, left, right, amount):

line = str(left) + ","

for i in xrange(8):
if (i < amount):
line += chara
else:
line += charb
line += chr(97 + i)
line += ","

line += str(right) + "\n"

return line

def saveHandlePlumes(self):

comments = """
This post-processes the output of ClassifyObjects to remove any
unwanted clustering of low-period objects appearing in puffer
exhaust.

state 0: vacuum

state 7: ON, still-life
state 8: OFF, still-life

state 9: ON, p2 oscillator
state 10: OFF, p2 oscillator

state 11: ON, higher-period object
state 12: OFF, higher-period object
"""
table = """
n_states:17
neighborhood:Moore
symmetries:permute

var da={0,2,4,6,8,10,12,14,16}
var db={0,2,4,6,8,10,12,14,16}
var dc={0,2,4,6,8,10,12,14,16}
var dd={0,2,4,6,8,10,12,14,16}
var de={0,2,4,6,8,10,12,14,16}
var df={0,2,4,6,8,10,12,14,16}
var dg={0,2,4,6,8,10,12,14,16}
var dh={0,2,4,6,8,10,12,14,16}

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

8,da,db,dc,dd,de,df,dg,dh,0
10,da,db,dc,dd,de,df,dg,dh,0

9,a,b,c,d,e,f,g,h,1
10,a,b,c,d,e,f,g,h,2
"""
colours = """
1 255 255 255
2 127 127 127
7 0 0 255
8 0 0 127
9 255 0 0
10 127 0 0
11 0 255 0
12 0 127 0
"""
self.saverule("APG_HandlePlumesCorrected", comments, table, colours)

def saveExpungeGliders(self):

comments = """
This removes unwanted gliders.
It is mandatory that one first runs the rules CoalesceObjects,
IdentifyGliders and ClassifyObjects.

Run this for two generations, and observe the population
counts after 1 and 2 generations. This will give the
following data:

number of gliders = (p(1) - p(2))/5
"""
table = """
n_states:17
neighborhood:Moore
symmetries:rotate4reflect

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

13,a,b,c,d,e,f,g,h,14
14,a,b,c,d,e,f,g,h,0
"""
colours = """
0 0 0 0
1 255 255 255
2 127 127 127
7 0 0 255
8 0 0 127
9 255 0 0
10 127 0 0
11 0 255 0
12 0 127 0
13 255 255 0
14 127 127 0
"""
self.saverule("APG_ExpungeGliders", comments, table, colours)

def saveIdentifyGliders(self):

comments = """
Run this after CoalesceObjects to find any gliders.

state 0: vacuum
state 1: ON
state 2: OFF
"""
table = """
n_states:17
neighborhood:Moore
symmetries:rotate4reflect

var a={0,2}
var b={0,2}
var c={0,2}
var d={0,2}
var e={0,2}
var f={0,2}
var g={0,2}
var h={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var i={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var j={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var k={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var l={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var m={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var n={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var o={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var p={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var q={3,4}
var r={9,10}
var s={11,12}

1,1,a,1,1,b,1,c,d,3
d,1,1,1,1,a,b,1,c,4

3,i,j,k,l,m,n,o,p,5
4,i,j,k,l,m,n,o,p,6

1,q,i,j,a,b,c,k,l,7
d,q,i,j,a,b,c,k,l,8
1,i,a,b,c,d,e,j,q,7
f,i,a,b,c,d,e,j,q,8

5,7,8,7,7,8,7,8,8,9
6,7,7,7,7,8,8,7,8,10
5,i,j,k,l,m,n,o,p,15
6,i,j,k,l,m,n,o,p,16
15,i,j,k,l,m,n,o,p,1
16,i,j,k,l,m,n,o,p,2

7,i,j,k,l,m,n,o,p,11
8,i,j,k,l,m,n,o,p,12

9,i,j,k,l,m,n,o,p,13
10,i,j,k,l,m,n,o,p,14
11,r,j,k,l,m,n,o,p,13
11,i,r,k,l,m,n,o,p,13
12,r,j,k,l,m,n,o,p,14
12,i,r,k,l,m,n,o,p,14

11,i,j,k,l,m,n,o,p,1
12,i,j,k,l,m,n,o,p,2
"""
colours = """
0 0 0 0
1 255 255 255
2 127 127 127
7 0 0 255
8 0 0 127
9 255 0 0
10 127 0 0
11 0 255 0
12 0 127 0
13 255 255 0
14 127 127 0
"""
self.saverule("APG_IdentifyGliders", comments, table, colours)

def saveEradicateInfection(self):

comments = """
To run after ContagiousLife to disinfect any cells in states 3 or 4.

state 0: vacuum
state 1: ON
state 2: OFF
"""
table = """
n_states:7
neighborhood:Moore
symmetries:permute

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

4,a,b,c,d,e,f,g,h,6
3,a,b,c,d,e,f,g,h,5
"""
colours = """
0 0 0 0
1 0 0 255
2 0 0 127
3 255 0 0
4 127 0 0
5 0 255 0
6 0 127 0
"""
self.saverule("APG_EradicateInfection", comments, table, colours)

def savePercolateInfection(self):

comments = """
Percolates any infection to all cells of that particular island.

state 0: vacuum
state 1: ON
state 2: OFF
"""
table = """
n_states:7
neighborhood:Moore
symmetries:permute

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

var q={3,4}
var da={2,4,6}
var la={1,3,5}

da,q,b,c,d,e,f,g,h,4
la,q,b,c,d,e,f,g,h,3
"""
colours = """
0 0 0 0
1 0 0 255
2 0 0 127
3 255 0 0
4 127 0 0
5 0 255 0
6 0 127 0
"""
self.saverule("APG_PercolateInfection", comments, table, colours)

def saveExpungeObjects(self):

comments = """
This removes unwanted monominos, blocks, blinkers and beehives.
It is mandatory that one first runs the rule ClassifyObjects.

Run this for four generations, and observe the population
counts after 0, 1, 2, 3 and 4 generations. This will give the
following data:

number of monominos = p(1) - p(0)
number of blocks = (p(2) - p(1))/4
number of blinkers = (p(3) - p(2))/5
number of beehives = (p(4) - p(3))/8
"""
table = "n_states:17\n"
table += "neighborhood:Moore\n"
table += "symmetries:rotate4reflect\n\n"

table += self.newvars(["a","b","c","d","e","f","g","h","i"], range(0, 17, 1))

table += """
# Monomino
7,0,0,0,0,0,0,0,0,0

# Death
6,a,b,c,d,e,f,g,h,0
a,6,b,c,d,e,f,g,h,0

# Block
7,7,7,7,0,0,0,0,0,1
1,1,1,1,0,0,0,0,0,0
1,a,b,c,d,e,f,g,h,7

# Blinker
10,0,0,0,9,9,9,0,0,2
9,9,10,0,0,0,0,0,10,3
2,a,b,c,d,e,f,g,h,10
3,a,b,c,d,e,f,g,h,9
9,2,0,3,0,2,0,3,0,6

# Beehive
7,0,7,8,7,0,0,0,0,1
7,0,0,7,8,8,7,0,0,1
8,7,7,8,7,7,0,7,0,4
4,1,1,4,1,1,0,1,0,5
4,a,b,c,d,e,f,g,h,8
5,5,b,c,d,e,f,g,h,6
5,a,b,c,d,e,f,g,h,15
15,a,b,c,d,e,f,g,h,8
"""

colours = """
0 0 0 0
1 255 255 255
2 127 127 127
7 0 0 255
8 0 0 127
9 255 0 0
10 127 0 0
11 0 255 0
12 0 127 0
13 255 255 0
14 127 127 0
"""
self.saverule("APG_ExpungeObjects", comments, table, colours)

def saveCoalesceObjects(self):

comments = """
A variant of HistoricalLife which separates a field of ash into
distinct objects.

state 0: vacuum
state 1: ON
state 2: OFF
"""
table = "n_states:3\n"
table += "neighborhood:Moore\n"
table += "symmetries:permute\n\n"

table += self.newvars(["a","b","c","d","e","f","g","h","i"], [0, 1, 2])
table += self.newvars(["da","db","dc","dd","de","df","dg","dh","di"], [0, 2])
table += self.newvars(["la","lb","lc","ld","le","lf","lg","lh","li"], [1])

minperc = 10

for i in xrange(9):
if (self.bee[i]):
if (minperc == 10):
minperc = i
table += self.scoline("l","d",0,1,i)
table += self.scoline("l","d",2,1,i)
if (self.ess[i]):
table += self.scoline("l","d",1,1,i)

table += "\n# Bridge inductors\n"

for i in xrange(9):
if (i >= minperc):
table += self.scoline("l","d",0,2,i)

table += self.scoline("","",1,2,0)

colours = """
0 0 0 0
1 255 255 255
2 127 127 127
"""
self.saverule("APG_CoalesceObjects_"+self.alphanumeric, comments, table, colours)

def saveClassifyObjects(self):

comments = """
This passively classifies objects as either still-lifes, p2 oscillators
or higher-period oscillators. It is mandatory that one first runs the
rule CoalesceObjects.

state 0: vacuum
state 1: input ON
state 2: input OFF

state 3: ON, will die
state 4: OFF, will remain off
state 5: ON, will survive
state 6: OFF, will become alive

state 7: ON, still-life
state 8: OFF, still-life

state 9: ON, p2 oscillator
state 10: OFF, p2 oscillator

state 11: ON, higher-period object
state 12: OFF, higher-period object
"""
table = "n_states:17\n"
table += "neighborhood:Moore\n"
table += "symmetries:permute\n\n"

table += self.newvars(["a","b","c","d","e","f","g","h","i"], range(0, 17, 1))
table += self.newvars(["la","lb","lc","ld","le","lf","lg","lh","li"], range(1, 17, 2))
table += self.newvars(["da","db","dc","dd","de","df","dg","dh","di"], range(0, 17, 2))
table += self.newvars(["pa","pb","pc","pd","pe","pf","pg","ph","pi"], [0, 3, 4])
table += self.newvars(["qa","qb","qc","qd","qe","qf","qg","qh","qi"], [5, 6])

for i in xrange(9):
if (self.bee[i]):
table += self.scoline("l","d",2,6,i)
table += self.scoline("q","p",3,9,i)
table += self.scoline("q","p",4,12,i)
if (self.ess[i]):
table += self.scoline("l","d",1,5,i)
table += self.scoline("q","p",5,7,i)
table += self.scoline("q","p",6,12,i)
table += self.scoline("","",2,4,0)
table += self.scoline("","",1,3,0)
table += self.scoline("","",5,11,0)
table += self.scoline("","",3,11,0)
table += self.scoline("","",4,8,0)
table += self.scoline("","",6,10,0)

table += """
# Propagate interestingness
7,11,b,c,d,e,f,g,h,11
7,12,b,c,d,e,f,g,h,11
7,9,b,c,d,e,f,g,h,9
7,10,b,c,d,e,f,g,h,9
8,11,b,c,d,e,f,g,h,12
8,12,b,c,d,e,f,g,h,12
8,9,b,c,d,e,f,g,h,10
8,10,b,c,d,e,f,g,h,10

7,13,b,c,d,e,f,g,h,11
7,14,b,c,d,e,f,g,h,11
8,13,b,c,d,e,f,g,h,14
8,14,b,c,d,e,f,g,h,14
9,13,b,c,d,e,f,g,h,11
9,14,b,c,d,e,f,g,h,11
10,13,b,c,d,e,f,g,h,14
10,14,b,c,d,e,f,g,h,14

9,11,b,c,d,e,f,g,h,11
9,12,b,c,d,e,f,g,h,11
10,11,b,c,d,e,f,g,h,12
10,12,b,c,d,e,f,g,h,12

13,11,b,c,d,e,f,g,h,11
13,12,b,c,d,e,f,g,h,11
14,11,b,c,d,e,f,g,h,12
14,12,b,c,d,e,f,g,h,12
13,9,b,c,d,e,f,g,h,11
14,9,b,c,d,e,f,g,h,12
"""

colours = """
0 0 0 0
1 255 255 255
2 127 127 127
7 0 0 255
8 0 0 127
9 255 0 0
10 127 0 0
11 0 255 0
12 0 127 0
13 255 255 0
14 127 127 0
"""
self.saverule("APG_ClassifyObjects_"+self.alphanumeric, comments, table, colours)

def saveContagiousLife(self):

comments = """
A variant of HistoricalLife used for detecting dependencies between
islands.

state 0: vacuum
state 1: ON
state 2: OFF
"""
table = "n_states:7\n"
table += "neighborhood:Moore\n"
table += "symmetries:permute\n\n"

table += self.newvars(["a","b","c","d","e","f","g","h","i"], range(0, 7, 1))
table += self.newvars(["la","lb","lc","ld","le","lf","lg","lh","li"], range(1, 7, 2))
table += self.newvars(["da","db","dc","dd","de","df","dg","dh","di"], range(0, 7, 2))
table += self.newvar("p",[3, 4])
table += self.newvars(["ta","tb","tc","td","te","tf","tg","th","ti"], [3])
table += self.newvars(["qa","qb","qc","qd","qe","qf","qg","qh","qi"], [0, 1, 2, 4, 5, 6])

for i in xrange(9):
if (self.bee[i]):
table += self.scoline("l","d",4,3,i)
table += self.scoline("l","d",2,1,i)
table += self.scoline("l","d",0,1,i)
table += self.scoline("l","d",6,5,i)
table += self.scoline("t","q",0,4,i)
if (self.ess[i]):
table += self.scoline("l","d",3,3,i)
table += self.scoline("l","d",5,5,i)
table += self.scoline("l","d",1,1,i)

table += "# Default behaviour (death):\n"
table += self.scoline("","",1,2,0)
table += self.scoline("","",5,6,0)
table += self.scoline("","",3,4,0)

colours = """
0 0 0 0
1 0 0 255
2 0 0 127
3 255 0 0
4 127 0 0
5 0 255 0
6 0 127 0
"""
self.saverule("APG_ContagiousLife_"+self.alphanumeric, comments, table, colours)

class Soup:

def __init__(self):

# The rule generator:
self.rg = RuleGenerator()

# Should we skip error-correction:
self.skipErrorCorrection = False

# A dict mapping binary representations of small possibly-pseudo-objects
# to their equivalent canonised representation.
#
# This is many-to-one, as (for example) all of these will map to
# the same pseudo-object (namely the beacon on block):
#
# ..**.** ..**.** **..... **.....
# ..**.** ...*.** **..... *......
# **..... *...... ..**... ...*.**
# **..... **..... ..**... [...12 others omitted...] ..**.**
# ....... ....... ....... .......
# ....... ....... ..**... .......
# ....... ....... ..**... .......
#
# The first few soups are much slower to process, as objects are being
# entered into the cache.
self.cache = {}

# A dict to store memoized decompositions of possibly-pseudo-objects
# into constituent parts. This is initialised with the unique minimal
# pseudo-still-life (two blocks on lock) that cannot be automatically
# separated by the routine pseudo_bangbang(). Any larger objects are
# ambiguous, such as this one:
#
# *
# * * **
# ** **
#
# * *** *
# ** * **
#
# Is it a (block on (lock on boat)) or ((block on lock) on boat)?
# Ahh, the joys of non-associativity.
#
# See http://paradise.caltech.edu/~cook/Workshop/CAs/2DOutTot/Life/StillLife/StillLifeTheory.html
self.decompositions = {"xs18_3pq3qp3": ["xs14_3123qp3", "xs4_33"]}

# A dict of objects in the form {"identifier": ("common name", points)}
#
# As a rough heuristic, an object is worth 15 + log2(n) points if it
# is n times rarer than the pentadecathlon.
#
# Still-lifes are limited to 10 points.
# p2 oscillators are limited to 20 points.
# p3 and p4 oscillators are limited to 30 points.
self.commonnames = {"xp3_co9nas0san9oczgoldlo0oldlogz1047210127401": ("pulsar", 8),
"xp15_4r4z4r4": ("pentadecathlon", 15),
"xp2_2a54": ("clock", 16),
"xp2_31ago": ("bipole", 17),
"xp2_0g0k053z32": ("quadpole", 18),
"xp2_g8gid1e8z1226": ("great on-off", 19),
"xp2_rhewehr": ("spark coil", 19),
"xp8_gk2gb3z11": ("figure-8", 20),
"xp4_37bkic": ("mold", 21),
"xp2_31a08zy0123cko": ("quadpole on ship", 20),
"xp2_g0k053z11": ("tripole", 20),
"xp4_ssj3744zw3": ("mazing", 23),
"xp8_g3jgz1ut": ("blocker", 24),
"xp3_695qc8zx33": ("jam", 24),
"xp30_w33z8kqrqk8zzzw33": ("cis-queen-bee-shuttle", 24),
"xp30_w33z8kqrqk8zzzx33": ("trans-queen-bee-shuttle", 24),
"xp4_8eh5e0e5he8z178a707a871": ("cloverleaf", 25),
"xp5_idiidiz01w1": ("octagon II", 26),
"xp6_ccb7w66z066": ("unix", 26),
"xp14_j9d0d9j": ("tumbler", 27),
"xp3_025qzrq221": ("trans-tub-eater", 28),
"xp3_4hh186z07": ("caterer", 29),
"xp3_025qz32qq1": ("cis-tub-eater", 30),
"xp8_wgovnz234z33": ("Tim Coe's p8", 31),
"xp5_3pmwmp3zx11": ("fumarole", 33),
"xp46_330279cx1aad3y833zx4e93x855bc": ("cis-twin-bees-shuttle", 35),
"xp46_330279cx1aad3zx4e93x855bcy8cc": ("trans-twin-bees-shuttle", 35),
"yl144_1_16_afb5f3db909e60548f086e22ee3353ac": ("block-laying switch engine", 16),
"yl384_1_59_7aeb1999980c43b4945fb7fcdb023326": ("glider-producing switch engine", 17),
"xp10_9hr": ("[HighLife] p10", 6),
"xp7_13090c8": ("[HighLife] p7", 9),
"xq48_07z8ca7zy1e531": ("[HighLife] bomber", 9),
"xq4_153": ("glider", 0),
"xq4_6frc": ("lightweight spaceship", 7),
"xq4_27dee6": ("middleweight spaceship", 9),
"xq4_27deee6": ("heavyweight spaceship", 12),
"xq7_3nw17862z6952": ("loafer", 70),
"xp2_7": ("blinker", 0),
"xs4_33": ("block", 0),
"xs4_252": ("tub", 0),
"xs5_253": ("boat", 0),
"xs6_bd": ("snake", 0),
"xs6_356": ("ship", 0),
"xs6_696": ("beehive", 0),
"xs6_25a4": ("barge", 0),
"xs6_39c": ("carrier", 0),
"xp2_7e": ("toad", 0),
"xp2_318c": ("beacon", 0),
"xs7_3lo": ("long snake", 0),
"xs7_25ac": ("long boat", 0),
"xs7_178c": ("eater", 0),
"xs7_2596": ("loaf", 0),
"xs8_178k8": ("twit", 0),
"xs8_32qk": ("hook with tail", 0),
"xs8_69ic": ("mango", 0),
"xs8_6996": ("pond", 0),
"xs8_25ak8": ("long barge", 0),
"xs8_3pm": ("shillelagh", 0),
"xs8_312ko": ("canoe", 0),
"xs8_31248c": ("very long snake", 0),
"xs8_35ac": ("long ship", 0),
"xs12_g8o653z11": ("ship-tie", 0),
"xs14_g88m952z121": ("half-bakery", 0),
"xs14_69bqic": ("paperclip", 0),
"xs9_31ego": ("integral sign", 0),
"xs10_g8o652z01": ("boat-tie", 0),
"xs14_g88b96z123": ("big ess", 0),
"xs16_g88m996z1221": ("bipond", 0),
"xs12_raar": ("table on table", 0),
"xs9_4aar": ("hat", 0),
"xs10_35ako": ("very long ship", 0),
"xs9_178ko": ("trans boat with tail", 0),
"xs15_354cgc453": ("moose antlers", 0),
"xs14_6970796": ("cis-mirrored r-bee", 0),
"xs10_32qr": ("block on table", 0),
"xs16_j1u0696z11": ("beehive on dock", 0),
"xs14_j1u066z11": ("block on dock", 0),
"xs11_g8o652z11": ("boat tie ship", 0),
"xs9_25ako": ("very long boat", 0),
"xs16_69egmiczx1": ("scorpion", 0),
"xs18_rhe0ehr": ("dead spark coil", 0),
"xs17_2ege1ege2": ("twinhat", 0),
"xs10_178kk8": ("beehive with tail", 0),
"xs10_69ar": ("loop", 0),
"xs14_69bo8a6": ("fourteener", 0),
"xs14_39e0e93": ("bookends", 0),
"xs9_178kc": ("cis boat with tail", 0),
"xs12_330f96": ("block and cap", 0),
"xs10_358gkc": ("10.003",0),
"xs12_330fho": ("trans block and longhook", 0),
"xs10_g0s252z11": ("prodigal sign", 0),
"xs11_g0s453z11": ("elevener", 0),
"xs14_6is079c": ("cis-rotated hook", 0),
"xs14_69e0eic": ("trans-mirrored R-bee", 0),
"xs11_ggm952z1": ("trans loaf with tail", 0),
"xs15_j1u06a4z11": ("cis boat and dock", 0),
"xs20_3lkkl3z32w23": ("mirrored dock", 0),
"xs12_178br": ("12.003",0),
"xs12_3hu066": ("cis block and longhook", 0),
"xs12_178c453": ("eater with nine", 0),
"xs10_0drz32": ("broken snake", 0),
"xs9_312453": ("long shillelagh", 0),
"xs10_3215ac": ("boat with long tail", 0),
"xs14_39e0e96": ("cis-hook and R-bee", 0),
"xs13_g88m96z121": ("beehive at loaf", 0),
"xs14_39e0eic": ("trans hook and R-bee", 0),
"xs10_3542ac": ("S-ten", 0),
"xs15_259e0eic": ("trans R-bee and R-loaf", 0),
"xs11_178jd": ("11-loop", 0),
"xs9_25a84c": ("tub with long tail", 0),
"xs15_3lkm96z01": ("bee-hat", 0),
"xs14_g8o0e96z121": ("cis-rotated R-bee", 0),
"xs13_69e0mq": ("R-bee and snake", 0),
"xs11_69lic": ("11.003", 0),
"xs12_6960ui": ("beehive and table", 0),
"xs16_259e0e952": ("cis-mirrored R-loaf", 0),
"xs10_1784ko": ("8-snake-eater", 0),
"xs13_4a960ui": ("ortho loaf and table", 0),
"xs9_g0g853z11": ("long canoe", 0),
"xs18_69is0si96": ("[cis-mirrored R-mango]", 0),
"xs11_178kic": ("cis loaf with tail", 0),
"xs16_69bob96": ("symmetric scorpion", 0),
"xs13_0g8o653z121": ("longboat on ship", 0),
"xs12_o4q552z01": ("beehive at beehive", 0),
"xs10_ggka52z1": ("trans barge with tail", 0),
"xs12_256o8a6": ("eater on boat", 0),
"xs14_6960uic": ("beehive with cap", 0),
"xs12_2egm93": ("snorkel loop", 0),
"xs12_2egm96": ("beehive bend tail", 0),
"xs11_g0s253z11": ("trans boat with nine", 0),
"xs15_3lk453z121": ("trans boat and dock", 0),
"xs19_69icw8ozxdd11": ("[mango with block on dock]", 0),
"xs13_2530f96": ("[cis boat and cap]", 0),
"xs11_2530f9": ("cis boat and table", 0),
"xs14_4a9m88gzx121": ("[bi-loaf2]", 0),
"xs11_ggka53z1": ("trans longboat with tail", 0),
"xs18_2egm9a4zx346": ("[loaf eater tail]", 0),
"xs15_4a9raic": ("[15-bent-paperclip]", 0),
"xs11_3586246": ("[11-snake]",0),
"xs11_178b52": ("[11-boat wrap tail]", 0),
"xs14_08u1e8z321": ("[hat join hook]", 0),
"xs14_g4s079cz11": ("[cis-mirrored offset hooks]", 0),
"xs13_31egma4": ("[13-boat wrap eater]", 0),
"xs14_69960ui": ("pond and table", 0),
"xs13_255q8a6": ("[eater tie beehive]", 0),
"xs15_09v0ccz321": ("[hook join table and block]",0)}

# First soup to contain a particular object:
self.alloccur = {}

# A tally of objects that have occurred during this run of apgsearch:
self.objectcounts = {}

# Any soups with positive scores, and the number of points.
self.soupscores = {}

# Temporary list of unidentified objects:
self.unids = []

# Things like glider guns and large oscillators belong here:
self.superunids = []
self.gridsize = 0
self.resets = 0

# For profiling purposes:
self.qlifetime = 0.0
self.ruletime = 0.0
self.gridtime = 0.0

# Increment object count by given value:
def incobject(self, obj, incval):
if (incval > 0):
if obj in self.objectcounts:
self.objectcounts[obj] = self.objectcounts[obj] + incval
else:
self.objectcounts[obj] = incval

# Increment soup score by given value:
def awardpoints(self, soupid, incval):
if (incval > 0):
if soupid in self.soupscores:
self.soupscores[soupid] = self.soupscores[soupid] + incval
else:
self.soupscores[soupid] = incval

# Increment soup score by appropriate value:
def awardpoints2(self, soupid, obj):

# Record the occurrence of this object:
if (obj in self.alloccur):
if (len(self.alloccur[obj]) < 10):
if (soupid not in self.alloccur[obj]):
self.alloccur[obj] += [soupid]
else:
self.alloccur[obj] = [soupid]

if obj in self.commonnames:
self.awardpoints(soupid, self.commonnames[obj][1])
elif (obj[0] == 'x'):
prefix = obj.split('_')[0]
prenum = int(prefix[2:])
if (obj[1] == 's'):
self.awardpoints(soupid, min(prenum, 20)) # for still-lifes, award one point per constituent cell (max 20)
elif (obj[1] == 'p'):
if (prenum == 2):
self.awardpoints(soupid, 20) # p2 oscillators are limited to 20 points
elif ((prenum == 3) | (prenum == 4)):
self.awardpoints(soupid, 30) # p3 and p4 oscillators are limited to 30 points
else:
self.awardpoints(soupid, 40)
else:
self.awardpoints(soupid, 50)
else:
self.awardpoints(soupid, 60)

# Assuming the pattern has stabilised, perform a census:
def census(self, stepsize):

g.setrule("APG_CoalesceObjects_" + self.rg.alphanumeric)
g.setbase(2)
g.setstep(stepsize)
g.step()

# apgsearch theoretically supports up to 2^14 rules, whereas the Guy
# glider is only stable in 2^8 rules. Ensure that this is one of these
# rules by doing some basic Boolean arithmetic.
#
# This should be parsed as `gliders exist', not `glider sexist':
glidersexist = self.rg.ess[2] & self.rg.ess[3] & (not self.rg.ess[1]) & (not self.rg.ess[4])
glidersexist = glidersexist & (not (self.rg.bee[4] | self.rg.bee[5]))

if (glidersexist):
g.setrule("APG_IdentifyGliders")
g.setbase(2)
g.setstep(2)
g.step()

g.setrule("APG_ClassifyObjects_" + self.rg.alphanumeric)
g.setbase(2)
g.setstep(max(8, stepsize))
g.step()

# Only do this if we have an infinite-growth pattern:
if (stepsize > 8):
g.setrule("APG_HandlePlumesCorrected")
g.setbase(2)
g.setstep(1)
g.step()
g.setrule("APG_ClassifyObjects_" + self.rg.alphanumeric)
g.setstep(stepsize)
g.step()

# Remove any gliders:
if (glidersexist):
g.setrule("APG_ExpungeGliders")
g.run(1)
pop5 = int(g.getpop())
g.run(1)
pop6 = int(g.getpop())
self.incobject("xq4_153", (pop5 - pop6)/5)

# Remove any blocks, blinkers and beehives:
g.setrule("APG_ExpungeObjects")
pop0 = int(g.getpop())
g.run(1)
pop1 = int(g.getpop())
g.run(1)
pop2 = int(g.getpop())
g.run(1)
pop3 = int(g.getpop())
g.run(1)
pop4 = int(g.getpop())

# Blocks, blinkers and beehives removed by ExpungeObjects:
self.incobject("xs1_1", (pop0-pop1))
self.incobject("xs4_33", (pop1-pop2)/4)
self.incobject("xp2_7", (pop2-pop3)/5)
self.incobject("xs6_696", (pop3-pop4)/8)

# Removes an object incident with (ix, iy) and returns the cell list:
def grabobj(self, ix, iy):

allcells = [ix, iy, g.getcell(ix, iy)]
g.setcell(ix, iy, 0)
livecells = []
deadcells = []

marker = 0
ll = 3

while (marker < ll):
x = allcells[marker]
y = allcells[marker+1]
z = allcells[marker+2]
marker += 3

if ((z % 2) == 1):
livecells.append(x)
livecells.append(y)
else:
deadcells.append(x)
deadcells.append(y)

for nx in xrange(x - 1, x + 2):
for ny in xrange(y - 1, y + 2):

nz = g.getcell(nx, ny)
if (nz > 0):
allcells.append(nx)
allcells.append(ny)
allcells.append(nz)
g.setcell(nx, ny, 0)
ll += 3

return livecells

# Command to Grab, Remove and IDentify an OBJect:
def gridobj(self, ix, iy, gsize, gspacing, pos):

allcells = [ix, iy, g.getcell(ix, iy)]
g.setcell(ix, iy, 0)
livecells = []
deadcells = []

# This tacitly assumes the object is smaller than 1000-by-1000.
# But this is okay, since it is only used by the routing logic.
dleft = ix + 1000
dright = ix - 1000
dtop = iy + 1000
dbottom = iy - 1000

lleft = ix + 1000
lright = ix - 1000
ltop = iy + 1000
lbottom = iy - 1000

lpop = 0
dpop = 0

marker = 0
ll = 3

while (marker < ll):
x = allcells[marker]
y = allcells[marker+1]
z = allcells[marker+2]
marker += 3

if ((z % 2) == 1):
livecells.append(x)
livecells.append(y)
lleft = min(lleft, x)
lright = max(lright, x)
ltop = min(ltop, y)
lbottom = max(lbottom, y)
lpop += 1
else:
deadcells.append(x)
deadcells.append(y)
dleft = min(dleft, x)
dright = max(dright, x)
dtop = min(dtop, y)
dbottom = max(dbottom, y)
dpop += 1

for nx in xrange(x - 1, x + 2):
for ny in xrange(y - 1, y + 2):

nz = g.getcell(nx, ny)
if (nz > 0):
allcells.append(nx)
allcells.append(ny)
allcells.append(nz)
g.setcell(nx, ny, 0)
ll += 3

lwidth = max(0, 1 + lright - lleft)
lheight = max(0, 1 + lbottom - ltop)
dwidth = max(0, 1 + dright - dleft)
dheight = max(0, 1 + dbottom - dtop)

llength = max(lwidth, lheight)
lbreadth = min(lwidth, lheight)
dlength = max(dwidth, dheight)
dbreadth = min(dwidth, dheight)

self.gridsize = max(self.gridsize, llength)

objid = "unidentified"
bitstring = 0

if (lpop == 0):
objid = "nothing"
else:
if ((lwidth <= 7) & (lheight <= 7)):
for i in xrange(0, lpop*2, 2):
bitstring += (1 << ((livecells[i] - lleft) + 7*(livecells[i + 1] - ltop)))

if bitstring in self.cache:
objid = self.cache[bitstring]

if (objid == "unidentified"):
# This has passed through the routing logic without being identified,
# so save it in a temporary list for later identification:
self.unids.append(bitstring)
self.unids.append(livecells)
self.unids.append(lleft)
self.unids.append(ltop)
elif (objid != "nothing"):
# The object is non-empty, so add it to the census:
ux = int(0.5 + float(lleft)/float(gspacing))
uy = int(0.5 + float(ltop)/float(gspacing))
soupid = ux + (uy * gsize) + pos

# Check whether the cached object is in the set of decompositions
# (this is usually the case, unless for example it is a high-period
# albeit small spaceship):
if objid in self.decompositions:
for comp in self.decompositions[objid]:
self.incobject(comp, 1)
self.awardpoints2(soupid, comp)
else:
self.incobject(objid, 1)
self.awardpoints2(soupid, objid)

# Tests for population periodicity:
def naivestab(self, period, security, length):

depth = 0
prevpop = 0
for i in xrange(length):
g.run(period)
currpop = int(g.getpop())
if (currpop == prevpop):
depth += 1
else:
depth = 0
prevpop = currpop
if (depth == security):
# Population is periodic.
return True

return False

# This should catch most short-lived soups with few gliders produced:
def naivestab2(self, period, length):

for i in xrange(length):
r = g.getrect()
if (len(r) == 0):
return True
pop0 = int(g.getpop())
g.run(period)
hash1 = g.hash(r)
pop1 = int(g.getpop())
g.run(period)
hash2 = g.hash(r)
pop2 = int(g.getpop())

if ((hash1 == hash2) & (pop0 == pop1) & (pop1 == pop2)):

if (g.getrect() == r):
return True

g.run((2*int(max(r[2], r[3])/period)+1)*period)
hash3 = g.hash(r)
pop3 = int(g.getpop())
if ((hash2 == hash3) & (pop2 == pop3)):
return True

return False

# Runs a pattern until stabilisation with a 99.99996% success rate.
# False positives are handled by a later error-correction stage.
def stabilise3(self):

# Phase I of stabilisation detection, designed to weed out patterns
# that stabilise into a cluster of low-period oscillators within
# about 6000 generations.

if (self.naivestab2(12, 10)):
return 4;

if (self.naivestab(12, 30, 200)):
return 4;

if (self.naivestab(30, 30, 200)):
return 5;

# Phase II of stabilisation detection, which is much more rigorous
# and based on oscar.py.

# Should be sufficient:
prect = [-2000, -2000, 4000, 4000]

# initialize lists
hashlist = [] # for pattern hash values
genlist = [] # corresponding generation counts

for j in xrange(4000):

g.run(30)

h = g.hash(prect)

# determine where to insert h into hashlist
pos = 0
listlen = len(hashlist)
while pos < listlen:
if h > hashlist[pos]:
pos += 1
elif h < hashlist[pos]:
# shorten lists and append info below
del hashlist[pos : listlen]
del genlist[pos : listlen]
break
else:
period = (int(g.getgen()) - genlist[pos])

prevpop = g.getpop()

for i in xrange(20):
g.run(period)
currpop = g.getpop()
if (currpop != prevpop):
period = max(period, 4000)
break
prevpop = currpop

return max(1 + int(math.log(period, 2)),3)

hashlist.insert(pos, h)
genlist.insert(pos, int(g.getgen()))

g.setalgo("HashLife")
g.setrule(self.rg.slashed)
g.setbase(2)
g.setstep(16)
g.step()
stepsize = 12
g.setalgo("QuickLife")
g.setrule(self.rg.slashed)

return 12

# Differs from oscar.py in that it detects absolute cycles, not eventual cycles.
def bijoscar(self, maxsteps):

initpop = int(g.getpop())
initrect = g.getrect()
if (len(initrect) == 0):
return 0
inithash = g.hash(initrect)

for i in xrange(maxsteps):

g.run(1)

if (int(g.getpop()) == initpop):

prect = g.getrect()
phash = g.hash(prect)

if (phash == inithash):

period = i + 1

if (prect == initrect):
return period
else:
return -period
return -1

# For a non-moving unidentified object, we check the dictionary of
# memoized decompositions of possibly-pseudo-objects. If the object is
# not already in the dictionary, it will be memoized.
#
# Low-period spaceships are also separated by this routine, although
# this is less important now that there is a more bespoke prodecure
# to handle disjoint unions of standard spaceships.
#
# @param moving a bool which specifies whether the object is moving
def enter_unid(self, unidname, soupid, moving):

if not(unidname in self.decompositions):

# Separate into pure components:
if (moving):
g.setrule("APG_CoalesceObjects_" + self.rg.alphanumeric)
g.setbase(2)
g.setstep(3)
g.step()
else:
pseudo_bangbang(self.rg.alphanumeric)

listoflists = [] # which incidentally don't contain themselves.

# Someone who plays the celllo:
celllist = g.join(g.getcells(g.getrect()), [0])

for i in xrange(0, len(celllist)-1, 3):
if (g.getcell(celllist[i], celllist[i+1]) != 0):
livecells = self.grabobj(celllist[i], celllist[i+1])
if (len(livecells) > 0):
listoflists.append(livecells)

listofobjs = []

for livecells in listoflists:

g.new("Subcomponent")
g.setalgo("QuickLife")
g.setrule(self.rg.slashed)
g.putcells(livecells)
period = self.bijoscar(1000)
canonised = canonise(abs(period))
if (period < 0):
listofobjs.append("xq"+str(0-period)+"_"+canonised)
elif (period == 1):
listofobjs.append("xs"+str(len(livecells)/2)+"_"+canonised)
else:
listofobjs.append("xp"+str(period)+"_"+canonised)

self.decompositions[unidname] = listofobjs

# Actually add to the census:
for comp in self.decompositions[unidname]:
self.incobject(comp, 1)
self.awardpoints2(soupid, comp)

# This function has lots of arguments (hence the name):
#
# @param gsize the square-root of the number of soups per page
# @param gspacing the minimum distance between centres of soups
# @param ashes a list of cell lists
# @param stepsize binary logarithm of amount of time to coalesce objects
# @param intergen binary logarithm of amount of time to run HashLife
# @param pos the index of the first soup on the page
def teenager(self, gsize, gspacing, ashes, stepsize, intergen, pos):

# For error-correction:
if (intergen > 0):
g.setalgo("HashLife")
g.setrule(self.rg.slashed)

# If this gets incremented, we panic and perform error-correction:
pathological = 0

# Draw the soups:
for i in xrange(gsize * gsize):

x = int(i % gsize)
y = int(i / gsize)

g.putcells(ashes[3*i], gspacing * x, gspacing * y)

# Because why not?
g.fit()
g.update()

# For error-correction:
if (intergen > 0):
g.setbase(2)
g.setstep(intergen)
g.step()

# Apply rules to coalesce objects and expunge annoyances such as
# blocks, blinkers, beehives and gliders:
start_time = time.clock()
self.census(stepsize)
end_time = time.clock()
self.ruletime += (end_time - start_time)

# Now begin identifying objects:
start_time = time.clock()
celllist = g.join(g.getcells(g.getrect()), [0])

if (len(celllist) > 2):
for i in xrange(0, len(celllist)-1, 3):
if (g.getcell(celllist[i], celllist[i+1]) != 0):
self.gridobj(celllist[i], celllist[i+1], gsize, gspacing, pos)

# If we have leftover unidentified objects, attempt to canonise them:
while (len(self.unids) > 0):
ux = int(0.5 + float(self.unids[-2])/float(gspacing))
uy = int(0.5 + float(self.unids[-1])/float(gspacing))
soupid = ux + (uy * gsize) + pos
unidname = self.process_unid()
if (unidname == "PATHOLOGICAL"):
pathological += 1
if (unidname != "nothing"):

if ((unidname[0] == 'U') & (unidname[1] == 'S') & (unidname[2] == 'S')):

# Union of standard spaceships:
countlist = unidname.split('_')

self.incobject("xq4_6frc", int(countlist[1]))
for i in xrange(int(countlist[1])):
self.awardpoints2(soupid, "xq4_6frc")

self.incobject("xq4_27dee6", int(countlist[2]))
for i in xrange(int(countlist[2])):
self.awardpoints2(soupid, "xq4_27dee6")

self.incobject("xq4_27deee6", int(countlist[3]))
for i in xrange(int(countlist[3])):
self.awardpoints2(soupid, "xq4_27deee6")

elif ((unidname[0] == 'x') & ((unidname[1] == 's') | (unidname[1] == 'p'))):
self.enter_unid(unidname, soupid, False)
else:
if ((unidname[0] == 'x') & (unidname[1] == 'q') & (unidname[3] == '_')):
# Separates low-period (<= 9) non-standard spaceships in medium proximity:
self.enter_unid(unidname, soupid, True)
else:
self.incobject(unidname, 1)
self.awardpoints2(soupid, unidname)

end_time = time.clock()
self.gridtime += (end_time - start_time)

return pathological

def stabilise_soups_parallel(self, root, pos, gsize, sym):

souplist = [[sym, root + str(pos + i)] for i in xrange(gsize * gsize)]

return self.stabilise_soups_parallel_orig(gsize, souplist, pos)

def stabilise_soups_parallel_list(self, gsize, stringlist, pos):

souplist = [s.split('/') for s in stringlist]

return self.stabilise_soups_parallel_orig(gsize, souplist, pos)

# This basically orchestrates everything:
def stabilise_soups_parallel_orig(self, gsize, souplist, pos):

ashes = []
stepsize = 3

g.new("Random soups")
g.setalgo("QuickLife")
g.setrule(self.rg.slashed)

gspacing = 0

# Generate and run the soups until stabilisation:
for i in xrange(gsize * gsize):

if (i < len(souplist)):

sym = souplist[i][0]
prehash = souplist[i][1]

# Generate the soup from the SHA-256 of the concatenation of the
# seed with the index:
g.putcells(hashsoup(prehash, sym), 0, 0)

# Run the soup until stabilisation:
start_time = time.clock()
stepsize = max(stepsize, self.stabilise3())
end_time = time.clock()
self.qlifetime += (end_time - start_time)

# Ironically, the spelling of this variable is incurrrect:
currrect = g.getrect()
ashes.append(g.getcells(currrect))

if (len(currrect) == 4):
ashes.append(currrect[0])
ashes.append(currrect[1])
# Choose the grid spacing based on the size of the ash:
gspacing = max(gspacing, 2*currrect[2])
gspacing = max(gspacing, 2*currrect[3])
g.select(currrect)
g.clear(0)
else:
ashes.append(0)
ashes.append(0)
g.select([])

# Account for any extra enlargement caused by running CoalesceObjects:
gspacing += 2 ** (stepsize + 1) + 1000

start_time = time.clock()

# Remember the dictionary, just in case we have a pathological object:
prevdict = self.objectcounts.copy()
prevscores = self.soupscores.copy()
prevunids = self.superunids[:]

# Process the soups:
returncode = self.teenager(gsize, gspacing, ashes, stepsize, 0, pos)

end_time = time.clock()

# Calculate the mean delay incurred (excluding qlifetime or error-correction):
meandelay = (end_time - start_time) / (gsize * gsize)

if (returncode > 0):
if (self.skipErrorCorrection == False):
# Arrrggghhhh, there's a pathological object! Usually this means
# that naive stabilisation detection returned a false positive.
self.resets += 1

# Reset the object counts:
self.objectcounts = prevdict
self.soupscores = prevscores
self.superunids = prevunids

# 2^18 generations should suffice. This takes about 30 seconds in
# HashLife, but error-correction only occurs very infrequently, so
# this has a negligible impact on mean performance:
gspacing += 2 ** 19
stepsize = max(stepsize, 12)

# Clear the universe:
g.new("Error-correcting phase")
self.teenager(gsize, gspacing, ashes, stepsize, 18, pos)

# Erase any ashes. Not least because England usually loses...
ashes = []

# Return the mean delay so that we can use machine-learning to
# find the optimal value of sqrtspp:
return meandelay

def reset(self):

self.objectcounts = {}
self.soupscores = {}
self.alloccur = {}
self.superunids = []
self.unids = []

# Pop the last unidentified object from the stack, and attempt to
# ascertain its period and classify it.
def process_unid(self):

g.new("Unidentified object")
g.setalgo("QuickLife")
g.setrule(self.rg.slashed)
y = self.unids.pop()
x = self.unids.pop()
livecells = self.unids.pop()
bitstring = self.unids.pop()
g.putcells(livecells, -x, -y, 1, 0, 0, 1, "or")
period = self.bijoscar(1000)

if (period == -1):
# Infinite growth pattern, probably. Most infinite-growth
# patterns are linear-growth (such as puffers, wickstretchers,
# guns etc.) so we analyse to see whether we have a linear-
# growth pattern:
descriptor = linearlyse(1500)
if (descriptor[0] == "y"):
return descriptor

# Similarly check for irregular power-law growth. This will
# catch replicators, for instance. Spend around 375 000
# generations; this seems like a reasonable amount of time.
descriptor = powerlyse(8, 1500)
if (descriptor[0] == "z"):
return descriptor

# It may be an unstabilised ember that slipped through the net,
# but this will be handled by error-correction (unless it
# persists another 2^18 gens, which is so unbelievably improbable
# that you are more likely to be picked up by a passing ship in
# the vacuum of space).
self.superunids.append(livecells)
self.superunids.append(x)
self.superunids.append(y)

return "PATHOLOGICAL"
elif (period == 0):
return "nothing"
else:
if (period == -4):

triple = countxwsses()

if (triple != (-1, -1, -1)):

# Union of Standard Spaceships:
return ("USS_" + str(triple[0]) + "_" + str(triple[1]) + "_" + str(triple[2]))

canonised = canonise(abs(period))

if (canonised == "#"):

# Okay, we know that it's an oscillator or spaceship with
# a non-astronomical period. But it's too large to canonise
# in any of its phases (i.e. transcends a 40-by-40 box).
self.superunids.append(livecells)
self.superunids.append(x)
self.superunids.append(y)

# Append a suffix according to whether it is a still-life,
# oscillator or moving object:
if (period == 1):
descriptor = ("ov_s"+str(len(livecells)/2))
elif (period > 0):
descriptor = ("ov_p"+str(period))
else:
descriptor = ("ov_q"+str(0-period))

return descriptor

else:

# Prepend a prefix according to whether it is a still-life,
# oscillator or moving object:
if (period == 1):
descriptor = ("xs"+str(len(livecells)/2)+"_"+canonised)
elif (period > 0):
descriptor = ("xp"+str(period)+"_"+canonised)
else:
descriptor = ("xq"+str(0-period)+"_"+canonised)

if (bitstring > 0):
self.cache[bitstring] = descriptor

return descriptor

# This doesn't really do much, since unids should be empty and
# actual pathological/oversized objects will rarely arise naturally.
def display_unids(self):

g.new("Unidentified objects")
g.setalgo("QuickLife")
g.setrule(self.rg.slashed)

rowlength = 1 + int(math.sqrt(len(self.superunids)/3))

for i in xrange(len(self.superunids)/3):

xpos = i % rowlength
ypos = int(i / rowlength)

g.putcells(self.superunids[3*i], xpos * (self.gridsize + 8) - self.superunids[3*i + 1], ypos * (self.gridsize + 8) - self.superunids[3*i + 2], 1, 0, 0, 1, "or")

g.fit()
g.update()

def compactify_scores(self):

# Number of soups to record:
highscores = 100
ilist = sorted(self.soupscores.iteritems(), key=operator.itemgetter(1), reverse=True)

# Empty the high score table:
self.soupscores = {}

for soupnum, score in ilist[:highscores]:
self.soupscores[soupnum] = score

# Saves a machine-readable textual file containing the census:
def save_progress(self, numsoups, root, symmetry='C1', save_file=True, payosha256_key=None):

g.show("Saving progress...")

# Count the total number of objects:
totobjs = 0
censustable = "@CENSUS TABLE\n"
tlist = sorted(self.objectcounts.iteritems(), key=operator.itemgetter(1), reverse=True)
for objname, count in tlist:
totobjs += count
censustable += objname + " " + str(count) + "\n"

g.show("Writing header information...")

# The MD5 hash of the root string:
md5root = hashlib.md5(root).hexdigest()

# Header information:
results = "@VERSION v1.1\n"
results += "@MD5 "+md5root+"\n"
results += "@ROOT "+root+"\n"
results += "@RULE "+self.rg.alphanumeric+"\n"
results += "@SYMMETRY "+symmetry+"\n"
results += "@NUM_SOUPS "+str(numsoups)+"\n"
results += "@NUM_OBJECTS "+str(totobjs)+"\n"

results += "\n"

# Census table:
results += censustable

g.show("Compactifying score table...")

results += "\n"

# Number of soups to record:
highscores = 100

results += "@TOP "+str(highscores)+"\n"

ilist = sorted(self.soupscores.iteritems(), key=operator.itemgetter(1), reverse=True)

# Empty the high score table:
self.soupscores = {}

for soupnum, score in ilist[:highscores]:
self.soupscores[soupnum] = score
results += str(soupnum) + " " + str(score) + "\n"

g.show("Saving soupids for rare objects...")

results += "\n@SAMPLE_SOUPIDS\n"
for objname, count in tlist:
# blinkers and gliders have no alloccur[] entry for some reason,
# so the line below avoids errors in B3/S23, maybe other rules too?
if objname in self.alloccur:
results += objname
for soup in self.alloccur[objname]:
results += " " + str(soup)
results += "\n"

g.show("Writing progress file...")

dirname = g.getdir("data")
separator = dirname[-1]
progresspath = dirname + "apgsearch" + separator + "progress" + separator
if not os.path.exists(progresspath):
os.makedirs(progresspath)

filename = progresspath + "search_" + md5root + ".txt"

try:
f = open(filename, 'w')
f.write(results)
f.close()
except:
g.warn("Unable to create progress file:\n" + filename)

if payosha256_key is not None:
if (len(payosha256_key) > 0):
return catagolue_results(results, payosha256_key, "post_apgsearch_haul")

# Save soup RLE:
def save_soup(self, root, soupnum, symmetry):

# Soup pattern will be stored in a temporary directory:
souphash = hashlib.sha256(root + str(soupnum))
rlepath = souphash.hexdigest()
rlepath = g.getdir("temp") + rlepath + ".rle"

results = "<a href=\"open:" + rlepath + "\">"
results += str(soupnum)
results += "</a>"

# Try to write soup patterns to file "rlepath":
try:
g.store(hashsoup(root + str(soupnum), symmetry), rlepath)
except:
g.warn("Unable to create soup pattern:\n" + rlepath)

return results

# Display results in Help window:
def display_census(self, numsoups, root, symmetry):

dirname = g.getdir("data")
separator = dirname[-1]
apgpath = dirname + "apgsearch" + separator
objectspath = apgpath + "objects" + separator + self.rg.alphanumeric + separator
if not os.path.exists(objectspath):
os.makedirs(objectspath)

results = "<html>\n<title>Census results</title>\n<body bgcolor=\"#FFFFCE\">\n"
results += "Census results after processing " + str(numsoups) + " soups (seed = " + root + ", symmetry = " + symmetry + "):\n"

tlist = sorted(self.objectcounts.iteritems(), key=operator.itemgetter(1), reverse=True)
results += "<center>\n"
results += "<table cellspacing=1 border=2 cols=2>\n"
results += "<tr><td> Object </td><td align=center> Common name </td>\n"
results += "<td align=right> Count </td><td> Sample occurrences </td></tr>\n"
for objname, count in tlist:
if (objname[0] == 'x'):
if (objname[1] == 'p'):
results += "<tr bgcolor=\"#CECECF\">"
elif (objname[1] == 'q'):
results += "<tr bgcolor=\"#CEFFCE\">"
else:
results += "<tr>"
else:
results += "<tr bgcolor=\"#FFCECE\">"
results += "<td>"
results += " "

# Using "open:" link enables one to click on the object name to open the pattern in Golly:
rlepath = objectspath + objname + ".rle"
if (objname[0] == 'x'):
results += "<a href=\"open:" + rlepath + "\">"
# If the name is longer than that of the block-laying switch engine:
if len(objname) > 51:
# Contract name and include ellipsis:
results += objname[:40] + "…" + objname[-10:]
else:
results += objname
if (objname[0] == 'x'):
results += "</a>"
results += " "

if (objname[0] == 'x'):
# save object in rlepath if it doesn't exist
if not os.path.exists(rlepath):
# Canonised objects are at most 40-by-40:
rledata = "x = 40, y = 40, rule = " + self.rg.slashed + "\n"
# http://ferkeltongs.livejournal.com/15837.html
compact = objname.split('_')[1] + "z"
i = 0
strip = []
while (i < len(compact)):
c = ord2(compact[i])
if (c >= 0):
if (c < 32):
# Conventional character:
strip.append(c)
else:
if (c == 35):
# End of line:
if (len(strip) == 0):
strip.append(0)
for j in xrange(5):
for d in strip:
if ((d & (1 << j)) > 0):
rledata += "o"
else:
rledata += "b"
rledata += "$\n"
strip = []
else:
# Multispace character:
strip.append(0)
strip.append(0)
if (c >= 33):
strip.append(0)
if (c == 34):
strip.append(0)
i += 1
d = ord2(compact[i])
for j in xrange(d):
strip.append(0)
i += 1
# End of pattern representation:
rledata += "!\n"
try:
f = open(rlepath, 'w')
f.write(rledata)
f.close()
except:
g.warn("Unable to create object pattern:\n" + rlepath)

results += "</td><td align=center> "
if (objname in self.commonnames):
results += self.commonnames[objname][0]
results += " </td><td align=right> " + str(count) + " "
results += "</td><td>"
if objname in self.alloccur:
results += " "
for soup in self.alloccur[objname]:
results += self.save_soup(root, soup, symmetry)
results += " "
results += "</td></tr>\n"
results += "</table>\n</center>\n"

ilist = sorted(self.soupscores.iteritems(), key=operator.itemgetter(1), reverse=True)
results += "<center>\n"
results += "<table cellspacing=1 border=2 cols=2>\n"
results += "<tr><td> Soup number </td><td align=right> Score </td></tr>\n"
for soupnum, score in ilist[:50]:
results += "<tr><td> "
results += self.save_soup(root, soupnum, symmetry)
results += " </td><td align=right> " + str(score) + " </td></tr>\n"

results += "</table>\n</center>\n"
results += "</body>\n</html>\n"

htmlname = apgpath + "latest_census.html"
try:
f = open(htmlname, 'w')
f.write(results)
f.close()
g.open(htmlname)
except:
g.warn("Unable to create html file:\n" + htmlname)

# Converts a base-36 case-insensitive alphanumeric character into a
# numerical value.
def ord2(char):

x = ord(char)

if ((x >= 48) & (x < 58)):
return x - 48

if ((x >= 65) & (x < 91)):
return x - 55

if ((x >= 97) & (x < 123)):
return x - 87

return -1

def apg_verify(rulestring, symmetry, payoshakey):

verifysoup = Soup()
verifysoup.rg.setrule(rulestring)
verifysoup.rg.saveAllRules()

return_point = [None]

catagolue_results(rulestring+"\n"+symmetry+"\n", payoshakey, "verify_apgsearch_haul", endpoint="/verify", return_point=return_point)

if return_point[0] is not None:

resplist = return_point[0].split("\n")

if ((len(resplist) >= 4) and (resplist[1] == "yes")):

md5 = resplist[2]
passcode = resplist[3]

stringlist = resplist[4:]

stringlist = [s for s in stringlist if (len(s) > 0 and s[0] != '*')]

# g.exit(stringlist[0])

gsize = 3

pos = 0

while (len(stringlist) > 0):

while (gsize * gsize > len(stringlist)):

gsize -= 1

listhead = stringlist[:(gsize*gsize)]
stringlist = stringlist[(gsize*gsize):]

verifysoup.stabilise_soups_parallel_list(gsize, listhead, pos)

pos += (gsize * gsize)

# verifysoup.display_census(-1, "verify", "verify")

payload = "@MD5 "+md5+"\n"
payload += "@PASSCODE "+passcode+"\n"
payload += "@RULE "+rulestring+"\n"
payload += "@SYMMETRY "+symmetry+"\n"

tlist = sorted(verifysoup.objectcounts.iteritems(), key=operator.itemgetter(1), reverse=True)

for objname, count in tlist:

payload += objname + " " + str(count) + "\n"

catagolue_results(payload, payoshakey, "submit_verification", endpoint="/verify")

def apg_main():

# ---------------- Hardcode the following inputs if running without a user interface ----------------
orignumber = int(g.getstring("How many soups to search between successive uploads?", "5000000"))
rulestring = g.getstring("Which rule to use?", "B3/S23")
symmstring = g.getstring("What symmetries to use?", "C1")
payoshakey = g.getstring("Please enter your key (visit "+get_server_address()+"/payosha256 in your browser).", "#anon")
# ---------------------------------------------------------------------------------------------------

# Sanitise input:
orignumber = max(orignumber, 100000)
orignumber = min(orignumber, 100000000)
number = orignumber
initpos = 0
if symmstring not in ["32x32", "1x256", "2x128", "4x64", "8x32", "C1", "C2_1", "C2_2", "C2_4", "C4_1", "C4_4", "D2_+1", "D2_+2", "D2_x", "D4_+1", "D4_+2", "D4_+4", "D4_x1", "D4_x4", "D8_1", "D8_4"]:
g.exit(symmstring+" is not a valid symmetry option")

quitapg = False

# Create associated rule tables:
soup = Soup()
soup.rg.setrule(rulestring)
soup.rg.saveAllRules()

# We have 100 soups per page, instead of one. This parallel approach
# was suggested by Tomas Rokicki, and results in approximately a
# fourfold increase in soup-searching speed!
sqrtspp_optimal = 10

# Initialise the census:
start_time = time.clock()
f = (lambda x : 'abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'[ord(x) % 56])
rootstring = ''.join(map(f, list(hashlib.sha256(payoshakey + datetime.datetime.now().isoformat()).digest()[:12])))
scount = 0

while (quitapg == False):

# Peer-review some soups:
for i in xrange(5):
apg_verify("b3s23", "C1", payoshakey)

# The 'for' loop has been replaced with a 'while' loop to allow sqrtspp
# to vary during runtime. The idea is that apgsearch can apply a basic
# form of machine-learning to dynamically locate the optimum sqrtspp:
while (scount < number):

delays = [0.0, 0.0, 0.0]

for i in xrange(1000):

page_time = time.clock()

sqrtspp = (sqrtspp_optimal + (i % 3) - 1) if (i < 150) else (sqrtspp_optimal)

# Don't overrun:
while (scount + sqrtspp * sqrtspp > number):
sqrtspp -= 1

meandelay = soup.stabilise_soups_parallel(rootstring, scount + initpos, sqrtspp, symmstring)
if (i < 150):
delays[i % 3] += meandelay
scount += (sqrtspp * sqrtspp)

current_speed = int((sqrtspp * sqrtspp)/(time.clock() - page_time))
alltime_speed = int((scount)/(time.clock() - start_time))

g.show(str(scount) + " soups processed (" + str(current_speed) +
" per second current; " + str(alltime_speed) + " overall)" +
" : (type 's' to see latest census or 'q' to quit).")

event = g.getevent()
if event.startswith("key"):
evt, ch, mods = event.split()
if ch == "s":
soup.save_progress(scount, rootstring, symmstring)
soup.display_census(scount, rootstring, symmstring)
elif ch == "q":
quitapg = True
break

if (scount >= number):
break

if (quitapg == True):
break

# Change sqrtspp to a more optimal value:
if (scount < number):
sqrtspp_new = sqrtspp_optimal

if (delays[0] < delays[1]):
sqrtspp_new = sqrtspp_optimal - 1
if ((delays[2] < delays[1]) and (delays[2] < delays[0])):
sqrtspp_new = sqrtspp_optimal + 1

sqrtspp_optimal = sqrtspp_new
sqrtspp_optimal = max(sqrtspp_optimal, 5)

# Compactify highscore table:
soup.compactify_scores()

if (quitapg == False):
# Save progress, upload it to Catagolue, and reset the census if successful:
a = soup.save_progress(scount, rootstring, symmstring, payosha256_key=payoshakey)
if (a == 0):
# Reset the census:
soup.reset()
start_time = time.clock()
f = (lambda x : 'abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'[ord(x) % 56])
rootstring = ''.join(map(f, list(hashlib.sha256(rootstring + payoshakey + datetime.datetime.now().isoformat()).digest()[:12])))
scount = 0
number = orignumber
else:
number += orignumber

end_time = time.clock()

soup.save_progress(scount, rootstring, symmstring, payosha256_key=payoshakey)

soup.display_unids()
soup.display_census(scount, rootstring, symmstring)

def symmetry_test():

g.new("Symmetry test")

symmetries = [["32x32", "C1", "8x32", "4x64", "2x128", "1x256"],
["C2_1", "C2_2", "C2_4"],
["C4_1", "C4_4"],
["D2_+1", "D2_+2", "D2_x"],
["D4_+1", "D4_+2", "D4_+4", "D4_x1", "D4_x4"],
["D8_1", "D8_4"]]

for i in range(len(symmetries)):
for j in range(len(symmetries[i])):

g.putcells(hashsoup("sym_test", symmetries[i][j]), 120 * j + 60 * (i % 2), 80 * i)
g.fit()

# Run the soup-searching script:
apg_main()
# apg_verify()
</pre>
-wwei23 10:21AM 6/25/2017 NY time

:Thanks -- this should make it easier to ensure that if others also search these symmetries, they'll generate soups the same way!

:And yes, eventually there won't be any new soups left to search, but that's not a concern in practice. [[User:Apple Bottom|Apple Bottom]] ([[User talk:Apple Bottom|talk]]) 09:06, 30 June 2017 (UTC)

== More symmetries ==

1x256X2 and 1x256X2+1 now available!
<pre>
# *************************************
# * Ash Pattern Generator (apgsearch) *
# *************************************
# * Version: v1.1 (beta release) *
# *************************************
#
# -- Processes roughly 100 soups per (second . core . GHz), using caching
# and machine-learning to optimise itself during runtime.
#
# -- Can perfectly identify oscillators with period < 1000, well-separated
# spaceships of low period, and certain infinite-growth patterns (such
# guns and puffers, including both naturally-occurring types of switch
# engine).
#
# -- Separates most pseudo-objects into their constituent parts, including
# all pseudo-still-lifes of 18 or fewer live cells (which is the maximum
# theoretically possible, given there is a 19-cell pseudo-still-life
# with two distinct decompositions).
#
# -- Correctly separates non-interacting standard spaceships, irrespective
# of their proximity. In particular, a LWSS-on-LWSS is registered as two
# LWSSes, whereas an LWSS-on-HWSS is registered as a single spaceship
# (since they interact by suppressing sparks).
#
# -- At least 99.9999999999% reliable at identifying objects in asymmetrical
# soups in B3/S23 (based on the fact that out of over 10^12 objects that
# have appeared, there are no errors).
#
# -- Scores soups based on the total excitement of the ash objects.
#
# -- Support for other outer-totalistic rules, including detection and
# classification of various types of infinite growth.
#
# -- Support for symmetrical soups.
#
# -- Uploads results to the server at http://catagolue.appspot.com (which
# currently has collected over 2.7 * 10^12 objects).
#
# -- Peer-reviews others' contributions to ensure data integrity for the
# asymmetrical B3/S23 census.
#
# By Adam P. Goucher, with contributions from Andrew Trevorrow, Tom Rokicki,
# Nathaniel Johnston, Dave Greene and Richard Schank.

import golly as g
from glife import rect, pattern
import time
import math
import operator
import hashlib
import datetime
import os
import urllib2

def get_server_address():
# Should be 'http://catagolue.appspot.com' for the released version,
# and 'http://localhost:8080' for the development version:
return 'http://catagolue.appspot.com'

# Engages with Catagolue's authentication system ('payment over SHA-256',
# affectionately abbreviated to 'payosha256'):
#
# The payosha256_key can be obtained from logging into Catagolue in your
# web browser and visiting http://catagolue.appspot.com/payosha256
def authenticate(payosha256_key, operation_name):

g.show("Authenticating with Catagolue via the payosha256 protocol...")

payload = "payosha256:get_token:"+payosha256_key+":"+operation_name

req = urllib2.Request(get_server_address() + "/payosha256", payload, {"Content-type": "text/plain"})
f = urllib2.urlopen(req)

if (f.getcode() != 200):
return None

resp = f.read()

lines = resp.splitlines()

for line in lines:
parts = line.split(':')

if (len(parts) < 3):
continue

if (parts[1] != 'good'):
continue

target = parts[2]
token = parts[3]

g.show("Token " + token + " obtained from payosha256. Performing proof of work with target " + target + "...")

for nonce in xrange(100000000):

prehash = token + ":" + str(nonce)
posthash = hashlib.sha256(prehash).hexdigest()

if (posthash < target):
break

if (posthash > target):
continue

g.show("String "+prehash+" is sufficiently valuable ("+posthash+" < "+target+").")

payload = "payosha256:pay_token:"+prehash+"\n"

return payload

return None

# Sends the results to Catagolue:
def catagolue_results(results, payosha256_key, operation_name, endpoint="/apgsearch", return_point=None):

try:

payload = authenticate(payosha256_key, operation_name)

if payload is None:
return 1

payload += results

req = urllib2.Request(get_server_address() + endpoint, payload, {"Content-type": "text/plain"})

f = urllib2.urlopen(req)

if (f.getcode() != 200):
return 2

resp = f.read()

try:
f2 = open(g.getdir("data")+"catagolue-response.txt", 'w')
f2.write(resp)
f2.close()

if return_point is not None:
return_point[0] = resp

except:
g.warn("Unable to save catagolue response file.")

return 0

except:

return 1

# Takes approximately 350 microseconds to construct a 16-by-16 soup based
# on a SHA-256 cryptographic hash in the obvious way.
def hashsoup(instring, sym):

s = hashlib.sha256(instring).digest()

thesoup = []

if sym in ['D2_x', 'D8_1', 'D8_4']:
d = 1
elif sym in ['D4_x1', 'D4_x4']:
d = 2
else:
d = 0

for j in xrange(32):

t = ord(s[j])

for k in xrange(8):

if (sym == '8x32'):

x = k + 8*(j % 4)
y = int(j / 4)

elif (sym == '4x64'):

x = k + 8*(j % 8)
y = int(j / 8)

elif (sym == '2x128'):

x = k + 8*(j % 16)
y = int(j / 16)

elif (sym in ['1x256', '1x256X2', '1x256X2+1']):

x = k + 8*(j % 32)
y = int(j / 32)

else:

x = k + 8*(j % 2)
y = int(j / 2)

if (t & (1 << (7 - k))):

if ((d == 0) | (x >= y)):

thesoup.append(x)
thesoup.append(y)

if (sym == '1x256X2+1'):

thesoup.append(-x)
thesoup.append(y)

if (sym == '1x256X2'):

thesoup.append(-1-x)
thesoup.append(y)

if (sym == '32x32'):

thesoup.append(x+16)
thesoup.append(y)
thesoup.append(x)
thesoup.append(y+16)
thesoup.append(x+16)
thesoup.append(y+16)

if (sym == '75p'):

thesoup.append(16-y)
thesoup.append(x)

elif (sym == 'D4_x1'):

thesoup.append(y)
thesoup.append(-x)

elif (sym == 'D4_x4'):

thesoup.append(y)
thesoup.append(-x-1)

if ((sym == 'D4_x1') & (x == y)):

thesoup.append(y)
thesoup.append(-x)

if ((sym == 'D4_x4') & (x == y)):

thesoup.append(y)
thesoup.append(-x-1)

# Checks for diagonal symmetries:
if (d >= 1):
for x in xrange(0, len(thesoup), 2):
thesoup.append(thesoup[x+1])
thesoup.append(thesoup[x])
if d == 2:
if (sym == 'D4_x1'):
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x+1])
thesoup.append(-thesoup[x])
else:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x+1] - 1)
thesoup.append(-thesoup[x] - 1)
return thesoup

# Checks for orthogonal x symmetry:
if sym in ['D2_+1', 'D4_+1', 'D4_+2']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(thesoup[x])
thesoup.append(-thesoup[x+1])
elif sym in ['D2_+2', 'D4_+4']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(thesoup[x])
thesoup.append(-thesoup[x+1] - 1)

# Checks for orthogonal y symmetry:
if sym in ['D4_+1']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x])
thesoup.append(thesoup[x+1])
elif sym in ['D4_+2', 'D4_+4']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x] - 1)
thesoup.append(thesoup[x+1])

# Checks for rotate2 symmetry:
if sym in ['C2_1', 'C4_1', 'D8_1']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x])
thesoup.append(-thesoup[x+1])
elif sym in ['C2_2']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x])
thesoup.append(-thesoup[x+1]-1)
elif sym in ['C2_4', 'C4_4', 'D8_4']:
for x in xrange(0, len(thesoup), 2):
thesoup.append(-thesoup[x]-1)
thesoup.append(-thesoup[x+1]-1)

# Checks for rotate4 symmetry:
if (sym in ['C4_1', 'D8_1']):
for x in xrange(0, len(thesoup), 2):
thesoup.append(thesoup[x+1])
thesoup.append(-thesoup[x])
elif (sym in ['C4_4', 'D8_4']):
for x in xrange(0, len(thesoup), 2):
thesoup.append(thesoup[x+1])
thesoup.append(-thesoup[x]-1)

return thesoup

# Obtains a canonical representation of any oscillator/spaceship that (in
# some phase) fits within a 40-by-40 bounding box. This representation is
# alphanumeric and lowercase, and so much more compact than RLE. Compare:
#
# Common name: pentadecathlon
# Canonical representation: 4r4z4r4
# Equivalent RLE: 2bo4bo$2ob4ob2o$2bo4bo!
#
# It is a generalisation of a notation created by Allan Weschler in 1992.
def canonise(duration):

representation = "#"

# We need to compare each phase to find the one with the smallest
# description:
for t in xrange(duration):

rect = g.getrect()
if (len(rect) == 0):
return "0"

if ((rect[2] <= 40) & (rect[3] <= 40)):
# Fits within a 40-by-40 bounding box, so eligible to be canonised.
# Choose the orientation which results in the smallest description:
representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0], rect[1], 1, 0, 0, 1))
representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0]+rect[2]-1, rect[1], -1, 0, 0, 1))
representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0], rect[1]+rect[3]-1, 1, 0, 0, -1))
representation = compare_representations(representation, canonise_orientation(rect[2], rect[3], rect[0]+rect[2]-1, rect[1]+rect[3]-1, -1, 0, 0, -1))
representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0], rect[1], 0, 1, 1, 0))
representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0]+rect[2]-1, rect[1], 0, -1, 1, 0))
representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0], rect[1]+rect[3]-1, 0, 1, -1, 0))
representation = compare_representations(representation, canonise_orientation(rect[3], rect[2], rect[0]+rect[2]-1, rect[1]+rect[3]-1, 0, -1, -1, 0))

g.run(1)

return representation

# A subroutine used by canonise:
def canonise_orientation(length, breadth, ox, oy, a, b, c, d):

representation = ""

chars = "0123456789abcdefghijklmnopqrstuvwxyz"

for v in xrange(int((breadth-1)/5)+1):
zeroes = 0
if (v != 0):
representation += "z"
for u in xrange(length):
baudot = 0
for w in xrange(5):
x = ox + a*u + b*(5*v + w)
y = oy + c*u + d*(5*v + w)
baudot = (baudot >> 1) + 16*g.getcell(x, y)
if (baudot == 0):
zeroes += 1
else:
if (zeroes > 0):
if (zeroes == 1):
representation += "0"
elif (zeroes == 2):
representation += "w"
elif (zeroes == 3):
representation += "x"
else:
representation += "y"
representation += chars[zeroes - 4]
zeroes = 0
representation += chars[baudot]
return representation

# Compares strings first by length, then by lexicographical ordering.
# A hash character is worse than anything else.
def compare_representations(a, b):

if (a == "#"):
return b
elif (b == "#"):
return a
elif (len(a) < len(b)):
return a
elif (len(b) < len(a)):
return b
elif (a < b):
return a
else:
return b

# Finds the gradient of the least-squares regression line corresponding
# to a list of ordered pairs:
def regress(pairlist):

cumx = 0.0
cumy = 0.0
cumvar = 0.0
cumcov = 0.0

for x,y in pairlist:

cumx += x
cumy += y

cumx = cumx / len(pairlist)
cumy = cumy / len(pairlist)

for x,y in pairlist:

cumvar += (x - cumx)*(x - cumx)
cumcov += (x - cumx)*(y - cumy)

return (cumcov / cumvar)

# Analyses a pattern whose average population follows a power-law:
def powerlyse(stepsize, numsteps):

g.setalgo("HashLife")
g.setbase(2)
g.setstep(stepsize)

poplist = [0]*numsteps

poplist[0] = int(g.getpop())

pointlist = []

for i in xrange(1, numsteps, 1):

g.step()
poplist[i] = int(g.getpop()) + poplist[i-1]

if (i % 50 == 0):

g.fit()
g.update()

if (i > numsteps/2):

pointlist.append((math.log(i),math.log(poplist[i]+1.0)))

power = regress(pointlist)

if (power < 1.10):
return "unidentified"
elif (power < 1.65):
return "zz_REPLICATOR"
elif (power < 2.05):
return "zz_LINEAR"
elif (power < 2.8):
return "zz_EXPLOSIVE"
else:
return "zz_QUADRATIC"

# Gets the period of an interleaving of degree-d polynomials:
def deepperiod(sequence, maxperiod, degree):

for p in xrange(1, maxperiod, 1):

good = True

for i in xrange(maxperiod):

diffs = [0] * (degree + 2)
for j in xrange(degree + 2):

diffs[j] = sequence[i + j*p]

# Produce successive differences:
for j in xrange(degree + 1):
for k in xrange(degree + 1):
diffs[k] = diffs[k] - diffs[k + 1]

if (diffs[0] != 0):
good = False
break

if (good):
return p
return -1

# Analyses a linear-growth pattern, returning a hash:
def linearlyse(maxperiod):

poplist = [0]*(3*maxperiod)

for i in xrange(3*maxperiod):

g.run(1)
poplist[i] = int(g.getpop())

p = deepperiod(poplist, maxperiod, 1)

if (p == -1):
return "unidentified"

difflist = [0]*(2*maxperiod)

for i in xrange(2*maxperiod):

difflist[i] = poplist[i + p] - poplist[i]

q = deepperiod(difflist, maxperiod, 0)

moments = [0, 0, 0]

for i in xrange(p):

moments[0] += (poplist[i + q] - poplist[i])
moments[1] += (poplist[i + q] - poplist[i]) ** 2
moments[2] += (poplist[i + q] - poplist[i]) ** 3

prehash = str(moments[1]) + "#" + str(moments[2])

# Linear-growth patterns with growth rate zero are clearly errors!
if (moments[0] == 0):
return "unidentified"

return "yl" + str(p) + "_" + str(q) + "_" + str(moments[0]) + "_" + hashlib.md5(prehash).hexdigest()

# This explodes pseudo-still-lifes and pseudo-oscillators into their
# constituent parts.
#
# -- Requires the period (if oscillatory) and graph-theoretic diameter
# to not exceed 4096.
# -- Never mistakenly separates a true object.
# -- Correctly separates most pseudo-still-lifes, including the famous:
# http://www.conwaylife.com/wiki/Quad_pseudo_still_life
# -- Works perfectly for all still-lifes of up to 17 bits.
# -- Doesn't separate 'locks', of which the smallest example has 18
# bits and is unique:
#
# ** **
# ** **
#
# * *** *
# ** * **
#
# To use this function (standalone), merely copy it into a script of
# the following form:
#
# import golly as g
#
# def pseudo_bangbang():
#
# [...]
#
# pseudo_bangbang()
#
# and execute it in Golly with a B3/S23 universe containing any still-
# lifes or oscillators you want to separate. Pure objects correspond to
# connected components in the final state of the universe.
#
# This has dependencies on the rules ContagiousLife, PercolateInfection
# and EradicateInfection.
#
# Not to be confused with the Unix shell instruction for repeating the
# previous instruction as a superuser (sudo !!), or indeed with any
# parodies of this song: https://www.youtube.com/watch?v=YswhUHH6Ufc
#
# Adam P. Goucher, 2014-08-25
def pseudo_bangbang(alpharule):

g.setrule("APG_ContagiousLife_" + alpharule)
g.setbase(2)
g.setstep(12)
g.step()

celllist = g.getcells(g.getrect())

for i in xrange(0, len(celllist)-1, 3):

# Only infect cells that haven't yet been infected:
if (g.getcell(celllist[i], celllist[i+1]) <= 2):

# Seed an initial 'infected' (red) cell:
g.setcell(celllist[i], celllist[i+1], g.getcell(celllist[i], celllist[i+1]) + 2)

prevpop = 0
currpop = int(g.getpop())

# Continue infecting until the entire component has been engulfed:
while (prevpop != currpop):

# Percolate the infection to every cell in the island:
g.setrule("APG_PercolateInfection")
g.setbase(2)
g.setstep(12)
g.step()

# Transmit the infection across any bridges.
g.setrule("APG_ContagiousLife_" + alpharule)
g.setbase(2)
g.setstep(12)
g.step()

prevpop = currpop
currpop = int(g.getpop())

g.fit()
g.update()

# Red becomes green:
g.setrule("APG_EradicateInfection")
g.step()

# Counts the number of live cells of each degree:
def degreecount():

celllist = g.getcells(g.getrect())
counts = [0,0,0,0,0,0,0,0,0]

for i in xrange(0, len(celllist), 2):

x = celllist[i]
y = celllist[i+1]

degree = -1

for ux in xrange(x - 1, x + 2):
for uy in xrange(y - 1, y + 2):

degree += g.getcell(ux, uy)

counts[degree] += 1

return counts

# Counts the number of live cells of each degree in generations 1 and 2:
def degreecount2():

g.run(1)
a = degreecount()
g.run(1)
b = degreecount()

return (a + b)

# If the universe consists only of disjoint *WSSes, this will return
# a triple (l, w, h) giving the quantities of each *WSS. Otherwise,
# this function will return (-1, -1, -1).
#
# This should only be used to separate period-4 moving objects which
# may contain multiple *WSSes.
def countxwsses():

degcount = degreecount2()
if (degreecount2() != degcount):
# Degree counts are not period-2:
return (-1, -1, -1)

# Degree counts of each standard spaceship:
hwssa = [1,4,6,2,0,0,0,0,0,0,0,0,4,4,6,1,2,1]
mwssa = [2,2,5,2,0,0,0,0,0,0,0,0,4,4,4,1,2,0]
lwssa = [1,2,4,2,0,0,0,0,0,0,0,0,4,4,2,2,0,0]
hwssb = [0,0,0,4,4,6,1,2,1,1,4,6,2,0,0,0,0,0]
mwssb = [0,0,0,4,4,4,1,2,0,2,2,5,2,0,0,0,0,0]
lwssb = [0,0,0,4,4,2,2,0,0,1,2,4,2,0,0,0,0,0]

# Calculate the number of standard spaceships in each phase:
hacount = degcount[17]
macount = degcount[16]/2 - hacount
lacount = (degcount[15] - hacount - macount)/2
hbcount = degcount[8]
mbcount = degcount[7]/2 - hbcount
lbcount = (degcount[6] - hbcount - mbcount)/2

# Determine the expected degcount given the calculated quantities:
pcounts = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: hacount*x, hwssa))
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: macount*x, mwssa))
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: lacount*x, lwssa))
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: hbcount*x, hwssb))
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: mbcount*x, mwssb))
pcounts = map(lambda x, y: x + y, pcounts, map(lambda x: lbcount*x, lwssb))

# Compare the observed and expected degcounts (to eliminate nonstandard spaceships):
if (pcounts != degcount):
# Expected and observed values do not match:
return (-1, -1, -1)

# Return the combined numbers of *WSSes:
return(lacount + lbcount, macount + mbcount, hacount + hbcount)

# Generates the helper rules for apgsearch, given a base outer-totalistic rule.
class RuleGenerator:

def __init__(self):

# Unless otherwise specified, assume standard B3/S23 rule:
self.bee = [False, False, False, True, False, False, False, False, False]
self.ess = [False, False, True, True, False, False, False, False, False]
self.alphanumeric = "B3S23"
self.slashed = "B3/S23"

# Save all helper rules:
def saveAllRules(self):

self.saveClassifyObjects()
self.saveCoalesceObjects()
self.saveExpungeObjects()
self.saveExpungeGliders()
self.saveIdentifyGliders()
self.saveHandlePlumes()
self.savePercolateInfection()
self.saveEradicateInfection()
self.saveContagiousLife()

# Set outer-totalistic rule:
def setrule(self, rulestring):

mode = 0
s = [False]*9
b = [False]*9

for c in rulestring:

if ((c == 's') | (c == 'S')):
mode = 0

if ((c == 'b') | (c == 'B')):
mode = 1

if (c == '/'):
mode = 1 - mode

if ((ord(c) >= 48) & (ord(c) <= 56)):
d = ord(c) - 48
if (mode == 0):
s[d] = True
else:
b[d] = True

prefix = "B"
suffix = "S"

for i in xrange(9):
if (b[i]):
prefix += str(i)
if (s[i]):
suffix += str(i)

self.alphanumeric = prefix + suffix
self.slashed = prefix + "/" + suffix
self.bee = b
self.ess = s

# Save a rule file:
def saverule(self, name, comments, table, colours):

ruledir = g.getdir("rules")
filename = ruledir + name + ".rule"

results = "@RULE " + name + "\n\n"
results += "*** File autogenerated by saverule. ***\n\n"
results += comments
results += "\n\n@TABLE\n\n"
results += table
results += "\n\n@COLORS\n\n"
results += colours

# Only create a rule file if it doesn't already exist; this avoids
# concurrency issues when booting an instance of apgsearch whilst
# one is already running.
if not os.path.exists(filename):
try:
f = open(filename, 'w')
f.write(results)
f.close()
except:
g.warn("Unable to create rule table:\n" + filename)

# Defines a variable:
def newvar(self, name, vallist):

line = "var "+name+"={"
for i in xrange(len(vallist)):
if (i > 0):
line += ','
line += str(vallist[i])
line += "}\n"

return line

# Defines a block of equivalent variables:
def newvars(self, namelist, vallist):

block = ""

for name in namelist:
block += self.newvar(name, vallist)

block += "\n"

return block

def scoline(self, chara, charb, left, right, amount):

line = str(left) + ","

for i in xrange(8):
if (i < amount):
line += chara
else:
line += charb
line += chr(97 + i)
line += ","

line += str(right) + "\n"

return line

def saveHandlePlumes(self):

comments = """
This post-processes the output of ClassifyObjects to remove any
unwanted clustering of low-period objects appearing in puffer
exhaust.

state 0: vacuum

state 7: ON, still-life
state 8: OFF, still-life

state 9: ON, p2 oscillator
state 10: OFF, p2 oscillator

state 11: ON, higher-period object
state 12: OFF, higher-period object
"""
table = """
n_states:17
neighborhood:Moore
symmetries:permute

var da={0,2,4,6,8,10,12,14,16}
var db={0,2,4,6,8,10,12,14,16}
var dc={0,2,4,6,8,10,12,14,16}
var dd={0,2,4,6,8,10,12,14,16}
var de={0,2,4,6,8,10,12,14,16}
var df={0,2,4,6,8,10,12,14,16}
var dg={0,2,4,6,8,10,12,14,16}
var dh={0,2,4,6,8,10,12,14,16}

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

8,da,db,dc,dd,de,df,dg,dh,0
10,da,db,dc,dd,de,df,dg,dh,0

9,a,b,c,d,e,f,g,h,1
10,a,b,c,d,e,f,g,h,2
"""
colours = """
1 255 255 255
2 127 127 127
7 0 0 255
8 0 0 127
9 255 0 0
10 127 0 0
11 0 255 0
12 0 127 0
"""
self.saverule("APG_HandlePlumesCorrected", comments, table, colours)

def saveExpungeGliders(self):

comments = """
This removes unwanted gliders.
It is mandatory that one first runs the rules CoalesceObjects,
IdentifyGliders and ClassifyObjects.

Run this for two generations, and observe the population
counts after 1 and 2 generations. This will give the
following data:

number of gliders = (p(1) - p(2))/5
"""
table = """
n_states:17
neighborhood:Moore
symmetries:rotate4reflect

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

13,a,b,c,d,e,f,g,h,14
14,a,b,c,d,e,f,g,h,0
"""
colours = """
0 0 0 0
1 255 255 255
2 127 127 127
7 0 0 255
8 0 0 127
9 255 0 0
10 127 0 0
11 0 255 0
12 0 127 0
13 255 255 0
14 127 127 0
"""
self.saverule("APG_ExpungeGliders", comments, table, colours)

def saveIdentifyGliders(self):

comments = """
Run this after CoalesceObjects to find any gliders.

state 0: vacuum
state 1: ON
state 2: OFF
"""
table = """
n_states:17
neighborhood:Moore
symmetries:rotate4reflect

var a={0,2}
var b={0,2}
var c={0,2}
var d={0,2}
var e={0,2}
var f={0,2}
var g={0,2}
var h={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var i={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var j={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var k={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var l={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var m={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var n={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var o={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var p={0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
var q={3,4}
var r={9,10}
var s={11,12}

1,1,a,1,1,b,1,c,d,3
d,1,1,1,1,a,b,1,c,4

3,i,j,k,l,m,n,o,p,5
4,i,j,k,l,m,n,o,p,6

1,q,i,j,a,b,c,k,l,7
d,q,i,j,a,b,c,k,l,8
1,i,a,b,c,d,e,j,q,7
f,i,a,b,c,d,e,j,q,8

5,7,8,7,7,8,7,8,8,9
6,7,7,7,7,8,8,7,8,10
5,i,j,k,l,m,n,o,p,15
6,i,j,k,l,m,n,o,p,16
15,i,j,k,l,m,n,o,p,1
16,i,j,k,l,m,n,o,p,2

7,i,j,k,l,m,n,o,p,11
8,i,j,k,l,m,n,o,p,12

9,i,j,k,l,m,n,o,p,13
10,i,j,k,l,m,n,o,p,14
11,r,j,k,l,m,n,o,p,13
11,i,r,k,l,m,n,o,p,13
12,r,j,k,l,m,n,o,p,14
12,i,r,k,l,m,n,o,p,14

11,i,j,k,l,m,n,o,p,1
12,i,j,k,l,m,n,o,p,2
"""
colours = """
0 0 0 0
1 255 255 255
2 127 127 127
7 0 0 255
8 0 0 127
9 255 0 0
10 127 0 0
11 0 255 0
12 0 127 0
13 255 255 0
14 127 127 0
"""
self.saverule("APG_IdentifyGliders", comments, table, colours)

def saveEradicateInfection(self):

comments = """
To run after ContagiousLife to disinfect any cells in states 3 or 4.

state 0: vacuum
state 1: ON
state 2: OFF
"""
table = """
n_states:7
neighborhood:Moore
symmetries:permute

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

4,a,b,c,d,e,f,g,h,6
3,a,b,c,d,e,f,g,h,5
"""
colours = """
0 0 0 0
1 0 0 255
2 0 0 127
3 255 0 0
4 127 0 0
5 0 255 0
6 0 127 0
"""
self.saverule("APG_EradicateInfection", comments, table, colours)

def savePercolateInfection(self):

comments = """
Percolates any infection to all cells of that particular island.

state 0: vacuum
state 1: ON
state 2: OFF
"""
table = """
n_states:7
neighborhood:Moore
symmetries:permute

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

var q={3,4}
var da={2,4,6}
var la={1,3,5}

da,q,b,c,d,e,f,g,h,4
la,q,b,c,d,e,f,g,h,3
"""
colours = """
0 0 0 0
1 0 0 255
2 0 0 127
3 255 0 0
4 127 0 0
5 0 255 0
6 0 127 0
"""
self.saverule("APG_PercolateInfection", comments, table, colours)

def saveExpungeObjects(self):

comments = """
This removes unwanted monominos, blocks, blinkers and beehives.
It is mandatory that one first runs the rule ClassifyObjects.

Run this for four generations, and observe the population
counts after 0, 1, 2, 3 and 4 generations. This will give the
following data:

number of monominos = p(1) - p(0)
number of blocks = (p(2) - p(1))/4
number of blinkers = (p(3) - p(2))/5
number of beehives = (p(4) - p(3))/8
"""
table = "n_states:17\n"
table += "neighborhood:Moore\n"
table += "symmetries:rotate4reflect\n\n"

table += self.newvars(["a","b","c","d","e","f","g","h","i"], range(0, 17, 1))

table += """
# Monomino
7,0,0,0,0,0,0,0,0,0

# Death
6,a,b,c,d,e,f,g,h,0
a,6,b,c,d,e,f,g,h,0

# Block
7,7,7,7,0,0,0,0,0,1
1,1,1,1,0,0,0,0,0,0
1,a,b,c,d,e,f,g,h,7

# Blinker
10,0,0,0,9,9,9,0,0,2
9,9,10,0,0,0,0,0,10,3
2,a,b,c,d,e,f,g,h,10
3,a,b,c,d,e,f,g,h,9
9,2,0,3,0,2,0,3,0,6

# Beehive
7,0,7,8,7,0,0,0,0,1
7,0,0,7,8,8,7,0,0,1
8,7,7,8,7,7,0,7,0,4
4,1,1,4,1,1,0,1,0,5
4,a,b,c,d,e,f,g,h,8
5,5,b,c,d,e,f,g,h,6
5,a,b,c,d,e,f,g,h,15
15,a,b,c,d,e,f,g,h,8
"""

colours = """
0 0 0 0
1 255 255 255
2 127 127 127
7 0 0 255
8 0 0 127
9 255 0 0
10 127 0 0
11 0 255 0
12 0 127 0
13 255 255 0
14 127 127 0
"""
self.saverule("APG_ExpungeObjects", comments, table, colours)

def saveCoalesceObjects(self):

comments = """
A variant of HistoricalLife which separates a field of ash into
distinct objects.

state 0: vacuum
state 1: ON
state 2: OFF
"""
table = "n_states:3\n"
table += "neighborhood:Moore\n"
table += "symmetries:permute\n\n"

table += self.newvars(["a","b","c","d","e","f","g","h","i"], [0, 1, 2])
table += self.newvars(["da","db","dc","dd","de","df","dg","dh","di"], [0, 2])
table += self.newvars(["la","lb","lc","ld","le","lf","lg","lh","li"], [1])

minperc = 10

for i in xrange(9):
if (self.bee[i]):
if (minperc == 10):
minperc = i
table += self.scoline("l","d",0,1,i)
table += self.scoline("l","d",2,1,i)
if (self.ess[i]):
table += self.scoline("l","d",1,1,i)

table += "\n# Bridge inductors\n"

for i in xrange(9):
if (i >= minperc):
table += self.scoline("l","d",0,2,i)

table += self.scoline("","",1,2,0)

colours = """
0 0 0 0
1 255 255 255
2 127 127 127
"""
self.saverule("APG_CoalesceObjects_"+self.alphanumeric, comments, table, colours)

def saveClassifyObjects(self):

comments = """
This passively classifies objects as either still-lifes, p2 oscillators
or higher-period oscillators. It is mandatory that one first runs the
rule CoalesceObjects.

state 0: vacuum
state 1: input ON
state 2: input OFF

state 3: ON, will die
state 4: OFF, will remain off
state 5: ON, will survive
state 6: OFF, will become alive

state 7: ON, still-life
state 8: OFF, still-life

state 9: ON, p2 oscillator
state 10: OFF, p2 oscillator

state 11: ON, higher-period object
state 12: OFF, higher-period object
"""
table = "n_states:17\n"
table += "neighborhood:Moore\n"
table += "symmetries:permute\n\n"

table += self.newvars(["a","b","c","d","e","f","g","h","i"], range(0, 17, 1))
table += self.newvars(["la","lb","lc","ld","le","lf","lg","lh","li"], range(1, 17, 2))
table += self.newvars(["da","db","dc","dd","de","df","dg","dh","di"], range(0, 17, 2))
table += self.newvars(["pa","pb","pc","pd","pe","pf","pg","ph","pi"], [0, 3, 4])
table += self.newvars(["qa","qb","qc","qd","qe","qf","qg","qh","qi"], [5, 6])

for i in xrange(9):
if (self.bee[i]):
table += self.scoline("l","d",2,6,i)
table += self.scoline("q","p",3,9,i)
table += self.scoline("q","p",4,12,i)
if (self.ess[i]):
table += self.scoline("l","d",1,5,i)
table += self.scoline("q","p",5,7,i)
table += self.scoline("q","p",6,12,i)
table += self.scoline("","",2,4,0)
table += self.scoline("","",1,3,0)
table += self.scoline("","",5,11,0)
table += self.scoline("","",3,11,0)
table += self.scoline("","",4,8,0)
table += self.scoline("","",6,10,0)

table += """
# Propagate interestingness
7,11,b,c,d,e,f,g,h,11
7,12,b,c,d,e,f,g,h,11
7,9,b,c,d,e,f,g,h,9
7,10,b,c,d,e,f,g,h,9
8,11,b,c,d,e,f,g,h,12
8,12,b,c,d,e,f,g,h,12
8,9,b,c,d,e,f,g,h,10
8,10,b,c,d,e,f,g,h,10

7,13,b,c,d,e,f,g,h,11
7,14,b,c,d,e,f,g,h,11
8,13,b,c,d,e,f,g,h,14
8,14,b,c,d,e,f,g,h,14
9,13,b,c,d,e,f,g,h,11
9,14,b,c,d,e,f,g,h,11
10,13,b,c,d,e,f,g,h,14
10,14,b,c,d,e,f,g,h,14

9,11,b,c,d,e,f,g,h,11
9,12,b,c,d,e,f,g,h,11
10,11,b,c,d,e,f,g,h,12
10,12,b,c,d,e,f,g,h,12

13,11,b,c,d,e,f,g,h,11
13,12,b,c,d,e,f,g,h,11
14,11,b,c,d,e,f,g,h,12
14,12,b,c,d,e,f,g,h,12
13,9,b,c,d,e,f,g,h,11
14,9,b,c,d,e,f,g,h,12
"""

colours = """
0 0 0 0
1 255 255 255
2 127 127 127
7 0 0 255
8 0 0 127
9 255 0 0
10 127 0 0
11 0 255 0
12 0 127 0
13 255 255 0
14 127 127 0
"""
self.saverule("APG_ClassifyObjects_"+self.alphanumeric, comments, table, colours)

def saveContagiousLife(self):

comments = """
A variant of HistoricalLife used for detecting dependencies between
islands.

state 0: vacuum
state 1: ON
state 2: OFF
"""
table = "n_states:7\n"
table += "neighborhood:Moore\n"
table += "symmetries:permute\n\n"

table += self.newvars(["a","b","c","d","e","f","g","h","i"], range(0, 7, 1))
table += self.newvars(["la","lb","lc","ld","le","lf","lg","lh","li"], range(1, 7, 2))
table += self.newvars(["da","db","dc","dd","de","df","dg","dh","di"], range(0, 7, 2))
table += self.newvar("p",[3, 4])
table += self.newvars(["ta","tb","tc","td","te","tf","tg","th","ti"], [3])
table += self.newvars(["qa","qb","qc","qd","qe","qf","qg","qh","qi"], [0, 1, 2, 4, 5, 6])

for i in xrange(9):
if (self.bee[i]):
table += self.scoline("l","d",4,3,i)
table += self.scoline("l","d",2,1,i)
table += self.scoline("l","d",0,1,i)
table += self.scoline("l","d",6,5,i)
table += self.scoline("t","q",0,4,i)
if (self.ess[i]):
table += self.scoline("l","d",3,3,i)
table += self.scoline("l","d",5,5,i)
table += self.scoline("l","d",1,1,i)

table += "# Default behaviour (death):\n"
table += self.scoline("","",1,2,0)
table += self.scoline("","",5,6,0)
table += self.scoline("","",3,4,0)

colours = """
0 0 0 0
1 0 0 255
2 0 0 127
3 255 0 0
4 127 0 0
5 0 255 0
6 0 127 0
"""
self.saverule("APG_ContagiousLife_"+self.alphanumeric, comments, table, colours)

class Soup:

def __init__(self):

# The rule generator:
self.rg = RuleGenerator()

# Should we skip error-correction:
self.skipErrorCorrection = False

# A dict mapping binary representations of small possibly-pseudo-objects
# to their equivalent canonised representation.
#
# This is many-to-one, as (for example) all of these will map to
# the same pseudo-object (namely the beacon on block):
#
# ..**.** ..**.** **..... **.....
# ..**.** ...*.** **..... *......
# **..... *...... ..**... ...*.**
# **..... **..... ..**... [...12 others omitted...] ..**.**
# ....... ....... ....... .......
# ....... ....... ..**... .......
# ....... ....... ..**... .......
#
# The first few soups are much slower to process, as objects are being
# entered into the cache.
self.cache = {}

# A dict to store memoized decompositions of possibly-pseudo-objects
# into constituent parts. This is initialised with the unique minimal
# pseudo-still-life (two blocks on lock) that cannot be automatically
# separated by the routine pseudo_bangbang(). Any larger objects are
# ambiguous, such as this one:
#
# *
# * * **
# ** **
#
# * *** *
# ** * **
#
# Is it a (block on (lock on boat)) or ((block on lock) on boat)?
# Ahh, the joys of non-associativity.
#
# See http://paradise.caltech.edu/~cook/Workshop/CAs/2DOutTot/Life/StillLife/StillLifeTheory.html
self.decompositions = {"xs18_3pq3qp3": ["xs14_3123qp3", "xs4_33"]}

# A dict of objects in the form {"identifier": ("common name", points)}
#
# As a rough heuristic, an object is worth 15 + log2(n) points if it
# is n times rarer than the pentadecathlon.
#
# Still-lifes are limited to 10 points.
# p2 oscillators are limited to 20 points.
# p3 and p4 oscillators are limited to 30 points.
self.commonnames = {"xp3_co9nas0san9oczgoldlo0oldlogz1047210127401": ("pulsar", 8),
"xp15_4r4z4r4": ("pentadecathlon", 15),
"xp2_2a54": ("clock", 16),
"xp2_31ago": ("bipole", 17),
"xp2_0g0k053z32": ("quadpole", 18),
"xp2_g8gid1e8z1226": ("great on-off", 19),
"xp2_rhewehr": ("spark coil", 19),
"xp8_gk2gb3z11": ("figure-8", 20),
"xp4_37bkic": ("mold", 21),
"xp2_31a08zy0123cko": ("quadpole on ship", 20),
"xp2_g0k053z11": ("tripole", 20),
"xp4_ssj3744zw3": ("mazing", 23),
"xp8_g3jgz1ut": ("blocker", 24),
"xp3_695qc8zx33": ("jam", 24),
"xp30_w33z8kqrqk8zzzw33": ("cis-queen-bee-shuttle", 24),
"xp30_w33z8kqrqk8zzzx33": ("trans-queen-bee-shuttle", 24),
"xp4_8eh5e0e5he8z178a707a871": ("cloverleaf", 25),
"xp5_idiidiz01w1": ("octagon II", 26),
"xp6_ccb7w66z066": ("unix", 26),
"xp14_j9d0d9j": ("tumbler", 27),
"xp3_025qzrq221": ("trans-tub-eater", 28),
"xp3_4hh186z07": ("caterer", 29),
"xp3_025qz32qq1": ("cis-tub-eater", 30),
"xp8_wgovnz234z33": ("Tim Coe's p8", 31),
"xp5_3pmwmp3zx11": ("fumarole", 33),
"xp46_330279cx1aad3y833zx4e93x855bc": ("cis-twin-bees-shuttle", 35),
"xp46_330279cx1aad3zx4e93x855bcy8cc": ("trans-twin-bees-shuttle", 35),
"yl144_1_16_afb5f3db909e60548f086e22ee3353ac": ("block-laying switch engine", 16),
"yl384_1_59_7aeb1999980c43b4945fb7fcdb023326": ("glider-producing switch engine", 17),
"xp10_9hr": ("[HighLife] p10", 6),
"xp7_13090c8": ("[HighLife] p7", 9),
"xq48_07z8ca7zy1e531": ("[HighLife] bomber", 9),
"xq4_153": ("glider", 0),
"xq4_6frc": ("lightweight spaceship", 7),
"xq4_27dee6": ("middleweight spaceship", 9),
"xq4_27deee6": ("heavyweight spaceship", 12),
"xq7_3nw17862z6952": ("loafer", 70),
"xp2_7": ("blinker", 0),
"xs4_33": ("block", 0),
"xs4_252": ("tub", 0),
"xs5_253": ("boat", 0),
"xs6_bd": ("snake", 0),
"xs6_356": ("ship", 0),
"xs6_696": ("beehive", 0),
"xs6_25a4": ("barge", 0),
"xs6_39c": ("carrier", 0),
"xp2_7e": ("toad", 0),
"xp2_318c": ("beacon", 0),
"xs7_3lo": ("long snake", 0),
"xs7_25ac": ("long boat", 0),
"xs7_178c": ("eater", 0),
"xs7_2596": ("loaf", 0),
"xs8_178k8": ("twit", 0),
"xs8_32qk": ("hook with tail", 0),
"xs8_69ic": ("mango", 0),
"xs8_6996": ("pond", 0),
"xs8_25ak8": ("long barge", 0),
"xs8_3pm": ("shillelagh", 0),
"xs8_312ko": ("canoe", 0),
"xs8_31248c": ("very long snake", 0),
"xs8_35ac": ("long ship", 0),
"xs12_g8o653z11": ("ship-tie", 0),
"xs14_g88m952z121": ("half-bakery", 0),
"xs14_69bqic": ("paperclip", 0),
"xs9_31ego": ("integral sign", 0),
"xs10_g8o652z01": ("boat-tie", 0),
"xs14_g88b96z123": ("big ess", 0),
"xs16_g88m996z1221": ("bipond", 0),
"xs12_raar": ("table on table", 0),
"xs9_4aar": ("hat", 0),
"xs10_35ako": ("very long ship", 0),
"xs9_178ko": ("trans boat with tail", 0),
"xs15_354cgc453": ("moose antlers", 0),
"xs14_6970796": ("cis-mirrored r-bee", 0),
"xs10_32qr": ("block on table", 0),
"xs16_j1u0696z11": ("beehive on dock", 0),
"xs14_j1u066z11": ("block on dock", 0),
"xs11_g8o652z11": ("boat tie ship", 0),
"xs9_25ako": ("very long boat", 0),
"xs16_69egmiczx1": ("scorpion", 0),
"xs18_rhe0ehr": ("dead spark coil", 0),
"xs17_2ege1ege2": ("twinhat", 0),
"xs10_178kk8": ("beehive with tail", 0),
"xs10_69ar": ("loop", 0),
"xs14_69bo8a6": ("fourteener", 0),
"xs14_39e0e93": ("bookends", 0),
"xs9_178kc": ("cis boat with tail", 0),
"xs12_330f96": ("block and cap", 0),
"xs10_358gkc": ("10.003",0),
"xs12_330fho": ("trans block and longhook", 0),
"xs10_g0s252z11": ("prodigal sign", 0),
"xs11_g0s453z11": ("elevener", 0),
"xs14_6is079c": ("cis-rotated hook", 0),
"xs14_69e0eic": ("trans-mirrored R-bee", 0),
"xs11_ggm952z1": ("trans loaf with tail", 0),
"xs15_j1u06a4z11": ("cis boat and dock", 0),
"xs20_3lkkl3z32w23": ("mirrored dock", 0),
"xs12_178br": ("12.003",0),
"xs12_3hu066": ("cis block and longhook", 0),
"xs12_178c453": ("eater with nine", 0),
"xs10_0drz32": ("broken snake", 0),
"xs9_312453": ("long shillelagh", 0),
"xs10_3215ac": ("boat with long tail", 0),
"xs14_39e0e96": ("cis-hook and R-bee", 0),
"xs13_g88m96z121": ("beehive at loaf", 0),
"xs14_39e0eic": ("trans hook and R-bee", 0),
"xs10_3542ac": ("S-ten", 0),
"xs15_259e0eic": ("trans R-bee and R-loaf", 0),
"xs11_178jd": ("11-loop", 0),
"xs9_25a84c": ("tub with long tail", 0),
"xs15_3lkm96z01": ("bee-hat", 0),
"xs14_g8o0e96z121": ("cis-rotated R-bee", 0),
"xs13_69e0mq": ("R-bee and snake", 0),
"xs11_69lic": ("11.003", 0),
"xs12_6960ui": ("beehive and table", 0),
"xs16_259e0e952": ("cis-mirrored R-loaf", 0),
"xs10_1784ko": ("8-snake-eater", 0),
"xs13_4a960ui": ("ortho loaf and table", 0),
"xs9_g0g853z11": ("long canoe", 0),
"xs18_69is0si96": ("[cis-mirrored R-mango]", 0),
"xs11_178kic": ("cis loaf with tail", 0),
"xs16_69bob96": ("symmetric scorpion", 0),
"xs13_0g8o653z121": ("longboat on ship", 0),
"xs12_o4q552z01": ("beehive at beehive", 0),
"xs10_ggka52z1": ("trans barge with tail", 0),
"xs12_256o8a6": ("eater on boat", 0),
"xs14_6960uic": ("beehive with cap", 0),
"xs12_2egm93": ("snorkel loop", 0),
"xs12_2egm96": ("beehive bend tail", 0),
"xs11_g0s253z11": ("trans boat with nine", 0),
"xs15_3lk453z121": ("trans boat and dock", 0),
"xs19_69icw8ozxdd11": ("[mango with block on dock]", 0),
"xs13_2530f96": ("[cis boat and cap]", 0),
"xs11_2530f9": ("cis boat and table", 0),
"xs14_4a9m88gzx121": ("[bi-loaf2]", 0),
"xs11_ggka53z1": ("trans longboat with tail", 0),
"xs18_2egm9a4zx346": ("[loaf eater tail]", 0),
"xs15_4a9raic": ("[15-bent-paperclip]", 0),
"xs11_3586246": ("[11-snake]",0),
"xs11_178b52": ("[11-boat wrap tail]", 0),
"xs14_08u1e8z321": ("[hat join hook]", 0),
"xs14_g4s079cz11": ("[cis-mirrored offset hooks]", 0),
"xs13_31egma4": ("[13-boat wrap eater]", 0),
"xs14_69960ui": ("pond and table", 0),
"xs13_255q8a6": ("[eater tie beehive]", 0),
"xs15_09v0ccz321": ("[hook join table and block]",0)}

# First soup to contain a particular object:
self.alloccur = {}

# A tally of objects that have occurred during this run of apgsearch:
self.objectcounts = {}

# Any soups with positive scores, and the number of points.
self.soupscores = {}

# Temporary list of unidentified objects:
self.unids = []

# Things like glider guns and large oscillators belong here:
self.superunids = []
self.gridsize = 0
self.resets = 0

# For profiling purposes:
self.qlifetime = 0.0
self.ruletime = 0.0
self.gridtime = 0.0

# Increment object count by given value:
def incobject(self, obj, incval):
if (incval > 0):
if obj in self.objectcounts:
self.objectcounts[obj] = self.objectcounts[obj] + incval
else:
self.objectcounts[obj] = incval

# Increment soup score by given value:
def awardpoints(self, soupid, incval):
if (incval > 0):
if soupid in self.soupscores:
self.soupscores[soupid] = self.soupscores[soupid] + incval
else:
self.soupscores[soupid] = incval

# Increment soup score by appropriate value:
def awardpoints2(self, soupid, obj):

# Record the occurrence of this object:
if (obj in self.alloccur):
if (len(self.alloccur[obj]) < 10):
if (soupid not in self.alloccur[obj]):
self.alloccur[obj] += [soupid]
else:
self.alloccur[obj] = [soupid]

if obj in self.commonnames:
self.awardpoints(soupid, self.commonnames[obj][1])
elif (obj[0] == 'x'):
prefix = obj.split('_')[0]
prenum = int(prefix[2:])
if (obj[1] == 's'):
self.awardpoints(soupid, min(prenum, 20)) # for still-lifes, award one point per constituent cell (max 20)
elif (obj[1] == 'p'):
if (prenum == 2):
self.awardpoints(soupid, 20) # p2 oscillators are limited to 20 points
elif ((prenum == 3) | (prenum == 4)):
self.awardpoints(soupid, 30) # p3 and p4 oscillators are limited to 30 points
else:
self.awardpoints(soupid, 40)
else:
self.awardpoints(soupid, 50)
else:
self.awardpoints(soupid, 60)

# Assuming the pattern has stabilised, perform a census:
def census(self, stepsize):

g.setrule("APG_CoalesceObjects_" + self.rg.alphanumeric)
g.setbase(2)
g.setstep(stepsize)
g.step()

# apgsearch theoretically supports up to 2^14 rules, whereas the Guy
# glider is only stable in 2^8 rules. Ensure that this is one of these
# rules by doing some basic Boolean arithmetic.
#
# This should be parsed as `gliders exist', not `glider sexist':
glidersexist = self.rg.ess[2] & self.rg.ess[3] & (not self.rg.ess[1]) & (not self.rg.ess[4])
glidersexist = glidersexist & (not (self.rg.bee[4] | self.rg.bee[5]))

if (glidersexist):
g.setrule("APG_IdentifyGliders")
g.setbase(2)
g.setstep(2)
g.step()

g.setrule("APG_ClassifyObjects_" + self.rg.alphanumeric)
g.setbase(2)
g.setstep(max(8, stepsize))
g.step()

# Only do this if we have an infinite-growth pattern:
if (stepsize > 8):
g.setrule("APG_HandlePlumesCorrected")
g.setbase(2)
g.setstep(1)
g.step()
g.setrule("APG_ClassifyObjects_" + self.rg.alphanumeric)
g.setstep(stepsize)
g.step()

# Remove any gliders:
if (glidersexist):
g.setrule("APG_ExpungeGliders")
g.run(1)
pop5 = int(g.getpop())
g.run(1)
pop6 = int(g.getpop())
self.incobject("xq4_153", (pop5 - pop6)/5)

# Remove any blocks, blinkers and beehives:
g.setrule("APG_ExpungeObjects")
pop0 = int(g.getpop())
g.run(1)
pop1 = int(g.getpop())
g.run(1)
pop2 = int(g.getpop())
g.run(1)
pop3 = int(g.getpop())
g.run(1)
pop4 = int(g.getpop())

# Blocks, blinkers and beehives removed by ExpungeObjects:
self.incobject("xs1_1", (pop0-pop1))
self.incobject("xs4_33", (pop1-pop2)/4)
self.incobject("xp2_7", (pop2-pop3)/5)
self.incobject("xs6_696", (pop3-pop4)/8)

# Removes an object incident with (ix, iy) and returns the cell list:
def grabobj(self, ix, iy):

allcells = [ix, iy, g.getcell(ix, iy)]
g.setcell(ix, iy, 0)
livecells = []
deadcells = []

marker = 0
ll = 3

while (marker < ll):
x = allcells[marker]
y = allcells[marker+1]
z = allcells[marker+2]
marker += 3

if ((z % 2) == 1):
livecells.append(x)
livecells.append(y)
else:
deadcells.append(x)
deadcells.append(y)

for nx in xrange(x - 1, x + 2):
for ny in xrange(y - 1, y + 2):

nz = g.getcell(nx, ny)
if (nz > 0):
allcells.append(nx)
allcells.append(ny)
allcells.append(nz)
g.setcell(nx, ny, 0)
ll += 3

return livecells

# Command to Grab, Remove and IDentify an OBJect:
def gridobj(self, ix, iy, gsize, gspacing, pos):

allcells = [ix, iy, g.getcell(ix, iy)]
g.setcell(ix, iy, 0)
livecells = []
deadcells = []

# This tacitly assumes the object is smaller than 1000-by-1000.
# But this is okay, since it is only used by the routing logic.
dleft = ix + 1000
dright = ix - 1000
dtop = iy + 1000
dbottom = iy - 1000

lleft = ix + 1000
lright = ix - 1000
ltop = iy + 1000
lbottom = iy - 1000

lpop = 0
dpop = 0

marker = 0
ll = 3

while (marker < ll):
x = allcells[marker]
y = allcells[marker+1]
z = allcells[marker+2]
marker += 3

if ((z % 2) == 1):
livecells.append(x)
livecells.append(y)
lleft = min(lleft, x)
lright = max(lright, x)
ltop = min(ltop, y)
lbottom = max(lbottom, y)
lpop += 1
else:
deadcells.append(x)
deadcells.append(y)
dleft = min(dleft, x)
dright = max(dright, x)
dtop = min(dtop, y)
dbottom = max(dbottom, y)
dpop += 1

for nx in xrange(x - 1, x + 2):
for ny in xrange(y - 1, y + 2):

nz = g.getcell(nx, ny)
if (nz > 0):
allcells.append(nx)
allcells.append(ny)
allcells.append(nz)
g.setcell(nx, ny, 0)
ll += 3

lwidth = max(0, 1 + lright - lleft)
lheight = max(0, 1 + lbottom - ltop)
dwidth = max(0, 1 + dright - dleft)
dheight = max(0, 1 + dbottom - dtop)

llength = max(lwidth, lheight)
lbreadth = min(lwidth, lheight)
dlength = max(dwidth, dheight)
dbreadth = min(dwidth, dheight)

self.gridsize = max(self.gridsize, llength)

objid = "unidentified"
bitstring = 0

if (lpop == 0):
objid = "nothing"
else:
if ((lwidth <= 7) & (lheight <= 7)):
for i in xrange(0, lpop*2, 2):
bitstring += (1 << ((livecells[i] - lleft) + 7*(livecells[i + 1] - ltop)))

if bitstring in self.cache:
objid = self.cache[bitstring]

if (objid == "unidentified"):
# This has passed through the routing logic without being identified,
# so save it in a temporary list for later identification:
self.unids.append(bitstring)
self.unids.append(livecells)
self.unids.append(lleft)
self.unids.append(ltop)
elif (objid != "nothing"):
# The object is non-empty, so add it to the census:
ux = int(0.5 + float(lleft)/float(gspacing))
uy = int(0.5 + float(ltop)/float(gspacing))
soupid = ux + (uy * gsize) + pos

# Check whether the cached object is in the set of decompositions
# (this is usually the case, unless for example it is a high-period
# albeit small spaceship):
if objid in self.decompositions:
for comp in self.decompositions[objid]:
self.incobject(comp, 1)
self.awardpoints2(soupid, comp)
else:
self.incobject(objid, 1)
self.awardpoints2(soupid, objid)

# Tests for population periodicity:
def naivestab(self, period, security, length):

depth = 0
prevpop = 0
for i in xrange(length):
g.run(period)
currpop = int(g.getpop())
if (currpop == prevpop):
depth += 1
else:
depth = 0
prevpop = currpop
if (depth == security):
# Population is periodic.
return True

return False

# This should catch most short-lived soups with few gliders produced:
def naivestab2(self, period, length):

for i in xrange(length):
r = g.getrect()
if (len(r) == 0):
return True
pop0 = int(g.getpop())
g.run(period)
hash1 = g.hash(r)
pop1 = int(g.getpop())
g.run(period)
hash2 = g.hash(r)
pop2 = int(g.getpop())

if ((hash1 == hash2) & (pop0 == pop1) & (pop1 == pop2)):

if (g.getrect() == r):
return True

g.run((2*int(max(r[2], r[3])/period)+1)*period)
hash3 = g.hash(r)
pop3 = int(g.getpop())
if ((hash2 == hash3) & (pop2 == pop3)):
return True

return False

# Runs a pattern until stabilisation with a 99.99996% success rate.
# False positives are handled by a later error-correction stage.
def stabilise3(self):

# Phase I of stabilisation detection, designed to weed out patterns
# that stabilise into a cluster of low-period oscillators within
# about 6000 generations.

if (self.naivestab2(12, 10)):
return 4;

if (self.naivestab(12, 30, 200)):
return 4;

if (self.naivestab(30, 30, 200)):
return 5;

# Phase II of stabilisation detection, which is much more rigorous
# and based on oscar.py.

# Should be sufficient:
prect = [-2000, -2000, 4000, 4000]

# initialize lists
hashlist = [] # for pattern hash values
genlist = [] # corresponding generation counts

for j in xrange(4000):

g.run(30)

h = g.hash(prect)

# determine where to insert h into hashlist
pos = 0
listlen = len(hashlist)
while pos < listlen:
if h > hashlist[pos]:
pos += 1
elif h < hashlist[pos]:
# shorten lists and append info below
del hashlist[pos : listlen]
del genlist[pos : listlen]
break
else:
period = (int(g.getgen()) - genlist[pos])

prevpop = g.getpop()

for i in xrange(20):
g.run(period)
currpop = g.getpop()
if (currpop != prevpop):
period = max(period, 4000)
break
prevpop = currpop

return max(1 + int(math.log(period, 2)),3)

hashlist.insert(pos, h)
genlist.insert(pos, int(g.getgen()))

g.setalgo("HashLife")
g.setrule(self.rg.slashed)
g.setbase(2)
g.setstep(16)
g.step()
stepsize = 12
g.setalgo("QuickLife")
g.setrule(self.rg.slashed)

return 12

# Differs from oscar.py in that it detects absolute cycles, not eventual cycles.
def bijoscar(self, maxsteps):

initpop = int(g.getpop())
initrect = g.getrect()
if (len(initrect) == 0):
return 0
inithash = g.hash(initrect)

for i in xrange(maxsteps):

g.run(1)

if (int(g.getpop()) == initpop):

prect = g.getrect()
phash = g.hash(prect)

if (phash == inithash):

period = i + 1

if (prect == initrect):
return period
else:
return -period
return -1

# For a non-moving unidentified object, we check the dictionary of
# memoized decompositions of possibly-pseudo-objects. If the object is
# not already in the dictionary, it will be memoized.
#
# Low-period spaceships are also separated by this routine, although
# this is less important now that there is a more bespoke prodecure
# to handle disjoint unions of standard spaceships.
#
# @param moving a bool which specifies whether the object is moving
def enter_unid(self, unidname, soupid, moving):

if not(unidname in self.decompositions):

# Separate into pure components:
if (moving):
g.setrule("APG_CoalesceObjects_" + self.rg.alphanumeric)
g.setbase(2)
g.setstep(3)
g.step()
else:
pseudo_bangbang(self.rg.alphanumeric)

listoflists = [] # which incidentally don't contain themselves.

# Someone who plays the celllo:
celllist = g.join(g.getcells(g.getrect()), [0])

for i in xrange(0, len(celllist)-1, 3):
if (g.getcell(celllist[i], celllist[i+1]) != 0):
livecells = self.grabobj(celllist[i], celllist[i+1])
if (len(livecells) > 0):
listoflists.append(livecells)

listofobjs = []

for livecells in listoflists:

g.new("Subcomponent")
g.setalgo("QuickLife")
g.setrule(self.rg.slashed)
g.putcells(livecells)
period = self.bijoscar(1000)
canonised = canonise(abs(period))
if (period < 0):
listofobjs.append("xq"+str(0-period)+"_"+canonised)
elif (period == 1):
listofobjs.append("xs"+str(len(livecells)/2)+"_"+canonised)
else:
listofobjs.append("xp"+str(period)+"_"+canonised)

self.decompositions[unidname] = listofobjs

# Actually add to the census:
for comp in self.decompositions[unidname]:
self.incobject(comp, 1)
self.awardpoints2(soupid, comp)

# This function has lots of arguments (hence the name):
#
# @param gsize the square-root of the number of soups per page
# @param gspacing the minimum distance between centres of soups
# @param ashes a list of cell lists
# @param stepsize binary logarithm of amount of time to coalesce objects
# @param intergen binary logarithm of amount of time to run HashLife
# @param pos the index of the first soup on the page
def teenager(self, gsize, gspacing, ashes, stepsize, intergen, pos):

# For error-correction:
if (intergen > 0):
g.setalgo("HashLife")
g.setrule(self.rg.slashed)

# If this gets incremented, we panic and perform error-correction:
pathological = 0

# Draw the soups:
for i in xrange(gsize * gsize):

x = int(i % gsize)
y = int(i / gsize)

g.putcells(ashes[3*i], gspacing * x, gspacing * y)

# Because why not?
g.fit()
g.update()

# For error-correction:
if (intergen > 0):
g.setbase(2)
g.setstep(intergen)
g.step()

# Apply rules to coalesce objects and expunge annoyances such as
# blocks, blinkers, beehives and gliders:
start_time = time.clock()
self.census(stepsize)
end_time = time.clock()
self.ruletime += (end_time - start_time)

# Now begin identifying objects:
start_time = time.clock()
celllist = g.join(g.getcells(g.getrect()), [0])

if (len(celllist) > 2):
for i in xrange(0, len(celllist)-1, 3):
if (g.getcell(celllist[i], celllist[i+1]) != 0):
self.gridobj(celllist[i], celllist[i+1], gsize, gspacing, pos)

# If we have leftover unidentified objects, attempt to canonise them:
while (len(self.unids) > 0):
ux = int(0.5 + float(self.unids[-2])/float(gspacing))
uy = int(0.5 + float(self.unids[-1])/float(gspacing))
soupid = ux + (uy * gsize) + pos
unidname = self.process_unid()
if (unidname == "PATHOLOGICAL"):
pathological += 1
if (unidname != "nothing"):

if ((unidname[0] == 'U') & (unidname[1] == 'S') & (unidname[2] == 'S')):

# Union of standard spaceships:
countlist = unidname.split('_')

self.incobject("xq4_6frc", int(countlist[1]))
for i in xrange(int(countlist[1])):
self.awardpoints2(soupid, "xq4_6frc")

self.incobject("xq4_27dee6", int(countlist[2]))
for i in xrange(int(countlist[2])):
self.awardpoints2(soupid, "xq4_27dee6")

self.incobject("xq4_27deee6", int(countlist[3]))
for i in xrange(int(countlist[3])):
self.awardpoints2(soupid, "xq4_27deee6")

elif ((unidname[0] == 'x') & ((unidname[1] == 's') | (unidname[1] == 'p'))):
self.enter_unid(unidname, soupid, False)
else:
if ((unidname[0] == 'x') & (unidname[1] == 'q') & (unidname[3] == '_')):
# Separates low-period (<= 9) non-standard spaceships in medium proximity:
self.enter_unid(unidname, soupid, True)
else:
self.incobject(unidname, 1)
self.awardpoints2(soupid, unidname)

end_time = time.clock()
self.gridtime += (end_time - start_time)

return pathological

def stabilise_soups_parallel(self, root, pos, gsize, sym):

souplist = [[sym, root + str(pos + i)] for i in xrange(gsize * gsize)]

return self.stabilise_soups_parallel_orig(gsize, souplist, pos)

def stabilise_soups_parallel_list(self, gsize, stringlist, pos):

souplist = [s.split('/') for s in stringlist]

return self.stabilise_soups_parallel_orig(gsize, souplist, pos)

# This basically orchestrates everything:
def stabilise_soups_parallel_orig(self, gsize, souplist, pos):

ashes = []
stepsize = 3

g.new("Random soups")
g.setalgo("QuickLife")
g.setrule(self.rg.slashed)

gspacing = 0

# Generate and run the soups until stabilisation:
for i in xrange(gsize * gsize):

if (i < len(souplist)):

sym = souplist[i][0]
prehash = souplist[i][1]

# Generate the soup from the SHA-256 of the concatenation of the
# seed with the index:
g.putcells(hashsoup(prehash, sym), 0, 0)

# Run the soup until stabilisation:
start_time = time.clock()
stepsize = max(stepsize, self.stabilise3())
end_time = time.clock()
self.qlifetime += (end_time - start_time)

# Ironically, the spelling of this variable is incurrrect:
currrect = g.getrect()
ashes.append(g.getcells(currrect))

if (len(currrect) == 4):
ashes.append(currrect[0])
ashes.append(currrect[1])
# Choose the grid spacing based on the size of the ash:
gspacing = max(gspacing, 2*currrect[2])
gspacing = max(gspacing, 2*currrect[3])
g.select(currrect)
g.clear(0)
else:
ashes.append(0)
ashes.append(0)
g.select([])

# Account for any extra enlargement caused by running CoalesceObjects:
gspacing += 2 ** (stepsize + 1) + 1000

start_time = time.clock()

# Remember the dictionary, just in case we have a pathological object:
prevdict = self.objectcounts.copy()
prevscores = self.soupscores.copy()
prevunids = self.superunids[:]

# Process the soups:
returncode = self.teenager(gsize, gspacing, ashes, stepsize, 0, pos)

end_time = time.clock()

# Calculate the mean delay incurred (excluding qlifetime or error-correction):
meandelay = (end_time - start_time) / (gsize * gsize)

if (returncode > 0):
if (self.skipErrorCorrection == False):
# Arrrggghhhh, there's a pathological object! Usually this means
# that naive stabilisation detection returned a false positive.
self.resets += 1

# Reset the object counts:
self.objectcounts = prevdict
self.soupscores = prevscores
self.superunids = prevunids

# 2^18 generations should suffice. This takes about 30 seconds in
# HashLife, but error-correction only occurs very infrequently, so
# this has a negligible impact on mean performance:
gspacing += 2 ** 19
stepsize = max(stepsize, 12)

# Clear the universe:
g.new("Error-correcting phase")
self.teenager(gsize, gspacing, ashes, stepsize, 18, pos)

# Erase any ashes. Not least because England usually loses...
ashes = []

# Return the mean delay so that we can use machine-learning to
# find the optimal value of sqrtspp:
return meandelay

def reset(self):

self.objectcounts = {}
self.soupscores = {}
self.alloccur = {}
self.superunids = []
self.unids = []

# Pop the last unidentified object from the stack, and attempt to
# ascertain its period and classify it.
def process_unid(self):

g.new("Unidentified object")
g.setalgo("QuickLife")
g.setrule(self.rg.slashed)
y = self.unids.pop()
x = self.unids.pop()
livecells = self.unids.pop()
bitstring = self.unids.pop()
g.putcells(livecells, -x, -y, 1, 0, 0, 1, "or")
period = self.bijoscar(1000)

if (period == -1):
# Infinite growth pattern, probably. Most infinite-growth
# patterns are linear-growth (such as puffers, wickstretchers,
# guns etc.) so we analyse to see whether we have a linear-
# growth pattern:
descriptor = linearlyse(1500)
if (descriptor[0] == "y"):
return descriptor

# Similarly check for irregular power-law growth. This will
# catch replicators, for instance. Spend around 375 000
# generations; this seems like a reasonable amount of time.
descriptor = powerlyse(8, 1500)
if (descriptor[0] == "z"):
return descriptor

# It may be an unstabilised ember that slipped through the net,
# but this will be handled by error-correction (unless it
# persists another 2^18 gens, which is so unbelievably improbable
# that you are more likely to be picked up by a passing ship in
# the vacuum of space).
self.superunids.append(livecells)
self.superunids.append(x)
self.superunids.append(y)

return "PATHOLOGICAL"
elif (period == 0):
return "nothing"
else:
if (period == -4):

triple = countxwsses()

if (triple != (-1, -1, -1)):

# Union of Standard Spaceships:
return ("USS_" + str(triple[0]) + "_" + str(triple[1]) + "_" + str(triple[2]))

canonised = canonise(abs(period))

if (canonised == "#"):

# Okay, we know that it's an oscillator or spaceship with
# a non-astronomical period. But it's too large to canonise
# in any of its phases (i.e. transcends a 40-by-40 box).
self.superunids.append(livecells)
self.superunids.append(x)
self.superunids.append(y)

# Append a suffix according to whether it is a still-life,
# oscillator or moving object:
if (period == 1):
descriptor = ("ov_s"+str(len(livecells)/2))
elif (period > 0):
descriptor = ("ov_p"+str(period))
else:
descriptor = ("ov_q"+str(0-period))

return descriptor

else:

# Prepend a prefix according to whether it is a still-life,
# oscillator or moving object:
if (period == 1):
descriptor = ("xs"+str(len(livecells)/2)+"_"+canonised)
elif (period > 0):
descriptor = ("xp"+str(period)+"_"+canonised)
else:
descriptor = ("xq"+str(0-period)+"_"+canonised)

if (bitstring > 0):
self.cache[bitstring] = descriptor

return descriptor

# This doesn't really do much, since unids should be empty and
# actual pathological/oversized objects will rarely arise naturally.
def display_unids(self):

g.new("Unidentified objects")
g.setalgo("QuickLife")
g.setrule(self.rg.slashed)

rowlength = 1 + int(math.sqrt(len(self.superunids)/3))

for i in xrange(len(self.superunids)/3):

xpos = i % rowlength
ypos = int(i / rowlength)

g.putcells(self.superunids[3*i], xpos * (self.gridsize + 8) - self.superunids[3*i + 1], ypos * (self.gridsize + 8) - self.superunids[3*i + 2], 1, 0, 0, 1, "or")

g.fit()
g.update()

def compactify_scores(self):

# Number of soups to record:
highscores = 100
ilist = sorted(self.soupscores.iteritems(), key=operator.itemgetter(1), reverse=True)

# Empty the high score table:
self.soupscores = {}

for soupnum, score in ilist[:highscores]:
self.soupscores[soupnum] = score

# Saves a machine-readable textual file containing the census:
def save_progress(self, numsoups, root, symmetry='C1', save_file=True, payosha256_key=None):

g.show("Saving progress...")

# Count the total number of objects:
totobjs = 0
censustable = "@CENSUS TABLE\n"
tlist = sorted(self.objectcounts.iteritems(), key=operator.itemgetter(1), reverse=True)
for objname, count in tlist:
totobjs += count
censustable += objname + " " + str(count) + "\n"

g.show("Writing header information...")

# The MD5 hash of the root string:
md5root = hashlib.md5(root).hexdigest()

# Header information:
results = "@VERSION v1.1\n"
results += "@MD5 "+md5root+"\n"
results += "@ROOT "+root+"\n"
results += "@RULE "+self.rg.alphanumeric+"\n"
results += "@SYMMETRY "+symmetry+"\n"
results += "@NUM_SOUPS "+str(numsoups)+"\n"
results += "@NUM_OBJECTS "+str(totobjs)+"\n"

results += "\n"

# Census table:
results += censustable

g.show("Compactifying score table...")

results += "\n"

# Number of soups to record:
highscores = 100

results += "@TOP "+str(highscores)+"\n"

ilist = sorted(self.soupscores.iteritems(), key=operator.itemgetter(1), reverse=True)

# Empty the high score table:
self.soupscores = {}

for soupnum, score in ilist[:highscores]:
self.soupscores[soupnum] = score
results += str(soupnum) + " " + str(score) + "\n"

g.show("Saving soupids for rare objects...")

results += "\n@SAMPLE_SOUPIDS\n"
for objname, count in tlist:
# blinkers and gliders have no alloccur[] entry for some reason,
# so the line below avoids errors in B3/S23, maybe other rules too?
if objname in self.alloccur:
results += objname
for soup in self.alloccur[objname]:
results += " " + str(soup)
results += "\n"

g.show("Writing progress file...")

dirname = g.getdir("data")
separator = dirname[-1]
progresspath = dirname + "apgsearch" + separator + "progress" + separator
if not os.path.exists(progresspath):
os.makedirs(progresspath)

filename = progresspath + "search_" + md5root + ".txt"

try:
f = open(filename, 'w')
f.write(results)
f.close()
except:
g.warn("Unable to create progress file:\n" + filename)

if payosha256_key is not None:
if (len(payosha256_key) > 0):
return catagolue_results(results, payosha256_key, "post_apgsearch_haul")

# Save soup RLE:
def save_soup(self, root, soupnum, symmetry):

# Soup pattern will be stored in a temporary directory:
souphash = hashlib.sha256(root + str(soupnum))
rlepath = souphash.hexdigest()
rlepath = g.getdir("temp") + rlepath + ".rle"

results = "<a href=\"open:" + rlepath + "\">"
results += str(soupnum)
results += "</a>"

# Try to write soup patterns to file "rlepath":
try:
g.store(hashsoup(root + str(soupnum), symmetry), rlepath)
except:
g.warn("Unable to create soup pattern:\n" + rlepath)

return results

# Display results in Help window:
def display_census(self, numsoups, root, symmetry):

dirname = g.getdir("data")
separator = dirname[-1]
apgpath = dirname + "apgsearch" + separator
objectspath = apgpath + "objects" + separator + self.rg.alphanumeric + separator
if not os.path.exists(objectspath):
os.makedirs(objectspath)

results = "<html>\n<title>Census results</title>\n<body bgcolor=\"#FFFFCE\">\n"
results += "Census results after processing " + str(numsoups) + " soups (seed = " + root + ", symmetry = " + symmetry + "):\n"

tlist = sorted(self.objectcounts.iteritems(), key=operator.itemgetter(1), reverse=True)
results += "<center>\n"
results += "<table cellspacing=1 border=2 cols=2>\n"
results += "<tr><td> Object </td><td align=center> Common name </td>\n"
results += "<td align=right> Count </td><td> Sample occurrences </td></tr>\n"
for objname, count in tlist:
if (objname[0] == 'x'):
if (objname[1] == 'p'):
results += "<tr bgcolor=\"#CECECF\">"
elif (objname[1] == 'q'):
results += "<tr bgcolor=\"#CEFFCE\">"
else:
results += "<tr>"
else:
results += "<tr bgcolor=\"#FFCECE\">"
results += "<td>"
results += " "

# Using "open:" link enables one to click on the object name to open the pattern in Golly:
rlepath = objectspath + objname + ".rle"
if (objname[0] == 'x'):
results += "<a href=\"open:" + rlepath + "\">"
# If the name is longer than that of the block-laying switch engine:
if len(objname) > 51:
# Contract name and include ellipsis:
results += objname[:40] + "…" + objname[-10:]
else:
results += objname
if (objname[0] == 'x'):
results += "</a>"
results += " "

if (objname[0] == 'x'):
# save object in rlepath if it doesn't exist
if not os.path.exists(rlepath):
# Canonised objects are at most 40-by-40:
rledata = "x = 40, y = 40, rule = " + self.rg.slashed + "\n"
# http://ferkeltongs.livejournal.com/15837.html
compact = objname.split('_')[1] + "z"
i = 0
strip = []
while (i < len(compact)):
c = ord2(compact[i])
if (c >= 0):
if (c < 32):
# Conventional character:
strip.append(c)
else:
if (c == 35):
# End of line:
if (len(strip) == 0):
strip.append(0)
for j in xrange(5):
for d in strip:
if ((d & (1 << j)) > 0):
rledata += "o"
else:
rledata += "b"
rledata += "$\n"
strip = []
else:
# Multispace character:
strip.append(0)
strip.append(0)
if (c >= 33):
strip.append(0)
if (c == 34):
strip.append(0)
i += 1
d = ord2(compact[i])
for j in xrange(d):
strip.append(0)
i += 1
# End of pattern representation:
rledata += "!\n"
try:
f = open(rlepath, 'w')
f.write(rledata)
f.close()
except:
g.warn("Unable to create object pattern:\n" + rlepath)

results += "</td><td align=center> "
if (objname in self.commonnames):
results += self.commonnames[objname][0]
results += " </td><td align=right> " + str(count) + " "
results += "</td><td>"
if objname in self.alloccur:
results += " "
for soup in self.alloccur[objname]:
results += self.save_soup(root, soup, symmetry)
results += " "
results += "</td></tr>\n"
results += "</table>\n</center>\n"

ilist = sorted(self.soupscores.iteritems(), key=operator.itemgetter(1), reverse=True)
results += "<center>\n"
results += "<table cellspacing=1 border=2 cols=2>\n"
results += "<tr><td> Soup number </td><td align=right> Score </td></tr>\n"
for soupnum, score in ilist[:50]:
results += "<tr><td> "
results += self.save_soup(root, soupnum, symmetry)
results += " </td><td align=right> " + str(score) + " </td></tr>\n"

results += "</table>\n</center>\n"
results += "</body>\n</html>\n"

htmlname = apgpath + "latest_census.html"
try:
f = open(htmlname, 'w')
f.write(results)
f.close()
g.open(htmlname)
except:
g.warn("Unable to create html file:\n" + htmlname)

# Converts a base-36 case-insensitive alphanumeric character into a
# numerical value.
def ord2(char):

x = ord(char)

if ((x >= 48) & (x < 58)):
return x - 48

if ((x >= 65) & (x < 91)):
return x - 55

if ((x >= 97) & (x < 123)):
return x - 87

return -1

def apg_verify(rulestring, symmetry, payoshakey):

verifysoup = Soup()
verifysoup.rg.setrule(rulestring)
verifysoup.rg.saveAllRules()

return_point = [None]

catagolue_results(rulestring+"\n"+symmetry+"\n", payoshakey, "verify_apgsearch_haul", endpoint="/verify", return_point=return_point)

if return_point[0] is not None:

resplist = return_point[0].split("\n")

if ((len(resplist) >= 4) and (resplist[1] == "yes")):

md5 = resplist[2]
passcode = resplist[3]

stringlist = resplist[4:]

stringlist = [s for s in stringlist if (len(s) > 0 and s[0] != '*')]

# g.exit(stringlist[0])

gsize = 3

pos = 0

while (len(stringlist) > 0):

while (gsize * gsize > len(stringlist)):

gsize -= 1

listhead = stringlist[:(gsize*gsize)]
stringlist = stringlist[(gsize*gsize):]

verifysoup.stabilise_soups_parallel_list(gsize, listhead, pos)

pos += (gsize * gsize)

# verifysoup.display_census(-1, "verify", "verify")

payload = "@MD5 "+md5+"\n"
payload += "@PASSCODE "+passcode+"\n"
payload += "@RULE "+rulestring+"\n"
payload += "@SYMMETRY "+symmetry+"\n"

tlist = sorted(verifysoup.objectcounts.iteritems(), key=operator.itemgetter(1), reverse=True)

for objname, count in tlist:

payload += objname + " " + str(count) + "\n"

catagolue_results(payload, payoshakey, "submit_verification", endpoint="/verify")

def apg_main():

# ---------------- Hardcode the following inputs if running without a user interface ----------------
orignumber = int(g.getstring("How many soups to search between successive uploads?", "5000000"))
rulestring = g.getstring("Which rule to use?", "B3/S23")
symmstring = g.getstring("What symmetries to use?", "C1")
payoshakey = g.getstring("Please enter your key (visit "+get_server_address()+"/payosha256 in your browser).", "#anon")
# ---------------------------------------------------------------------------------------------------

# Sanitise input:
#orignumber = max(orignumber, 100000)
#orignumber = min(orignumber, 100000000)
number = orignumber
initpos = 0
if symmstring not in ["1x256X2+1", "1x256X2", "32x32", "25p", "75p", "1x256", "2x128", "4x64", "8x32", "C1", "C2_1", "C2_2", "C2_4", "C4_1", "C4_4", "D2_+1", "D2_+2", "D2_x", "D4_+1", "D4_+2", "D4_+4", "D4_x1", "D4_x4", "D8_1", "D8_4"]:
g.exit(symmstring+" is not a valid symmetry option")

if symmstring in ["25p"]:
g.exit(symmstring+" is faulty and DOES NOT WORK CORRECTLY")

quitapg = False

# Create associated rule tables:
soup = Soup()
soup.rg.setrule(rulestring)
soup.rg.saveAllRules()

# We have 100 soups per page, instead of one. This parallel approach
# was suggested by Tomas Rokicki, and results in approximately a
# fourfold increase in soup-searching speed!
sqrtspp_optimal = 10

# Initialise the census:
start_time = time.clock()
f = (lambda x : 'abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'[ord(x) % 56])
rootstring = ''.join(map(f, list(hashlib.sha256(payoshakey + datetime.datetime.now().isoformat()).digest()[:12])))
scount = 0

while (quitapg == False):

# Peer-review some soups:
for i in xrange(5):
apg_verify("b3s23", "32x32", payoshakey)
apg_verify("b3s23", "4x64", payoshakey)
apg_verify("b3s23", "2x128", payoshakey)
apg_verify("b3s23", "1x256", payoshakey)
apg_verify("b3s23", "1x256X2", payoshakey)
apg_verify("b3s23", "1x256X2+1", payoshakey)

# The 'for' loop has been replaced with a 'while' loop to allow sqrtspp
# to vary during runtime. The idea is that apgsearch can apply a basic
# form of machine-learning to dynamically locate the optimum sqrtspp:
while (scount < number):

delays = [0.0, 0.0, 0.0]

for i in xrange(1000):

page_time = time.clock()

sqrtspp = (sqrtspp_optimal + (i % 3) - 1) if (i < 150) else (sqrtspp_optimal)

# Don't overrun:
while (scount + sqrtspp * sqrtspp > number):
sqrtspp -= 1

meandelay = soup.stabilise_soups_parallel(rootstring, scount + initpos, sqrtspp, symmstring)
if (i < 150):
delays[i % 3] += meandelay
scount += (sqrtspp * sqrtspp)

current_speed = int((sqrtspp * sqrtspp)/(time.clock() - page_time))
alltime_speed = int((scount)/(time.clock() - start_time))

g.show(str(scount) + " soups processed (" + str(current_speed) +
" per second current; " + str(alltime_speed) + " overall)" +
" : (type 's' to see latest census or 'q' to quit).")

event = g.getevent()
if event.startswith("key"):
evt, ch, mods = event.split()
if ch == "s":
soup.save_progress(scount, rootstring, symmstring)
soup.display_census(scount, rootstring, symmstring)
elif ch == "q":
quitapg = True
break

if (scount >= number):
break

if (quitapg == True):
break

# Change sqrtspp to a more optimal value:
if (scount < number):
sqrtspp_new = sqrtspp_optimal

if (delays[0] < delays[1]):
sqrtspp_new = sqrtspp_optimal - 1
if ((delays[2] < delays[1]) and (delays[2] < delays[0])):
sqrtspp_new = sqrtspp_optimal + 1

sqrtspp_optimal = sqrtspp_new
sqrtspp_optimal = max(sqrtspp_optimal, 5)

# Compactify highscore table:
soup.compactify_scores()

if (quitapg == False):
# Save progress, upload it to Catagolue, and reset the census if successful:
a = soup.save_progress(scount, rootstring, symmstring, payosha256_key=payoshakey)
if (a == 0):
# Reset the census:
soup.reset()
start_time = time.clock()
f = (lambda x : 'abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'[ord(x) % 56])
rootstring = ''.join(map(f, list(hashlib.sha256(rootstring + payoshakey + datetime.datetime.now().isoformat()).digest()[:12])))
scount = 0
number = orignumber
else:
number += orignumber

end_time = time.clock()

soup.save_progress(scount, rootstring, symmstring, payosha256_key=payoshakey)

soup.display_unids()
soup.display_census(scount, rootstring, symmstring)

def symmetry_test():

g.new("Symmetry test")

symmetries = [["1x256X2+1", "1x256X2", "32x32", "25p", "75p", "C1", "8x32", "4x64", "2x128", "1x256"],
["C2_1", "C2_2", "C2_4"],
["C4_1", "C4_4"],
["D2_+1", "D2_+2", "D2_x"],
["D4_+1", "D4_+2", "D4_+4", "D4_x1", "D4_x4"],
["D8_1", "D8_4"]]

for i in range(len(symmetries)):
for j in range(len(symmetries[i])):

g.putcells(hashsoup("sym_test", symmetries[i][j]), 120 * j + 60 * (i % 2), 80 * i)
g.fit()

# Run the soup-searching script:
apg_main()
# apg_verify()
</pre>
Yes, I get silly all the time. -wwei23 9:53 AM 8/7/2017 NY time

:Thanks. BTW, there is no use in calling apg_verify for your higher newly-created symmetries -- peer review is not enabled server-side for these in the first place. [[User:Apple Bottom|Apple Bottom]] ([[User talk:Apple Bottom|talk]]) 11:00, 7 August 2017 (UTC)

== picture ==

may the homepage picture be changed to the Christmas theme to fit whatever is currently happening? [[User:Snacked|Snacked]] ([[User talk:Snacked|talk]]) 23:37, 20 December 2022 (UTC)

User:Snacked/Apgcodes

2022-10-14T00:40:33Z

Snacked: Added the third page of "Cool apgcodes" to this page.

The BEST apgcodes belong here! 
[https://conwaylife.com/forums/viewtopic.php?f=12&t=2687&p=109218| Carried from here]
= 0 =
[https://catagolue.appspot.com/object/xq15_013631zaoa/b3-n4az7s2-i3-c4z| 013631zaoa] 
[https://catagolue.appspot.com/object/xq26_0379qe4zzzzom66/b2i3-q4zs23-c| 0379qe4zzzzom66] 
[https://catagolue.appspot.com/object/xq8_04abgrakz6/b2ci3aejns2-c3-enr4-ait| 04abgrakz6] 
[https://catagolue.appspot.com/object/xp2_0gocure4z13631/b2ce3cjn4ceir5ci6an7e8s13i4-cez5-c67| 0gocure4z13631] 
[https://catagolue.appspot.com/object/xp7_0hmesooooss8zfvpof7/b2ce3cn4ceir5ci6an7e8s13i4-cez5-c67| 0hmesooooss8zfvpof7] 
[https://catagolue.appspot.com/object/xp2_0jhewehjz344owo443zy011/b3s23| 0jhewehjz344owo443zy011] 
[https://catagolue.appspot.com/object/xp7_0ogie0ehez4aaa4/b3s2-n36c| 0ogie0ehez4aaa4] 
[https://catagolue.appspot.com/object/xq6_0pziri/b3-ck4cijqz5eky6ai7c8s1c2-cn3-acy4cey5n6ac| 0pziri] 
[https://catagolue.appspot.com/object/xq64_0sq2sgyf4elhea4a0e4z4q3g08foy6g80rxgoxggzyg1x137x331/b3s2-e36| 0sq2sgyf4elhea4a0e4z4q3g08foy6g80rxgoxggzyg1x137x331]
= 1 =
[https://catagolue.appspot.com/object/yl90_1_150_bed59fcfac7fa7a8650636a3478ccbeb/b2ce3cjn4ceir5ci6an7e8s13i4-cez5-c67| 1_150_bed59fcfac7fa7a8650636a3478ccbeb] 
[https://catagolue.appspot.com/object/yl360_12_18912_2d77ed2dbae758648b929ab5002b0f3b/b2-ac3i4as12| 12_18912_2d77ed2dbae758648b929ab5002b0f3b] 
[https://catagolue.appspot.com/object/xq8_13p4/b2n3s23-q| 13p4] 
[https://catagolue.appspot.com/object/xq6_15x16/b2-a3c7s12-i| 15x16] 
[https://catagolue.appspot.com/object/xp2_1db8/b38s034678| 1db8] 
[https://catagolue.appspot.com/object/xp17_1jrpg/b2ce3ai4y6ks23ei4-i56| 1jrpg]
= 2 =
[https://catagolue.appspot.com/object/xp92_2528k0amis/b3aijkn4ty5es2-i3-aey4cny5iny6a7| 2528k0amis] 
[https://catagolue.appspot.com/object/xs12_259e0oo/b2in3-n5ys23| 259e0oo] 
[https://catagolue.appspot.com/object/xq45_27d/b3aijqr4i5cs2-in3-a4cqz5acek6-i8| 27d] 
[https://catagolue.appspot.com/object/xq8_27deeeeeee6/b3aeij4an5inr6is2-n3-ck4in| 27deeeeeee6] 
[https://catagolue.appspot.com/object/xq2_27x27/b2ci3aikr5ys1e2-a3aci| 27x27] 
[https://catagolue.appspot.com/object/xq4_2ate6/r2b6t8s5t7| 2ate6] 
[https://catagolue.appspot.com/object/xp6_2can/b2e3ai4t5e6ciks1c2-a3-a4-aeit5ikr| 2can]
= 3 =
[https://catagolue.appspot.com/object/xp8_317wogs/b3aijn4iw5ys1c2ace3jnr| 317wogs] 
[https://catagolue.appspot.com/object/xp3_31ewe13/b2in3-n5ys23| 31ewe13] 
[https://catagolue.appspot.com/object/xp2_35agic/b3-a4ejw5cky6ns234a5a8| 35agic] 
[https://catagolue.appspot.com/object/xp27_3falaf3/b2ce3ai4y6ks23ei4-i56| 3falaf3] 
[https://catagolue.appspot.com/object/xp27_3fanaf3/b2ce3ai4y6ks23ei4-i56| 3fanaf3] 
[https://catagolue.appspot.com/object/xq43_3fuuc/b34a8s0456-c78| 3fuuc] 
[https://catagolue.appspot.com/object/xq2_3p3/b2ek3cinqy4-cnqyz5acjq6aeks1c2cei3aeik4wz5cekny6-in7e8| 3p3] 
[https://catagolue.appspot.com/object/xp6_3phi/x7x3xb3-s23-shining| 3phi] 
[https://catagolue.appspot.com/object/xs31_3pmgmiczciq2qic/b3s23| 3pmgmiczciq2qic] 
[https://catagolue.appspot.com/object/xs10_3qq3/b2in3-n5ys23| 3qq3] 
[https://catagolue.appspot.com/object/xp27_3fataf3/b2ce3ai4y6ks23ei4-i56| 3fataf3]
= 4 =
[https://catagolue.appspot.com/object/xq2_44rave/b2k3s2cek3-a4-jkrw| 44rave] 
[https://catagolue.appspot.com/object/xq17_4aa4w4arl/b34n7s23| 4aa4w4arl] 
[https://catagolue.appspot.com/object/xp5_4aarahrrharaa4/b3s23| 4aarahrrharaa4] 
[https://catagolue.appspot.com/object/xs33_4aarharharhar/b3s23| 4aarharharhar] 
[https://catagolue.appspot.com/object/xp2_4ahdiczx1/b3aijkn4ty5es2-i3-aey4cny5iny6a7| 4ahdiczx1] 
[https://catagolue.appspot.com/object/xq8_4ahhhhhh197/b3aeij4an5inr6is2-n3-ck4in| 4ahhhhhh197] 
[https://catagolue.appspot.com/object/xs9_4ala4/b3s234c| 4ala4] 
[https://catagolue.appspot.com/object/xp2_4ervus8zx11/b2ce3cjn4ceir5ci6an7e8s13i4-cez5-c67| 4ervus8zx11] 
[https://catagolue.appspot.com/object/xp2_4he/b2ce3i4s345-jqr| 4he]
= 5 =
[https://catagolue.appspot.com/object/xp38_50s/b2-ak3ais12a| 50s] 
[https://catagolue.appspot.com/object/xp4_525weee/b38s034678| 525weee] 
[https://catagolue.appspot.com/object/xp26_57x75/b2in3-cqy4eknqwz5eiry6e7cs2-kn3cejnr4cjryz5ckq6aek| 57x75] 
[https://catagolue.appspot.com/object/xq20_5thme/b3s23-i5-iq| 5thme]
= 6 =
[https://catagolue.appspot.com/object/xs24_69bobjob96/b3s23| 69bobjob96] 
[https://catagolue.appspot.com/object/xq28_6r0gmzw1of8kc8y1gokee6c8zy2c4x8s49gd30scgzy9111x7847y26sozyfo48oy2of61zy2c8x4e953cg0fc21zx6s4ac4y136btsoc4zom12rz01/b3s2cek3-a4-ijkrw| 6r0gmzw1of8kc8y1gokee6c8zy2c4x8s49gd30scgzy9111x7847y26sozyfo48oy2of61zy2c8x4e953cg0fc21zx6s4ac4y136btsoc4zom12rz01]
= 7 =
[https://catagolue.appspot.com/object/xq8_77n7777777be4zw7b/b3aeij4an5inr6is2-n3-ck4in| 77n7777777be4zw7b] 
[https://catagolue.appspot.com/object/xp24_7bra/b2ei3ajkr4-cjnry5acjkr6-ak7c8s1e2ak3einqy4jnry5einqy6ak7e| 7bra] 
[https://catagolue.appspot.com/object/xp24_7oz7/b2ce3ai4y6ks23ei4-i56| 7oz7] 
[https://catagolue.appspot.com/object/xp2_7p2/b3is123-i4| 7p2]
= 8 =
[https://catagolue.appspot.com/object/xp2_8smfucogzw13731/b2ce3cjn4ceir5ci6an7e8s13i4-cez5-c67| 8smfucogzw13731]
= 9 =
= a =
[https://catagolue.appspot.com/object/xq2_aaaaaaaaaaaaaaev/b2cen3ackr4-jkryz5ckqy6-cn7e8s12i3qy4aciw5-jkr6ak| aaaaaaaaaaaaaaev] 
[https://catagolue.appspot.com/object/xp4_adolfarz023/b3s2456| adolfarz023] 
[https://catagolue.appspot.com/object/xp2_araara/b3s13| araara] 
[https://catagolue.appspot.com/object/xp6_arrozales/b4i5c6ns2-i3-q4acnry5einqr6-ck| arrozales] 
[https://catagolue.appspot.com/object/xp18_ava/b2-ac3aei4ae6i8s23-ejq8| ava]
= b =
[https://catagolue.appspot.com/object/xq4_brb/b2e3aeijn4rtzs23-a4eijkrtz5ai| brb] 
[https://catagolue.appspot.com/object/xq95_bzzzy92022/b2ce3k4ej5jrs12ei3-aq4aejkrty5ejqy6ac7e8| bzzzy92022]
= c =
[https://catagolue.appspot.com/object/xs16_ciddiczw11/b3s2-i34q| ciddiczw11] 
[https://catagolue.appspot.com/object/xs31_cimgehlmzx3470696/b3s23| cimgehlmzx3470696] 
[https://catagolue.appspot.com/object/xp6_clunksgzw175/b3s2456| clunksgzw175] 
[https://catagolue.appspot.com/object/xp3_co9nas0san9oczgoldlo0oldlogz1047210127401/b3s23| co9nas0san9oczgoldlo0oldlogz1047210127401] 
[https://catagolue.appspot.com/object/xp48_cuj6soooooooo8kzw1fvs8/b2ce3cn4ceir5ci6an7e8s13i4-cez5-c67| cuj6soooooooo8kzw1fvs8]
= d =
[https://catagolue.appspot.com/object/xs11_damp/b2e3ai4t5e6ciks1c2-a3-a4-aeit5ikr| damp] 
[https://catagolue.appspot.com/object/xp4_dohje/b34s26| dohje]
= e =
[https://catagolue.appspot.com/object/xq2_eah/b2ek3cinqy4-cnqyz5acjq6aeks1c2cei3aeik4wz5cekny6-in7e8| eah] 
[https://catagolue.appspot.com/object/xp2_ear/b2i3-ekn4jqrty5cy6n8s1c2-ci3-aey4cetyz5ack6ack7e| ear] 
[https://catagolue.appspot.com/object/xq4_edu/b2ce3a4cekqry5ajky6cs02aek3acjkn4-aeyz5-cjky6-ak78| edu]
= f =
[https://catagolue.appspot.com/object/xp48_flu/b2-a3akn6-cs1c2-i3aeinr4w| flu]
= g =
[https://catagolue.appspot.com/object/xp2_g0k0l05zw2/b2ce3cjn4ceir5ci6an7e8s13i4-cez5-c67| g0k0l05zw2] 
[https://catagolue.appspot.com/object/xs10_g0o453z11/b2in3-n5ys23| g0o453z11] 
[https://catagolue.appspot.com/object/xs42_g8ogill2zhaaaaahz12319ll8/b3s23| g8ogill2zhaaaaahz12319ll8] 
[https://catagolue.appspot.com/object/xq8_gogif13z32_w84/g4b3s23| gogif13z32_w84]
= h =
= i =
[https://catagolue.appspot.com/object/xp20_ihkozy248/b3aijn4iw5ys1c2ace3jnr| ihkozy248]
= j =
= k =
= l =
[https://catagolue.appspot.com/object/xp6_l0l/b2c3-cekq4ikt5i8s2-in3-acky4aijry5eiky6i| l0l] 
[https://catagolue.appspot.com/object/xp2_level/b013s| level]
= m =
= n =
[https://catagolue.appspot.com/object/xs16_nwtwlv/x7x3xb3-s23-shining| nwtwlv]
= o =
[https://catagolue.appspot.com/object/xp2_osubbus8z01/b2ce3cjn4ceir5ci6an7e8s13i4-cez5-c67| osubbus8z01] 
[https://catagolue.appspot.com/object/xs15_owowowbwrz6/x7x3xb3-s23-shining| owowowbwrz6]
= p =
[https://catagolue.appspot.com/object/xs16_phhhpzgzd/x7x3xb3-s23-shining| phhhpzgzd]
= q =
= r =
[https://catagolue.appspot.com/object/xs20_raaraar/b3s23| raaraar] 
[https://catagolue.appspot.com/object/xs21_ratiozx3271/b3s2456| ratiozx3271] 
[https://catagolue.appspot.com/object/xs10_rwawr/x7x3xb3-s23-shining| rwawr]
= s =
[https://catagolue.appspot.com/object/xq25_si1iszxg8oy7419i9f2zy01/b3-cky4e8s23-c4cn| si1iszxg8oy7419i9f2zy01] 
[https://catagolue.appspot.com/object/xq2_sotutosz027f72/b3678s34678| sotutosz027f72] 
[https://catagolue.appspot.com/object/xp4_sql3744zw3/b34ws2-k3-ck4t| sql3744zw3] 
[https://catagolue.appspot.com/object/xq4_surf72z01/x22x17x12xalternating_fattylife_scenery| surf72z01]
= t =
[https://catagolue.appspot.com/object/xq8_tjsgz4a03eozxq961/b2en3ij4a5e7e8s1c2cek3-a4aiqw5aky| tjsgz4a03eozxq961]
= u =
= v =
[https://catagolue.appspot.com/object/xq23_vcuz1/b3aijn4aejkz5cqy6kn7cs2ace3jnr4n5r7e| vcuz1]
= w =
[https://catagolue.appspot.com/object/xs32_wmmge1ege1ege2z643/b3s23| wmmge1ege1ege2z643]
= x =
[https://catagolue.appspot.com/object/xs154_xgosue63336eusogzouf731y5137fusgzvvgycgvvz037fusogy2gosuf73zy1133766667331/r5b38t61s29t58| xgosue63336eusogzouf731y5137fusgzvvgycgvvz037fusogy2gosuf73zy1133766667331]
= y =
[https://catagolue.appspot.com/object/xp3_y1g0s3g0s0s0g0g0s0s0g3s0gz8844ll050103030303030301050ll4488zwaaaaayfaaaaazwgglllyflllggzgg22aa2yf2aa22ggzw115d0t0c0u0u0e0e0u0u0c0t0d511zy316w101y1101w61/b2-ac3i4as12| y1g0s3g0s0s0g0g0s0s0g3s0gz8844ll050103030303030301050ll4488zwaaaaayfaaaaazwgglllyflllggzgg22aa2yf2aa22ggzw115d0t0c0u0u0e0e0u0u0c0t0d511zy316w101y1101w61] 
[https://catagolue.appspot.com/object/xq82_y888w401y112ozy2gg401yb4zxg61yzyoc8ggogzxj8yzyr2323z061y22yhgggz1sy7gya776bgy6gy1ggya1zw34e8811hgy3q0acy613y5us604s731zy674444403_yagg0888sssooywgxgzy6osmujioutvqvivtiq8ypgwpsuuusg28gzy2ouuvlvvvfvvvvvbsbvjj3fyog04193rvvstfusskogk88zy14n77vviv4u5u024010101y8gogyf7f6fvnvvffvf77384zxssstscdvvet7gg1y8g8wkoefvl3quqqsosqsoqi08y167s3vvvku3hczxbj3vffevfudtsrsquu01y39g77fufefffb3b7vtnvf7nj84y422x2zy01112283jnnuud25f421y71111y0111171zy811zyzyfoquuogw8g8zyzyg237h36edge2_zy6oy18utn22205gqyu4uuuszy54420s17xgy23eys93qvvste6cog0ggzy2g12y04s0gw4x101y8gogyf7f69vnnvcfv3573zy1ghxgocd3ygge09y1osgoogoogy4101puuku3zy01010c2fescsk1cy01y577f6fef7fb3b7mtnf7373zy01w228w1wg8044421yk1zzyzyg266y08gzyzyg237gy0ge_yagg0888sssoozy7s6e32804aqqih42o8ys8cuuusgzy2ouuvlfo0c7311n10bvjj0eyq41y0105fuscx488zy147671j030g0ay41yzmuvf71y084zxssccs482gw40g1y8g8w406bigy0ooosgw2208y3s2311xgczxbi3i1fes2g0gsrcy89gy01eeff8086f547wgg84y422x2zy111x1hmgqe1wbya111y56zy811zyzyfoogwgzyzyh33y32_yagg0888sssooywgxgzy6osmujige95050vpi28ys1y228gzy2ouur1l7j2w1101y131yzwgkkogk88zy14n75vcisyzya8w8uf77384zxssstsc5d7202ybg8wko8ck4y02w4asoqi08y3s0suuku3hczxbj3vfx1y1gquu01y39g77fue01y2hojof7nj84y422x2zy01112282jnnuuc25f421y71111y0111171zy811/g9r3b6t7s7t9| y888w401y112ozy2gg401yb4zxg61yzyoc8ggogzxj8yzyr2323z061y22yhgggz1sy7gya776bgy6gy1ggya1zw34e8811hgy3q0acy613y5us604s731zy674444403_yagg0888sssooywgxgzy6osmujioutvqvivtiq8ypgwpsuuusg28gzy2ouuvlvvvfvvvvvbsbvjj3fyog04193rvvstfusskogk88zy14n77vviv4u5u024010101y8gogyf7f6fvnvvffvf77384zxssstscdvvet7gg1y8g8wkoefvl3quqqsosqsoqi08y167s3vvvku3hczxbj3vffevfudtsrsquu01y39g77fufefffb3b7vtnvf7nj84y422x2zy01112283jnnuud25f421y71111y0111171zy811zyzyfoquuogw8g8zyzyg237h36edge2_zy6oy18utn22205gqyu4uuuszy54420s17xgy23eys93qvvste6cog0ggzy2g12y04s0gw4x101y8gogyf7f69vnnvcfv3573zy1ghxgocd3ygge09y1osgoogoogy4101puuku3zy01010c2fescsk1cy01y577f6fef7fb3b7mtnf7373zy01w228w1wg8044421yk1zzyzyg266y08gzyzyg237gy0ge_yagg0888sssoozy7s6e32804aqqih42o8ys8cuuusgzy2ouuvlfo0c7311n10bvjj0eyq41y0105fuscx488zy147671j030g0ay41yzmuvf71y084zxssccs482gw40g1y8g8w406bigy0ooosgw2208y3s2311xgczxbi3i1fes2g0gsrcy89gy01eeff8086f547wgg84y422x2zy111x1hmgqe1wbya111y56zy811zyzyfoogwgzyzyh33y32_yagg0888sssooywgxgzy6osmujige95050vpi28ys1y228gzy2ouur1l7j2w1101y131yzwgkkogk88zy14n75vcisyzya8w8uf77384zxssstsc5d7202ybg8wko8ck4y02w4asoqi08y3s0suuku3hczxbj3vfx1y1gquu01y39g77fue01y2hojof7nj84y422x2zy01112282jnnuuc25f421y71111y0111171zy811] 
[https://catagolue.appspot.com/object/xq28_yaomi111imozyd101zy68goy7og8z4rh3ga635k9210soy1os0129k536ag3hr4zx32257p3gw7pfy1fp7wg3p75223zy513311y511331zz0262yp262/b3s2cek3-a4-ijkrw| yaomi111imozyd101zy68goy7og8z4rh3ga635k9210soy1os0129k536ag3hr4zx32257p3gw7pfy1fp7wg3p75223zy513311y511331zz0262yp262] 
[https://catagolue.appspot.com/object/xq41_yberry14ezg8gy4s8k8y0s0ksz121/b3-ck7es23-cr4q6c| yberry14ezg8gy4s8k8y0s0ksz121]
= z =

User:Snacked/Apgcodes

2022-10-13T00:20:11Z

Snacked:

User:Snacked/Apgcodes

2022-10-09T01:17:09Z

Snacked: Made the page lol

User:Snacked

2022-10-08T23:54:05Z

Snacked: Created page with "Lemme make some cool apgcodes"

Lemme make some cool apgcodes