# The `(m,2,2)` gap: projection obstruction and Lucas-boundary cases

Reference: Glenn Bruda, Joseph Cooper, Kareem Jaber, Raul Marquez, and Steven J. Miller, **“Variants of Conway Checkers and k-nacci Jumping,”** arXiv:2408.08856v3, December 2025. I use their notation and cite Theorem 1.1/equation (1.2), Lemma 4.4, Lemma 4.5, Theorem 4.6, and Definition 4.10 below.

## Question checked

The one-dimensional `k=2` case is closed by Bruda et al. §4.2--§4.3, so the smallest genuinely open scope is `d=2`. Theorem 1.1/equation (1.2), specialized to `k=2,d=2`, gives the one-row window

```text
floor(log_phi m) + 4 <= n_M(m,2,2) <= floor(log_phi m) + 5,
```

where the integer floors are the operative form because `n_M` is an integer and `phi` is irrational. The paper states that the upper bound is attainable for almost all `m`, but does not give a complete classification of the exceptional `m`.

This pass does **not** close the open problem. It documents the exact pagoda bound, reproduces the standard projection construction, and isolates the precise slack condition where that construction lands one row below the pagoda upper bound.

## Pagoda upper bound

For `k=2`, set `alpha=1/phi`. Bruda et al. Lemma 4.5 computes the `d`-dimensional initial energy for a target on row `n` as

```text
E(d) = m alpha^n (1+alpha)^(d-1) / (1-alpha)^d.
```

For `d=2`, using `1-alpha=1/phi^2` and `1+alpha=phi`, this simplifies to

```text
E(2) = m phi^(5-n).
```

A checker on the target has energy `1`, so reachability requires `m phi^(5-n) >= 1`, hence

```text
n <= log_phi(m) + 5.
```

Since no integer `m>1` is an exact power of `phi`, equality does not produce an integer boundary. Therefore the exact pagoda upper bound recorded by the script is

```text
pagoda_upper(m) = floor(log_phi m) + 5.
```

This means the pagoda method alone never improves equation (1.2) for integer `m>1` in `d=2`; the whole question is constructive.

## Projection construction lower bound

The §4.4 row-1 theorem says that, in the one-dimensional `k=2` game, a side column can add exactly

```text
floor(m/(phi-1)) = floor(phi m)
```

checkers to row 1. In `Z^2 -> Z`, using the two horizontal sides plus the original projected column gives the per-site projected capacity

```text
M(m) = m + 2 floor(phi m).
```

Applying the exact one-dimensional theorem from §4.2--§4.3 then gives the certified lower bound

```text
best_projection(m) = floor(log_phi(M(m)) + 2).
```

The ideal projected capacity needed to match the `d=2` pagoda upper bound is `phi^3 m`, because

```text
floor(log_phi(phi^3 m) + 2) = floor(log_phi m) + 5.
```

The projection construction supplies

```text
M(m) = phi^3 m - 2 {phi m},
```

so the exact logarithmic loss is

```text
delta(m) = -log_phi(1 - 2 {phi m}/(phi^3 m)).
```

The projection construction reaches the pagoda upper bound exactly when

```text
{log_phi m} >= delta(m).
```

When `{log_phi m} < delta(m)`, the construction is one row short. Those rows are marked `open` in the CSV because this script has not proved impossibility and has not reconstructed a stronger two-dimensional construction.

## Computational reproduction

Artifacts:

- Pagoda script: [`research/scripts/mkd_2d_pagoda.py`](scripts/mkd_2d_pagoda.py)
- Construction/table script: [`research/scripts/mkd_2d_construction.py`](scripts/mkd_2d_construction.py)
- Shared arithmetic: [`research/scripts/mkd_2d_common.py`](scripts/mkd_2d_common.py)
- Script README: [`research/scripts/README.md`](scripts/README.md)
- CSV table: [`research/data/m-k-d-table-d2.csv`](data/m-k-d-table-d2.csv)

Run:

```sh
python3 research/scripts/mkd_2d_pagoda.py --min 2 --max 50 \
  --out research/data/m-k-d-pagoda-d2.csv
python3 research/scripts/mkd_2d_construction.py --min 2 --max 500 \
  --include-even-lucas-to 30 \
  --out research/data/m-k-d-table-d2.csv
```

Output from the construction run:

```text
wrote 508 rows to research/data/m-k-d-table-d2.csv
upper-attained by projection: 493; open/gap-of-1 rows: 15
open rows: 3, 7, 18, 47, 123, 322, 843, 2207, 5778, 15127, 39603, 103682, 271443, 710647, 1860498
```

Columns include the required fields:

- `m`: initial checkers per cell.
- `floor_log_phi_m`: `floor(log_phi m)`.
- `pagoda_upper_m_2_2`: exact pagoda upper bound `floor(log_phi m)+5`.
- `best_construction_m_2_2`: lower bound from projection plus the exact 1-D theorem.
- `verdict`: `upper-attained` if the projection reaches the pagoda upper bound; `open` if the projection is one row short.

First rows:

| m | floor log | frac log | projected M | pagoda upper | construction | verdict |
|---:|---:|---:|---:|---:|---:|---|
| 2 | 1 | 0.440420090413 | 8 | 6 | 6 | upper-attained |
| 3 | 2 | 0.283011828589 | 11 | 7 | 6 | open |
| 4 | 2 | 0.880840180825 | 16 | 7 | 7 | upper-attained |
| 5 | 3 | 0.344551876369 | 21 | 8 | 8 | upper-attained |
| 6 | 3 | 0.723431919002 | 24 | 8 | 8 | upper-attained |
| 7 | 4 | 0.043770430650 | 29 | 9 | 8 | open |
| 8 | 4 | 0.321260271238 | 32 | 9 | 9 | upper-attained |
| 9 | 4 | 0.566023657179 | 37 | 9 | 9 | upper-attained |
| 10 | 4 | 0.784971966782 | 42 | 9 | 9 | upper-attained |
| 11 | 4 | 0.983034804894 | 45 | 9 | 9 | upper-attained |
| 12 | 5 | 0.163852009414 | 50 | 10 | 10 | upper-attained |
| 13 | 5 | 0.330187713371 | 55 | 10 | 10 | upper-attained |
| 14 | 5 | 0.484190521063 | 58 | 10 | 10 | upper-attained |
| 15 | 5 | 0.627563704958 | 63 | 10 | 10 | upper-attained |
| 16 | 5 | 0.761680361650 | 66 | 10 | 10 | upper-attained |
| 17 | 5 | 0.887663595352 | 71 | 10 | 10 | upper-attained |
| 18 | 6 | 0.006443747591 | 76 | 11 | 10 | open |

## Pattern hypothesis

The projection-obstruction rows are exactly the even-indexed Lucas numbers in the tested range:

```text
L(2)=3, L(4)=7, L(6)=18, L(8)=47, L(10)=123, L(12)=322,
L(14)=843, L(16)=2207, L(18)=5778, L(20)=15127,
L(22)=39603, L(24)=103682, L(26)=271443, L(28)=710647, L(30)=1860498.
```

This matches Bruda et al. Definition 4.10 and the paragraph following it: even Lucas numbers are natural candidates because

```text
L(2r) = phi^(2r) + phi^(-2r)
```

lies just above a power of `phi`, so `{log_phi m}` is tiny. The projection loss `delta(m)` is also tiny, but for the listed even Lucas numbers through `L(30)` it is still slightly larger than `{log_phi m}`, causing the one-row construction failure.

The same paragraph in Bruda et al. says their algorithm fails at `L(2),L(4),...,L(30)` but succeeds at `L(32)=4870847`. I did **not** reconstruct that fuller `L(32)` success here. The scripts reproduce the clean projection obstruction; they should not be cited as a complete implementation of every construction known to the authors.

## Outcome shape

This lands as **documented obstruction**, not a closed characterization of `n_M(m,2,2)`.

What is proved/reproduced here:

1. The exact `d=2,k=2` pagoda upper bound is `floor(log_phi m)+5` for every integer `m>1`.
2. The standard §4.4/§4.5 projection construction reaches `floor(log_phi(m+2 floor(phi m))+2)`.
3. Projection succeeds exactly when `{log_phi m} >= delta(m)` with `delta(m) = -log_phi(1 - 2{phi m}/(phi^3 m))`.
4. The projection gap rows through the tested Lucas boundary are the even Lucas candidates listed above, agreeing with the paper's warning that Lucas numbers are where the construction is fragile.

What remains open after this pass:

- For rows marked `open`, the table only says the reproduced projection construction is one row short. It does **not** prove `n_M = floor(log_phi m)+4`.
- A stronger two-dimensional construction, of the sort the paper says succeeds at `L(32)`, is needed to decide at least some of these boundary cases.
- I did not include a blind two-dimensional IDA* solver. For the relevant target rows it is far less informative than the symbolic pagoda/projection calculation, and a naive bounded search would be easy to overinterpret. The honest computational artifact is therefore the exact arithmetic table, not a fake exhaustive search.