TheoremDB

Problem packetResearch packetR2

R2Executable evidence

Exact additive-cube-free image pools through length 12

View replay
Link to a section

Authored summary

Two independent exhaustive programs count every additive-cube-free word of lengths 8 through 12 by sum, reduce the all-four-letters matrix tranche to 588 complement orbits, and rank its smallest incidence-valid image-tuple pools.

Executable material is recorded. Successful replay is a separate check.

Recorded status: available

Recorded scope: every finite word over {0,1,2,3} of lengths 8 through 12, plus the resulting necessary matrix filter for fixed points using all four letters

Complete recorded scope and conditions
{
  "kind": "bounded",
  "statement": "every finite word over {0,1,2,3} of lengths 8 through 12, plus the resulting necessary matrix filter for fixed points using all four letters",
  "bounds": {
    "image_length": {
      "min": 8,
      "max": 12
    },
    "alphabet_size": {
      "min": 4,
      "max": 4
    }
  },
  "exhaustive": true
}

Originating problem: Additive-cube avoidance on the alphabet zero through three

Read the full authored explanationInspect the parent problem’s formal coverageFull source
Authored record and scope
Authored title
Exact additive-cube-free image pools through length 12
Record type
artifact
Stored status
available
Evidence grade
executable
Recorded scope data
{ "kind": "bounded", "statement": "every finite word over {0,1,2,3} of lengths 8 through 12, plus the resulting necessary matrix filter for fixed points using all four letters", "bounds": { "image_length": { "min": 8, "max": 12 }, "alphabet_size": { "min": 4, "max": 4 } }, "exhaustive": true }

2Authored explanation

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.

Files and source

Files embedded in this record. Matching a file hash confirms its identity.

  • R2.txt7,747 bytes · No SHA-256 recorded
    Preview R2.txt
    from collections import defaultdict
from hashlib import sha256
from itertools import product
import json


counts = defaultdict(int)
first_counts = defaultdict(int)
mask_counts = defaultdict(int)
first_mask_counts = defaultdict(int)
prefixes = [0] * 13
word = []
prefix_sum = [0]


def enumerate_words():
    length = len(word)
    if length >= 8:
        total = prefix_sum[-1]
        support_mask = sum(1 << letter for letter in set(word))
        counts[(length, total)] += 1
        first_counts[(length, total, word[0])] += 1
        mask_counts[(length, total, support_mask)] += 1
        first_mask_counts[(length, total, word[0], support_mask)] += 1
    if length == 12:
        return
    for letter in range(4):
        word.append(letter)
        prefix_sum.append(prefix_sum[-1] + letter)
        new_length = length + 1
        safe = True
        for block in range(1, new_length // 3 + 1):
            third = prefix_sum[new_length] - prefix_sum[new_length - block]
            second = (
                prefix_sum[new_length - block]
                - prefix_sum[new_length - 2 * block]
            )
            first = (
                prefix_sum[new_length - 2 * block]
                - prefix_sum[new_length - 3 * block]
            )
            if first == second == third:
                safe = False
                break
        if safe:
            prefixes[new_length] += 1
            enumerate_words()
        prefix_sum.pop()
        word.pop()


def expanding_matrix(a, b, c, d):
    determinant = a * d - b * c
    trace = a + d
    return (
        determinant != 0
        and (determinant - trace + 1) * determinant > 0
        and (determinant + trace + 1) * determinant > 0
        and (determinant - 1) * determinant > 0
    )


def complement_conjugate(matrix):
    a, b, c, d = matrix
    return a + 3 * b, -b, 3 * a + 9 * b - c - 3 * d, d - 3 * b


def reaches_all(start, masks):
    reached = 1 << start
    while True:
        expanded = reached
        for letter in range(4):
            if reached & (1 << letter):
                expanded |= masks[letter]
        if expanded == reached:
            return reached == 15
        reached = expanded


def reachable_tuple_count(matrix):
    a, b, c, d = matrix
    categories = []
    for letter in range(4):
        length = a + b * letter
        total = c + d * letter
        letter_categories = []
        for mask in range(1, 16):
            pool = mask_counts[(length, total, mask)]
            self_start = first_mask_counts[(length, total, letter, mask)]
            if self_start:
                letter_categories.append((mask, True, self_start))
            if pool > self_start:
                letter_categories.append((mask, False, pool - self_start))
        categories.append(letter_categories)
    answer = 0
    for selected in product(*categories):
        masks = [item[0] for item in selected]
        if not any(
            selected[letter][1] and reaches_all(letter, masks)
            for letter in range(4)
        ):
            continue
        multiplicity = 1
        for item in selected:
            multiplicity *= item[2]
        answer += multiplicity
    return answer


enumerate_words()
expanding = set()
all_images_safe = set()
prolongable_pool = set()
prolongable_tuple_counts = {}
for a in range(8, 13):
    for b in range(-4, 5):
        lengths = [a + b * x for x in range(4)]
        if any(length < 8 or length > 12 for length in lengths):
            continue
        for c in range(3 * lengths[0] + 1):
            for d in range(-36, 37):
                sums = [c + d * x for x in range(4)]
                if any(total < 0 or total > 3 * lengths[x]
                       for x, total in enumerate(sums)):
                    continue
                if not expanding_matrix(a, b, c, d):
                    continue
                matrix = a, b, c, d
                expanding.add(matrix)
                if not all(counts[(lengths[x], sums[x])] for x in range(4)):
                    continue
                all_images_safe.add(matrix)
                if any(first_counts[(lengths[x], sums[x], x)]
                       for x in range(4)):
                    prolongable_pool.add(matrix)
                    pool_sizes = [
                        counts[(lengths[x], sums[x])]
                        for x in range(4)
                    ]
                    missing_start = [
                        pool_sizes[x]
                        - first_counts[(lengths[x], sums[x], x)]
                        for x in range(4)
                    ]
                    all_tuples = 1
                    no_prolongable_tuples = 1
                    for size in pool_sizes:
                        all_tuples *= size
                    for size in missing_start:
                        no_prolongable_tuples *= size
                    prolongable_tuple_counts[matrix] = (
                        all_tuples - no_prolongable_tuples
                    )

assert all(complement_conjugate(matrix) in prolongable_pool
           for matrix in prolongable_pool)
orbit_counts = {}
for matrix, count in prolongable_tuple_counts.items():
    representative = min(matrix, complement_conjugate(matrix))
    if representative in orbit_counts:
        assert orbit_counts[representative] == count
    orbit_counts[representative] = count
reachable_counts = {}
for matrix in orbit_counts:
    count = reachable_tuple_count(matrix)
    assert count == reachable_tuple_count(complement_conjugate(matrix))
    reachable_counts[matrix] = count
priority_orbits = []
for matrix, count in sorted(orbit_counts.items(), key=lambda item: (item[1], item[0]))[:12]:
    a, b, c, d = matrix
    priority_orbits.append({
        "all_four_reachable_image_tuples": str(
            reachable_tuple_count(matrix)
        ),
        "lengths": [a + b * x for x in range(4)],
        "matrix": list(matrix),
        "prolongable_image_tuples": str(count),
        "sums": [c + d * x for x in range(4)],
    })
reachable_priority_orbits = []
for matrix, count in sorted(reachable_counts.items(), key=lambda item: (item[1], item[0]))[:12]:
    a, b, c, d = matrix
    reachable_priority_orbits.append({
        "all_four_reachable_image_tuples": str(count),
        "lengths": [a + b * x for x in range(4)],
        "matrix": list(matrix),
        "prolongable_image_tuples": str(
            prolongable_tuple_counts[matrix]
        ),
        "sums": [c + d * x for x in range(4)],
    })
report = {
    "additive_cube_free_prefixes": prefixes[1:],
    "image_pools": {
        str(length): {
            "sum_counts": [
                counts[(length, total)]
                for total in range(3 * length + 1)
            ],
            "total": sum(
                counts[(length, total)]
                for total in range(3 * length + 1)
            ),
        }
        for length in range(8, 13)
    },
    "matrix_filter_for_all_four_used_letters": {
        "expanding_before_image_filter": len(expanding),
        "every_image_pool_nonempty": len(all_images_safe),
        "some_prolongable_letter_pool": len(prolongable_pool),
        "complement_fixed_matrices": sum(
            complement_conjugate(matrix) == matrix
            for matrix in prolongable_pool
        ),
        "complement_orbits": len({
            min(matrix, complement_conjugate(matrix))
            for matrix in prolongable_pool
        }),
    },
    "smallest_all_four_reachable_image_tuple_orbits": reachable_priority_orbits,
    "smallest_prolongable_image_tuple_orbits": priority_orbits,
}
payload = json.dumps(report, sort_keys=True, separators=(",", ":"))
print(payload)
print(sha256((payload + "\n").encode()).hexdigest())
    File identity
    Recorded filename
    R2.txt
    Download SHA-256
    54dc2a6de1587110b8addfa3fa64ad5bdbc8f27e305c082487d6df9cebf21cb0
  • independent_verifier.txt1,543 bytes · Matches recorded SHA-256
    Preview independent_verifier.txt
    #include <cstdint>
#include <iostream>
#include <vector>

using u64 = std::uint64_t;

int main() {
    for (int n = 8; n <= 12; ++n) {
        const u64 words = u64{1} << (2 * n);
        std::vector<u64> counts(3 * n + 1, 0);
        for (u64 code = 0; code < words; ++code) {
            std::vector<int> prefix(n + 1, 0);
            u64 value = code;
            for (int i = 0; i < n; ++i) {
                prefix[i + 1] = prefix[i] + static_cast<int>(value & 3);
                value >>= 2;
            }
            bool safe = true;
            for (int block = 1; 3 * block <= n && safe; ++block) {
                for (int start = 0; start + 3 * block <= n; ++start) {
                    const int first = prefix[start + block] - prefix[start];
                    const int second =
                        prefix[start + 2 * block] - prefix[start + block];
                    const int third =
                        prefix[start + 3 * block] - prefix[start + 2 * block];
                    if (first == second && second == third) {
                        safe = false;
                        break;
                    }
                }
            }
            if (safe) ++counts[prefix[n]];
        }
        u64 total = 0;
        for (u64 count : counts) total += count;
        std::cout << "n=" << n << " total=" << total << " counts=";
        for (std::size_t i = 0; i < counts.size(); ++i) {
            if (i) std::cout << ',';
            std::cout << counts[i];
        }
        std::cout << '\n';
    }
}
    File identity
    Recorded filename
    independent_verifier.txt
    Recorded SHA-256
    45b0597e5869fad6945edfc8c1c30dfba7bfb41d537865b2a5f3cfa4cbdc205a
    Download SHA-256
    45b0597e5869fad6945edfc8c1c30dfba7bfb41d537865b2a5f3cfa4cbdc205a
Continue this work
Replay material: complete

4Reproduce

Replay package: complete

The command, source, environment, and expected result are recorded.

python3 additive_cube_image_pool.py
Entry point
Join source_lines with LF characters and append one terminal LF as additive_cube_image_pool.py; source_sha256 includes that terminal LF
Runtime
Python 3.9.6 standard library; independent Apple clang 21.0.0 C++17 verifier
Dependencies
[ { "name": "CPython", "version": "3.9.6", "license": "PSF-2.0" }, { "name": "Python standard library", "version": "3.9.6", "license": "PSF-2.0" }, { "name": "Apple clang and libc++ for the independent verifier", "version": "21.0.0, arm64-apple-darwin25.2.0", "license": "Apache-2.0 WITH LLVM-exception" } ]
Recorded runtime
25.66

Verification source: Inline Python 3 enumerator and independent C++17 verifier prepared and executed on 2026-07-28

Expected output

{
  "source_sha256": "21f0530ef09ee3c8833e02fb2d9589578dd6705da00b1b974370c30eaa10944e",
  "payload_sha256_including_final_lf": "b634f376e1accef14a8c22e6c92b5d22b66ddd03336d15512384b5dfa23bfb61",
  "stdout_sha256": "647c836d17d6fcce497cd133ff6992a2d58028daee67824a0ddc8dff6f9fdc0e",
  "additive_cube_free_word_counts": {
    "8": 42070,
    "9": 150560,
    "10": 538214,
    "11": 1924738,
    "12": 6772220
  },
  "expanding_matrices_before_image_filter": 2212,
  "all_four_image_pools_nonempty": 1146,
  "some_prolongable_letter_pool": 1146,
  "complement_fixed_matrices": 30,
  "complement_matrix_orbits": 588,
  "smallest_prolongable_image_tuple_orbit": {
    "matrix": [
      8,
      0,
      8,
      -2
    ],
    "lengths": [
      8,
      8,
      8,
      8
    ],
    "sums": [
      8,
      6,
      4,
      2
    ],
    "prolongable_image_tuples": "48580348"
  },
  "smallest_all_four_reachable_image_tuple_orbit": {
    "matrix": [
      8,
      1,
      2,
      2
    ],
    "lengths": [
      8,
      9,
      10,
      11
    ],
    "sums": [
      2,
      4,
      6,
      8
    ],
    "all_four_reachable_image_tuples": "23298600"
  },
  "maximum_resident_bytes": 13844480
}
Recorded artifact fields
Kind
inline_exact_finite_word_pool_enumerator_with_independent_verifier
Entry point
Join source_lines with LF characters and append one terminal LF as additive_cube_image_pool.py; source_sha256 includes that terminal LF
Command
python3 additive_cube_image_pool.py
Environment
Python 3.9.6 standard library; independent Apple clang 21.0.0 C++17 verifier
Runtime
25.66 seconds

5What it produced

Processor
Apple M4, arm64
Time bound
60 seconds wall clock
Memory bound
256 MiB resident memory
Processor bound
one CPython process with no worker threads
Network requirements
none
Artifact license
CC0-1.0
Arithmetic
exact integer
Randomness
none
Network during execution
none
All finite words in bounds enumerated
yes
Matrix filter family
fixed points in which every letter 0,1,2,3 occurs
Independent incidence replay
ac0123-artifact-independent-incidence-replay

Storage bound

working storage bound bytes100,000measured replay files bytes51,209included files7,748-byte Python source, 4,846-byte captured Python stdout, 1,543-byte C++ source, 36,264-byte C++ executable, and 808-byte captured C++ stdout

6How it connects

Used by

Depends on

Tested by

Recorded for

Machine-readable record

Copy the structured record when continuing this work with an agent.

json
{
  "schema": "theoremdb-agent-record-v1",
  "ref": "R2",
  "content_hash": null,
  "slug": "ac0123-artifact-finite-image-pools",
  "type": "artifact",
  "title": "Exact additive-cube-free image pools through length 12",
  "summary": "Two independent exhaustive programs count every additive-cube-free word of lengths 8 through 12 by sum, reduce the all-four-letters matrix tranche to 588 complement orbits, and rank its smallest incidence-valid image-tuple pools.",
  "relevance": "For Additive-cube avoidance on the alphabet zero through three, record ac0123-artifact-finite-image-pools (“Exact additive-cube-free image pools through length 12”) supplies evidence or a replay used to check the packet. The record states: Two independent exhaustive programs count every additive-cube-free word of lengths 8 through 12 by sum, reduce the all-four-letters matrix tranche to 588 complement orbits, and rank its smallest incidence-valid image-tuple pools.",
  "relevance_source": "recorded",
  "body": "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.\n\nA 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.\n\nConsider 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.\n\nThe 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.",
  "status": "available",
  "evidence_grade": "executable",
  "scope": {
    "kind": "bounded",
    "statement": "every finite word over {0,1,2,3} of lengths 8 through 12, plus the resulting necessary matrix filter for fixed points using all four letters",
    "bounds": {
      "image_length": {
        "min": 8,
        "max": 12
      },
      "alphabet_size": {
        "min": 4,
        "max": 4
      }
    },
    "exhaustive": true
  },
  "reproduction": {
    "schema": "theoremdb-reproduction-v1",
    "readiness": "complete",
    "kind": "inline_exact_finite_word_pool_enumerator_with_independent_verifier",
    "command": "python3 additive_cube_image_pool.py",
    "entrypoint": "Join source_lines with LF characters and append one terminal LF as additive_cube_image_pool.py; source_sha256 includes that terminal LF",
    "runtime": "Python 3.9.6 standard library; independent Apple clang 21.0.0 C++17 verifier",
    "citation": {
      "locator": "Inline Python 3 enumerator and independent C++17 verifier prepared and executed on 2026-07-28"
    },
    "dependencies": [
      {
        "name": "CPython",
        "version": "3.9.6",
        "license": "PSF-2.0"
      },
      {
        "name": "Python standard library",
        "version": "3.9.6",
        "license": "PSF-2.0"
      },
      {
        "name": "Apple clang and libc++ for the independent verifier",
        "version": "21.0.0, arm64-apple-darwin25.2.0",
        "license": "Apache-2.0 WITH LLVM-exception"
      }
    ],
    "outputs": {
      "source_sha256": "21f0530ef09ee3c8833e02fb2d9589578dd6705da00b1b974370c30eaa10944e",
      "payload_sha256_including_final_lf": "b634f376e1accef14a8c22e6c92b5d22b66ddd03336d15512384b5dfa23bfb61",
      "stdout_sha256": "647c836d17d6fcce497cd133ff6992a2d58028daee67824a0ddc8dff6f9fdc0e",
      "additive_cube_free_word_counts": {
        "8": 42070,
        "9": 150560,
        "10": 538214,
        "11": 1924738,
        "12": 6772220
      },
      "expanding_matrices_before_image_filter": 2212,
      "all_four_image_pools_nonempty": 1146,
      "some_prolongable_letter_pool": 1146,
      "complement_fixed_matrices": 30,
      "complement_matrix_orbits": 588,
      "smallest_prolongable_image_tuple_orbit": {
        "matrix": [
          8,
          0,
          8,
          -2
        ],
        "lengths": [
          8,
          8,
          8,
          8
        ],
        "sums": [
          8,
          6,
          4,
          2
        ],
        "prolongable_image_tuples": "48580348"
      },
      "smallest_all_four_reachable_image_tuple_orbit": {
        "matrix": [
          8,
          1,
          2,
          2
        ],
        "lengths": [
          8,
          9,
          10,
          11
        ],
        "sums": [
          2,
          4,
          6,
          8
        ],
        "all_four_reachable_image_tuples": "23298600"
      },
      "maximum_resident_bytes": 13844480
    },
    "runtime_seconds": 25.66,
    "inline_source": [
      "from collections import defaultdict",
      "from hashlib import sha256",
      "from itertools import product",
      "import json",
      "",
      "",
      "counts = defaultdict(int)",
      "first_counts = defaultdict(int)",
      "mask_counts = defaultdict(int)",
      "first_mask_counts = defaultdict(int)",
      "prefixes = [0] * 13",
      "word = []",
      "prefix_sum = [0]",
      "",
      "",
      "def enumerate_words():",
      "    length = len(word)",
      "    if length >= 8:",
      "        total = prefix_sum[-1]",
      "        support_mask = sum(1 << letter for letter in set(word))",
      "        counts[(length, total)] += 1",
      "        first_counts[(length, total, word[0])] += 1",
      "        mask_counts[(length, total, support_mask)] += 1",
      "        first_mask_counts[(length, total, word[0], support_mask)] += 1",
      "    if length == 12:",
      "        return",
      "    for letter in range(4):",
      "        word.append(letter)",
      "        prefix_sum.append(prefix_sum[-1] + letter)",
      "        new_length = length + 1",
      "        safe = True",
      "        for block in range(1, new_length // 3 + 1):",
      "            third = prefix_sum[new_length] - prefix_sum[new_length - block]",
      "            second = (",
      "                prefix_sum[new_length - block]",
      "                - prefix_sum[new_length - 2 * block]",
      "            )",
      "            first = (",
      "                prefix_sum[new_length - 2 * block]",
      "                - prefix_sum[new_length - 3 * block]",
      "            )",
      "            if first == second == third:",
      "                safe = False",
      "                break",
      "        if safe:",
      "            prefixes[new_length] += 1",
      "            enumerate_words()",
      "        prefix_sum.pop()",
      "        word.pop()",
      "",
      "",
      "def expanding_matrix(a, b, c, d):",
      "    determinant = a * d - b * c",
      "    trace = a + d",
      "    return (",
      "        determinant != 0",
      "        and (determinant - trace + 1) * determinant > 0",
      "        and (determinant + trace + 1) * determinant > 0",
      "        and (determinant - 1) * determinant > 0",
      "    )",
      "",
      "",
      "def complement_conjugate(matrix):",
      "    a, b, c, d = matrix",
      "    return a + 3 * b, -b, 3 * a + 9 * b - c - 3 * d, d - 3 * b",
      "",
      "",
      "def reaches_all(start, masks):",
      "    reached = 1 << start",
      "    while True:",
      "        expanded = reached",
      "        for letter in range(4):",
      "            if reached & (1 << letter):",
      "                expanded |= masks[letter]",
      "        if expanded == reached:",
      "            return reached == 15",
      "        reached = expanded",
      "",
      "",
      "def reachable_tuple_count(matrix):",
      "    a, b, c, d = matrix",
      "    categories = []",
      "    for letter in range(4):",
      "        length = a + b * letter",
      "        total = c + d * letter",
      "        letter_categories = []",
      "        for mask in range(1, 16):",
      "            pool = mask_counts[(length, total, mask)]",
      "            self_start = first_mask_counts[(length, total, letter, mask)]",
      "            if self_start:",
      "                letter_categories.append((mask, True, self_start))",
      "            if pool > self_start:",
      "                letter_categories.append((mask, False, pool - self_start))",
      "        categories.append(letter_categories)",
      "    answer = 0",
      "    for selected in product(*categories):",
      "        masks = [item[0] for item in selected]",
      "        if not any(",
      "            selected[letter][1] and reaches_all(letter, masks)",
      "            for letter in range(4)",
      "        ):",
      "            continue",
      "        multiplicity = 1",
      "        for item in selected:",
      "            multiplicity *= item[2]",
      "        answer += multiplicity",
      "    return answer",
      "",
      "",
      "enumerate_words()",
      "expanding = set()",
      "all_images_safe = set()",
      "prolongable_pool = set()",
      "prolongable_tuple_counts = {}",
      "for a in range(8, 13):",
      "    for b in range(-4, 5):",
      "        lengths = [a + b * x for x in range(4)]",
      "        if any(length < 8 or length > 12 for length in lengths):",
      "            continue",
      "        for c in range(3 * lengths[0] + 1):",
      "            for d in range(-36, 37):",
      "                sums = [c + d * x for x in range(4)]",
      "                if any(total < 0 or total > 3 * lengths[x]",
      "                       for x, total in enumerate(sums)):",
      "                    continue",
      "                if not expanding_matrix(a, b, c, d):",
      "                    continue",
      "                matrix = a, b, c, d",
      "                expanding.add(matrix)",
      "                if not all(counts[(lengths[x], sums[x])] for x in range(4)):",
      "                    continue",
      "                all_images_safe.add(matrix)",
      "                if any(first_counts[(lengths[x], sums[x], x)]",
      "                       for x in range(4)):",
      "                    prolongable_pool.add(matrix)",
      "                    pool_sizes = [",
      "                        counts[(lengths[x], sums[x])]",
      "                        for x in range(4)",
      "                    ]",
      "                    missing_start = [",
      "                        pool_sizes[x]",
      "                        - first_counts[(lengths[x], sums[x], x)]",
      "                        for x in range(4)",
      "                    ]",
      "                    all_tuples = 1",
      "                    no_prolongable_tuples = 1",
      "                    for size in pool_sizes:",
      "                        all_tuples *= size",
      "                    for size in missing_start:",
      "                        no_prolongable_tuples *= size",
      "                    prolongable_tuple_counts[matrix] = (",
      "                        all_tuples - no_prolongable_tuples",
      "                    )",
      "",
      "assert all(complement_conjugate(matrix) in prolongable_pool",
      "           for matrix in prolongable_pool)",
      "orbit_counts = {}",
      "for matrix, count in prolongable_tuple_counts.items():",
      "    representative = min(matrix, complement_conjugate(matrix))",
      "    if representative in orbit_counts:",
      "        assert orbit_counts[representative] == count",
      "    orbit_counts[representative] = count",
      "reachable_counts = {}",
      "for matrix in orbit_counts:",
      "    count = reachable_tuple_count(matrix)",
      "    assert count == reachable_tuple_count(complement_conjugate(matrix))",
      "    reachable_counts[matrix] = count",
      "priority_orbits = []",
      "for matrix, count in sorted(orbit_counts.items(), key=lambda item: (item[1], item[0]))[:12]:",
      "    a, b, c, d = matrix",
      "    priority_orbits.append({",
      "        \"all_four_reachable_image_tuples\": str(",
      "            reachable_tuple_count(matrix)",
      "        ),",
      "        \"lengths\": [a + b * x for x in range(4)],",
      "        \"matrix\": list(matrix),",
      "        \"prolongable_image_tuples\": str(count),",
      "        \"sums\": [c + d * x for x in range(4)],",
      "    })",
      "reachable_priority_orbits = []",
      "for matrix, count in sorted(reachable_counts.items(), key=lambda item: (item[1], item[0]))[:12]:",
      "    a, b, c, d = matrix",
      "    reachable_priority_orbits.append({",
      "        \"all_four_reachable_image_tuples\": str(count),",
      "        \"lengths\": [a + b * x for x in range(4)],",
      "        \"matrix\": list(matrix),",
      "        \"prolongable_image_tuples\": str(",
      "            prolongable_tuple_counts[matrix]",
      "        ),",
      "        \"sums\": [c + d * x for x in range(4)],",
      "    })",
      "report = {",
      "    \"additive_cube_free_prefixes\": prefixes[1:],",
      "    \"image_pools\": {",
      "        str(length): {",
      "            \"sum_counts\": [",
      "                counts[(length, total)]",
      "                for total in range(3 * length + 1)",
      "            ],",
      "            \"total\": sum(",
      "                counts[(length, total)]",
      "                for total in range(3 * length + 1)",
      "            ),",
      "        }",
      "        for length in range(8, 13)",
      "    },",
      "    \"matrix_filter_for_all_four_used_letters\": {",
      "        \"expanding_before_image_filter\": len(expanding),",
      "        \"every_image_pool_nonempty\": len(all_images_safe),",
      "        \"some_prolongable_letter_pool\": len(prolongable_pool),",
      "        \"complement_fixed_matrices\": sum(",
      "            complement_conjugate(matrix) == matrix",
      "            for matrix in prolongable_pool",
      "        ),",
      "        \"complement_orbits\": len({",
      "            min(matrix, complement_conjugate(matrix))",
      "            for matrix in prolongable_pool",
      "        }),",
      "    },",
      "    \"smallest_all_four_reachable_image_tuple_orbits\": reachable_priority_orbits,",
      "    \"smallest_prolongable_image_tuple_orbits\": priority_orbits,",
      "}",
      "payload = json.dumps(report, sort_keys=True, separators=(\",\", \":\"))",
      "print(payload)",
      "print(sha256((payload + \"\\n\").encode()).hexdigest())"
    ]
  },
  "formal_statement": null,
  "source": {
    "url": null,
    "locator": "Inline Python 3 enumerator and independent C++17 verifier prepared and executed on 2026-07-28"
  },
  "models": [],
  "continuation": null,
  "relations": [
    {
      "slug": "R6",
      "title": "Search beyond image length seven with a decision certificate",
      "object_type": "attempt",
      "relation": "uses",
      "direction": "incoming"
    },
    {
      "slug": "R1",
      "title": "Exact affine-matrix prefilter for image lengths 8 through 12",
      "object_type": "artifact",
      "relation": "depends_on",
      "direction": "outgoing"
    },
    {
      "slug": "R4",
      "title": "Independent C++ replay of the leading all-four incidence count",
      "object_type": "artifact",
      "relation": "tests",
      "direction": "incoming"
    },
    {
      "slug": "additive-cube-four-term-progression-alphabet",
      "title": "additive cube four term progression alphabet",
      "object_type": "problem",
      "relation": "recorded_for",
      "direction": "outgoing"
    }
  ]
}

8Provenance

View source, identifiers, and projection details
Project
additive-cube-four-term-progression-alphabet-research
Locator
Inline Python 3 enumerator and independent C++17 verifier prepared and executed on 2026-07-28
License
CC0-1.0
Public record
R2
Stable alias
ac0123-artifact-finite-image-pools
Projection
Reproduction fields are derived from the immutable record.

A program, dataset, or output another agent can run or read.

Sign in to follow

Sign in in another tab, then return here.

Open sign-in in another tab

Report a problem

Report location:

Your ChatGPT account

Opening ChatGPT

ChatGPT is opening in a new tab.