alpha vs. x as polynomial variable in GF(q^m)?

[donludovico]

(moved this from the issue for clarification: #569)
Hi all,

I just started using Galois today and really liked it from the very first moment.
However, what confused me was that for extension field GFq^m).repr("poly") prints as polynomials over $\alpha$, but .repr_table() prints the power and the polynomials over $x$. One also has to pass the irreducible_poly in powers of $x$ to the constructor.

Is that on purpose and do I do not get the math right? Should not all polynomials in the extension field be defined over $\alpha$ (which most of the literature I know use as nomenclature - any other would be possible, of course) or at least consistently?
Or maybe one could pass a character to the GF constructor like GF(..., prim_char='α') - Would that be possible/usefull (I have not had a look into the source yet)?

Adding to that: if one takes powers of the primitive element $\alpha$ of the extension field, I get the powers of the conway_polynomial, even if I had chosen another primitive polynomial.

Example:

import galois
q = 2
m = 6
prim_poly = galois.matlab_primitive_poly(q,m)
print(prim_poly) # is x^6 + x + 1, i.e. x^6 = x + 1 -> given in variable 'x'
gf = galois.GF(q, m, irreducible_poly=galois.matlab_primitive_poly(q,m)) 
# default/conway polynomial would be x^6 + x^4 + x^3 + x + 1, i.e. x^6 = x^4 + x^3 + x + 1
print("\nGF(2^6) primitive element:", gf.primitive_element, "\n")
# prints the configured irreducible polynomial , correctly, in variable 'x'
# prints (the first/minimal) primitive element as 'x'
print(gf.repr_table(sort="power"))  # prints polynomial over variable 'x', too

# However:
alpha = GF.primitive_element
gf.repr("poly")
print("Primitive Element:", alpha) 
# prints α! not 'x'

# and, is this correct?
print(alpha**6)
# !!! gives α^4 + α^3 + α + 1 as by the conway/default polynomial, but not α + 1 as by the selected primitive polynomial of the GF(2^6)

I guess I have some twisted thought in my mind. Can you help me? Is this behavior correct/expected?

Thanks
donludovico

[mhostetter]

The convention I used is that if x is a primitive element of the field, which happens when the irreducible polynomial is primitive, then alpha = x so I write the polynomial indeterminate as alpha. The powers of alpha always generate the multiplicative group. When alpha is more complicated than x, eg x + 1, I leave the polynomial indeterminate as x. I think this is a standard convention. Here's an example.

poly = galois.primitive_poly(2, 4)
assert poly.is_primitive()
GF = galois.GF(2**4, irreducible_poly=poly, repr="poly")
print(GF.primitive_element)  # Primitive element is x, so we replace x with alpha
print(GF.elements)

α
[                0                 1                 α             α + 1
               α^2           α^2 + 1           α^2 + α       α^2 + α + 1
               α^3           α^3 + 1           α^3 + α       α^3 + α + 1
         α^3 + α^2     α^3 + α^2 + 1     α^3 + α^2 + α α^3 + α^2 + α + 1]

poly = [f for f in galois.irreducible_polys(2, 4) if not f.is_primitive()][0]
assert not poly.is_primitive()
GF = galois.GF(2**4, irreducible_poly=poly, repr="poly")
print(GF.primitive_element)  # Primitive element is alpha = x + 1
print(GF.elements)

x + 1
[                0                 1                 x             x + 1
               x^2           x^2 + 1           x^2 + x       x^2 + x + 1
               x^3           x^3 + 1           x^3 + x       x^3 + x + 1
         x^3 + x^2     x^3 + x^2 + 1     x^3 + x^2 + x x^3 + x^2 + x + 1]

[donludovico]

Ah, I see. Thanks for clarifying - for me, this makes sense, although I admit that I see my limitation (for my field of application alpha = x is always true). I will drop the issue.