Data type for finite fields in Haskell?

Question

I'm trying to learn a bit of Haskell by writing a small set of functions for computations over finite (Galois) fields. Years ago I wrote the first version of a similar library for the computer algebra system GNU Maxima (see here) and I thought I'd try the same thing with Haskell.

However, I'm getting myself all muddled with data types. For a finite field, you need a base prime q (the characteristic of the field), and a polynomial p(x) which is irreducible modulo q. If p(x) has degree n, then the order of the field is q^n and its elements are all polynomials (modulo q) with degree n-1 or less.

We can represent polynomials as lists of their coefficients, so that elements of the field are simply lists (or vectors, if you prefer) of elements of Z_q and of length n. Addition is done component-wise modulo q, and multiplication is done modulo p(x).

I reckon if I can get the data type and addition sorted out the rest will be straightforward. My first attempt is this:

import Data.List

data GF = GF {characteristic::Int
             ,power::Int
             ,poly::[Int]
             ,irreducible::[Int]
             } deriving(Eq, Show)

The power element is unnecessary - it is after all simply one less than the length of the irreducible polynomial - but it's a convenience to have it rather than having to compute it.

Then I had my addition function as:

addGF :: GF -> GF -> GF
addGF x y = GF q n zp p
  where
    q = characteristic x
    n = power x
    zp = zipWith (\i j -> rem (i+j) q) xp yp
      where
        xp = poly x
        yp = poly y
    p = irreducible x

This works, but is inelegant, and I'm sure very "un-Haskell-ish". Part of the problem is that I don't know how to decouple the definition (or type) of a Galois field from its elements.

What I need to do is to provide a general type for a field, and on top of that define elements of it. There are, after all, things I might want to do with a field which are independent of its elements, such as generate a normal basis, find a primitive element, generate a table of logarithms for a primitive element, generate random elements, etc.

So I guess my question is: how do I define a generic type of a Galois field, in such a way that operations on its elements are as natural as possible?

I have read a number of pages about defining data types, classes, etc, and I've no doubt that one of them contains the solution to my problem. But the more I read the more confused I become. All I want is for somebody to point me gently but firmly in the right direction. Thanks!

Answer 1

I don't think your GF type is ugly or incorrect. The main issue I see is that addGF does not enforce that the elements can actually be added. Instead you could do:

addGF :: GF -> GF -> Maybe GF
addGF x y -- the pipes below are called "guards", a multi-way `if` syntax
  | q == characteristic y && n == power y && p == irreducible y = Just $ GF q n zp p
  | otherwise = Nothing
  where
    q = characteristic x
    n = power x
    zp = zipWith (\i j -> rem (i+j) q) xp yp
      where
        xp = poly x
        yp = poly y
    p = irreducible x

It might be more ergonomic and useful (but not a fundamentally different solution) to separate the notion of a field from its elements, like this:

-- these names are probably not appropriate
data Field  
  = Field { characteristic::Int
          , power::Int
          , irreducible::[Int]
          } deriving(Eq, Show)

-- formerly `GF`:
data FieldElement
  = FieldElement 
          { field::Field
          , poly::[Int]
          } deriving(Eq, Show)

Then in the guard above, you'd simply need to do e.g.

...
| field x == field y = Just $ ...

RecordWildCards is also a nice extension for removing boilerplate when you wish to work with record names.

If you know that you will be working with particular fields with parameters known at compile-time, then you can allow the type-checker to enforce the invariant in addGF for you. One way would be like this:

-- see `Data.Proxy` for info about this idiom
class SomeField f where
   characteristic :: proxy f -> Int
   power :: proxy f -> Int
   irreducible :: proxy f -> [Int]

-- A field element is just the polynomial, tagged with its field using the `f` type parameter
-- you may want to not expose the internals of `GF` but instead expose a 
-- makeGF function which enforces whatever invariants should hold between the parameters
-- of a field and the polynomial of its element.
newtype GF f = GF { poly :: [Int] }

-- `addGF` is no longer partial; the type system enforces that both arguments are elements of the same field
addGF :: (SomeField f)=> GF f -> GF f -> GF f
addGF x@(GF xp) (GF yp) = GF $ zipWith (\i j -> rem (i+j) q) xp yp
  where q = characteristic x

I mentioned "vectors" only be cause the problem and various approaches you have open to you here is the same as the one you have with vector arithmetic, in which e.g. only vectors of the same dimension can be added.

Answer 2

It is easy enough to lift characteristic and power into the type system in modern Haskell (GHC>=7.8), that is,

{-# LANGUAGE TypeOperators, DataKinds #-}
{-# LANGUAGE FlexibleContexts, TypeFamilies, UndecidableInstances #-}
{-# LANGUAGE StandaloneDeriving #-}

and express that the coefficients of the polynomials come from the finite group whose size is the characteristic:

import GHC.TypeLits
import Data.Modular

data GF χ -- characteristic
        n -- power
   = GF { irreducible :: [ℤ/χ]
        , poly :: [ℤ/χ]
        }

This already gives you for free that any additions on polynomials will be modulo χ.

You could furthermore express that there are always n + 1 coefficients:

import qualified Data.Vector.Fixed as Fix
import qualified Data.Vector.Fixed.Boxed as Fix

data GF χ n
   = GF { irreducible :: Fix.Vec (n+1) (ℤ/χ)
        , poly :: Fix.Vec (n+1) (ℤ/χ)
        }
deriving instance (KnownNat χ, Fix.Arity (n+1)) => Show (GF χ n)

addGF :: (KnownNat χ, Fix.Arity (n+1))
           => GF χ n -> GF χ n -> GF χ n
addGF (GF irr xp) (GF irr' yp)
 | irr==irr'  = GF irr $ Fix.zipWith (+) xp yp
 | otherwise  = error "Cannot add elements of finite fields with different irreducible polynomials!"

main = print (GF irr (Fix.fromList [0,0,1]) `addGF` GF irr (Fix.fromList [0,1,1])
               :: GF 2 2)
 where irr = Fix.fromList [1,1,1]

Result:

GF {irreducible = fromList [1,1,1], poly = fromList [0,1,0]}

It's still ugly that we have to runtime-check the irreducible polynomial. While it would in principle be possible to lift that into the type level as well, I'm not sure if that would really work out very well; we're already pushing against the boundaries here of how well Haskell can be used as a dependently-typed language. Perhaps it would be enough to choose for every characteristic and power only once an irreducible polynomial that would always be used?