Algebra.Units

Class

class C a => C a where

This class lets us deal with the units in a ring. isUnit tells whether an element is a unit. The other operations let us canonically write an element as a unit times another element. Two elements a, b of a ring R are _associates_ if a=b*u for a unit u. For an element a, we want to write it as a=b*u where b is an associate of a. The map (a->b) is called StandardAssociate by Gap, "unitCanonical" by Axiom, and "canAssoc" by DoCon. The map (a->u) is called "canInv" by DoCon and "unitNormal(x).unit" by Axiom.

The laws are

  stdAssociate x * stdUnit x === x
    stdUnit x * stdUnitInv x === 1
 isUnit u ==> stdAssociate x === stdAssociate (x*u)

Currently some algorithms assume

 stdAssociate(x*y) === stdAssociate x * stdAssociate y

Minimal definition: isUnit and (stdUnit or stdUnitInv) and optionally stdAssociate

Minimal complete definition

isUnit, (stdUnit | stdUnitInv)

Methods

isUnit :: a -> Bool

stdAssociate, stdUnit, stdUnitInv :: a -> a

Instances

C Int

Methods

isUnit :: Int -> Bool

stdAssociate :: Int -> Int

stdUnit :: Int -> Int

stdUnitInv :: Int -> Int

C Int8

Methods

isUnit :: Int8 -> Bool

stdAssociate :: Int8 -> Int8

stdUnit :: Int8 -> Int8

stdUnitInv :: Int8 -> Int8

C Int16

Methods

isUnit :: Int16 -> Bool

stdAssociate :: Int16 -> Int16

stdUnit :: Int16 -> Int16

stdUnitInv :: Int16 -> Int16

C Int32

Methods

isUnit :: Int32 -> Bool

stdAssociate :: Int32 -> Int32

stdUnit :: Int32 -> Int32

stdUnitInv :: Int32 -> Int32

C Int64

Methods

isUnit :: Int64 -> Bool

stdAssociate :: Int64 -> Int64

stdUnit :: Int64 -> Int64

stdUnitInv :: Int64 -> Int64

C Integer

Methods

isUnit :: Integer -> Bool

stdAssociate :: Integer -> Integer

stdUnit :: Integer -> Integer

stdUnitInv :: Integer -> Integer

C T

Methods

isUnit :: T -> Bool

stdAssociate :: T -> T

stdUnit :: T -> T

stdUnitInv :: T -> T

Integral a => C (T a)

Methods

isUnit :: T a -> Bool

stdAssociate :: T a -> T a

stdUnit :: T a -> T a

stdUnitInv :: T a -> T a

(C a, C a) => C (T a)

Methods

isUnit :: T a -> Bool

stdAssociate :: T a -> T a

stdUnit :: T a -> T a

stdUnitInv :: T a -> T a

(Ord a, C a) => C (T a)

Methods

isUnit :: T a -> Bool

stdAssociate :: T a -> T a

stdUnit :: T a -> T a

stdUnitInv :: T a -> T a

C a => C (T a)

Methods

isUnit :: T a -> Bool

stdAssociate :: T a -> T a

stdUnit :: T a -> T a

stdUnitInv :: T a -> T a

isUnit :: C a => a -> Bool

stdAssociate, stdUnit, stdUnitInv :: C a => a -> a

stdAssociate, stdUnit, stdUnitInv :: C a => a -> a

stdAssociate, stdUnit, stdUnitInv :: C a => a -> a

Standard implementations for instances

intQuery :: (Integral a, C a) => a -> Bool

intAssociate :: (Integral a, C a, C a) => a -> a

intStandard :: (Integral a, C a, C a) => a -> a

intStandardInverse :: (Integral a, C a, C a) => a -> a

Properties

propComposition :: (Eq a, C a) => a -> Bool

propInverseUnit :: (Eq a, C a) => a -> Bool

propUniqueAssociate :: (Eq a, C a) => a -> a -> Property

propAssociateProduct :: (Eq a, C a) => a -> a -> Bool

Currently some algorithms assume this property.