TheoremDB

Problem packetResearch packetR4

R4Executable evidence

Independent C++ replay of the leading all-four incidence count

View replay
Link to a section

Authored summary

A direct C++17 enumeration independently reproduces the finite image pools, the 1,146 prolongable matrices and 588 complement orbits, and the exact 23,298,600 incidence-valid tuples for matrix (8,1,2,2).

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

Recorded status: available

Recorded scope: all finite image words of lengths 8 through 12 and the exact all-four incidence count for affine matrix (8,1,2,2)

Complete recorded scope and conditions
{
  "kind": "bounded",
  "statement": "all finite image words of lengths 8 through 12 and the exact all-four incidence count for affine matrix (8,1,2,2)",
  "bounds": {
    "image_length": {
      "min": 8,
      "max": 12
    },
    "alphabet_size": {
      "min": 4,
      "max": 4
    },
    "matrix_a": {
      "min": 8,
      "max": 8
    },
    "matrix_b": {
      "min": 1,
      "max": 1
    },
    "matrix_c": {
      "min": 2,
      "max": 2
    },
    "matrix_d": {
      "min": 2,
      "max": 2
    }
  },
  "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
Independent C++ replay of the leading all-four incidence count
Record type
artifact
Stored status
available
Evidence grade
executable
Recorded scope data
{ "kind": "bounded", "statement": "all finite image words of lengths 8 through 12 and the exact all-four incidence count for affine matrix (8,1,2,2)", "bounds": { "image_length": { "min": 8, "max": 12 }, "alphabet_size": { "min": 4, "max": 4 }, "matrix_a": { "min": 8, "max": 8 }, "matrix_b": { "min": 1, "max": 1 }, "matrix_c": { "min": 2, "max": 2 }, "matrix_d": { "min": 2, "max": 2 } }, "exhaustive": true }

2Authored explanation

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.

Files and source

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

  • R4.txt7,620 bytes · No SHA-256 recorded
    Preview R4.txt
    #include <algorithm>
#include <array>
#include <cassert>
#include <cstdint>
#include <iostream>
#include <map>
#include <string>
#include <tuple>
#include <vector>

using Matrix = std::array<int, 4>;
using u64 = std::uint64_t;
using u128 = unsigned __int128;

static bool expanding(const Matrix &m) {
    const auto [a, b, c, d] = m;
    const std::int64_t determinant = a * d - b * c;
    const std::int64_t trace = a + d;
    return determinant != 0
        && (determinant - trace + 1) * determinant > 0
        && (determinant + trace + 1) * determinant > 0
        && (determinant - 1) * determinant > 0;
}

static Matrix conjugate(const Matrix &m) {
    const auto [a, b, c, d] = m;
    return {a + 3 * b, -b, 3 * a + 9 * b - c - 3 * d, d - 3 * b};
}

static std::string decimal(u128 value) {
    if (value == 0) return "0";
    std::string result;
    while (value) {
        result.push_back(static_cast<char>('0' + value % 10));
        value /= 10;
    }
    std::reverse(result.begin(), result.end());
    return result;
}

int main() {
    std::array<std::array<u64, 37>, 13> counts{};
    std::array<std::array<std::array<u64, 4>, 37>, 13> first_counts{};
    std::array<std::array<std::array<u64, 16>, 37>, 13> mask_counts{};
    std::array<std::array<std::array<std::array<u64, 16>, 4>, 37>, 13>
        first_mask_counts{};
    for (int n = 8; n <= 12; ++n) {
        const u64 limit = u64{1} << (2 * n);
        for (u64 code = 0; code < limit; ++code) {
            std::array<int, 13> prefix{};
            u64 value = code;
            const int first_letter = static_cast<int>(value & 3);
            int support_mask = 0;
            for (int i = 0; i < n; ++i) {
                const int letter = static_cast<int>(value & 3);
                prefix[i + 1] = prefix[i] + letter;
                support_mask |= 1 << letter;
                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 x = prefix[start + block] - prefix[start];
                    const int y = prefix[start + 2 * block] - prefix[start + block];
                    const int z = prefix[start + 3 * block] - prefix[start + 2 * block];
                    if (x == y && y == z) {
                        safe = false;
                        break;
                    }
                }
            }
            if (safe) {
                ++counts[n][prefix[n]];
                ++first_counts[n][prefix[n]][first_letter];
                ++mask_counts[n][prefix[n]][support_mask];
                ++first_mask_counts[n][prefix[n]][first_letter][support_mask];
            }
        }
    }
    for (int n = 8; n <= 12; ++n) {
        u64 total = 0;
        for (int sum = 0; sum <= 3 * n; ++sum) total += counts[n][sum];
        std::cout << "n=" << n << " total=" << total << " counts=";
        for (int sum = 0; sum <= 3 * n; ++sum) {
            if (sum) std::cout << ',';
            std::cout << counts[n][sum];
        }
        std::cout << '\n';
    }

    std::map<Matrix, u128> matrix_counts;
    for (int a = 8; a <= 12; ++a) {
        for (int b = -4; b <= 4; ++b) {
            std::array<int, 4> lengths{};
            for (int x = 0; x < 4; ++x) lengths[x] = a + b * x;
            if (std::any_of(lengths.begin(), lengths.end(),
                            [](int length) { return length < 8 || length > 12; })) {
                continue;
            }
            for (int c = 0; c <= 3 * lengths[0]; ++c) {
                for (int d = -36; d <= 36; ++d) {
                    Matrix matrix{a, b, c, d};
                    if (!expanding(matrix)) continue;
                    std::array<int, 4> sums{};
                    bool feasible = true;
                    for (int x = 0; x < 4; ++x) {
                        sums[x] = c + d * x;
                        feasible &= 0 <= sums[x] && sums[x] <= 3 * lengths[x];
                        feasible &= feasible && counts[lengths[x]][sums[x]] != 0;
                    }
                    if (!feasible) continue;
                    u128 all = 1;
                    u128 none = 1;
                    bool any_start = false;
                    for (int x = 0; x < 4; ++x) {
                        const u64 pool = counts[lengths[x]][sums[x]];
                        const u64 starts = first_counts[lengths[x]][sums[x]][x];
                        all *= pool;
                        none *= pool - starts;
                        any_start |= starts != 0;
                    }
                    if (any_start) matrix_counts[matrix] = all - none;
                }
            }
        }
    }

    std::map<Matrix, u128> orbits;
    for (const auto &[matrix, count] : matrix_counts) {
        const Matrix representative = std::min(matrix, conjugate(matrix));
        const auto [it, inserted] = orbits.emplace(representative, count);
        assert(inserted || it->second == count);
    }
    std::vector<std::pair<u128, Matrix>> ranked;
    for (const auto &[matrix, count] : orbits) ranked.emplace_back(count, matrix);
    std::sort(ranked.begin(), ranked.end());
    std::cout << "matrices=" << matrix_counts.size()
              << " orbits=" << orbits.size() << '\n';
    for (int i = 0; i < 12; ++i) {
        const auto &[count, matrix] = ranked[i];
        const auto [a, b, c, d] = matrix;
        std::cout << a << ',' << b << ',' << c << ',' << d
                  << ' ' << decimal(count) << '\n';
    }

    struct Category {
        int mask;
        bool self_start;
        u64 count;
    };
    const std::array<int, 4> lengths{8, 9, 10, 11};
    const std::array<int, 4> sums{2, 4, 6, 8};
    std::array<std::vector<Category>, 4> categories;
    for (int letter = 0; letter < 4; ++letter) {
        for (int mask = 1; mask < 16; ++mask) {
            const u64 all = mask_counts[lengths[letter]][sums[letter]][mask];
            const u64 self =
                first_mask_counts[lengths[letter]][sums[letter]][letter][mask];
            if (self) categories[letter].push_back({mask, true, self});
            if (all > self) categories[letter].push_back({mask, false, all - self});
        }
    }
    const auto reaches_all = [](int start, const std::array<int, 4> &masks) {
        int reached = 1 << start;
        while (true) {
            int expanded = reached;
            for (int letter = 0; letter < 4; ++letter) {
                if (reached & (1 << letter)) expanded |= masks[letter];
            }
            if (expanded == reached) return reached == 15;
            reached = expanded;
        }
    };
    u128 incidence_count = 0;
    for (const auto &a : categories[0])
        for (const auto &b : categories[1])
            for (const auto &c : categories[2])
                for (const auto &d : categories[3]) {
                    const std::array<Category, 4> selected{a, b, c, d};
                    const std::array<int, 4> masks{a.mask, b.mask, c.mask, d.mask};
                    bool accepted = false;
                    u128 multiplicity = 1;
                    for (int letter = 0; letter < 4; ++letter) {
                        accepted |= selected[letter].self_start
                            && reaches_all(letter, masks);
                        multiplicity *= selected[letter].count;
                    }
                    if (accepted) incidence_count += multiplicity;
                }
    std::cout << "matrix=8,1,2,2 incidence_valid="
              << decimal(incidence_count) << '\n';
}
    File identity
    Recorded filename
    R4.txt
    Download SHA-256
    c24d254c8443d04174b848997d040611d9ac2c7558a0ec22c419e9a5db0bc9ea
Continue this work
Replay material: complete

4Reproduce

Replay package: complete

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

clang++ -O3 -std=c++17 -Wall -Wextra -pedantic additive_cube_incidence_verify.cpp -o additive_cube_incidence_verify && /usr/bin/time -lp ./additive_cube_incidence_verify > additive_cube_incidence_verify.out
Entry point
Join source_lines with LF characters and append one terminal LF as additive_cube_incidence_verify.cpp; source_sha256 includes that terminal LF
Runtime
Apple clang version 21.0.0, target arm64-apple-darwin25.2.0, ISO C++17, standard library only
Dependencies
[ { "name": "Apple clang", "version": "21.0.0", "license": "Apache-2.0 WITH LLVM-exception" }, { "name": "Apple libc++", "version": "system toolchain for arm64-apple-darwin25.2.0", "license": "Apache-2.0 WITH LLVM-exception" } ]
Recorded runtime
0.47

Verification source: Inline C++17 source prepared and replayed on 2026-07-28 as an independent check of ac0123-artifact-finite-image-pools

Expected output

{
  "source_sha256": "ce1387c000d0b071cb3213302323443a791e8f69777c359a1f8922de45cfb79b",
  "stdout_sha256": "7d7282fe69ef972424cb0c179d40b183c1fafc3408ad92aa825c05d2c930d5b1",
  "additive_cube_free_word_counts": {
    "8": 42070,
    "9": 150560,
    "10": 538214,
    "11": 1924738,
    "12": 6772220
  },
  "prolongable_matrices": 1146,
  "complement_matrix_orbits": 588,
  "selected_matrix": [
    8,
    1,
    2,
    2
  ],
  "selected_image_lengths": [
    8,
    9,
    10,
    11
  ],
  "selected_image_sums": [
    2,
    4,
    6,
    8
  ],
  "selected_image_pool_sizes": [
    1,
    33,
    510,
    5831
  ],
  "incidence_valid_image_tuples": "23298600",
  "maximum_resident_bytes": 1835008
}
Recorded artifact fields
Kind
inline_cpp17_deterministic_independent_incidence_check
Entry point
Join source_lines with LF characters and append one terminal LF as additive_cube_incidence_verify.cpp; source_sha256 includes that terminal LF
Command
clang++ -O3 -std=c++17 -Wall -Wextra -pedantic additive_cube_incidence_verify.cpp -o additive_cube_incidence_verify && /usr/bin/time -lp ./additive_cube_incidence_verify > additive_cube_incidence_verify.out
Environment
Apple clang version 21.0.0, target arm64-apple-darwin25.2.0, ISO C++17, standard library only
Runtime
0.47 seconds

5What it produced

Processor
Apple M4, arm64
Time bound
10 seconds wall clock
Memory bound
128 MiB resident memory
Processor bound
one single-threaded native process
Network requirements
none
Artifact license
CC0-1.0
Arithmetic
exact integer, with unsigned 128-bit tuple counts
Randomness
none
Network during execution
none
Independence
direct two-bit word enumeration and block-first cube scans, separate from the recursive Python generator
Coverage limit
recomputes the leading matrix incidence count but does not independently rerank all 588 matrices by incidence count

Storage bound

working storage bound bytes70,000measured replay files bytes64,635included files7,621-byte source, 55,920-byte executable, and 1,094-byte captured stdout

6How it connects

Tests

Recorded for

Machine-readable record

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

json
{
  "schema": "theoremdb-agent-record-v1",
  "ref": "R4",
  "content_hash": null,
  "slug": "ac0123-artifact-independent-incidence-replay",
  "type": "artifact",
  "title": "Independent C++ replay of the leading all-four incidence count",
  "summary": "A direct C++17 enumeration independently reproduces the finite image pools, the 1,146 prolongable matrices and 588 complement orbits, and the exact 23,298,600 incidence-valid tuples for matrix (8,1,2,2).",
  "relevance": "For Additive-cube avoidance on the alphabet zero through three, record ac0123-artifact-independent-incidence-replay (“Independent C++ replay of the leading all-four incidence count”) supplies evidence or a replay used to check the packet. The record states: A direct C++17 enumeration independently reproduces the finite image pools, the 1,146 prolongable matrices and 588 complement orbits, and the exact 23,298,600 incidence-valid tuples for matrix (8,1,2,2).",
  "relevance_source": "recorded",
  "body": "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`.\n\nThe 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.\n\nThe 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.",
  "status": "available",
  "evidence_grade": "executable",
  "scope": {
    "kind": "bounded",
    "statement": "all finite image words of lengths 8 through 12 and the exact all-four incidence count for affine matrix (8,1,2,2)",
    "bounds": {
      "image_length": {
        "min": 8,
        "max": 12
      },
      "alphabet_size": {
        "min": 4,
        "max": 4
      },
      "matrix_a": {
        "min": 8,
        "max": 8
      },
      "matrix_b": {
        "min": 1,
        "max": 1
      },
      "matrix_c": {
        "min": 2,
        "max": 2
      },
      "matrix_d": {
        "min": 2,
        "max": 2
      }
    },
    "exhaustive": true
  },
  "reproduction": {
    "schema": "theoremdb-reproduction-v1",
    "readiness": "complete",
    "kind": "inline_cpp17_deterministic_independent_incidence_check",
    "command": "clang++ -O3 -std=c++17 -Wall -Wextra -pedantic additive_cube_incidence_verify.cpp -o additive_cube_incidence_verify && /usr/bin/time -lp ./additive_cube_incidence_verify > additive_cube_incidence_verify.out",
    "entrypoint": "Join source_lines with LF characters and append one terminal LF as additive_cube_incidence_verify.cpp; source_sha256 includes that terminal LF",
    "runtime": "Apple clang version 21.0.0, target arm64-apple-darwin25.2.0, ISO C++17, standard library only",
    "citation": {
      "locator": "Inline C++17 source prepared and replayed on 2026-07-28 as an independent check of ac0123-artifact-finite-image-pools"
    },
    "dependencies": [
      {
        "name": "Apple clang",
        "version": "21.0.0",
        "license": "Apache-2.0 WITH LLVM-exception"
      },
      {
        "name": "Apple libc++",
        "version": "system toolchain for arm64-apple-darwin25.2.0",
        "license": "Apache-2.0 WITH LLVM-exception"
      }
    ],
    "outputs": {
      "source_sha256": "ce1387c000d0b071cb3213302323443a791e8f69777c359a1f8922de45cfb79b",
      "stdout_sha256": "7d7282fe69ef972424cb0c179d40b183c1fafc3408ad92aa825c05d2c930d5b1",
      "additive_cube_free_word_counts": {
        "8": 42070,
        "9": 150560,
        "10": 538214,
        "11": 1924738,
        "12": 6772220
      },
      "prolongable_matrices": 1146,
      "complement_matrix_orbits": 588,
      "selected_matrix": [
        8,
        1,
        2,
        2
      ],
      "selected_image_lengths": [
        8,
        9,
        10,
        11
      ],
      "selected_image_sums": [
        2,
        4,
        6,
        8
      ],
      "selected_image_pool_sizes": [
        1,
        33,
        510,
        5831
      ],
      "incidence_valid_image_tuples": "23298600",
      "maximum_resident_bytes": 1835008
    },
    "runtime_seconds": 0.47,
    "inline_source": [
      "#include <algorithm>",
      "#include <array>",
      "#include <cassert>",
      "#include <cstdint>",
      "#include <iostream>",
      "#include <map>",
      "#include <string>",
      "#include <tuple>",
      "#include <vector>",
      "",
      "using Matrix = std::array<int, 4>;",
      "using u64 = std::uint64_t;",
      "using u128 = unsigned __int128;",
      "",
      "static bool expanding(const Matrix &m) {",
      "    const auto [a, b, c, d] = m;",
      "    const std::int64_t determinant = a * d - b * c;",
      "    const std::int64_t trace = a + d;",
      "    return determinant != 0",
      "        && (determinant - trace + 1) * determinant > 0",
      "        && (determinant + trace + 1) * determinant > 0",
      "        && (determinant - 1) * determinant > 0;",
      "}",
      "",
      "static Matrix conjugate(const Matrix &m) {",
      "    const auto [a, b, c, d] = m;",
      "    return {a + 3 * b, -b, 3 * a + 9 * b - c - 3 * d, d - 3 * b};",
      "}",
      "",
      "static std::string decimal(u128 value) {",
      "    if (value == 0) return \"0\";",
      "    std::string result;",
      "    while (value) {",
      "        result.push_back(static_cast<char>('0' + value % 10));",
      "        value /= 10;",
      "    }",
      "    std::reverse(result.begin(), result.end());",
      "    return result;",
      "}",
      "",
      "int main() {",
      "    std::array<std::array<u64, 37>, 13> counts{};",
      "    std::array<std::array<std::array<u64, 4>, 37>, 13> first_counts{};",
      "    std::array<std::array<std::array<u64, 16>, 37>, 13> mask_counts{};",
      "    std::array<std::array<std::array<std::array<u64, 16>, 4>, 37>, 13>",
      "        first_mask_counts{};",
      "    for (int n = 8; n <= 12; ++n) {",
      "        const u64 limit = u64{1} << (2 * n);",
      "        for (u64 code = 0; code < limit; ++code) {",
      "            std::array<int, 13> prefix{};",
      "            u64 value = code;",
      "            const int first_letter = static_cast<int>(value & 3);",
      "            int support_mask = 0;",
      "            for (int i = 0; i < n; ++i) {",
      "                const int letter = static_cast<int>(value & 3);",
      "                prefix[i + 1] = prefix[i] + letter;",
      "                support_mask |= 1 << letter;",
      "                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 x = prefix[start + block] - prefix[start];",
      "                    const int y = prefix[start + 2 * block] - prefix[start + block];",
      "                    const int z = prefix[start + 3 * block] - prefix[start + 2 * block];",
      "                    if (x == y && y == z) {",
      "                        safe = false;",
      "                        break;",
      "                    }",
      "                }",
      "            }",
      "            if (safe) {",
      "                ++counts[n][prefix[n]];",
      "                ++first_counts[n][prefix[n]][first_letter];",
      "                ++mask_counts[n][prefix[n]][support_mask];",
      "                ++first_mask_counts[n][prefix[n]][first_letter][support_mask];",
      "            }",
      "        }",
      "    }",
      "    for (int n = 8; n <= 12; ++n) {",
      "        u64 total = 0;",
      "        for (int sum = 0; sum <= 3 * n; ++sum) total += counts[n][sum];",
      "        std::cout << \"n=\" << n << \" total=\" << total << \" counts=\";",
      "        for (int sum = 0; sum <= 3 * n; ++sum) {",
      "            if (sum) std::cout << ',';",
      "            std::cout << counts[n][sum];",
      "        }",
      "        std::cout << '\\n';",
      "    }",
      "",
      "    std::map<Matrix, u128> matrix_counts;",
      "    for (int a = 8; a <= 12; ++a) {",
      "        for (int b = -4; b <= 4; ++b) {",
      "            std::array<int, 4> lengths{};",
      "            for (int x = 0; x < 4; ++x) lengths[x] = a + b * x;",
      "            if (std::any_of(lengths.begin(), lengths.end(),",
      "                            [](int length) { return length < 8 || length > 12; })) {",
      "                continue;",
      "            }",
      "            for (int c = 0; c <= 3 * lengths[0]; ++c) {",
      "                for (int d = -36; d <= 36; ++d) {",
      "                    Matrix matrix{a, b, c, d};",
      "                    if (!expanding(matrix)) continue;",
      "                    std::array<int, 4> sums{};",
      "                    bool feasible = true;",
      "                    for (int x = 0; x < 4; ++x) {",
      "                        sums[x] = c + d * x;",
      "                        feasible &= 0 <= sums[x] && sums[x] <= 3 * lengths[x];",
      "                        feasible &= feasible && counts[lengths[x]][sums[x]] != 0;",
      "                    }",
      "                    if (!feasible) continue;",
      "                    u128 all = 1;",
      "                    u128 none = 1;",
      "                    bool any_start = false;",
      "                    for (int x = 0; x < 4; ++x) {",
      "                        const u64 pool = counts[lengths[x]][sums[x]];",
      "                        const u64 starts = first_counts[lengths[x]][sums[x]][x];",
      "                        all *= pool;",
      "                        none *= pool - starts;",
      "                        any_start |= starts != 0;",
      "                    }",
      "                    if (any_start) matrix_counts[matrix] = all - none;",
      "                }",
      "            }",
      "        }",
      "    }",
      "",
      "    std::map<Matrix, u128> orbits;",
      "    for (const auto &[matrix, count] : matrix_counts) {",
      "        const Matrix representative = std::min(matrix, conjugate(matrix));",
      "        const auto [it, inserted] = orbits.emplace(representative, count);",
      "        assert(inserted || it->second == count);",
      "    }",
      "    std::vector<std::pair<u128, Matrix>> ranked;",
      "    for (const auto &[matrix, count] : orbits) ranked.emplace_back(count, matrix);",
      "    std::sort(ranked.begin(), ranked.end());",
      "    std::cout << \"matrices=\" << matrix_counts.size()",
      "              << \" orbits=\" << orbits.size() << '\\n';",
      "    for (int i = 0; i < 12; ++i) {",
      "        const auto &[count, matrix] = ranked[i];",
      "        const auto [a, b, c, d] = matrix;",
      "        std::cout << a << ',' << b << ',' << c << ',' << d",
      "                  << ' ' << decimal(count) << '\\n';",
      "    }",
      "",
      "    struct Category {",
      "        int mask;",
      "        bool self_start;",
      "        u64 count;",
      "    };",
      "    const std::array<int, 4> lengths{8, 9, 10, 11};",
      "    const std::array<int, 4> sums{2, 4, 6, 8};",
      "    std::array<std::vector<Category>, 4> categories;",
      "    for (int letter = 0; letter < 4; ++letter) {",
      "        for (int mask = 1; mask < 16; ++mask) {",
      "            const u64 all = mask_counts[lengths[letter]][sums[letter]][mask];",
      "            const u64 self =",
      "                first_mask_counts[lengths[letter]][sums[letter]][letter][mask];",
      "            if (self) categories[letter].push_back({mask, true, self});",
      "            if (all > self) categories[letter].push_back({mask, false, all - self});",
      "        }",
      "    }",
      "    const auto reaches_all = [](int start, const std::array<int, 4> &masks) {",
      "        int reached = 1 << start;",
      "        while (true) {",
      "            int expanded = reached;",
      "            for (int letter = 0; letter < 4; ++letter) {",
      "                if (reached & (1 << letter)) expanded |= masks[letter];",
      "            }",
      "            if (expanded == reached) return reached == 15;",
      "            reached = expanded;",
      "        }",
      "    };",
      "    u128 incidence_count = 0;",
      "    for (const auto &a : categories[0])",
      "        for (const auto &b : categories[1])",
      "            for (const auto &c : categories[2])",
      "                for (const auto &d : categories[3]) {",
      "                    const std::array<Category, 4> selected{a, b, c, d};",
      "                    const std::array<int, 4> masks{a.mask, b.mask, c.mask, d.mask};",
      "                    bool accepted = false;",
      "                    u128 multiplicity = 1;",
      "                    for (int letter = 0; letter < 4; ++letter) {",
      "                        accepted |= selected[letter].self_start",
      "                            && reaches_all(letter, masks);",
      "                        multiplicity *= selected[letter].count;",
      "                    }",
      "                    if (accepted) incidence_count += multiplicity;",
      "                }",
      "    std::cout << \"matrix=8,1,2,2 incidence_valid=\"",
      "              << decimal(incidence_count) << '\\n';",
      "}"
    ]
  },
  "formal_statement": null,
  "source": {
    "url": null,
    "locator": "Inline C++17 source prepared and replayed on 2026-07-28 as an independent check of ac0123-artifact-finite-image-pools"
  },
  "models": [],
  "continuation": null,
  "relations": [
    {
      "slug": "R2",
      "title": "Exact additive-cube-free image pools through length 12",
      "object_type": "artifact",
      "relation": "tests",
      "direction": "outgoing"
    },
    {
      "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 C++17 source prepared and replayed on 2026-07-28 as an independent check of ac0123-artifact-finite-image-pools
License
CC0-1.0
Public record
R4
Stable alias
ac0123-artifact-independent-incidence-replay
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.