Unproven conjectures

[I6_I6]

For every finite Game of Life pattern with n live cells, the next generation contains at most 3n−6 live cells.

I don't have a mathematical proof for this; I just know that a straight line with n cells (n > 2) has a population of 3n-6 in the next generation, and that looks pretty optimal. Has work on this been done before?

[Chris857]

For every finite Game of Life pattern with n live cells, the next generation contains at most 3n−6 live cells.

I don't have a mathematical proof for this; I just know that a straight line with n cells (n > 2) has a population of 3n-6 in the next generation, and that looks pretty optimal. Has work on this been done before?

0 cells has a next gen population of zero, but 3*0-6 = -6 (0 > -6, counterexample)
1 cell has a next gen population of zero, but 3*1-6 = -3 (0 > -3, counterexample)
2 cells (domino or duoplet or separate cells) can only go to zero, but 3*2-6 = 0 (0 = 0, matches conjecture)
3 cells as preblock can go to 4, but 3*3-6 = 3 (4 > 3, counterexample)
4 cells the best I can think of offhand is the line of 4 going to 6 like you are thinking

[Rhombicubocta]

Every phoenix in Life I have seen has an even population in every phase. I conjecture odd population phoenices are impossible in Life.

[I6_I6]

For every finite Game of Life pattern with n live cells, the next generation contains at most 3n−6 live cells.

I don't have a mathematical proof for this; I just know that a straight line with n cells (n > 2) has a population of 3n-6 in the next generation, and that looks pretty optimal. Has work on this been done before?

0 cells has a next gen population of zero, but 3*0-6 = -6 (0 > -6, counterexample)
1 cell has a next gen population of zero, but 3*1-6 = -3 (0 > -3, counterexample)
2 cells (domino or duoplet or separate cells) can only go to zero, but 3*2-6 = 0 (0 = 0, matches conjecture)
3 cells as preblock can go to 4, but 3*3-6 = 3 (4 > 3, counterexample)
4 cells the best I can think of offhand is the line of 4 going to 6 like you are thinking

Oh, right, I completely forgot about 0 and 1. Can we be certain that 0, 1 and 3 are the only exceptions? How could this be proven?

[hotdogPi]

Every phoenix in Life I have seen has an even population in every phase. I conjecture odd population phoenices are impossible in Life.

Counterexample

Code: Select all

x = 43, y = 18, rule = B3/S23
7bo27bo$7bobo23bobo$3bobo31bobo$3bo6b2o19b2o6bo$bo39bo$11bo19bo$2o11bo
5bo3bo5bo11b2o$13bobobobo3bobobobo$2bo18bo18bo$16bo9bo$2b2o10bo3bobobo
bo3bo10b2o$12bobo3bo5bo3bobo$4bo33bo$10b2o19b2o$4b2o31b2o$10bo21bo$6bo
bo25bobo$8bo25bo!

[Chris857]

Oh, right, I completely forgot about 0 and 1. Can we be certain that 0, 1 and 3 are the only exceptions? How could this be proven?

My somewhat cheeky answer is that LLMs have been managing some interesting things in (dis)proving some conjectures lately.

Not a counterexample, but constructions like this, a grid of pre-blocks that evolves into a giant m x n rectangle in one step, are one of the better cases I can come up with that isn't just the straight line case. This particular example is a 4x4 grid of pre-blocks with population 48 evolving into an 11x11 square of population 121. 3*48-6=138 > 121, conjecture still holds.

Code: Select all

x = 11, y = 11, rule = B3/S23
2ob2ob2ob2o$bo2bo2bo2bo2$2ob2ob2ob2o$bo2bo2bo2bo2$2ob2ob2ob2o$bo2bo2b
o2bo2$2ob2ob2ob2o$bo2bo2bo2bo!

[hotdogPi]

4 is too low to qualify; the T-tetromino becomes seven cells.

[I6_I6]

4 is too low to qualify; the T-tetromino becomes seven cells.

Hmm. Looks like straight lines aren't always optimal, which could hold true for higher population counts as well. We could do some searches for lower population counts, but I'd really like a concrete proof.

[yyh_baboon]

4 is too low to qualify; the T-tetromino becomes seven cells.

Hmm. Looks like straight lines aren't always optimal, which could hold true for higher population counts as well. We could do some searches for lower population counts, but I'd really like a concrete proof.

I think that for a n-cell pattern(n is sufficiently large), there will at most be (2n-4)cells to be born in the next generation.

[HartmutHolzwart]

4 is too low to qualify; the T-tetromino becomes seven cells.

Hmm. Looks like straight lines aren't always optimal, which could hold true for higher population counts as well. We could do some searches for lower population counts, but I'd really like a concrete proof.

I think that for a n-cell pattern(n is sufficiently large), there will at most be (2n-4)cells to be born in the next generation.

I‘d think ChatGPT is be able to prove that… Can someone give it a try?

[NNlk05]

I‘d think ChatGPT is be able to prove that… Can someone give it a try?

Claude Haiku 4.5 thinking:

Prove:
Under Conway's Game of Life rules (Born on 3, survive on 2 and 3). For n, for all n-celled patterns in t = 0, the total population in t = 1 must be no larger then
For every finite Game of Life pattern with (a sufficiently large) n live cells, the next generation contains at most 3n−6 live cells. (sufficiently large because there exiest counter examples for n = 0, 1, 3)

I don't have a mathematical proof for this; I just know that a straight line with n cells (n > 2) has a population of 3n-6 in the next generation, and that looks pretty optimal.

This is an interesting mathematical question about Conway's Game of Life. The user is asking me to prove that for sufficiently large n-celled patterns, the next generation has at most 3n-6 live cells.

Let me think about this carefully:

First, let me understand the rules:
- A dead cell with exactly 3 live neighbors becomes alive (birth)
- A live cell with 2 or 3 live neighbors survives
- All other cells die or stay dead

The user notes that:
1. A straight line with n cells (n > 2) produces exactly 3n-6 cells in the next generation
2. They believe this is optimal (maximal)
3. There are counterexamples for small n (0, 1, 3)

Let me verify the straight line case first. A horizontal line of n cells:
```
...OOOOO...
```

For a line of 5 cells:
- Each end cell (2 of them) has 1 live neighbor, so dies
- Each internal cell (3 of them) has 2 live neighbors, so survives (3 cells survive)
- Each dead cell adjacent to an end has 1 live neighbor, doesn't birth
- Each dead cell adjacent to two cells has 2 live neighbors, doesn't birth
- Each dead cell adjacent to only one cell... wait, let me think more carefully.

Actually, for a horizontal line of n cells at positions 1, 2, 3, ..., n:
- Cells at positions 2 through n-1 survive (they have 2 live neighbors each) - that's n-2 cells
- Cell at position 0 (left of the line) has 1 neighbor, doesn't birth
- Cell at position 1 (left of position 1) has 1 neighbor (the cell at position 1), doesn't birth
- I need to consider the 2D grid properly. For a horizontal line of n cells at y=0, births can occur in the rows above and below. At y=1 and y=-1, cells directly above or below the line's endpoints and internal cells will have exactly 3 neighbors (the cell below/above plus two horizontal neighbors), creating new live cells in those rows. The endpoints of the original line die since they only have 1 neighbor, while the n-2 internal cells survive with 2 neighbors each. 1) through (n-2, -1) birth, that's n-3 cells.

For cells in row +2 and beyond, I need to check if any can have exactly 3 live neighbors. A cell at (k, 2) has neighbors at (k-1, 1), (k, 1), (k+1, 1), (k-1, 2), (k+1, 2). Only cells in row 1 could be alive from the previous generation. For 1 ≤ k ≤ n-2, there are 3 live neighbors in row 1, so these cells birth. Cells at k=0 and k=n-1 have only 2 neighbors in row 1, so they don't birth. This gives n-3 cells in row 2, and by symmetry, n-3 cells in row -2.

Total births: (n-2) + (n-3) + (n-3) + (n-3) + (n-3) = 3n - 8.

But the expected answer is 3n - 6. Let me verify with n=3: the line (0,0), (1,0), (2,0) should produce 3(3) - 6 = 3 cells. Checking births at (1,1), (1,-1), and... I need to reconsider what cells actually birth.

Testing n=3: (1,0) survives with 2 neighbors. Above it, (1,1) has 3 neighbors so births. Below, (1,-1) also births. That's 3 total. ✓

For n=4: (1,0) and (2,0) survive. Above, (1,1) and (2,1) each have 3 neighbors and birth. Below, (1,-1) and (2,-1) birth. Total: 2 + 2 + 2 = 6 = 3(4) - 6. ✓

For n=5: (1,0), (2,0), (3,0) survive. The cells (1,1), (2,1), (3,1) birth above, and the same three birth below.

The pattern holds—the formula 3n-6 correctly predicts the generation count for horizontal lines. Now I need to show this is actually an upper bound across all possible configurations. The challenge is that different arrangements create different numbers of births. The key is understanding how many new cells can be born from a given set of live cells. Each live cell can contribute to births in its surrounding 8 cells, but a birth requires exactly 3 live neighbors. So I need to bound how many cells can simultaneously have exactly 3 neighbors from the original n cells. seems worth exploring carefully. The straight line configuration is intuitive as optimal, but I should verify whether it actually achieves the bound or if there's a tighter constraint. Let me consider what happens at the endpoints and interior of a line—births can only occur at the ends where dead cells have exactly three live neighbors, which limits growth significantly. For a configuration with n live cells arranged linearly, the maximum births would be bounded by the geometry of how many dead cells can simultaneously have exactly three live neighbors, and this appears to give roughly 3n-6 as a natural limit.This is a genuinely interesting open problem in cellular automata! You're right to be skeptical about having a clean proof—this is harder than it looks.

## Observations and Challenges

You've correctly identified that **the horizontal line achieves 3n−6**, and you suspect it's optimal. However, proving this upper bound rigorously requires careful analysis. Here are the key challenges:

### Why this is non-trivial

1. **Births are constrained but complex**: A dead cell birthing requires exactly 3 live neighbors. The spatial arrangement matters enormously—the same n live cells in different patterns produce vastly different results.

2. **The "boundary cost" intuition**: Intuitively, births can only occur in dead cells touching the pattern. You have n live cells, creating a boundary of at most ~8n dead cells (very rough upper bound). But not all boundary cells birth—only those with exactly 3 neighbors.

3. **Survival doesn't cost**: The n cells surviving depends only on local 2-3 neighbor structure. A line survives n−2 cells optimally (the two ends die). Could some other pattern do worse and compensate elsewhere? Unlikely, but proving this is hard.

### A Sketch Toward a Proof

Rather than a full proof, here's how I'd structure an attack on this:

**Upper bound on births:** Consider an n-cell pattern P. The maximum number of dead cells with exactly 3 live neighbors is bounded by:
- Each live cell c can participate in at most 8 cells' neighborhoods (its Moore neighbors).
- A dead cell d can "use up" contributions from at most 3 live cells.
- By a counting argument on (live cell, dead cell) neighbor pairs: if there are B such pairs, then the number of births is at most B/3.
- The total neighbor pairs can't exceed 8n (each live cell has ≤8 neighbors).
- So births ≤ 8n/3 ≈ **2.67n**.

**Survivors:** At most n survive (obviously). More realistically, the structure of the pattern determines this. For a line, n−2 survive.

**Putting it together:** If births ≤ 2.67n and survivors ≤ n, that gives roughly 3.67n as an upper bound, not tight.

To get 3n−6, you'd need:
- Tighter accounting of the birth constraint (not all 8n neighbor-pairs can actually yield births)
- A proof that survivors + births ≤ 3n−6 specifically

### Why the Line Might Be Optimal

The horizontal line is elegant because:
- It maximizes birth cells (every internal cell above and below births)
- It minimizes "wasted" neighbors (no long-distance spacing)
- The two-end cells that die are unavoidable in any linear arrangement

**However**, proving that no other configuration beats it would require showing that any "spreading out" of the n cells either:
- Kills more survivors, or
- Fails to create additional births, or
- Both

---

## What I'd Suggest

1. **Try small cases systematically**: For n=4 through n=8, enumerate all distinct patterns and compute the next generation. Plot survivors + births vs. the line's 3n−6. This might reveal whether the line is actually optimal or if counterexamples exist for larger n.

2. **Look for patterns that might beat the line**:
- Dense clusters (do corners generate extra births?)
- Specific T-shapes or other configurations
- Diagonals or knight's-move spacing

3. **If the line holds empirically**, try to formalize the neighbor-pair counting argument more carefully, perhaps using graph-theoretic or combinatorial optimization techniques.

This is exactly the kind of problem where computational exploration can guide a proof strategy. Do you want to test some larger patterns, or would you like to discuss a particular approach further?

Try a brute force of all kingwise connected cells using OR-Tools CP-SAT to maximize population.

The user wants me to use OR-Tools CP-SAT (a constraint programming solver) to brute force all kingwise connected patterns and find which one maximizes the population after one generation of Conway's Game of Life.

This is a clever approach! Rather than me trying to reason about this theoretically, we can actually compute it.

However, I need to be practical here. I can't actually run code directly - I'm Claude, an AI language model. I can't execute Python code with OR-Tools. But I can help the user by:

1. Writing the Python code they would need to run
2. Explaining the approach
3. Discussing what results would mean

Let me think about what this would need:
- Generate all possible kingwise connected patterns up to some size n
- For each pattern, simulate one generation of Conway's Game of Life
- Use OR-Tools CP-SAT to find the pattern that maximizes the population at t=1
- Track whether it matches 3n-6 or if there are counterexamples

Actually, I think the user might be asking me to actually try this, but I can't run code. However, I should clarify what I can and can't do, and provide them with the code they need to run this themselves.

Let me write out a comprehensive solution that they can run.I appreciate the creative idea! However, I should clarify: **I can't directly execute code or run OR-Tools**, as I'm an AI language model without a runtime environment. But I can write you a complete Python solution that you can run locally to do exactly this.

Here's a robust implementation:

```python
from collections import deque

def gol_step(cells):
"""Apply one generation of Conway's Game of Life. Returns set of live cells."""
if not cells:
return set()

# Find bounding box
min_x = min(c[0] for c in cells)
max_x = max(c[0] for c in cells)
min_y = min(c[1] for c in cells)
max_y = max(c[1] for c in cells)

# Expand bounding box to account for births
min_x -= 1
max_x += 1
min_y -= 1
max_y += 1

next_gen = set()
cell_set = set(cells)

for x in range(min_x, max_x + 1):
for y in range(min_y, max_y + 1):
# Count live neighbors (Moore neighborhood)
neighbors = sum(
(x + dx, y + dy) in cell_set
for dx in [-1, 0, 1]
for dy in [-1, 0, 1]
if (dx, dy) != (0, 0)
)

is_alive = (x, y) in cell_set

# Conway's rules: born on 3, survive on 2-3
if (not is_alive and neighbors == 3) or (is_alive and neighbors in [2, 3]):
next_gen.add((x, y))

return next_gen

def normalize_pattern(cells):
"""Translate pattern so minimum coordinates are at origin."""
if not cells:
return tuple()
min_x = min(c[0] for c in cells)
min_y = min(c[1] for c in cells)
return tuple(sorted((c[0] - min_x, c[1] - min_y) for c in cells))

def visualize_pattern(pattern):
"""Return a visual representation of the pattern."""
if not pattern:
return "Empty"

min_x = min(c[0] for c in pattern)
max_x = max(c[0] for c in pattern)
min_y = min(c[1] for c in pattern)
max_y = max(c[1] for c in pattern)

pattern_set = set(pattern)
lines = []
for x in range(min_x, max_x + 1):
row = ""
for y in range(min_y, max_y + 1):
row += "O" if (x, y) in pattern_set else "."
lines.append(row)

return "\n".join(lines)

def generate_connected_patterns(n):
"""Generate all kingwise connected patterns of size n."""
if n == 0:
return []
if n == 1:
return [((0, 0),)]

all_patterns = set()

# Start with single cell
candidates = {((0, 0),)}
all_patterns.add(((0, 0),))

# Grow patterns one cell at a time
for size in range(2, n + 1):
next_candidates = set()

for pattern in candidates:
pattern_set = set(pattern)

# Find all kingwise neighbors of current pattern
boundary = set()
for x, y in pattern:
for dx in [-1, 0, 1]:
for dy in [-1, 0, 1]:
if (dx, dy) != (0, 0):
neighbor = (x + dx, y + dy)
if neighbor not in pattern_set:
boundary.add(neighbor)

# Try adding each boundary cell
for new_cell in boundary:
new_pattern = tuple(sorted(list(pattern) + [new_cell]))
normalized = normalize_pattern(new_pattern)

if normalized not in all_patterns:
next_candidates.add(normalized)
all_patterns.add(normalized)

candidates = next_candidates

return [p for p in all_patterns if len(p) == n]

def test_upper_bound(max_n=12):
"""Test the 3n-6 conjecture against all kingwise connected patterns."""
print("Testing 3n-6 upper bound conjecture\n")
print(f"{'n':>3} {'Patterns':>10} {'Max Pop':>10} {'3n-6':>10} {'Ratio':>8}")
print("-" * 55)

all_counterexamples = []

for n in range(1, max_n + 1):
patterns = generate_connected_patterns(n)
max_population = 0
best_pattern = None
best_next_gen = None

if not patterns:
print(f"{n:3d} {0:10d} {'N/A':>10} {3*n-6:10d} {'N/A':>8}")
continue

for pattern in patterns:
next_gen = gol_step(pattern)
pop = len(next_gen)

if pop > max_population:
max_population = pop
best_pattern = pattern
best_next_gen = next_gen

expected = 3 * n - 6
ratio = max_population / expected if expected > 0 else float('inf')

# Flag counterexamples
flag = " EXCEEDS" if max_population > expected and n > 3 else ""

print(f"{n:3d} {len(patterns):10d} {max_population:10d} {expected:10d} {ratio:8.3f}{flag}")

if max_population > expected and n > 3:
all_counterexamples.append((n, max_population, expected, best_pattern, best_next_gen))

# Print the winning pattern
print(f"\n Generation t=0 (n={n}):")
for line in visualize_pattern(best_pattern).split('\n'):
print(f" {line}")
print(f"\n Generation t=1 (population={max_population}):")
for line in visualize_pattern(best_next_gen).split('\n'):
print(f" {line}")
print()

print("=" * 55)
if all_counterexamples:
print("\n COUNTEREXAMPLES FOUND:\n")
for n, pop, expected, pattern, next_gen in all_counterexamples:
print(f"n={n}: Population={pop}, Expected 3n-6={expected}")
print(f" t=0: {pattern}")
print(f" t=1: {next_gen}")
else:
print("\n✓ No counterexamples found for n > 3")
print("The conjecture 3n-6 holds for all tested patterns!")

if __name__ == "__main__":
test_upper_bound(max_n=10)
```

**What this does:**

1. **Generates all kingwise-connected patterns** of each size n (up to n=12 by default)
2. **Simulates one GoL generation** for each pattern
3. **Tracks the maximum population** reached for each n
4. **Compares against 3n−6** to find counterexamples

**To run this:**

```bash
pip install ortools
python gol_search.py
```

---

## Why I didn't use OR-Tools directly here

Actually, after thinking about it: **constraint programming isn't quite the right tool** for this problem because we're not optimizing subject to complex constraints—we're just enumerating a finite space and simulating. The above brute-force approach is simpler and faster.

However, if you wanted to use OR-Tools for something like "find the densest pattern with exactly k live cells that maximizes births," that would be a valid CP-SAT use case. Would you like me to write that variant instead?

---

**What I expect you'll find:**

- For n ≤ 3: Counterexamples exist (as you mentioned)
- For n ≥ 4: The horizontal line likely achieves the maximum, confirming 3n−6
- A clear pattern will emerge showing which shape is optimal

Let me know what results you get!

EDIT: Results, note this just count polylets:

Code: Select all

Testing 3n-6 upper bound conjecture

  n   Patterns    Max Pop       3n-6    Ratio
-------------------------------------------------------
  1          1          0         -3      inf

  Generation t=0 (n=1):
    Empty

  Generation t=1 (population=0):
    Empty

  2          4          0          0      inf

  Generation t=0 (n=2):
    Empty

  Generation t=1 (population=0):
    Empty

  3         20          4          3    1.333

  Generation t=0 (n=3):
    OO
    O.

  Generation t=1 (population=4):
    OO
    OO

  4        110          7          6    1.167 ⚠️ EXCEEDS

  Generation t=0 (n=4):
    .O.
    OOO

  Generation t=1 (population=7):
    OOO
    OOO
    .O.

  5        638          9          9    1.000

  Generation t=0 (n=5):
    OOOOO

  Generation t=1 (population=9):
    OOO
    OOO
    OOO

  6       3832         12         12    1.000

  Generation t=0 (n=6):
    OOOOOO

  Generation t=1 (population=12):
    OOOO
    OOOO
    OOOO

  7      23592         15         15    1.000

  Generation t=0 (n=7):
    OOOOOOO

  Generation t=1 (population=15):
    OOOOO
    OOOOO
    OOOOO

  8     147941         18         18    1.000

  Generation t=0 (n=8):
    O
    O
    O
    O
    O
    O
    O
    O

  Generation t=1 (population=18):
    OOO
    OOO
    OOO
    OOO
    OOO
    OOO

^C

The conjecture holds true, so far. This took about 5 mins on a old Macbook, so I think someone can possibly do n = 10.

max_pop.py.txt

[HartmutHolzwart]

Can Claude prove that if gen0 <= n then gen1 <= 3 x n?

[speedydelete]

I came up with a conjecture, but then I proved it, so here's the proof:

This is a procedure for turning any 3SAT problem into a LLS input file, therefore proving that the "generalized lifesrc problem" (the problem solved by LLS) is NP-complete

It is built out of a series of 5x5 parts, each part specifies 2 generations of the pattern, they can be placed anywhere, the rule B1e2i8/S01e2i is used

For every variable in the problem, create 2 LLS variables, let's call them v and w, v corresponds to the positive literals of that variable, w is the negative literals
do this part:

Code: Select all

# gen 0
0,0,0,0,0
0,1,1,1,0
0,1,v,1,0
0,1,1,1,0
0,0,0,0,0
# gen 1
*,*,*,*,*
*,*,*,*,*
*,*,w,*,*
*,*,*,*,*
*,*,*,*,*

This forces v XOR w = 1 because of the presence of B8 and the lack of S8

Then. for every clause, each of which consists of literals a, b, and c, do this:

Code: Select all

# gen 0
0,0,0,0,0
0,0,0,0,0
0,a,b,c,0
0,0,0,0,0
0,0,0,0,0
# gen 1
*,*,*,*,*
*,*,*,*,*
*,*,1,*,*
*,*,*,*,*
*,*,*,*,*

This works because of the presence of B1e, B2i, S0, S1e, and S2i, which means that the middle cell evaluates to (a OR b OR c), matching the 3SAT clause

[andrewthelifer]

A lively pattern in Life is a pattern where every live cell survives to the next generation (because they all have 2 or 3 live neighbours). By this definition, still-lives are the lively patterns where no dead cell has exactly 3 neighbours so no birth can occur.

The above describes 1-lively patterns. An N+1-lively pattern is one with an N-lively successor: generation 3 of the pi-heptomino (holding that pi is gen 0) aka "house" is 2-lively, because it's lively and so is its successor.

Conjectures:

• No pattern in Conway's Game of Life is 3-lively or higher except still-lives.

• No pattern in Conway's Game of Life is w-lively except still-lives (an example of a non-SL pattern like this being the shoots of Life without Death).

hotdogPi has attempted a proof that the only >=3-lively patterns are still-lives: "in generation 0 all cells must be S2, but this cannot be true in generation 1 because a B3 just occurred". Is this proof correct? If not, can a good proof or disproof be found?

[NNlk05]

Yet another conjecture regarding lively.
There exists a lively spaceship, I think this have been investigated before, let me find it.

[speedydelete]

Yet another conjecture regarding lively.
There exists a lively spaceship, I think this have been investigated before, let me find it.

Do you mean a spaceship that is lively in at least 1 phase?

[NNlk05]

Do you mean a spaceship that is lively in at least 1 phase?

Yes.

[I6_I6]

A lively pattern in Life is a pattern where every live cell survives to the next generation (because they all have 2 or 3 live neighbours). By this definition, still-lives are the lively patterns where no dead cell has exactly 3 neighbours so no birth can occur.

The above describes 1-lively patterns. An N+1-lively pattern is one with an N-lively successor: generation 3 of the pi-heptomino (holding that pi is gen 0) aka "house" is 2-lively, because it's lively and so is its successor.

Conjectures:

• No pattern in Conway's Game of Life is 3-lively or higher except still-lives.

• No pattern in Conway's Game of Life is w-lively except still-lives (an example of a non-SL pattern like this being the shoots of Life without Death).

hotdogPi has attempted a proof that the only >=3-lively patterns are still-lives: "in generation 0 all cells must be S2, but this cannot be true in generation 1 because a B3 just occurred". Is this proof correct? If not, can a good proof or disproof be found?

The pre-block is a counterexample for both conjectures:

Code: Select all

x = 2, y = 2, rule = B3/S23
2A$.A!

[speedydelete]

Do you mean a spaceship that is lively in at least 1 phase?

Yes.

This shouldn't be too hard to make with some ECCA stuff...

[NNlk05]

This shouldn't be too hard to make with some ECCA stuff...

Won’t be basing third on the Stable Storage Spaceship better?

[andrewthelifer]

[catagolue][/catagolue]
The pre-block is a counterexample for both conjectures:

Code: Select all

x = 2, y = 2, rule = B3/S23
2A$.A!

You've done it! And of course the reward of a taskmaster to his subjects is to set them another task.

A spirited pattern in Life is a pattern where all live cells have 2 or 3 neighbours (so they all survive) and at least one dead cell has 3 neighbours (so it will come alive in the next generation). The set of spirited patterns in Life is the set of induction coils with still-lives excluded, or the set of lively patterns with still-lives excluded.

A 1-spirited pattern immediately evolves into a non-spirited pattern, e.g. the preblock evolving into a block. An N+1-spirited pattern has an N-spirited successor: house is 2-spirited, because its gen-0 form is spirited and so is its gen-1 form.

Conjectures still open:

• There is no 3-spirited pattern. (thus there is no N-spirited pattern with N > 3, because they rely on the existence of 3-spirited patterns somewhere down the line)

• There is no w-spirited pattern. (e.g. the shoots from Life without death)

[TheWayOfTheCon]

Conjecture: In DryLife and similar rules, chaotic growth patterns will eventually produce every possible still life and oscillator.

Could this even be proven?

[rabbit]

Conjecture: In DryLife and similar rules, chaotic growth patterns will eventually produce every possible still life and oscillator.

Could this even be proven?

If an unsynthesizable still life or an unsynthesizable oscillator can be found in DryLife or any other rule, this conjecture would be disproven.

[TheWayOfTheCon]

If an unsynthesizable still life or an unsynthesizable oscillator can be found in DryLife or any other rule, this conjecture would be disproven.

I said "every possible" as in every still life/oscillator that can form naturally, from soups and stuff.

[speedydelete]

Conjecture: In DryLife and similar rules, chaotic growth patterns will eventually produce every possible still life and oscillator.

Could this even be proven?

If an unsynthesizable still life or an unsynthesizable oscillator can be found in DryLife or any other rule, this conjecture would be disproven.

Is one of the existing B3/S23 unsynthesizable still lifes still self-forcing in B37/S23? B3/S23 still lifes cannot contain A7...