Math.Singular.Factory.Domains

Base domains.

These are the base rings and fields Factory can work with, namely:

• the ring integers
• the field of rationals
• finite fields (prime fields and Galois fields)

Another representation for finite fields are explicit algebraic extensions of prime fields. This has less limitations (does not rely on precomputed tables), but it is not implemented yet.

Note1: non-prime order Galois fields are supported only for small orders! (this is a limitation by singular-factory). Also for them to work, we need to be able to figure out the location of the "gftables" directory first.

Note2: as Factory has the base domain as a global state (...), this whole library is not at all thread safe!

The global characteristics

type Prime = Int

data FactoryChar

Constructors

CharZero

QQ

CharFp !Prime

prime field

CharGF !Prime !Int

Galois field

Instances

Eq FactoryChar

Defined in Math.Singular.Factory.Domains

Methods

(==) :: FactoryChar -> FactoryChar -> Bool

(/=) :: FactoryChar -> FactoryChar -> Bool

Show FactoryChar

Defined in Math.Singular.Factory.Domains

Methods

showsPrec :: Int -> FactoryChar -> ShowS

show :: FactoryChar -> String

showList :: [FactoryChar] -> ShowS

theFactoryChar :: IORef FactoryChar

Unfortunately, Factory maintains a global state...

setFactoryChar :: FactoryChar -> IO ()

mapIntoCF :: FactoryChar -> CF -> CF

Prime fields

newtype Fp (p :: Nat)

Haskell prime fields (this is provided only for completeness)

Constructors

Fp Int

Instances

Eq (Fp p)

Defined in Math.Singular.Factory.Domains

Methods

(==) :: Fp p -> Fp p -> Bool

(/=) :: Fp p -> Fp p -> Bool

KnownNat p => Num (Fp p)

Defined in Math.Singular.Factory.Domains

Methods

(+) :: Fp p -> Fp p -> Fp p

(-) :: Fp p -> Fp p -> Fp p

(*) :: Fp p -> Fp p -> Fp p

negate :: Fp p -> Fp p

abs :: Fp p -> Fp p

signum :: Fp p -> Fp p

fromInteger :: Integer -> Fp p

Show (Fp p)

Defined in Math.Singular.Factory.Domains

Methods

showsPrec :: Int -> Fp p -> ShowS

show :: Fp p -> String

showList :: [Fp p] -> ShowS

KnownNat p => FiniteDomain (Fp p)

Defined in Math.Singular.Factory.Domains

Methods

domainSize :: Proxy (Fp p) -> Int

enumerateDomain :: [Fp p]

KnownNat p => BaseDomain (Fp p)

Defined in Math.Singular.Factory.Domains

Methods

characteristic :: Proxy (Fp p) -> Int

charExponent :: Proxy (Fp p) -> Int

baseDomainName :: Proxy (Fp p) -> String

factoryChar :: Proxy (Fp p) -> FactoryChar

baseToCF :: Fp p -> CF

unsafeCfToBase :: CF -> Fp p

isZero :: Fp p -> Bool

isOne :: Fp p -> Bool

fpPrime :: KnownNat p => Fp p -> Int

modp :: (KnownNat p, Integral a) => a -> Fp p

fpToFF :: KnownNat p => Fp p -> FF p

Finite fields

newtype FF (p :: Nat)

Factory prime fields

Constructors

FF

Fields

• unFF :: CF

Instances

Eq (FF p)

Defined in Math.Singular.Factory.Domains

Methods

(==) :: FF p -> FF p -> Bool

(/=) :: FF p -> FF p -> Bool

KnownNat p => Fractional (FF p)

Defined in Math.Singular.Factory.Domains

Methods

(/) :: FF p -> FF p -> FF p

recip :: FF p -> FF p

fromRational :: Rational -> FF p

KnownNat p => Num (FF p)

Defined in Math.Singular.Factory.Domains

Methods

(+) :: FF p -> FF p -> FF p

(-) :: FF p -> FF p -> FF p

(*) :: FF p -> FF p -> FF p

negate :: FF p -> FF p

abs :: FF p -> FF p

signum :: FF p -> FF p

fromInteger :: Integer -> FF p

Show (FF p)

Defined in Math.Singular.Factory.Domains

Methods

showsPrec :: Int -> FF p -> ShowS

show :: FF p -> String

showList :: [FF p] -> ShowS

KnownNat p => FiniteDomain (FF p)

Defined in Math.Singular.Factory.Domains

Methods

domainSize :: Proxy (FF p) -> Int

enumerateDomain :: [FF p]

KnownNat p => BaseDomain (FF p)

Defined in Math.Singular.Factory.Domains

Methods

characteristic :: Proxy (FF p) -> Int

charExponent :: Proxy (FF p) -> Int

baseDomainName :: Proxy (FF p) -> String

factoryChar :: Proxy (FF p) -> FactoryChar

baseToCF :: FF p -> CF

unsafeCfToBase :: CF -> FF p

isZero :: FF p -> Bool

isOne :: FF p -> Bool

mkFF :: (KnownNat p, Integral a) => a -> FF p

ffPrime :: KnownNat p => FF p -> Int

Galois fields

newtype GF (p :: Nat) (n :: Nat) (x :: Symbol)

Galois fields GF(p^n).

The (nonzero) elements are represented as powers of the canonical generator.

The symbol is the name of the canonical generator (used for pretty-printing).

Note: because of how Factory is implemented, it is required that n >= 2... (use FF for prime fields).

Also, the sizes are really limited (because they rely on tables, and only small tables are included): p < 256 and p^n < 65536

Constructors

GF

Fields

• unGF :: CF

Instances

Eq (GF p n x)

Defined in Math.Singular.Factory.Domains

Methods

(==) :: GF p n x -> GF p n x -> Bool

(/=) :: GF p n x -> GF p n x -> Bool

(KnownNat p, KnownNat n, KnownSymbol x) => Fractional (GF p n x)

Defined in Math.Singular.Factory.Domains

Methods

(/) :: GF p n x -> GF p n x -> GF p n x

recip :: GF p n x -> GF p n x

fromRational :: Rational -> GF p n x

(KnownNat p, KnownNat n, KnownSymbol x) => Num (GF p n x)

Defined in Math.Singular.Factory.Domains

Methods

(+) :: GF p n x -> GF p n x -> GF p n x

(-) :: GF p n x -> GF p n x -> GF p n x

(*) :: GF p n x -> GF p n x -> GF p n x

negate :: GF p n x -> GF p n x

abs :: GF p n x -> GF p n x

signum :: GF p n x -> GF p n x

fromInteger :: Integer -> GF p n x

(KnownNat p, KnownNat n, KnownSymbol x) => Show (GF p n x)

Defined in Math.Singular.Factory.Domains

Methods

showsPrec :: Int -> GF p n x -> ShowS

show :: GF p n x -> String

showList :: [GF p n x] -> ShowS

(KnownNat p, KnownNat n, KnownSymbol x) => FiniteDomain (GF p n x)

Defined in Math.Singular.Factory.Domains

Methods

domainSize :: Proxy (GF p n x) -> Int

enumerateDomain :: [GF p n x]

(KnownNat p, KnownNat n, KnownSymbol x) => BaseDomain (GF p n x)

Defined in Math.Singular.Factory.Domains

Methods

characteristic :: Proxy (GF p n x) -> Int

charExponent :: Proxy (GF p n x) -> Int

baseDomainName :: Proxy (GF p n x) -> String

factoryChar :: Proxy (GF p n x) -> FactoryChar

baseToCF :: GF p n x -> CF

unsafeCfToBase :: CF -> GF p n x

isZero :: GF p n x -> Bool

isOne :: GF p n x -> Bool

mkGF :: (KnownNat p, KnownNat n, KnownSymbol x, Integral a) => a -> GF p n x

Create elements of the prime subfield. For the rest, you can use the powers of the generator.

genGF :: (KnownNat p, KnownNat n, KnownSymbol x) => GF p n x

The canonical generator of the (multiplicative group of the) Galois field

genPowGF :: (KnownNat p, KnownNat n, KnownSymbol x) => Int -> GF p n x

A power of the canonical generator

powGF :: (KnownNat p, KnownNat n, KnownSymbol x) => GF p n x -> Int -> GF p n x

gfPrime :: KnownNat p => GF p n x -> Int

gfExponent :: KnownNat n => GF p n x -> Int

gfSymbol :: KnownSymbol x => GF p n x -> String

Base domains

class (Eq a, Show a, Num a) => BaseDomain a where

Methods

characteristic :: Proxy a -> Int

charExponent :: Proxy a -> Int

baseDomainName :: Proxy a -> String

factoryChar :: Proxy a -> FactoryChar

baseToCF :: a -> CF

unsafeCfToBase :: CF -> a

isZero :: a -> Bool

isOne :: a -> Bool

Instances

BaseDomain Integer

Defined in Math.Singular.Factory.Domains

Methods

characteristic :: Proxy Integer -> Int

charExponent :: Proxy Integer -> Int

baseDomainName :: Proxy Integer -> String

factoryChar :: Proxy Integer -> FactoryChar

baseToCF :: Integer -> CF

unsafeCfToBase :: CF -> Integer

isZero :: Integer -> Bool

isOne :: Integer -> Bool

BaseDomain Rational

Defined in Math.Singular.Factory.Domains

Methods

characteristic :: Proxy Rational -> Int

charExponent :: Proxy Rational -> Int

baseDomainName :: Proxy Rational -> String

factoryChar :: Proxy Rational -> FactoryChar

baseToCF :: Rational -> CF

unsafeCfToBase :: CF -> Rational

isZero :: Rational -> Bool

isOne :: Rational -> Bool

KnownNat p => BaseDomain (FF p)

Defined in Math.Singular.Factory.Domains

Methods

characteristic :: Proxy (FF p) -> Int

charExponent :: Proxy (FF p) -> Int

baseDomainName :: Proxy (FF p) -> String

factoryChar :: Proxy (FF p) -> FactoryChar

baseToCF :: FF p -> CF

unsafeCfToBase :: CF -> FF p

isZero :: FF p -> Bool

isOne :: FF p -> Bool

KnownNat p => BaseDomain (Fp p)

Defined in Math.Singular.Factory.Domains

Methods

characteristic :: Proxy (Fp p) -> Int

charExponent :: Proxy (Fp p) -> Int

baseDomainName :: Proxy (Fp p) -> String

factoryChar :: Proxy (Fp p) -> FactoryChar

baseToCF :: Fp p -> CF

unsafeCfToBase :: CF -> Fp p

isZero :: Fp p -> Bool

isOne :: Fp p -> Bool

(KnownNat p, KnownNat n, KnownSymbol x) => BaseDomain (GF p n x)

Defined in Math.Singular.Factory.Domains

Methods

characteristic :: Proxy (GF p n x) -> Int

charExponent :: Proxy (GF p n x) -> Int

baseDomainName :: Proxy (GF p n x) -> String

factoryChar :: Proxy (GF p n x) -> FactoryChar

baseToCF :: GF p n x -> CF

unsafeCfToBase :: CF -> GF p n x

isZero :: GF p n x -> Bool

isOne :: GF p n x -> Bool

setBaseDomain :: BaseDomain a => Proxy a -> IO ()

Finite domains

class BaseDomain domain => FiniteDomain domain where

Methods

domainSize :: Proxy domain -> Int

enumerateDomain :: [domain]

Instances

KnownNat p => FiniteDomain (FF p)

Defined in Math.Singular.Factory.Domains

Methods

domainSize :: Proxy (FF p) -> Int

enumerateDomain :: [FF p]

KnownNat p => FiniteDomain (Fp p)

Defined in Math.Singular.Factory.Domains

Methods

domainSize :: Proxy (Fp p) -> Int

enumerateDomain :: [Fp p]

(KnownNat p, KnownNat n, KnownSymbol x) => FiniteDomain (GF p n x)

Defined in Math.Singular.Factory.Domains

Methods

domainSize :: Proxy (GF p n x) -> Int

enumerateDomain :: [GF p n x]

Proxy

mkProxy :: a -> Proxy a

proxyUndef :: Proxy a -> a