Proposition 6.4.1 of Lietard's thesis states that there is a 70,880,000-letter word over \(\{0,1,2,3\}\) containing no three consecutive equal-length blocks with equal sums. Chapter 6 constructs the word with the deterministic Up and Down method, which alternates the letter priority \(0,1,2,3\) and \(3,2,1,0\) after a failure threshold and a fixed retreat. Section 6.4.2 reports that the computation took several weeks.

This is the strongest finite construction located in the dated audit. It supplies no infinite word or impossibility proof. The thesis page for the word and program currently points to a file-share URL that returned HTTP 404 on 2026-07-28. The proposition is therefore recorded as sourced evidence without an independent replay of the 70,880,000-letter artifact.

Lietard and Rosenfeld call two same-size numerical alphabets equivalent when a letter map preserves and reflects equal-length, equal-sum equivalence for every pair of finite words. Their Lemma 1 shows that every affine map \(x\mapsto ax+b\), with \(a\ne0\), preserves this equivalence. Their Main Theorem and Corollary 1 give an infinite additive-cube-free word over every complex alphabet of size four outside the class of \(\{0,1,2,3\}\). In the integer setting, the exceptional class consists of four-term arithmetic progressions under an affine image.

Their closing Question 1 leaves \(\{0,1,2,3\}\) open and reports an exhaustive failure for morphisms whose four images each have length at most seven. Andrade and Mol state in their February 2025 introduction that it is still unknown whether an infinite additive-cube-free word exists over \(\{0,1,2,3\}\). This later explicit status is the latest direct statement located in the audit.

With failure threshold 1,209, retreat length 100, and checkpoint spacing 10,000, the constructor reached length 1,000,000 after testing 2,480,028 candidate letters. The output file, including its final line feed, has SHA-256 digest `15d439b42fefa8501203775cf0b4457f7eaf19bae14ae5797b5d405e03ed1846`.

The constructor's internal scan checked every end position and block length. The independent checker scanned every block length and start position. Each covered all 166,666,500,000 admissible factor specifications and found no additive cube. The symbol counts are 282,092 zeros, 217,686 ones, 217,697 twos, and 282,525 threes. Lietard's source-reported word has length 70,880,000. The acceptance condition still asks for an infinite word or an impossibility proof.

The audit searched the live TheoremDB directory by exact title terms, object, parameter, and additive-cube aliases. It found one canonical target, problem 2826, and no attached research records. The exact slug search endpoint tokenized the query differently and returned zero, so the title-term result and canonical object were checked directly. No duplicate target or competing packet was found.

The literature pass started with Rao's 2015 paper, which asks the question and reports a finite word of about \(1.4\times10^5\) letters. Lietard and Rosenfeld's 2020 classification makes the arithmetic-progression class the sole four-letter exception and reports finite words above \(10^7\). Lietard's thesis raises the finite construction to exactly 70,880,000. The 2022 survey repeats the open exception. Andrade and Mol explicitly call the case unknown in arXiv:2408.15390v2, revised February 2025. Popoli, Shallit, and Stipulanti address neighboring additive-complexity and Walnut questions.

Exact-title, exact-alphabet, finite-length, morphism, citation, arXiv, DOI, and author-page searches were run through 2026-07-28. The result is a dated search report. Its finite scope cannot establish the absence of later or unpublished work.

The attempt reconstructed the thesis's finite Up-and-Down idea using exact prefix sums. It used ascending priority \(0,1,2,3\), descending priority \(3,2,1,0\), a failure threshold of 1,209, a retreat of 100 letters, and checkpoints every 10,000 letters. The stopping rule was target length 1,000,000 or 10,000,000,000 tested candidate letters.

The run reached its target after 2,480,028 tests, 1,271,032 rejected candidates, 208,996 recorded backtracks, and 1,097 direction changes. Construction plus the internal quadratic scan took 180.38 wall seconds. A separate checker took 102.68 wall seconds and accepted the same word. A 250,000-letter calibration run used 617,607 tests and produced digest `c9e5f13458e3bec984fc37f91541edc8a9b0fff78e47d9949626aa0f15a95520`.

The million-letter execution is a separate deterministic construction. It agrees with the 250,000-letter execution for the first 249,900 symbols, then changes because the longer run retreats 100 symbols at the 250,000 checkpoint.

The failed route kept the priority \(0,1,2,3\) throughout and backtracked lexicographically after rejected extensions. It started from the empty word, targeted length 30,000, and stopped exactly at 10,000,000 tested candidate letters. The final retained prefix had length 24,382 and passed a full scan of 99,076,257 candidate factors. Its file digest, including the final line feed, is `c7fdbaa5242a859193ee96fa8a6a767f3be7162e00417a9f0b3a8e6cc4c44a1d`.

The thesis reports that its direct approach reaches 24,396 quickly and then spends two more hours reaching 24,397. The unavailable original code and possible initial-prefix difference prevent an exact replay comparison. The present run calibrates this reconstruction and lands in the same narrow length range. Raising the candidate cap alone would repeat a poor route. A retry is justified if the original source and initial word are recovered, or if a structural pruning rule changes the search tree.

Lietard and Rosenfeld report that every morphism over \(\{0,1,2,3\}\) whose four images have length at most seven fails to provide an additive-cube-free infinite fixed point. The next experiment should begin outside that published negative range.

The included exact prefilters cover affine image lengths 8 through 12. They leave 1,130 complement-conjugacy orbits of expanding length-sum matrices. Requiring each of the four image pools to contain an additive-cube-free word reduces the all-four-letters tranche to 588 orbits. Requiring a self-starting image whose incidence-reachable component contains all four letters gives an exact second ranking. The smallest orbit representative has matrix \((8,1,2,2)\), image lengths \((8,9,10,11)\), image sums \((2,4,6,8)\), and 23,298,600 retained tuples.

Enumerate that representative first, then continue in the recorded all-four-reachability order. A one-million-symbol scan is an early rejection screen. For each surviving morphism, compute the short-factor bound required by Theorem 2.4 and record an exhaustive initial check through that bound. The million-symbol scan can serve as this initial check only when it reaches the computed bound. Next enumerate the finite template-ancestor set, then run the theorem's final template check. Preserve the first cube for every rejection. Fixed points omitting a letter form a separate tranche whose ternary subalphabet status should be audited first.

The template decision algorithm is due to Currie, Mol, Rampersad, and Shallit and implemented by Andrade and Mol. Theorem 2.4 makes it decisive for morphisms satisfying the stated affine and expanding hypotheses. Use a 16 GiB memory limit and a 12-hour wall limit per candidate. Preserve parameter regions, source digests, short-factor bounds, initial-check results, ancestor sets, final checks, first-cube witnesses, and resource exits so later searches can skip completed work.

The constructor stores exact unsigned 64-bit prefix sums. A candidate letter is accepted precisely when no additive cube ends at the new final position. In Up-and-Down mode it starts with priority \(0,1,2,3\), switches to \(3,2,1,0\) after 1,209 rejected candidates or at each 10,000-letter checkpoint, retreats 100 letters, and repeats. The thesis's displayed main directly switches direction and retreats at the checkpoints. It fixes the failure threshold at 1,209 and uses a retreat of 100 in the threshold-tuning code, while also saying that the retreat changed during the long construction. The program therefore records the exact 100-letter retreat as a source-informed choice specific to this reconstruction.

After construction, the program scans every end position and every admissible block length again before printing the word. The execution is deterministic and uses no randomness, floating point, network, or external service. Its implementation was written independently from the unavailable thesis source and should be treated as a source-informed reconstruction.

This checker shares the prefix-sum formula with the mathematical definition and shares no construction or backtracking code. Its outer loop is block length and its inner loop is start position, unlike the constructor's internal end-position loop. It reads a word file, rejects symbols outside \(0,1,2,3\), and returns the first additive cube or the count of all checked pairs.

On the million-letter output it completed all 166,666,500,000 admissible \((\text{block length},\text{start})\) pairs and returned valid=true. The same source checked the separately generated 250,000-letter output over 10,416,625,000 pairs.

For a morphism on letters \(x=0,1,2,3\), affineness requires image lengths \(L_x=a+bx\) and image sums \(S_x=c+dx\). Requiring every \(L_x\) to lie in \([8,12]\) leaves nine length vectors. A sum is feasible precisely when \(0\le S_x\le3L_x\), since every integer in that interval is the sum of an \(L_x\)-letter word over \(\{0,1,2,3\}\).

For \(M=[[a,b],[c,d]]\), write \(T=a+d\) and \(D=ad-bc\). The program checks the expanding-eigenvalue condition with exact integer arithmetic by applying the quadratic Schur criterion to the reciprocal eigenvalues. Its three inequalities are \((D-T+1)D>0\), \((D+T+1)D>0\), and \((D-1)D>0\), with \(D\ne0\).

The exhaustive matrix-level pass finds 2,895 feasible length-sum matrices, of which 2,724 are nonsingular and 2,212 meet the expanding condition. Complement conjugation sends \((a,b,c,d)\) to \((a+3b,-b,3a+9b-c-3d,d-3b)\). It is an involution on the expanding set, with 48 fixed matrices and 1,130 orbits. Prolongability and additive-cube avoidance remain word-level stages in the recommended experiment.

The Python program grows every word over \(\{0,1,2,3\}\) through length 12 and rejects a prefix as soon as an additive cube ends at its final position. The exact numbers of surviving words at lengths 8 through 12 are 42,070, 150,560, 538,214, 1,924,738, and 6,772,220. It also retains the count for every pair of length and sum, first letter, and symbol-support mask.

A separate C++ program enumerates all \(4^n\) words by two-bit integer code for each \(8\le n\le12\). It scans factors in block-length and start-position order. The five complete sum-count vectors agree exactly with the recursive program.

Consider a fixed point that uses all four letters. Each image \(f(x)\) then occurs as a factor and must itself avoid additive cubes. Applying this necessary condition to the 2,212 expanding matrices leaves 1,146 matrices. Each has at least one letter whose viable image pool contains a word beginning with that letter, so the matrix-level prolongability test makes no further deletion. Complement conjugation reduces the tranche to 588 orbits, with 30 fixed matrices.

The support masks permit an exact incidence-graph filter without enumerating individual image tuples. For each tuple of four support categories, the program tests whether some self-starting image gives a prolongation letter whose reachable component contains all four letters. After this filter, the representative matrix \((8,1,2,2)\), with lengths \((8,9,10,11)\) and sums \((2,4,6,8)\), has the smallest retained pool: 23,298,600 image tuples. Its four unfiltered image-pool sizes are 1, 33, 510, and 5,831. The output records the first twelve orbit representatives under both the prolongability and all-four-reachability rankings. Fixed points that omit a letter lie outside this first tranche and require a separate subalphabet audit.

This replay enumerates every word over \(\{0,1,2,3\}\) of lengths 8 through 12 by two-bit integer code. It scans every possible additive-cube factor in block-length and start-position order, then records length, sum, first letter, and support mask for each surviving word. This implementation is separate from the recursive Python generator in `ac0123-artifact-finite-image-pools`.

The program independently obtains 1,146 expanding matrices whose four image pools are nonempty and permit a self-starting image, then reduces them to 588 complement-conjugacy orbits. It reproduces the first twelve prolongability-ranked representatives. For the incidence-leading matrix \((8,1,2,2)\), it partitions each image pool by support mask and whether the image begins with its own letter. Exact directed reachability over those categories gives 23,298,600 tuples with a prolongation letter whose fixed-point component uses all four letters.

The replay checks the claimed leading incidence count. The primary Python artifact performs the exhaustive incidence ranking across all 588 orbits; this C++ program does not repeat that global ranking.