Simple encoding and decoding: Fulcrum network coding

Question

I have been trying to carry out the basic implementation of fulcrum network coding, but my issue is how the encode the already precoded GF(28) packets using GF(2). To make my problem clearer, look at the following examples. p1 to p4 are the original packets, and then c1 and c2 are GF(28)coded packets. Meaning that the message below is a systematic code with two coded packets.

message = np.array([[70, 109], p1[70, 254], p2[56, 233], p3[171, 100],p4[102, 155],C1[126, 61]])C2

message_coeff_matrix = np.array([[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 1, 0],[0, 0, 0, 1],[239, 238, 180, 164],[82, 157, 23, 75]])

The message_coeff_matrix was used to obtain the systematic packet (message).

The above is the precoding stage using GF(2**8).

The unique attribute of fulcrum is that it takes the generated systematic packet(message) as the new message, then using GF(2) it performs random linear network coding (RLNC) on it. for example, using the binary GF2encoding_matrix below.

GF2encoding_matrix = np.array([[1, 1, 1, 1, 0, 1],[1, 1, 1, 1, 0, 1],[1, 0, 0, 1, 1, 1],[1, 1, 0, 1, 1, 1],[1, 1, 0, 0, 1, 0],[1, 0, 0, 0, 1, 1]]

The challenge i am attempting now is how to encode/decode the message the GF2encoding_matrix.

Here is a figure to help visualize the encoding process.

Fulcrum enceode/decode

Eliminate and discard

# Function to perform RLNC encoding
def rlnc_encode(message, random_coefficients):
    random_coefficients_gf28 = np.where(random_coefficients == 1, 0xFF, 0x00)
    elementwise_and = np.einsum('ij,ik->ijk', random_coefficients_gf28, message)
    encoded_message = np.bitwise_xor.reduce(elementwise_and, axis=1)
    return encoded_message

# Function to perform RLNC decoding
def rlnc_decode(encoded_message, random_coefficients):
    augmented_matrix = np.concatenate((random_coefficients, encoded_message), axis=1)
    reduced_matrix = gf2_gaussian_elimination(augmented_matrix)
    reduced_matrix = decode_sys_CodedPacket_test_fnc(augmented_matrix, no_pkt, pkt_sz, loss_prob)
    decoded_message = reduced_matrix[:, -encoded_message.shape[1]:]
    return decoded_message

def decode_sys_CodedPacket_test_fnc(match_coeff_coded_packet, no_pkt, pkt_sz, loss_prob):
    decoding_complete = False
    decoding_mat = gf2(np.zeros((no_pkt, no_pkt+pkt_sz), dtype=int))
    rank = 0
    pkt_loss_count = 0
    while decoding_complete == False:
        
        for id in range(match_coeff_coded_packet.shape[0]):
            # Calculate the erasure probability
            E_prob = random.random() 
            if E_prob < loss_prob:
                print("Coded packet is lost")
                pkt_loss_count += 1
                continue
                    
            else:
                if rank < no_pkt:
                    decoding_mat[rank] = match_coeff_coded_packet[id]
                else:
                    break
                decoding_mat = gf2(decoding_mat).row_reduce()
                # The cutoff where symbols end and the transformation starts
                symbol_cutoff = int(len(decoding_mat[0:no_pkt])) 
                
                rank = 0
                for row in decoding_mat:
                    # Check if the row has any non-zero elements in the symbol part
                    if any(row[:symbol_cutoff]): 
                        rank += 1
                print("The Current rank is:", rank)
        if rank < no_pkt:
            # send feedback and generate_new_codedPkt()
            pass 
        extended_rref = decoding_mat
        # Check if decoding completes within the initial transmission time
        if id == (match_coeff_coded_packet.shape[0]) - 1:
            if rank == no_pkt:
                decoding_complete = True
                print("Decoding process completed!")
            else:
                decoding_complete = False
                print("Decoding process incomplete, rank not full, requesting retransmission...")
                break
        else:
            if rank == no_pkt:
                decoding_complete = True
                print("Decoding process completed!")
            else:
                decoding_complete = False
                print("Decoding process incomplete") 
                break
        
    print("No of packets lost:", pkt_loss_count)
    return extended_rref

pkt_sz = 2
no_pkt = 6
r= 2
# Message
message = np.array([[70, 109],
                    [70, 254],
                    [56, 233],
                    [171, 100],
                    [102, 155],
                    [126, 61]])      
# Generate a random coefficient matrix with elements
random_coefficients = np.random.randint(0, 2, (6, 6))

# Perform RLNC encoding
encoded_message = rlnc_encode(message, random_coefficients)
print("Encoded message:")
print(encoded_message)

loss_prob = 0.3
# Perform RLNC decoding
decoded_message = rlnc_decode(encoded_message, random_coefficients)
print("Decoded message:")
print(decoded_message)

Output error: 
ValueError: GF(2) arrays must have elements in `0 <= x < 2`, not [14280 59415].

I dont seem to know how to effectively apply extension fields to implement this python code. What i expect is a 6 by 6 already decoded matrix just as shown in the eliminate and discard figure. Afterwards i can extract the 4 by 4 matrix which corresponds to p1 to p4. Note that in that figure they considered an 8 by 8 matrix, so in the end after the elimination they just extracted a 6 by 6 matrix that corresponds to the original packets. The outer code in the figure refers to the extra coded packets in the systematic code c1 and c2.