{
  "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"
  },
  "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"
    }
  ]
}