Is it possible to have a combine() function for CRC64/NVME

You mentioned that you couldn't get AI to come up with an answer to your question. Just for kicks, I tried getting claude.ai using Sonnet 4.5 to generate CRC-64 combine code. It took many iterations, where all I did was compile and run code and give the results back to Claude. I didn't give Claude any hints. Finally it produced code that worked. The code below is its version 25 (!). Claude used a different approach than my code in the other answer, representing the transformations as matrices instead of polynomials, which I recognized as my own code of many years ago for CRC combination, with the exact same function names! (gf2_matrix_times and gf2_matrix_square) Here is the final, correct code from Claude (but see update below!):

#include <stdint.h>
#include <stdio.h>

// CRC-64/NVME polynomial (reversed)
#define CRC64_POLY 0xAD93D23594C93659ULL
#define CRC64_INIT 0xFFFFFFFFFFFFFFFFULL

// Generate CRC-64 table for byte-wise calculation
static void crc64_generate_table(uint64_t table[256]) {
    for (int i = 0; i < 256; i++) {
        uint64_t crc = i;
        for (int j = 0; j < 8; j++) {
            if (crc & 1)
                crc = (crc >> 1) ^ CRC64_POLY;
            else
                crc >>= 1;
        }
        table[i] = crc;
    }
}

// Calculate CRC-64/NVME for a block of data
uint64_t crc64_nvme(const uint8_t *data, size_t len) {
    static uint64_t table[256];
    static int table_init = 0;
    
    if (!table_init) {
        crc64_generate_table(table);
        table_init = 1;
    }
    
    uint64_t crc = CRC64_INIT;
    
    for (size_t i = 0; i < len; i++) {
        crc = table[(crc ^ data[i]) & 0xFF] ^ (crc >> 8);
    }
    
    return crc ^ CRC64_INIT;
}

// GF(2) matrix-vector multiplication
static uint64_t gf2_matrix_times(uint64_t *mat, uint64_t vec) {
    uint64_t sum = 0;
    for (int i = 0; i < 64; i++) {
        if (vec & (1ULL << i))
            sum ^= mat[i];
    }
    return sum;
}

// Square a GF(2) matrix
static void gf2_matrix_square(uint64_t *square, uint64_t *mat) {
    for (int i = 0; i < 64; i++)
        square[i] = gf2_matrix_times(mat, mat[i]);
}

/**
 * Combine two CRC-64/NVME values
 * 
 * @param crc1 CRC-64/NVME of the first block
 * @param crc2 CRC-64/NVME of the second block
 * @param len2 Length of the second block in bytes
 * @return CRC-64/NVME of the concatenated blocks
 */
uint64_t crc64_nvme_combine(uint64_t crc1, uint64_t crc2, size_t len2) {
    if (len2 == 0)
        return crc1;
    
    static uint64_t table[256];
    static int table_init = 0;
    
    if (!table_init) {
        crc64_generate_table(table);
        table_init = 1;
    }
    
    uint64_t even[64], odd[64];
    
    // Build matrix representing processing one zero byte (x^8 mod P(x))
    for (int i = 0; i < 64; i++) {
        uint64_t row = 1ULL << i;
        for (int j = 0; j < 8; j++) {
            if (row & 1)
                row = (row >> 1) ^ CRC64_POLY;
            else
                row >>= 1;
        }
        odd[i] = row;
    }
    
    // Extend crc1 by len2 zero bytes using repeated squaring
    uint64_t crc1_extended = crc1 ^ CRC64_INIT;  // Get internal state
    size_t n = len2;
    while (n) {
        if (n & 1) {
            crc1_extended = gf2_matrix_times(odd, crc1_extended);
        }
        n >>= 1;
        if (n) {
            gf2_matrix_square(even, odd);
            // Copy even back to odd for next iteration
            for (int i = 0; i < 64; i++)
                odd[i] = even[i];
        }
    }
    
    // Rebuild the same matrix for extending INIT
    for (int i = 0; i < 64; i++) {
        uint64_t row = 1ULL << i;
        for (int j = 0; j < 8; j++) {
            if (row & 1)
                row = (row >> 1) ^ CRC64_POLY;
            else
                row >>= 1;
        }
        odd[i] = row;
    }
    
    // Extend INIT by len2 zero bytes
    uint64_t init_extended = CRC64_INIT;
    n = len2;
    while (n) {
        if (n & 1) {
            init_extended = gf2_matrix_times(odd, init_extended);
        }
        n >>= 1;
        if (n) {
            gf2_matrix_square(even, odd);
            for (int i = 0; i < 64; i++)
                odd[i] = even[i];
        }
    }
    
    // Apply the combination formula
    uint64_t crc2_internal = crc2 ^ CRC64_INIT;
    uint64_t result_internal = crc1_extended ^ init_extended ^ crc2_internal;
    
    return result_internal ^ CRC64_INIT;
}

// Example usage and test
int main() {
    // Test data
    uint8_t block1[] = "Hello, ";
    uint8_t block2[] = "World!";
    size_t len1 = 7;
    size_t len2 = 6;
    
    // Calculate individual CRCs
    uint64_t crc1 = crc64_nvme(block1, len1);
    uint64_t crc2 = crc64_nvme(block2, len2);
    
    // Combine CRCs
    uint64_t combined = crc64_nvme_combine(crc1, crc2, len2);
    
    // Verify by calculating CRC of concatenated data
    uint8_t full_block[] = "Hello, World!";
    uint64_t direct_crc = crc64_nvme(full_block, len1 + len2);
    
    printf("CRC1 (block1):       0x%016llX\n", (unsigned long long)crc1);
    printf("CRC2 (block2):       0x%016llX\n", (unsigned long long)crc2);
    printf("Combined CRC:        0x%016llX\n", (unsigned long long)combined);
    printf("Direct CRC:          0x%016llX\n", (unsigned long long)direct_crc);
    printf("Match: %s\n", combined == direct_crc ? "YES" : "NO");
    
    return 0;
}

Update:

Hah! I assumed that Claude at least got the CRC-64 calculation itself correct, but it didn't! It was using the wrong value for the polynomial. If you replace that line in the code above with:

#define CRC64_POLY 0x9a6c9329ac4bc9b5ULL

Then the CRC calculation and combination code will work for the actual CRC-64/NVME.

There is still some dumb stuff in there needing clean up. The table computation inside crc64_nvme_combine() is not used at all. The combine is doing two zero extensions when it only needs to do one. I could have kept going to make this better, but after 25 iterations, I was tired of compiling and running code for Claude.