A simpler way of identifying which elements of Tuples[{0,1,2,3},6] multiply with each of my codewords to give zero?

Question

So I have a list of codewords. The codewords have length 64, so there are 64 codewords in my code. My code is over an alphabet of 4 (the code can be thought of as having four elements $0,1,2,3$ and operations over mod4).

Think of the codewords as vectors of length 6.

I want to find a list of vectors $V$ which, when multiplied with each of the specified codewords $c \in C$, gives $0$.

i.e $V=$ { $v \text{ }| \text{ } v.c=0 \text{ }\forall \text{} c \in C$ }

I figured that $V$ must consist of all the tuples of length 6 over the four-symbol alphabet:

tuples=Tuples[{0,1,2,3}, 6]

I then created a table of values storing the result of each tuple being multiplied (dot product) by each codeword

table=Table[tuples[[i]].codewords[[j]], {i,1,Length[tuples]}, {j,1,Length[codewords]}]

I then attempted to iterate through the table and if there are any entries of 64 zeroes, then we store the tuple corresponding that those zeroes in $V$

If[Total[table[[#]]]==0, tuples[[#]], Nothing]

However, I think this is far too big for mathematica to handle. It keeps crashing. Is there any way of condensing this, or not iterating over everything so that I can find $V$?

---

Note, I actually constructed my code over GF[4] using the finite fields package, however, my problem is just with the largeness of the dataset of tuples over a four letter alphabet of length 6, so the bones of the question remain the same if you assume it is just a code over mod4 consisting of {0,1,2,3}

Answer 1

This answer works over finite fields (package already established and GF(4) already established, not included in code below), however, I think you would just need to use NullSpace[codewords, Modulus->4] in order to work over $\mathbb{Z}4$ instead.

Rather than attempt to find all of the possible tuples of {f4[0], f4[1], f4[2], f4[3]} of length 6 and then finding which of these tuples is orthogonal to every vector in "codewords", instead I followed @ydd's approach of using the null space of my codewords.

I found the null space of my codewords, which provides a basis for all the vectors which are orthogonal to the codewords (i.e satisfy the equation C.x == 0, where C are the codewords and x is a vector in GF(4) orthogonal to every codeword).

I then found all of the possible combinations of the row space multiplied by elements from the finite field, in order to find every vector orthogonal to the codewords in GF(4).

Then, I found the Union of this result to remove duplicate vectors.

dualcodewords = Module[{H, row1, row2, row3},
  H = RowReduce[NullSpace[codewords]];
  row1 = H[[1]];
  row2 = H[[2]];
  row3 = H[[3]];
  table = Table[
            f4[i] row1 + f4[j] row2 + f4[k] row3, 
            {i, 0, 4}, {j, 0, 4}, {k, 0, 4}
          ];
  Union[Flatten[table, 2]]
 ]