# Same Length, Fewer Chunks? Methods and claim sheet

Publication date: 2026-11-11
Evidence label: evidence review with a reproducible exact calculation and a source-code inspection
Canonical page: https://www.altamens.com/research/digit-span-chunking-patterns/

## Question

How often does a random digit list contain an easy-to-group pattern, and what does the research on
chunking say about how such patterns can change a digit span score?

## Provenance

- No participant, customer, account, device, analytics or telemetry data was used.
- The generator modelled as `no_repeat` mirrors `makeDigits()` in
  `app/tests/working-memory/page.tsx` of the Altamens repository at commit
  `6dd71de0699c92c610e2be0c82632a6f24bc69ed` (inspected 2026-11-11): the first digit is uniform on
  0 to 9 and each later digit is uniform on the 9 digits that differ from the previous one. The
  test starts at 3 digits and adds one digit after each correct list.
- The `uniform` generator draws every digit independently and uniformly from 0 to 9, for comparison.

## Pattern definitions

Adjacent digits only, and no wrap-around from 9 to 0.

| Pattern | Rule | Examples |
| --- | --- | --- |
| `repeat` | two equal neighbours | 5-5 |
| `counting_run` | three neighbours stepping +1 twice or -1 twice | 4-5-6, 8-7-6 |
| `equal_step_run` | three neighbours with the same non-zero step (includes counting runs) | 2-4-6, 9-6-3 |
| `any_pattern` | at least one repeat or equal-step run | |

These are simple, transparent definitions chosen for this note. They are not the compression
metric of Mathy and Feldman (2012) or Chekaf, Cowan and Mathy (2016), and no study cited here
measured the recall benefit of exactly these patterns.

## Calculation

`calculate.py` computes, for list lengths 3 to 12, the exact probability that a list contains at
least one pattern. It uses dynamic programming over the state (last digit, last step) with exact
fractions, then checks the result in two independent ways:

1. brute-force enumeration of every possible list for lengths 3 to 6;
2. a Monte Carlo run of 200,000 lists per length and generator with seed `20261111`
   (every estimate must fall within 5 binomial standard errors of the exact value).

Hand-checkable spot values asserted by the script: a 3-digit uniform list repeats a neighbour with
probability 1 - 0.9^2 = 19%; a 3-digit `no_repeat` list is a counting run with probability
16/810 (8 ascending and 8 descending runs out of 10 x 9 x 9 lists).

## Reproduction

Python 3 standard library only (tested with Python 3.11.18). It takes under a minute.

```text
python3 calculate.py --csv results.csv
```

Expected: the script prints one line per generator, length and pattern, raises no assertion error,
and writes a `results.csv` identical to the published one.

SHA-256 of the published files at release:

- `calculate.py`: `8d1b6bdf03bd22995de9df67b67a506dede94b04a76174559a69d27b225c6241`
- `results.csv`: `4b6d59ba016e1f7e341349e9e5034425f7369147b34083082aae7dbe1a53a355`

## Claim sheet

| Claim in the paper | Source |
| --- | --- |
| Uniform 7-digit lists contain at least one repeated neighbour 46.9% of the time; 58.6% contain a repeat or an equal-step run | `results.csv` |
| The Altamens generator never produces repeats; 8.9% of its 7-digit lists contain a counting run and 22.1% an equal-step run | `results.csv` |
| At 9 digits the Altamens generator gives 12.2% (counting run) and 29.5% (equal-step run); at 12 digits, 17.0% and 39.2% | `results.csv` |
| Removing repeats slightly raises the counting-run rate (7.3% to 8.9% at 7 digits) | `results.csv` |
| A central capacity of about 3 to 5 chunks in adults | Cowan 2001; Cowan 2010 |
| Measured digit span depended on the length of the list after compression; about 3 or 4 distinct chunks | Mathy and Feldman 2012 (abstract) |
| Span of about three items for lists with no structure, rising linearly as structure was added | Chekaf, Cowan and Mathy 2016 (abstract) |
| Chunking reduced load and helped recall of other material; chunk benefit was not independent of chunk size in all conditions; early chunks helped, late chunks did not | Thalmann, Souza and Oberauer 2019 (abstract) |
| Two-word chunks behaved like redintegration, three-word chunks like data compression | Norris, Kalm and Hall 2020 (abstract) |
| Temporal grouping effects in immediate serial recall of mid-length lists | Spurgeon et al. 2015 (abstract) |
| Temporal grouping effects did not depend on the predictability of the grouping pattern | Hartley, Hurlstone and Hitch 2016 (abstract) |
| After more than 230 hours of practice, one person's digit span rose from 7 to 79 | Ericsson, Chase and Faloon 1980 (abstract) |

## Claim boundaries

- The calculation describes how often lists contain patterns. It does not measure how much any
  pattern helps recall in the Altamens test or anywhere else.
- Nothing here estimates norms, percentiles, reliability, practice effects or a training benefit.
- Strategy research shows that recoding helps the practised material and task. It does not show
  better memory in everyday life, and this note makes no such claim.
- The literature review is targeted, not systematic. Several claims rely on abstracts.

## Review status

Literature search, calculation, drafting, source checks and publication preparation used an AI
assistant. The script and the figures in the paper received automated consistency checks only.
There was no independent human methods review and no journal peer review.