Is anyone studying the active part of soups?

For general discussion about Conway's Game of Life.
Post Reply
User avatar
pcallahan
Posts: 845
Joined: April 26th, 2013, 1:04 pm

Is anyone studying the active part of soups?

Post by pcallahan » March 9th, 2019, 2:25 pm

I can't find an existing topic, at least scanning over anything recent. One thing that has piqued my curiosity off and on is what we can say about the part of the Life pattern that is acting like a "Wolfram class 3" CA locally before it settles down into oscillators and spaceships. I don't think we can say very much, but there might be some interesting statistical analyses looking at cell state as a time signal.

I once added a custom hack (since lost) to either Xlife or something I had written that could store and match "time signatures", which were 32-bit sequences of consecutive live/dead values of a given cell position. It is a quick and dirty way to find things like gliders, pulsars, stabilized shuttles, etc. False positives can happen, but generally with a specific enough sequence, you get what you're looking for. The nice thing about this is you don't have to worry about all the symmetries. A passing glider is going to assign cells a certain way (after the leading 1) no matter what direction it's coming from.

With longer sequences, you might be able to make a qualitative judgments. Clearly, if something is settled and periodic, it is recognizable, likewise if it is empty space with an occasional passing glider. Intuitively, some regions look hot or cold depending on activity level (and that can be captured in graphics). Actually, though, a p46 shuttle is much "colder" than it looks in the sense that all of the activity is repeated. The active part of a methuselah will produce many more distinct time signals over thousands of steps.

I see a lot of interest in soup experiments, mostly (I think), in the interest of classifying identifiable patterns. My question is whether anyone is trying to analyze something like the "thermodynamics" of the hot part of the soup. It's unclear where this will go except for a fairly arbitrary classification of regions of a pattern, but it is more a question of how to nail down an intuitive notion of "active part." I am also a little curious what these signals look like. I imagine they could be modeled (approximately) as a markov process with just a small amount of previous history.

ADDED: one thing we will find besides the statistics is recurring "motifs", with b-heptomino and pi-heptomino predominating I think. So another question is with all the interest in tracking the stable components, is anyone tracking the frequency of these short-lived but often useful sequences?

User avatar
pcallahan
Posts: 845
Joined: April 26th, 2013, 1:04 pm

Re: Is anyone studying the active part of soups?

Post by pcallahan » March 10th, 2019, 1:06 pm

I'm posting one new reply to myself just to make the topic show up as active (the problem, I think with just editing a post is the thread looks untouched). But should I assume the answer to the subject line is "no" or "not many" or "nobody here"?

The sort of specific question that could be answered is "How frequently does the b-heptomino show up in soups?" "How long (on average) does it evolve before crashing into something else?" I have never heard of that being answered, but it's possible I missed it. There might also be reactions that show up repeatedly but not often enough to have been noticed. We should see a time series in which the cell is empty for a while, then changes according to a pseudorandom sequence, but prefixes of this exact sequence show up much more often than predicted by chance. Is there anything new to be found here? I may investigate it but I'd like to avoid repeating work.

User avatar
testitemqlstudop
Posts: 1367
Joined: July 21st, 2016, 11:45 am
Location: in catagolue
Contact:

Re: Is anyone studying the active part of soups?

Post by testitemqlstudop » March 10th, 2019, 1:23 pm

I was thinking of something along the lines, modify apgsearch so that it also catagolues constellations. I think it's possible, keeping track of Herschel/B-hept/R-pent/switch occurrences.

User avatar
Rhombic
Posts: 1072
Joined: June 1st, 2013, 5:41 pm

Re: Is anyone studying the active part of soups?

Post by Rhombic » March 10th, 2019, 7:03 pm

I am not aware of any recent research in that line. It would surely be interesting especially if applied to an arbitrarily low starting density.
SoL : FreeElectronics : DeadlyEnemies : 6a-ite : Rule X3VI
what is “sesame oil”?

User avatar
Rhombic
Posts: 1072
Joined: June 1st, 2013, 5:41 pm

Re: Is anyone studying the active part of soups?

Post by Rhombic » March 18th, 2019, 3:39 pm

Bump. Now I am. To some extent.
I am trying to draw some general parallels between evolution dynamics and partitioning of activity in soups, but it looks quite complicated. Currently analysing some large 3% density soups to understand what the initial steps in growth would be in an aperiodic, arbitrarily low-density infinite plane.
SoL : FreeElectronics : DeadlyEnemies : 6a-ite : Rule X3VI
what is “sesame oil”?

User avatar
pcallahan
Posts: 845
Joined: April 26th, 2013, 1:04 pm

Re: Is anyone studying the active part of soups?

Post by pcallahan » March 20th, 2019, 12:57 am

Rhombic wrote:Bump. Now I am. To some extent.
I'm interested in hearing what you find, though I think I have the higher density cases in mind. Here was an idea I had a really long time ago that didn't pan out (over 25 years ago), but I didn't understand Life well enough at the time (ADDED also, I lacked the CPU, sparse algorithm implementations, and disk space for output; I think I hacked XLife and then put it aside):

If you only know the last n values of a single cell, can you say anything interesting about the next value? The final cell value is a function of a 2n+1 x 2n+1 neighborhood around the cell, but not all these neighborhoods are equally likely in a typical soup, so that history may contain a lot of information about the surroundings. Let n=10. There are 1024 possible cell histories, but the ones that appear in a b-heptomino evolution occur at more than uniform probability, so you will probably predict with better than 50% success if you assume you are seeing a b-heptomino (of course you can extend this to surroundings and do even better, probably even with just one adjacent history, or three in a triangle and actually infer the orientation of the b-heptomino if it is one). (Or in a simpler case, if you have ten 0s in a row, you will mostly likely get another 0).

But let's assume some of those histories are not especially predictive. You still might do better than 50% if the next cell is just always more likely to be one state than another (clearly true in stable ash, but I don't know about the explosive part). So this immediately gives a way of clustering history strings. Given a particular series of n cell values, what is the probability that the next is 0 or 1. What does this distribution look like? I would guess it should be distributed around a fixed density value, with some spikes for special cases like a passing glider or part of the b-heptomino or pi heptomino. Maybe it has more than one mode. Maybe my intuition is just totally off here. Has anyone compiled such statistics? (And seriously, this is a lot easier than most of the things we're working on.)

ADDED: And what is this good for besides making histograms? Well (and this was probably my idea at the time), if you do identify time series that are unusually predictive, you can set alarms for them in a long-running soup, and possibly find reactions that are more common than usual and might come up in syntheses. I'm a little less optimistic now than I was at one time, but b and pi heptominoes will show up in a search like this (potentially with false positives). If there are any small active patterns we haven't classified, they may also show up.
Last edited by pcallahan on March 20th, 2019, 12:35 pm, edited 2 times in total.

User avatar
Macbi
Posts: 903
Joined: March 29th, 2009, 4:58 am

Re: Is anyone studying the active part of soups?

Post by Macbi » March 20th, 2019, 4:57 am

It sounds like you might be trying to calculate the correlation functions.

User avatar
pcallahan
Posts: 845
Joined: April 26th, 2013, 1:04 pm

Re: Is anyone studying the active part of soups?

Post by pcallahan » March 20th, 2019, 12:40 pm

Macbi wrote:It sounds like you might be trying to calculate the correlation functions.
Maybe. I would start with much simpler analysis though, really just counting frequencies in a histogram. Now that I think about this more, I had more ambitious ideas at the time of trying to correlate time series of neighboring cells.

You are probably correct that it falls in the broad category of statistical mechanics. Does anyone know some results on this? The active, non-periodic, unstructured part of patterns is the one we talk about the least, and are usually just very happy when it disappears and leaves something nice behind. What can we say about it?

NickGotts
Posts: 101
Joined: November 10th, 2011, 6:20 pm

Re: Is anyone studying the active part of soups?

Post by NickGotts » June 8th, 2019, 11:44 am

Rhombic wrote:
Currently analysing some large 3% density soups to understand what the initial steps in growth would be in an aperiodic, arbitrarily low-density infinite plane.
I don't think looking at 3% soups will get you far in understanding the arbitrarily low-density infinite plane ("Sparse Life"), although I'm sure they'd be interesting in their own right. I've done quite a bit of work on Sparse Life, including some published papers, and am currently returning to it. The "Systematic Survey of Small Patterns" thread reports on one aspect of this. If you're interested, send me an email (you can find a list of my publications, and a contact page on my website, nickgotts.weebly.com).

User avatar
confocaloid
Posts: 2729
Joined: February 8th, 2022, 3:15 pm

Re: Is anyone studying the active part of soups?

Post by confocaloid » August 4th, 2022, 5:38 pm

I was motivated by the idea of "time signatures" and the idea of counting occurrences of different 3x3 blocks. I wondered what happens if every alive cell "remembers" whether it is old or new.

Precisely, a "new" cell is an "on" cell which was "off" in the previous generation; an "old" cell is an "on" cell which was "on" in the previous generation. I did not distinguish between "off" cells, so there are three states in total: off = state 0, new = state 1, old = state 2.

With three states, there are 3^9 = 19683 distinct 3x3 windows counting every rotation and reflection. If rotations and reflections of the same 3x3 window are considered equivalent, there are 2862 distinct 3x3 windows. I think 627 out of these 2862 cannot occur as a result of evolution according to the rules of Life (unless present at generation 0). Each of the remaining 2235 windows can occur as a result of evolution.

I generated 100,000,000 pseudorandom soups in the 32x32 toroidal universe. Each soup was evolved for 5 ticks, then the resulting pattern was scanned to count occurrences of each 3x3 window. Then the same was repeated with each soup evolved for 10, 15, 50 ticks.

The least frequent 3x3 window seems to be an "off" cell surrounded by eight "new" cells. The following table gives the number of occurrences for twenty least frequent 3x3 windows, for each of four runs (5 ticks, 10 ticks, 15 ticks, 50 ticks); counts for all 3x3 windows can be found in the attachment.

Code: Select all

3x3 window      5 ticks    10 ticks    15 ticks    50 ticks
221/100/121       18762       14988       12490        6742
010/111/010                                            6464
212/101/201                                            6255
221/011/111                                            5670
111/101/110       25792       17279       13210        5486
101/010/101       18406       15645       13185
111/020/111       17829       12341       13113
110/111/010       17235       12392        9682        4502
221/100/211       19271       12024        9070        3910
121/020/121       21127       13211        9954        3873
211/021/111       18820       12772        9624        3851
121/010/111       16871       15386       13195
222/101/212       12598        8364        6563        2751
121/010/121        5578        4402        4033        2466
221/202/122       13035        7982        6015        2393
110/011/101        8689        5445        3637        1652
111/121/010        4966        3362        2573        1582
110/121/011        7249        4431        2889        1126
121/110/101        4582        2908        2095         822
121/110/121        3396        2395        1780         772
211/110/101        3013        1762        1373         496
111/010/101        1365         741         643         256
111/101/111          66          27          43          13
The following is an example soup in the 32x32 toroidal universe, with generation 50 containing an "off" cell surrounded by eight "new" cells (in generation 49 the central cell was "on" and its neighbours were all "off"):

Code: Select all

x = 32, y = 32, rule = B3/S23:T32,32
o3bobob3o5b2o2b4o3bobobo$3obobo5bo4bobobo2bob2obobo$bobob2ob2o6b4o2bo
3bo$o2b4ob4ob3o2b2o2b3ob2ob2o$3ob3o3bobo4b4o4b6o$2b3obo4bo2b3o2bo2b4o
3b2o$o2bob2o2b2o2b5o2bob6o2b2o$bo2b2ob2ob4o3bo2b3o3bobo2bo$3bo3bobobo
3b2obo6b3ob2o$6o4b4o3b2ob2ob5o2bo$obobo2bo3b2o2b4o4b3o2b2o$2o2b2o2bobo
b2o3b5obob3ob2o$bo5b3o2bo2b3obobo3b2o$bo2bo6bobobobobo2bob2ob3obo$3b2o
2bo4bobobob2o2bobob4obo$3bo4bo8b2o2bob2o3b4o$2o5bob4ob3ob3obo2bobob2o$
2obo4b3obob4o2b6ob4o$4ob3obo2b3o2b4o3b3o2bobo$bo5b2obobobobobo4b2o2b2o
b2o$bo2bobo3b2o2bo2bo2b3ob3o3bo$bob2o2bob4ob5o4bo2bo2bo$6b3o3b3o3b2obo
2bo3bo2bo$ob2obob2obobobo3b7obo2bobo$b2o2bo3bobob2obob2obob3obo2bo$obo
b2obo2bo3b3o2b2o3bo4bo$2o5bob2obo3bobobobo2bobob3o$b5obobo5bo2b2o4bob
3o$obob2o8bo2bo2bob2o4b2o$3o2bo2bob3ob4ob3o2bo3bobo$ob5o3b3o5b6ob4o$b
3ob2obobobob2o6bobob6o!
I think the following partial specifications cover most impossible 3x3 windows (those which cannot occur except at generation 0):
  • Central cell is 0, 5 neighbours of state 1, 3 neighbours of state 2.
  • Central cell is either 1 or 2, at least 4 neighbours of state 2.
  • Central cell is 1, at least 6 neighbours of state 1.
  • Central cell is 2, at least 7 neighbours of state 1.
  • Each of the following six partial specifications. In each case, there is an "on" cell with four "old" neighbours which were all "on" in the previous generation, contradicting the possibility of birth/survival of that "on" cell.

Code: Select all

 22*   22*   22*   22*   22*   22*
 12*   22*   12*   22*   1**   2**
 *2*   *2*   2**   2**   22*   22*
  • In addition, the following fully specified 3x3 windows are impossible:

Code: Select all

 111   121   121   201   220   221   221   221   221   222
 120   020   120   011   102   101   101   102   102   201
 101   111   111   111   212   021   201   101   212   212
Doing this with four states instead of three (with all four 2-tick time signatures distinguished) would probably require more computing time to get every possible 3x3 window at least once.

Update 1: the description of impossible 3x3 windows was incomplete - hopefully fixed now.

Update 2: I think the following are the 243 three-by-three windows which can occur as a result of evolution, but which never occur during evolution of the R-pentomino:

Code: Select all

010/111/010 010/121/010 101/010/101 101/020/101 110/010/011 110/010/110 110/011/101 110/011/110 110/021/101
110/101/011 110/110/001 110/111/001 110/111/010 110/121/001 110/121/010 110/121/011 111/010/101 111/020/101
111/101/010 111/101/101 111/101/110 111/101/111 111/110/001 111/110/100 111/111/000 111/120/011 111/121/000
111/121/010 111/121/020 120/011/111 120/011/120 120/021/111 120/022/120 120/101/111 120/101/120 120/102/011
120/102/120 120/110/011 120/110/111 120/111/011 120/111/020 120/111/021 120/111/101 120/111/120 120/112/101
120/112/111 120/121/111 121/010/111 121/010/121 121/020/121 121/100/121 121/101/010 121/101/110 121/101/111
121/101/120 121/101/121 121/110/010 121/110/011 121/110/021 121/110/101 121/110/110 121/110/121 121/111/010
121/111/020 121/111/120 121/120/101 121/120/110 121/121/110 121/200/021 121/201/021 121/201/110 121/201/111
121/210/101 121/211/101 121/211/110 121/212/111 201/001/110 201/001/111 201/010/102 201/011/101 201/011/110
201/020/101 201/020/102 201/021/110 201/021/111 201/022/121 202/010/201 202/020/201 210/001/121 210/002/101
210/011/101 210/011/111 210/011/121 210/011/201 210/011/210 210/012/011 210/012/111 210/021/102 210/021/110
210/021/111 210/101/011 210/102/011 210/111/011 210/112/011 210/121/011 211/001/102 211/001/121 211/001/201
211/001/210 211/001/211 211/002/101 211/002/111 211/010/101 211/010/111 211/010/112 211/011/001 211/011/011
211/011/101 211/011/102 211/011/110 211/011/120 211/011/121 211/011/211 211/012/011 211/012/110 211/012/111
211/012/121 211/012/211 211/020/102 211/021/011 211/021/110 211/021/111 211/101/011 211/101/012 211/101/020
211/101/021 211/101/110 211/101/111 211/102/011 211/102/110 211/102/111 211/110/011 211/110/101 211/110/102
211/111/001 211/111/010 211/111/021 211/111/100 211/111/102 211/112/011 211/112/101 211/120/011 211/120/101
211/121/011 211/121/101 211/121/102 211/121/110 211/121/112 212/000/101 212/000/121 212/000/211 212/010/110
212/010/111 212/010/121 212/020/111 212/100/021 212/100/121 212/100/201 212/101/020 212/101/120 212/101/200
212/101/201 212/110/011 212/110/021 212/110/101 212/110/110 212/110/111 212/110/112 212/110/121 212/111/010
212/111/020 212/111/121 212/120/021 212/120/200 212/120/201 212/121/020 212/121/101 212/121/120 212/121/121
212/121/210 212/121/211 220/101/112 220/101/201 220/101/210 220/101/211 220/101/212 220/102/101 220/102/111
220/102/211 220/111/111 221/001/110 221/001/111 221/001/112 221/011/110 221/011/121 221/100/021 221/100/101
221/100/121 221/100/211 221/101/110 221/101/111 221/101/120 221/101/200 221/102/121 221/102/201 221/102/211
221/110/110 221/110/111 221/111/011 221/120/111 221/200/011 221/201/001 221/201/101 221/202/022 221/202/122
221/211/110 221/211/111 221/220/101 221/221/111 222/000/111 222/010/111 222/020/111 222/100/111 222/100/201
222/100/212 222/101/101 222/101/212 222/120/111 222/121/111 222/201/012 222/201/021 222/201/102 222/201/112
Attachments
32x32_100000000soups.zip
(130 KiB) Downloaded 11 times
Last edited by confocaloid on August 6th, 2022, 3:24 pm, edited 1 time in total.
127:1 B3/S234c User:Confocal/R (isotropic rules, incomplete)
Unlikely events happen.
My silence does not imply agreement, nor indifference. If I disagreed with something in the past, then please do not construe my silence as something that could change that.

dani
Posts: 1222
Joined: October 27th, 2017, 3:43 pm

Re: Is anyone studying the active part of soups?

Post by dani » August 5th, 2022, 2:36 pm

confocaloid wrote:
August 4th, 2022, 5:38 pm
The least frequent 3x3 window seems to be an "off" cell surrounded by eight "new" cells.
This makes sense. Is there any 5x5 window that generates such a history other than this one?:

Code: Select all

bobob $
obbbo $
bbobb $
obbbo $
bobob !
You're limited to the center cell, plus a hollow 5x5 square around the origin. I think the center cell is required, and the above configuration is the only one I found that could satisfy all B3 births.

I'm very interested about the time signatures bit that pcallahan was talking about too. For example, "off off on on on on off on off off" would be the off cell in the back end of a b-heptomino. I'd be curious as to what the least common one would be. Perhaps the paradiddle "on off on on off on off off on off" or thue-morse "on off off on off on on off off on".

User avatar
pcallahan
Posts: 845
Joined: April 26th, 2013, 1:04 pm

Re: Is anyone studying the active part of soups?

Post by pcallahan » August 6th, 2022, 4:22 pm

dani wrote:
August 5th, 2022, 2:36 pm
I'm very interested about the time signatures bit that pcallahan was talking about too. For example, "off off on on on on off on off off" would be the off cell in the back end of a b-heptomino. I'd be curious as to what the least common one would be. Perhaps the paradiddle "on off on on off on off off on off" or thue-morse "on off off on off on on off off on".
I started working on a Python script to find things like this in Golly. It's not hard just to accumulate the series of bits, but I got bogged down in analysis. I thought about building a tree or deriving a Markov model. I think there are many possibilities. But it might be simplest just to enumerate fixed window sizes. I need to get back to it (or someone else can).

User avatar
pcallahan
Posts: 845
Joined: April 26th, 2013, 1:04 pm

Re: Is anyone studying the active part of soups?

Post by pcallahan » August 7th, 2022, 11:10 am

Since it sounds like there's some interest, I just cleaned up the Golly script I was working on. I originally had a more ambitious goal, but this just collects and counts the bit "signatures" of cells that are live for at least one generation in a given time window. You could use this as input for making a Markov chain, e.g. determine the frequency of 0 vs 1 showing up as the last value in a window given those preceding it. The script:

Code: Select all

import sys

from collections import Counter

from glife import rect
import golly as g

def update(cell_histories, cells, mask):
  for cell in cells: 
    cell_histories[cell] = ((cell_histories.get(cell, 0) << 1) & mask) + 1
 
  live = set(cells)
  zeros = []
  for pos, val in cell_histories.items():
    if pos not in live:
      next_val = (val << 1) & mask
      if next_val != 0:
        cell_histories[pos] = next_val
      else:
        zeros.append(pos)
  for pos in zeros:
    cell_histories.pop(pos)

signature_length = int(g.getstring('Bit length of signatures.', '10'))
m = int(g.getstring('Generation to start collecting signatures.', str(signature_length)))
n = int(g.getstring('Number of generations to collect:', '100'))
output_file = g.getstring('Output to file', '/tmp/sigs.txt')
mask = (1 << signature_length) - 1

counts = Counter()
cell_histories = {}
for i in range(m + n):
  celllist = g.getcells(g.getrect())
  cells = list(zip(celllist[::2], celllist[1::2]))
  update(cell_histories, cells, mask)
  g.run(1)
  if i >= m:
    counts += Counter(cell_histories.values())

with open(output_file, 'w') as o:
  for signature, count in sorted(counts.items()):
    o.write('%s %d\n' % (bin(signature)[2:].zfill(signature_length), count))
  o.close()  
Output of running a glider for 12 generations:

Code: Select all

0000000001 12
0000000011 12
0000000111 12
0000001111 12
0000011110 12
0000111100 6
0000111101 6
0001000000 6
0001111000 6
0001111010 6
0010000000 6
0011110001 6
0011110100 6
0100000000 12
0111100010 6
0111101000 6
1000000000 12
1000100000 6
1010000000 6
1100010000 6
1101000000 6
1110001000 6
1110100000 6
1111000100 6
1111010000 6
Output of running a stabilized queen bee shuttle for 300 generations:

Code: Select all

0000000001 940
0000000010 460
0000000011 500
0000000100 220
0000000101 240
0000000110 280
0000000111 260
0000001000 140
0000001001 80
0000001010 160
0000001011 100
0000001100 160
0000001101 120
0000001110 80
0000001111 220
0000010000 140
0000010010 40
0000010011 40
0000010100 180
0000010110 20
0000010111 80
0000011000 140
0000011001 40
0000011010 40
0000011011 80
0000011100 40
0000011101 40
0000011110 120
0000011111 100
0000100000 140
0000100100 40
0000100110 40
0000101000 160
0000101001 20
0000101101 20
0000101110 40
0000101111 40
0000110000 140
0000110001 40
0000110010 40
0000110100 60
0000110101 40
0000110110 40
0000110111 40
0000111000 40
0000111010 40
0000111011 20
0000111100 100
0000111101 20
0000111110 60
0000111111 40
0001000000 220
0001001000 40
0001001100 40
0001010000 120
0001010001 80
0001010010 20
0001011011 20
0001011100 40
0001011110 40
0001100000 160
0001100011 40
0001100101 40
0001101000 20
0001101001 40
0001101010 40
0001101100 80
0001101111 40
0001110000 40
0001110100 40
0001110110 20
0001111000 100
0001111010 20
0001111100 40
0001111101 40
0001111111 100
0010000000 240
0010000001 40
0010010000 40
0010011001 40
0010100000 100
0010100001 80
0010100010 40
0010100011 40
0010100100 20
0010101000 40
0010110110 20
0010111000 40
0010111100 40
0011000000 200
0011000110 40
0011001010 40
0011001111 40
0011010000 20
0011010010 40
0011010100 40
0011011000 40
0011011001 40
0011011110 40
0011100000 40
0011101000 20
0011101001 20
0011101100 20
0011110000 100
0011110100 20
0011110111 40
0011111000 40
0011111011 40
0011111111 100
0100000000 380
0100000010 20
0100000011 40
0100000101 20
0100001100 40
0100001101 60
0100001110 20
0100010000 40
0100011000 20
0100011111 40
0100100000 60
0100101000 60
0100110011 40
0101000000 140
0101000011 120
0101000100 40
0101000111 40
0101001000 20
0101010000 40
0101101100 20
0101110001 40
0101111000 40
0110000000 300
0110001101 40
0110001111 20
0110010101 40
0110011000 40
0110011110 40
0110100000 20
0110100101 40
0110101000 40
0110110000 40
0110110001 20
0110110011 40
0110111100 40
0111000000 20
0111000001 20
0111000100 40
0111010000 20
0111010010 20
0111011000 20
0111100000 140
0111100010 40
0111101000 20
0111101111 40
0111110000 40
0111110110 40
0111111100 40
0111111110 60
0111111111 60
1000000000 940
1000000001 20
1000000011 40
1000000101 20
1000000111 40
1000001010 20
1000001100 20
1000011000 40
1000011010 60
1000011101 20
1000100000 80
1000101000 40
1000110000 20
1000110110 40
1000111110 20
1000111111 60
1001000000 60
1001010000 60
1001010100 40
1001100000 40
1001100111 40
1001111011 40
1010000000 140
1010000001 20
1010000010 20
1010000110 100
1010000111 20
1010001000 40
1010001100 20
1010001111 40
1010010000 20
1010010100 60
1010100000 40
1010100001 40
1011000000 100
1011000111 20
1011001100 40
1011011000 20
1011100010 40
1011110000 40
1011110001 40
1011111110 40
1011111111 20
1100000000 580
1100000001 40
1100000110 20
1100010000 40
1100010100 40
1100011011 40
1100011111 40
1100101010 40
1100110000 40
1100111101 40
1101000000 20
1101000001 20
1101000110 20
1101001010 60
1101010000 40
1101100000 100
1101100011 20
1101100110 40
1101111000 40
1101111111 60
1110000000 320
1110000011 20
1110001000 40
1110001010 40
1110001111 20
1110100000 20
1110100011 20
1110100101 20
1110110000 60
1110111111 60
1111000000 300
1111000101 40
1111000111 20
1111010001 20
1111011000 40
1111011111 60
1111100000 160
1111100011 20
1111101100 40
1111101111 20
1111110000 120
1111110001 20
1111110111 20
1111111000 140
1111111011 20
1111111100 100
1111111101 20
1111111110 60
1111111111 2000
The latter hits such a large percentage of possible signatures, that it may be a good idea to increase the window length (there's a prompt for it).

Post Reply