SubHask.Algebra

This module defines the algebraic type-classes used in subhask. The class hierarchies are significantly more general than those in the standard Prelude.

Comparisons

type family Logic a :: *

Every type has an associated logic. Most types use classical logic, which corresponds to the Bool type. But types can use any logical system they want. Functions, for example, use an infinite logic. You probably want your logic to be an instance of Boolean, but this is not required.

See wikipedia's articles on algebraic logic, and infinitary logic for more details.

Instances

type Logic Bool = Bool

type Logic Char = Bool

type Logic Double = Bool

type Logic Float = Bool

type Logic Int = Bool

type Logic Integer = Bool

type Logic Ordering = Bool

type Logic Rational = Bool

type Logic TypeRep = Bool

type Logic Type = Bool

type Logic Dec = Bool

type Logic Name = Bool

type Logic () = ()

type Logic POrdering = Bool

type Logic K3 = Bool

type Logic H3 = Bool

type Logic [a] = Logic a

type Logic (Maybe a) = Logic a

type Logic (Maybe' a) = Logic a

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (WithPreludeOrd a0) = Logic a0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (NonNegative t0) = Logic t0

type Logic (VedicSquare n0) = Logic (Z n0)

type Logic (VedicSquare n0) = Logic (Z n0)

type Logic (VedicSquare n0) = Logic (Z n0)

type Logic (VedicSquare n0) = Logic (Z n0)

type Logic (VedicSquare n0) = Logic (Z n0)

type Logic (Ball v) = Logic v

type Logic (Componentwise v) = Logic v

type Logic (ZIndex a0) = Logic (Z (Order a0))

type Logic (ZIndex a0) = Logic (Z (Order a0))

type Logic (ZIndex a0) = Logic (Z (Order a0))

type Logic (ZIndex a0) = Logic (Z (Order a0))

type Logic (ZIndex a0) = Logic (Z (Order a0))

type Logic (ZIndex a0) = Logic (Z (Order a0))

type Logic (ZIndex a0) = Logic (Z (Order a0))

type Logic (BArray e) = Logic e

type Logic (UArray e) = Logic e

type Logic (Box v) = Logic v

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Jaccard a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Hamming a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Levenshtein a0) = Logic a0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Uncompensated s0) = Logic s0

type Logic (Lexical a0) = Logic a0

type Logic (Lexical a0) = Logic a0

type Logic (Lexical a0) = Logic a0

type Logic (Lexical a0) = Logic a0

type Logic (Lexical a0) = Logic a0

type Logic (Lexical a0) = Logic a0

type Logic (Lexical a0) = Logic a0

type Logic (Lexical a0) = Logic a0

type Logic (Lexical a0) = Logic a0

type Logic (Lexical a0) = Logic a0

type Logic (ComponentWise a0) = Logic a0

type Logic (ComponentWise a0) = Logic a0

type Logic (ComponentWise a0) = Logic a0

type Logic (ComponentWise a0) = Logic a0

type Logic (ComponentWise a0) = Logic a0

type Logic (ComponentWise a0) = Logic a0

type Logic (ComponentWise a0) = Logic a0

type Logic (ComponentWise a0) = Logic a0

type Logic (ComponentWise a0) = Logic a0

type Logic (ComponentWise a0) = Logic a0

type Logic (Goedel_ r0) = Logic r0

type Logic (Goedel_ r0) = Logic r0

type Logic (Goedel_ r0) = Logic r0

type Logic (Goedel_ r0) = Logic r0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Boolean2Ring b0) = Logic b0

type Logic (Seq a) = Bool

type Logic (IntMap e) = Bool

type Logic (IntMap' e) = Bool

type Logic (Set a) = Logic a

type Logic (LexSet a) = Bool

type Logic (ByteString b) = Bool

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (PartitionOnNewline a0) = Logic a0

type Logic (a -> b) = a -> Logic b

type Logic (a, b) = Logic a

type Logic (Labeled' x y) = Logic x

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Galois p0 k0) = Logic (Z ((^) p0 k0))

type Logic (Polynomial_ a b) = Logic b

type Logic ((+>) a b) = Bool

type Logic (BloomFilter n a) = Bool

type Logic (Map i e) = Bool

type Logic (Map' i e) = Bool

type Logic (a, b, c) = Logic a

type Logic ((/) k a0 b0) = Logic a0

type Logic ((/) k a0 b0) = Logic a0

type Logic ((/) k a0 b0) = Logic a0

type Logic ((/) k a0 b0) = Logic a0

type Logic ((/) k a0 b0) = Logic a0

type Logic ((/) k a0 b0) = Logic a0

type Logic (SVector k n r) = Logic r

type Logic (UVector k n r) = Logic r

type Logic (HyperLogLog k k1 p a) = Bool

type ValidLogic a = Complemented (Logic a)

type ClassicalLogic a = Logic a ~ Bool

Classical logic is implemented using the Prelude's Bool type.

class Eq_ a where

Defines equivalence classes over the type. The values need not have identical representations in the machine to be equal.

See wikipedia and ncatlab for more details.

Minimal complete definition

(==)

Methods

(==) :: a -> a -> Logic a infix 4

(/=) :: ValidLogic a => a -> a -> Logic a infix 4

In order to have the "not equals to" relation, your logic must have a notion of "not", and therefore must be Boolean.

Instances

Eq_ Bool

Eq_ Char

Eq_ Double

Eq_ Float

Eq_ Int

Eq_ Integer

Eq_ Ordering

Eq_ Rational

Eq_ ()

Eq_ POrdering

Eq_ K3

Eq_ H3

ValidEq a => Eq_ [a]

ValidEq a => Eq_ (Maybe a)

ValidEq a => Eq_ (Maybe' a)

Eq_ a0 => Eq_ (WithPreludeOrd a)

Eq_ t0 => Eq_ (NonNegative t)

Eq_ (Z n0) => Eq_ (VedicSquare n)

(Eq v, HasScalar v) => Eq_ (Ball v)

Eq_ v => Eq_ (Componentwise v)

Eq_ (Z (Order a0)) => Eq_ (ZIndex a)

(ValidLogic e, Eq_ e) => Eq_ (BArray e)

(Unboxable e, Eq_ e) => Eq_ (UArray e)

(Eq v, HasScalar v) => Eq_ (Box v)

Eq_ a0 => Eq_ (Jaccard a)

Eq_ a0 => Eq_ (Hamming a)

Eq_ a0 => Eq_ (Levenshtein a)

Eq_ s0 => Eq_ (Uncompensated s)

Eq_ a0 => Eq_ (Lexical a)

Eq_ a0 => Eq_ (ComponentWise a)

Eq_ r0 => Eq_ (Goedel_ r)

Eq_ b0 => Eq_ (Boolean2Ring b)

Eq a => Eq_ (Seq a)

Eq e => Eq_ (IntMap e)

Eq e => Eq_ (IntMap' e)

Eq a => Eq_ (Set a)

Eq_ (LexSet a)

Eq_ (ByteString Char)

Eq_ a0 => Eq_ (PartitionOnNewline a)

Eq_ b => Eq_ (a -> b)

(ValidEq a, ValidEq b, (~) * (Logic a) (Logic b)) => Eq_ (a, b)

Eq_ x => Eq_ (Labeled' x y)

Eq_ (Z ((^) p0 k0)) => Eq_ (Galois p k)

Eq b => Eq_ (Polynomial_ a b)

(Eq i, Eq e) => Eq_ (Map i e)

(Eq i, Eq e) => Eq_ (Map' i e)

(ValidEq a, ValidEq b, ValidEq c, (~) * (Logic a) (Logic b), (~) * (Logic b) (Logic c)) => Eq_ (a, b, c)

Eq_ a0 => Eq_ ((/) k a b)

(KnownNat n, Eq_ r, ValidLogic r, ValidSVector Nat n r) => Eq_ (SVector Nat n r)

(Eq r, Monoid r, ValidSVector Symbol n r) => Eq_ (SVector Symbol n r)

(Eq r, Monoid r, Prim r) => Eq_ (UVector Symbol n r)

type Eq a = (Eq_ a, Logic a ~ Bool)

type ValidEq a = (Eq_ a, ValidLogic a)

law_Eq_reflexive :: Eq a => a -> Logic a

law_Eq_symmetric :: Eq a => a -> a -> Logic a

law_Eq_transitive :: Eq a => a -> a -> a -> Logic a

class Eq_ b => POrd_ b where

This is more commonly known as a "meet" semilattice

Minimal complete definition

inf

Methods

inf :: b -> b -> b

(<=) :: b -> b -> Logic b infix 4

(<) :: Complemented (Logic b) => b -> b -> Logic b infix 4

Instances

POrd_ Bool

POrd_ Char

POrd_ Double

POrd_ Float

POrd_ Int

POrd_ Integer

POrd_ Rational

POrd_ ()

POrd_ K3

POrd_ H3

Eq a => POrd_ [a]

(POrd_ a0, Eq_ a0) => POrd_ (WithPreludeOrd a)

(POrd_ t0, Eq_ t0) => POrd_ (NonNegative t)

(ClassicalLogic e, POrd_ e) => POrd_ (BArray e)

(Unboxable e, POrd_ e) => POrd_ (UArray e)

(POrd_ a0, Eq_ a0) => POrd_ (Jaccard a)

(POrd_ a0, Eq_ a0) => POrd_ (Hamming a)

(POrd_ a0, Eq_ a0) => POrd_ (Levenshtein a)

(POrd_ s0, Eq_ s0) => POrd_ (Uncompensated s)

((~) * (Logic a) Bool, Ord (Elem a), Foldable a, Eq_ a) => POrd_ (Lexical a)

(SimpleContainerLogic a, Eq_ a, POrd_ (Elem a), Foldable a) => POrd_ (ComponentWise a)

OrdRing_ r => POrd_ (Goedel_ r)

(POrd_ b0, Eq_ b0) => POrd_ (Boolean2Ring b)

POrd a => POrd_ (Seq a)

Eq e => POrd_ (IntMap e)

Eq e => POrd_ (IntMap' e)

Ord a => POrd_ (Set a)

POrd_ (LexSet a)

POrd_ (ByteString Char)

(POrd_ a0, Eq_ a0) => POrd_ (PartitionOnNewline a)

POrd_ b => POrd_ (a -> b)

(ClassicalLogic x, Ord_ x) => POrd_ (Labeled' x y)

(Ord i, Eq e) => POrd_ (Map i e)

(Ord i, Eq e) => POrd_ (Map' i e)

type POrd a = (Eq a, POrd_ a)

law_POrd_commutative :: (Eq b, POrd_ b) => b -> b -> Bool

law_POrd_associative :: (Eq b, POrd_ b) => b -> b -> b -> Bool

theorem_POrd_idempotent :: (Eq b, POrd_ b) => b -> Bool

class POrd_ b => Lattice_ b where

See wikipedia for more details.

Minimal complete definition

sup

Methods

sup :: b -> b -> b

(>=) :: b -> b -> Logic b infix 4

(>) :: Boolean (Logic b) => b -> b -> Logic b infix 4

pcompare :: (Logic b ~ Bool) => b -> b -> POrdering

This function does not make sense on non-classical logics

FIXME: there are probably related functions for all these other logics; is there a nice way to represent them all?

Instances

Lattice_ Bool

Lattice_ Char

Lattice_ Double

Lattice_ Float

Lattice_ Int

Lattice_ Integer

Lattice_ Rational

Lattice_ ()

Lattice_ K3

Lattice_ H3

(Lattice_ a0, POrd_ a0) => Lattice_ (WithPreludeOrd a)

(Lattice_ t0, POrd_ t0) => Lattice_ (NonNegative t)

(Lattice_ a0, POrd_ a0) => Lattice_ (Jaccard a)

(Lattice_ a0, POrd_ a0) => Lattice_ (Hamming a)

(Lattice_ a0, POrd_ a0) => Lattice_ (Levenshtein a)

(Lattice_ s0, POrd_ s0) => Lattice_ (Uncompensated s)

((~) * (Logic a) Bool, Ord (Elem a), Foldable a, Eq_ a) => Lattice_ (Lexical a)

(SimpleContainerLogic a, Eq_ a, Lattice_ (Elem a), Foldable a) => Lattice_ (ComponentWise a)

OrdRing_ r => Lattice_ (Goedel_ r)

(Lattice_ b0, POrd_ b0) => Lattice_ (Boolean2Ring b)

Ord a => Lattice_ (Set a)

Lattice_ (LexSet a)

(Lattice_ a0, POrd_ a0) => Lattice_ (PartitionOnNewline a)

Lattice_ b => Lattice_ (a -> b)

(ClassicalLogic x, Ord_ x) => Lattice_ (Labeled' x y)

type Lattice a = (Eq a, Lattice_ a)

isChain :: Lattice a => [a] -> Logic a

A chain is a collection of elements all of which can be compared

isAntichain :: Lattice a => [a] -> Logic a

An antichain is a collection of elements none of which can be compared

See wikipedia for more details.

See also the article on Dilward's Theorem.

data POrdering

Represents all the possible ordering relations in a classical logic (i.e. Logic a ~ Bool)

Constructors

PLT

PGT

PEQ

PNA

Instances

Read POrdering

Show POrdering

Arbitrary POrdering

IsMutable POrdering

Monoid POrdering

Semigroup POrdering

FIXME: there are many semigroups over POrdering; how should we represent the others? newtypes?

Eq_ POrdering

type Logic POrdering = Bool

data Mutable m POrdering = Mutable_ConT_SubHask_Algebra_POrdering (PrimRef m POrdering)

law_Lattice_commutative :: (Eq b, Lattice_ b) => b -> b -> Bool

law_Lattice_associative :: (Eq b, Lattice_ b) => b -> b -> b -> Bool

theorem_Lattice_idempotent :: (Eq b, Lattice_ b) => b -> Bool

law_Lattice_infabsorption :: (Eq b, Lattice b) => b -> b -> Bool

law_Lattice_supabsorption :: (Eq b, Lattice b) => b -> b -> Bool

law_Lattice_reflexivity :: Lattice a => a -> Logic a

law_Lattice_antisymmetry :: Lattice a => a -> a -> Logic a

law_Lattice_transitivity :: Lattice a => a -> a -> a -> Logic a

defn_Lattice_greaterthan :: Lattice a => a -> a -> Logic a

class POrd_ b => MinBound_ b where

Most Lattice literature only considers Bounded lattices, but here we have both upper and lower bounded lattices.

minBound <= b || not (minBound > b)

Methods

minBound :: b

Instances

MinBound_ Bool

MinBound_ Char

MinBound_ Double

MinBound_ Float

MinBound_ Int

MinBound_ ()

MinBound_ K3

MinBound_ H3

Eq a => MinBound_ [a]

(MinBound_ a0, POrd_ a0) => MinBound_ (WithPreludeOrd a)

(MinBound_ t0, POrd_ t0) => MinBound_ (NonNegative t)

(ClassicalLogic e, POrd_ e) => MinBound_ (BArray e)

(Unboxable e, POrd_ e) => MinBound_ (UArray e)

(MinBound_ a0, POrd_ a0) => MinBound_ (Jaccard a)

(MinBound_ a0, POrd_ a0) => MinBound_ (Hamming a)

(MinBound_ a0, POrd_ a0) => MinBound_ (Levenshtein a)

(MinBound_ s0, POrd_ s0) => MinBound_ (Uncompensated s)

((~) * (Logic a) Bool, Ord (Elem a), Foldable a, Eq_ a) => MinBound_ (Lexical a)

(SimpleContainerLogic a, Eq_ a, POrd_ (Elem a), Foldable a) => MinBound_ (ComponentWise a)

OrdRing_ r => MinBound_ (Goedel_ r)

(MinBound_ b0, POrd_ b0) => MinBound_ (Boolean2Ring b)

POrd a => MinBound_ (Seq a)

POrd e => MinBound_ (IntMap e)

POrd e => MinBound_ (IntMap' e)

Ord a => MinBound_ (Set a)

Ord a => MinBound_ (LexSet a)

MinBound_ (ByteString Char)

(MinBound_ a0, POrd_ a0) => MinBound_ (PartitionOnNewline a)

MinBound_ b => MinBound_ (a -> b)

(Ord i, POrd e) => MinBound_ (Map i e)

(Ord i, POrd e) => MinBound_ (Map' i e)

type MinBound a = (Eq a, MinBound_ a)

law_MinBound_inf :: (Eq b, MinBound_ b) => b -> Bool

class (Lattice_ b, MinBound_ b) => Bounded b where

A Bounded lattice is a lattice with both a minimum and maximum element

Methods

maxBound :: b

Instances

Bounded Bool

Bounded Char

Bounded Double

Bounded Float

Bounded Int

Bounded ()

Bounded K3

Bounded H3

(Bounded a0, Lattice_ a0, MinBound_ a0) => Bounded (WithPreludeOrd a)

(Bounded t0, Lattice_ t0, MinBound_ t0) => Bounded (NonNegative t)

(Bounded a0, Lattice_ a0, MinBound_ a0) => Bounded (Jaccard a)

(Bounded a0, Lattice_ a0, MinBound_ a0) => Bounded (Hamming a)

(Bounded a0, Lattice_ a0, MinBound_ a0) => Bounded (Levenshtein a)

(Bounded s0, Lattice_ s0, MinBound_ s0) => Bounded (Uncompensated s)

OrdRing_ r => Bounded (Goedel_ r)

(Bounded b0, Lattice_ b0, MinBound_ b0) => Bounded (Boolean2Ring b)

(Bounded a0, Lattice_ a0, MinBound_ a0) => Bounded (PartitionOnNewline a)

Bounded b => Bounded (a -> b)

law_Bounded_sup :: (Eq b, Bounded b) => b -> Bool

supremum :: (Foldable bs, Elem bs ~ b, Bounded b) => bs -> b

supremum_ :: (Foldable bs, Elem bs ~ b, Lattice_ b) => b -> bs -> b

infimum :: (Foldable bs, Elem bs ~ b, Bounded b) => bs -> b

infimum_ :: (Foldable bs, Elem bs ~ b, POrd_ b) => b -> bs -> b

class Bounded b => Complemented b where

Methods

not :: b -> b

Instances

Complemented Bool

Complemented ()

(Complemented a0, Bounded a0) => Complemented (WithPreludeOrd a)

(Complemented t0, Bounded t0) => Complemented (NonNegative t)

(Complemented a0, Bounded a0) => Complemented (Jaccard a)

(Complemented a0, Bounded a0) => Complemented (Hamming a)

(Complemented a0, Bounded a0) => Complemented (Levenshtein a)

(Complemented s0, Bounded s0) => Complemented (Uncompensated s)

(Complemented b0, Bounded b0) => Complemented (Boolean2Ring b)

(Complemented a0, Bounded a0) => Complemented (PartitionOnNewline a)

Complemented b => Complemented (a -> b)

law_Complemented_not :: (ValidLogic b, Complemented b) => b -> Logic b

class Bounded b => Heyting b where

Heyting algebras are lattices that support implication, but not necessarily the law of excluded middle.

FIXME: Is every Heyting algebra a cancellative Abelian semigroup? If so, should we make that explicit in the class hierarchy?

Laws

There is a single, simple law that Heyting algebras must satisfy:

a ==> b = c   ===>   a && c < b

Theorems

From the laws, we automatically get the properties of:

distributivity

See wikipedia for more details.

Methods

(==>) :: b -> b -> b infixl 3

FIXME: think carefully about infix

Instances

Heyting Bool

Heyting ()

Heyting H3

(Heyting a0, Bounded a0) => Heyting (WithPreludeOrd a)

(Heyting t0, Bounded t0) => Heyting (NonNegative t)

(Heyting a0, Bounded a0) => Heyting (Jaccard a)

(Heyting a0, Bounded a0) => Heyting (Hamming a)

(Heyting a0, Bounded a0) => Heyting (Levenshtein a)

(Heyting s0, Bounded s0) => Heyting (Uncompensated s)

OrdRing_ r => Heyting (Goedel_ r)

(Heyting b0, Bounded b0) => Heyting (Boolean2Ring b)

(Heyting a0, Bounded a0) => Heyting (PartitionOnNewline a)

Heyting b => Heyting (a -> b)

modusPonens :: Boolean b => b -> b -> b

FIXME: add the axioms for intuitionist logic, which are theorems based on these laws

Modus ponens gives us a default definition for "==>" in a Boolean algebra. This formula is guaranteed to not work in a Heyting algebra that is not Boolean.

See wikipedia for more details.

law_Heyting_maxbound :: (Eq b, Heyting b) => b -> Bool

law_Heyting_infleft :: (Eq b, Heyting b) => b -> b -> Bool

law_Heyting_infright :: (Eq b, Heyting b) => b -> b -> Bool

law_Heyting_distributive :: (Eq b, Heyting b) => b -> b -> b -> Bool

class (Complemented b, Heyting b) => Boolean b

Generalizes Boolean variables.

See wikipedia for more details.

Instances

Boolean Bool

Boolean ()

(Boolean a0, Complemented a0, Heyting a0) => Boolean (WithPreludeOrd a)

(Boolean t0, Complemented t0, Heyting t0) => Boolean (NonNegative t)

(Boolean a0, Complemented a0, Heyting a0) => Boolean (Jaccard a)

(Boolean a0, Complemented a0, Heyting a0) => Boolean (Hamming a)

(Boolean a0, Complemented a0, Heyting a0) => Boolean (Levenshtein a)

(Boolean s0, Complemented s0, Heyting s0) => Boolean (Uncompensated s)

(Boolean b0, Complemented b0, Heyting b0) => Boolean (Boolean2Ring b)

(Boolean a0, Complemented a0, Heyting a0) => Boolean (PartitionOnNewline a)

Boolean b => Boolean (a -> b)

law_Boolean_infcomplement :: (Eq b, Boolean b) => b -> Bool

law_Boolean_supcomplement :: (Eq b, Boolean b) => b -> Bool

law_Boolean_infdistributivity :: (Eq b, Boolean b) => b -> b -> b -> Bool

law_Boolean_supdistributivity :: (Eq b, Boolean b) => b -> b -> b -> Bool

class Lattice b => Graded b where

An element of a graded poset has a unique predecessor.

See wikipedia for more details.

Methods

pred :: b -> b

the predecessor in the ordering

fromEnum :: b -> Int

Algebrists typically call this function the "rank" of the element in the poset; however we use the name from the standard prelude instead

Instances

Graded Bool

Graded Char

Graded Int

Graded Integer

(Graded a0, Lattice a0) => Graded (WithPreludeOrd a)

(Graded t0, Lattice t0) => Graded (NonNegative t)

law_Graded_pred :: Graded b => b -> b -> Bool

law_Graded_fromEnum :: (Lattice b, Graded b) => b -> b -> Bool

class Lattice_ a => Ord_ a where

This is the class of total orderings.

See https://en.wikipedia.org/wiki/Total_order

Minimal complete definition

Nothing

Methods

compare :: (Logic a ~ Bool, Ord_ a) => a -> a -> Ordering

Instances

Ord_ Bool

Ord_ Char

Ord_ Double

Ord_ Float

Ord_ Int

Ord_ Integer

Ord_ Rational

Ord_ ()

Ord_ K3

Ord_ H3

Monad OrdHask LexSet

Functor * OrdHask LexSet

(Ord_ a0, Lattice_ a0) => Ord_ (WithPreludeOrd a)

(Ord_ t0, Lattice_ t0) => Ord_ (NonNegative t)

(Ord_ a0, Lattice_ a0) => Ord_ (Jaccard a)

(Ord_ a0, Lattice_ a0) => Ord_ (Hamming a)

(Ord_ a0, Lattice_ a0) => Ord_ (Levenshtein a)

(Ord_ s0, Lattice_ s0) => Ord_ (Uncompensated s)

((~) * (Logic a) Bool, Ord (Elem a), Foldable a, Eq_ a) => Ord_ (Lexical a)

OrdRing_ r => Ord_ (Goedel_ r)

Ord_ (LexSet a)

(ClassicalLogic x, Ord_ x) => Ord_ (Labeled' x y)

law_Ord_totality :: Ord a => a -> a -> Bool

law_Ord_min :: Ord a => a -> a -> Bool

law_Ord_max :: Ord a => a -> a -> Bool

type Ord a = (Eq a, Ord_ a)

data Ordering :: *

Constructors

LT

EQ

GT

Instances

Bounded Ordering

Enum Ordering

Eq Ordering

Ord Ordering

Read Ordering

Show Ordering

Ix Ordering

Generic Ordering

Arbitrary Ordering

CoArbitrary Ordering

Monoid Ordering

Serial Ordering

>>> runGetL deserialize $ runPutL $ serialize LT::Ordering
LT
>>> runGetL deserialize $ runPutL $ serialize EQ::Ordering
EQ
>>> runGetL deserialize $ runPutL $ serialize GT::Ordering
GT

Hashable Ordering

Semigroup Ordering

Monoid Ordering

Semigroup Ordering

Eq_ Ordering

type Rep Ordering = D1 D1Ordering ((:+:) (C1 C1_0Ordering U1) ((:+:) (C1 C1_1Ordering U1) (C1 C1_2Ordering U1)))

type Logic Ordering = Bool

data Mutable m Ordering = Mutable_ConT_GHC_Types_Ordering (PrimRef m Ordering)

type (==) Ordering a b = EqOrdering a b

min :: Ord_ a => a -> a -> a

max :: Ord_ a => a -> a -> a

maximum :: (ValidLogic b, Bounded b) => [b] -> b

maximum_ :: (ValidLogic b, Ord_ b) => b -> [b] -> b

minimum :: (ValidLogic b, Bounded b) => [b] -> b

minimum_ :: (ValidLogic b, Ord_ b) => b -> [b] -> b

argmin :: Ord b => a -> a -> (a -> b) -> a

argmax :: Ord b => a -> a -> (a -> b) -> a

class (Graded b, Ord_ b) => Enum b where

In a WellFounded type, every element (except the 'maxBound" if it exists) has a successor element

See http://ncatlab.org/nlab/show/well-founded+relation for more info.

Methods

succ :: b -> b

toEnum :: Int -> b

Instances

Enum Bool

Enum Char

Enum Int

Enum Integer

(Enum a0, Graded a0, Ord_ a0) => Enum (WithPreludeOrd a)

(Enum t0, Graded t0, Ord_ t0) => Enum (NonNegative t)

law_Enum_succ :: Enum b => b -> b -> Bool

law_Enum_toEnum :: (Lattice b, Enum b) => b -> Bool

Boolean helpers

(||) :: Lattice_ b => b -> b -> b infixr 2

(&&) :: Lattice_ b => b -> b -> b infixr 3

true :: Bounded b => b

"true" is an lower bound because `a && true = true` for all a.

false :: MinBound_ b => b

"false" is an upper bound because `a && false = false` for all a.

and :: (Foldable bs, Elem bs ~ b, Boolean b) => bs -> b

or :: (Foldable bs, Elem bs ~ b, Boolean b) => bs -> b

Set-like

type family Elem s

Instances

type Elem Double = Double

type Elem Double = Double

type Elem Float = Float

type Elem Float = Float

type Elem Int = Int

type Elem Int = Int

type Elem Integer = Integer

type Elem Integer = Integer

type Elem Rational = Rational

type Elem Rational = Rational

type Elem [a] = a

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (WithPreludeOrd a0) = Elem a0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (NonNegative t0) = Elem t0

type Elem (VedicSquare n0) = Elem (Z n0)

type Elem (VedicSquare n0) = Elem (Z n0)

type Elem (VedicSquare n0) = Elem (Z n0)

type Elem (VedicSquare n0) = Elem (Z n0)

type Elem (VedicSquare n0) = Elem (Z n0)

type Elem (Ball v) = v

type Elem (Componentwise v) = Scalar v

type Elem (ZIndex a0) = Elem (Z (Order a0))

type Elem (ZIndex a0) = Elem (Z (Order a0))

type Elem (ZIndex a0) = Elem (Z (Order a0))

type Elem (ZIndex a0) = Elem (Z (Order a0))

type Elem (ZIndex a0) = Elem (Z (Order a0))

type Elem (ZIndex a0) = Elem (Z (Order a0))

type Elem (ZIndex a0) = Elem (Z (Order a0))

type Elem (BArray e) = e

type Elem (UArray e) = e

type Elem (Box v) = v

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Jaccard a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Hamming a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Levenshtein a0) = Elem a0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Uncompensated s0) = Elem s0

type Elem (Lexical a0) = Elem a0

type Elem (Lexical a0) = Elem a0

type Elem (Lexical a0) = Elem a0

type Elem (Lexical a0) = Elem a0

type Elem (Lexical a0) = Elem a0

type Elem (Lexical a0) = Elem a0

type Elem (Lexical a0) = Elem a0

type Elem (Lexical a0) = Elem a0

type Elem (Lexical a0) = Elem a0

type Elem (Lexical a0) = Elem a0

type Elem (ComponentWise a0) = Elem a0

type Elem (ComponentWise a0) = Elem a0

type Elem (ComponentWise a0) = Elem a0

type Elem (ComponentWise a0) = Elem a0

type Elem (ComponentWise a0) = Elem a0

type Elem (ComponentWise a0) = Elem a0

type Elem (ComponentWise a0) = Elem a0

type Elem (ComponentWise a0) = Elem a0

type Elem (ComponentWise a0) = Elem a0

type Elem (ComponentWise a0) = Elem a0

type Elem (Goedel_ r0) = Elem r0

type Elem (Goedel_ r0) = Elem r0

type Elem (Goedel_ r0) = Elem r0

type Elem (Goedel_ r0) = Elem r0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Boolean2Ring b0) = Elem b0

type Elem (Seq a) = a

type Elem (IntMap e) = e

type Elem (IntMap' e) = e

type Elem (Set a) = a

type Elem (LexSet a) = a

type Elem (ByteString b) = b

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (PartitionOnNewline a0) = Elem a0

type Elem (Any cxt x) = x

type Elem (Labeled' x y) = Elem x

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (Galois p0 k0) = Elem (Z ((^) p0 k0))

type Elem (BloomFilter n a) = a

type Elem (Map i e) = e

type Elem (Map' i e) = e

type Elem ((/) k a0 b0) = Elem a0

type Elem ((/) k a0 b0) = Elem a0

type Elem ((/) k a0 b0) = Elem a0

type Elem ((/) k a0 b0) = Elem a0

type Elem ((/) k a0 b0) = Elem a0

type Elem ((/) k a0 b0) = Elem a0

type Elem (SVector k n r) = Scalar r

type Elem (UVector k n r) = Scalar r

type Elem (HyperLogLog * k p a) = a

type family SetElem s t

Instances

type SetElem Double a = Double

type SetElem Float a = Float

type SetElem Int a = Int

type SetElem Integer a = Integer

type SetElem Rational a = Rational

type SetElem [a] b = [b]

type SetElem (Ball v) v' = Ball v'

type SetElem (Componentwise v) v' = Componentwise v'

type SetElem (BArray e) e' = BArray e'

type SetElem (UArray e) e' = UArray e'

type SetElem (Box v) v' = Box v'

type SetElem (Seq a) b = Seq b

type SetElem (IntMap e) e' = IntMap e'

type SetElem (IntMap' e) e' = IntMap' e'

type SetElem (Set a) b = Set b

type SetElem (LexSet a) b = LexSet b

type SetElem (ByteString b) c = ByteString c

type SetElem (BloomFilter n a) b = BloomFilter n b

type SetElem (Map i e) e' = Map i e'

type SetElem (Map' i e) e' = Map' i e'

type SetElem (SVector k n r) b = SVector k n b

type SetElem (UVector k n r) b = UVector k n b

class (ValidLogic s, Constructible s, ValidSetElem s) => Container s where

This is a generalization of a "set". We do not require a container to be a boolean algebra, just a semigroup.

Minimal complete definition

elem

Methods

elem :: Elem s -> s -> Logic s

notElem :: Elem s -> s -> Logic s

Instances

ValidEq a => Container [a]

(Metric v, HasScalar v, ClassicalLogic v) => Container (Ball v)

(ValidLogic e, Eq_ e) => Container (BArray e)

Unboxable e => Container (UArray e)

(Lattice v, HasScalar v) => Container (Box v)

Eq a => Container (Seq a)

Ord a => Container (Set a)

Ord a => Container (LexSet a)

Container (ByteString Char)

KnownNat n => Container (BloomFilter n a)

law_Container_preservation :: (Heyting (Logic s), Container s) => s -> s -> Elem s -> Logic s

class Semigroup s => Constructible s where

This is the class for any type that gets "constructed" from smaller types. It is a massive generalization of the notion of a constructable set in topology.

See wikipedia for more details.

Minimal complete definition

singleton | cons | fromList1

Methods

singleton :: Elem s -> s

creates the smallest value containing the given element

cons :: Elem s -> s -> s

inserts an element on the left

snoc :: s -> Elem s -> s

inserts an element on the right; in a non-abelian Constructible, this may not insert the element; this occurs, for example, in the Map type.

fromList1 :: Elem s -> [Elem s] -> s

Construct the type from a list. Since lists may be empty (but not all Constructibles can be empty) we explicitly pass in an Elem s.

fromList1N :: Int -> Elem s -> [Elem s] -> s

Like "fromList1" but passes in the size of the list for more efficient construction.

Instances

Constructible [a]

(Metric v, HasScalar v, ClassicalLogic v) => Constructible (Ball v)

Constructible (BArray e)

Constructible (UArray Bool)

Constructible (UArray Char)

Constructible (UArray Double)

Constructible (UArray Float)

Constructible (UArray Int)

(ClassicalLogic r, Eq_ r, Unbox r, Prim r, FreeModule r, IsScalar r, Prim y, Unbox y) => Constructible (UArray (Labeled' (UVector Symbol s r) y))

(ClassicalLogic r, Eq_ r, Unbox r, Prim r, FreeModule r, IsScalar r) => Constructible (UArray (UVector Symbol s r))

(Lattice v, HasScalar v) => Constructible (Box v)

(Constructible a0, Semigroup a0) => Constructible (Jaccard a)

(Constructible a0, Semigroup a0) => Constructible (Hamming a)

(Constructible a0, Semigroup a0) => Constructible (Levenshtein a)

(Constructible s0, Semigroup s0) => Constructible (Uncompensated s)

(Constructible a0, Semigroup a0) => Constructible (Lexical a)

(Constructible a0, Semigroup a0) => Constructible (ComponentWise a)

Constructible (Seq a)

Ord a => Constructible (Set a)

Ord a => Constructible (LexSet a)

Constructible (ByteString Char)

(Constructible a0, Semigroup a0) => Constructible (PartitionOnNewline a)

Constructible (Any Foldable x)

KnownNat n => Constructible (BloomFilter n a)

(ReifiesConfig k p, Serial a) => Constructible (HyperLogLog * k p a)

type Constructible0 x = (Monoid x, Constructible x)

law_Constructible_singleton :: Container s => s -> Elem s -> Logic s

defn_Constructible_cons :: (Eq_ s, Constructible s) => s -> Elem s -> Logic s

defn_Constructible_snoc :: (Eq_ s, Constructible s) => s -> Elem s -> Logic s

defn_Constructible_fromList :: (Eq_ s, Constructible s) => s -> Elem s -> [Elem s] -> Logic s

defn_Constructible_fromListN :: (Eq_ s, Constructible s) => s -> Elem s -> [Elem s] -> Logic s

theorem_Constructible_cons :: Container s => s -> Elem s -> Logic s

fromString :: (Monoid s, Constructible s, Elem s ~ Char) => String -> s

This function needed for the OverloadedStrings language extension

fromList :: (Monoid s, Constructible s) => [Elem s] -> s

FIXME: if -XOverloadedLists is enabled, this causes an infinite loop for some reason

fromListN :: (Monoid s, Constructible s) => Int -> [Elem s] -> s

generate :: (Monoid v, Constructible v) => Int -> (Int -> Elem v) -> v

insert :: Constructible s => Elem s -> s -> s

A more suggestive name for inserting an element into a container that does not remember location

empty :: (Monoid s, Constructible s) => s

A slightly more suggestive name for a container's monoid identity

isEmpty :: (ValidEq s, Monoid s, Constructible s) => s -> Logic s

A slightly more suggestive name for checking if a container is empty

class (Constructible s, Monoid s, Normed s, Scalar s ~ Int) => Foldable s where

Provides inverse operations for Constructible.

FIXME: should this class be broken up into smaller pieces?

Minimal complete definition

foldMap | foldr

Methods

toList :: Foldable s => s -> [Elem s]

Convert the container into a list.

uncons :: s -> Maybe (Elem s, s)

Remove an element from the left of the container.

unsnoc :: s -> Maybe (s, Elem s)

Remove an element from the right of the container.

sum :: Monoid (Elem s) => s -> Elem s

Add all the elements of the container together.

foldMap :: Monoid a => (Elem s -> a) -> s -> a

the default summation uses kahan summation sum :: (Abelian (Elem s), Group (Elem s)) => s -> Elem s sum = snd . foldl' go (zero,zero) where go (c,t) i = ((t'-t)-y,t') where y = i-c t' = t+y

foldr :: (Elem s -> a -> a) -> a -> s -> a

foldr' :: (Elem s -> a -> a) -> a -> s -> a

foldl :: (a -> Elem s -> a) -> a -> s -> a

foldl' :: (a -> Elem s -> a) -> a -> s -> a

foldr1 :: (Elem s -> Elem s -> Elem s) -> s -> Elem s

foldr1' :: (Elem s -> Elem s -> Elem s) -> s -> Elem s

foldl1 :: (Elem s -> Elem s -> Elem s) -> s -> Elem s

foldl1' :: (Elem s -> Elem s -> Elem s) -> s -> Elem s

Instances

Foldable [a]

Foldable (BArray e)

Unboxable e => Foldable (UArray e)

(Foldable a0, Constructible a0, Monoid a0, Normed a0, (~) * (Scalar a0) Int) => Foldable (Jaccard a)

(Foldable a0, Constructible a0, Monoid a0, Normed a0, (~) * (Scalar a0) Int) => Foldable (Hamming a)

(Foldable a0, Constructible a0, Monoid a0, Normed a0, (~) * (Scalar a0) Int) => Foldable (Levenshtein a)

Foldable s => Foldable (Uncompensated s)

(Foldable a0, Constructible a0, Monoid a0, Normed a0, (~) * (Scalar a0) Int) => Foldable (Lexical a)

(Foldable a0, Constructible a0, Monoid a0, Normed a0, (~) * (Scalar a0) Int) => Foldable (ComponentWise a)

ValidEq a => Foldable (Seq a)

Ord a => Foldable (Set a)

Ord a => Foldable (LexSet a)

Foldable (ByteString Char)

(Foldable a0, Constructible a0, Monoid a0, Normed a0, (~) * (Scalar a0) Int) => Foldable (PartitionOnNewline a)

Show x => Show (Any Foldable x)

Foldable (Any Foldable x)

Constructible (Any Foldable x)

Normed (Any Foldable x)

Monoid (Any Foldable x)

Semigroup (Any Foldable x)

law_Foldable_sum :: (Logic (Scalar s) ~ Logic s, Logic (Elem s) ~ Logic s, Heyting (Logic s), Monoid (Elem s), Eq_ (Elem s), Foldable s) => s -> s -> Logic s

FIXME: This law can't be automatically included in the current test system because it breaks parametricity by requiring Monoid (Elem s)

theorem_Foldable_tofrom :: (Eq_ s, Foldable s) => s -> Logic s

Note: The inverse "theorem" of (toList . fromList) xs == xs is actually not true. See the Set type for a counter example.

defn_Foldable_foldr :: (Eq_ a, a ~ Elem s, Logic a ~ Logic (Elem s), Logic (Scalar s) ~ Logic (Elem s), Boolean (Logic (Elem s)), Foldable s) => (Elem s -> Elem s -> Elem s) -> Elem s -> s -> Logic (Elem s)

defn_Foldable_foldr' :: (Eq_ a, a ~ Elem s, Logic a ~ Logic (Elem s), Logic (Scalar s) ~ Logic (Elem s), Boolean (Logic (Elem s)), Foldable s) => (Elem s -> Elem s -> Elem s) -> Elem s -> s -> Logic (Elem s)

defn_Foldable_foldl :: (Eq_ a, a ~ Elem s, Logic a ~ Logic (Elem s), Logic (Scalar s) ~ Logic (Elem s), Boolean (Logic (Elem s)), Foldable s) => (Elem s -> Elem s -> Elem s) -> Elem s -> s -> Logic (Elem s)

defn_Foldable_foldl' :: (Eq_ a, a ~ Elem s, Logic a ~ Logic (Elem s), Logic (Scalar s) ~ Logic (Elem s), Boolean (Logic (Elem s)), Foldable s) => (Elem s -> Elem s -> Elem s) -> Elem s -> s -> Logic (Elem s)

defn_Foldable_foldr1 :: (Eq_ (Elem s), Logic (Scalar s) ~ Logic (Elem s), Boolean (Logic (Elem s)), Foldable s) => (Elem s -> Elem s -> Elem s) -> s -> Logic (Elem s)

defn_Foldable_foldr1' :: (Eq_ (Elem s), Logic (Scalar s) ~ Logic (Elem s), Boolean (Logic (Elem s)), Foldable s) => (Elem s -> Elem s -> Elem s) -> s -> Logic (Elem s)

defn_Foldable_foldl1 :: (Eq_ (Elem s), Logic (Scalar s) ~ Logic (Elem s), Boolean (Logic (Elem s)), Foldable s) => (Elem s -> Elem s -> Elem s) -> s -> Logic (Elem s)

defn_Foldable_foldl1' :: (Eq_ (Elem s), Logic (Scalar s) ~ Logic (Elem s), Boolean (Logic (Elem s)), Foldable s) => (Elem s -> Elem s -> Elem s) -> s -> Logic (Elem s)

foldtree1 :: Monoid a => [a] -> a

This fold is not in any of the standard libraries.

length :: Normed s => s -> Scalar s

For anything foldable, the norm must be compatible with the folding structure.

reduce :: (Monoid (Elem s), Foldable s) => s -> Elem s

concat :: (Monoid (Elem s), Foldable s) => s -> Elem s

headMaybe :: Foldable s => s -> Maybe (Elem s)

tailMaybe :: Foldable s => s -> Maybe s

lastMaybe :: Foldable s => s -> Maybe (Elem s)

initMaybe :: Foldable s => s -> Maybe s

indexed containers

type family Index s

Instances

type Index Double = Int

type Index Double = Int

type Index Float = Int

type Index Float = Int

type Index Int = Int

type Index Int = Int

type Index Integer = Int

type Index Integer = Int

type Index Rational = Int

type Index Rational = Int

type Index [a] = Int

type Index (BArray e) = Int

type Index (UArray e) = Int

type Index (IntMap e) = Key

type Index (IntMap' e) = Key

type Index (Map i e) = i

type Index (Map' i e) = i

type Index (SVector k n r) = Int

type Index (UVector k n r) = Int

type family SetIndex s a

Instances

type SetIndex Double a = Int

type SetIndex Float a = Int

type SetIndex Int a = Int

type SetIndex Integer a = Int

type SetIndex Rational a = Int

type SetIndex (Map i e) i' = Map i' e

type SetIndex (Map' i e) i' = Map' i' e

class (ValidLogic s, Monoid s, ValidSetElem s) => IxContainer s where

An indexed constructible container associates an Index with each Elem. This class generalizes the map abstract data type.

There are two differences in the indexed hierarchy of containers from the standard hierarchy. 1. IxConstructible requires a Monoid constraint whereas Constructible requires a Semigroup constraint because there are no valid IxConstructibles (that I know of at least) that are not also Monoids. 2. Many regular containers are indexed containers, but not the other way around. So the class hierarchy is in a different order.

Minimal complete definition

lookup, imap, toIxList

Associated Types

type ValidElem s e :: Constraint

FIXME: should the functions below be moved to other classes?

Methods

lookup :: Index s -> s -> Maybe (Elem s)

(!) :: s -> Index s -> Elem s

findWithDefault :: Elem s -> Index s -> s -> Elem s

hasIndex :: s -> Index s -> Logic s

imap :: (ValidElem s (Elem s), ValidElem s b) => (Index s -> Elem s -> b) -> s -> SetElem s b

toIxList :: s -> [(Index s, Elem s)]

indices :: s -> [Index s]

values :: s -> [Elem s]

Instances

IxContainer Double

IxContainer Float

IxContainer Int

IxContainer Integer

IxContainer Rational

ValidLogic a => IxContainer [a]

ValidLogic e => IxContainer (BArray e)

Unboxable e => IxContainer (UArray e)

Eq e => IxContainer (IntMap e)

Eq e => IxContainer (IntMap' e)

(Ord i, Eq e) => IxContainer (Map i e)

(Ord i, Eq e) => IxContainer (Map' i e)

(KnownNat n, Monoid r, ValidLogic r, ValidSVector Nat n r, IsScalar r, FreeModule r) => IxContainer (SVector Nat n r)

(Monoid r, ValidLogic r, ValidSVector Symbol n r, IsScalar r, FreeModule r) => IxContainer (SVector Symbol n r)

(Monoid r, ValidLogic r, Prim r, IsScalar r) => IxContainer (UVector Symbol n r)

law_IxContainer_preservation :: (Logic (Elem s) ~ Logic s, ValidLogic s, Eq_ (Elem s), IxContainer s) => s -> s -> Index s -> Logic s

defn_IxContainer_bang :: (Eq_ (Elem s), ValidLogic (Elem s), IxContainer s) => s -> Index s -> Logic (Elem s)

defn_IxContainer_findWithDefault :: (Eq_ (Elem s), IxContainer s) => s -> Index s -> Elem s -> Logic (Elem s)

defn_IxContainer_hasIndex :: (Eq_ (Elem s), IxContainer s) => s -> Index s -> Logic s

(!?) :: IxContainer s => s -> Index s -> Maybe (Elem s)

An infix operator equivalent to lookup

class (IxContainer s, Enum (Index s)) => Sliceable s where

Sliceable containers generalize the notion of a substring to any IxContainer.

Methods

slice :: Index s -> Int -> s -> s

Instances

ValidLogic e => Sliceable (BArray e)

Unboxable e => Sliceable (UArray e)

class IxContainer s => IxConstructible s where

Some containers that use indices are not typically constructed with those indices (e.g. Arrays).

Minimal complete definition

singletonAt | consAt

Methods

singletonAt :: Index s -> Elem s -> s

Construct a container with only the single (index,element) pair. This function is equivalent to singleton in the Constructible class.

consAt :: Index s -> Elem s -> s -> s

Insert an element, overwriting the previous value if the index already exists. This function is equivalent to cons in the Constructible class.

snocAt :: s -> Index s -> Elem s -> s

Insert an element only if the index does not already exist. If the index already exists, the container is unmodified. This function is equivalent to snoc in the Constructible class.

fromIxList :: [(Index s, Elem s)] -> s

This function is the equivalent of fromList in the Constructible class. We do not require all the variants of fromList because of our Monoid constraint.

Instances

Eq e => IxConstructible (IntMap e)

Eq e => IxConstructible (IntMap' e)

(Ord i, Eq e) => IxConstructible (Map i e)

(Ord i, Eq e) => IxConstructible (Map' i e)

law_IxConstructible_lookup :: (ValidLogic (Elem s), Eq_ (Elem s), IxConstructible s) => s -> Index s -> Elem s -> Logic (Elem s)

defn_IxConstructible_consAt :: (Eq_ s, IxConstructible s) => s -> Index s -> Elem s -> Logic s

defn_IxConstructible_snocAt :: (Eq_ s, IxConstructible s) => s -> Index s -> Elem s -> Logic s

defn_IxConstructible_fromIxList :: (Eq_ s, IxConstructible s) => s -> [(Index s, Elem s)] -> Logic s

insertAt :: IxConstructible s => Index s -> Elem s -> s -> s

Types

class CanError a where

Minimal complete definition

errorVal, isError

Methods

errorVal :: a

isError :: a -> Bool

isJust :: a -> Bool

Instances

CanError Double

CanError Float

CanError [a]

CanError (Maybe a)

CanError (Maybe' a)

data Maybe' a

Constructors

Nothing'

Just'

Fields

fromJust' :: !a

Instances

NFData a => NFData (Maybe' a)

IsMutable (Maybe' a)

CanError (Maybe' a)

Semigroup a => Monoid (Maybe' a)

Semigroup a => Semigroup (Maybe' a)

ValidEq a => Eq_ (Maybe' a)

data Mutable m (Maybe' a0) = Mutable_AppT__ConT_SubHask_Algebra_Maybe'___VarT_a_1627508936_ (PrimRef m (Maybe' a))

type Scalar (Maybe' a) = Scalar a

type Logic (Maybe' a) = Logic a

justs' :: [Maybe' a] -> [a]

data Labeled' x y

Constructors

Labeled'

Fields

xLabeled' :: !x

yLabeled' :: !y

Instances

(ClassicalLogic r, Eq_ r, Unbox r, Prim r, FreeModule r, IsScalar r, Prim y, Unbox y) => Constructible (UArray (Labeled' (UVector Symbol s r) y))

(Read x, Read y) => Read (Labeled' x y)

(Show x, Show y) => Show (Labeled' x y)

(Arbitrary x, Arbitrary y) => Arbitrary (Labeled' x y)

(CoArbitrary x, CoArbitrary y) => CoArbitrary (Labeled' x y)

(NFData x, NFData y) => NFData (Labeled' x y)

IsMutable (Labeled' a b)

Metric x => Metric (Labeled' x y)

Normed x => Normed (Labeled' x y)

Semigroup x => Action (Labeled' x y)

(ClassicalLogic x, Ord_ x) => Ord_ (Labeled' x y)

(ClassicalLogic x, Ord_ x) => Lattice_ (Labeled' x y)

(ClassicalLogic x, Ord_ x) => POrd_ (Labeled' x y)

Eq_ x => Eq_ (Labeled' x y)

data MVector s (Labeled' (UVector Symbol n elem) y) = UArray_Labeled'_MUVector !(MutableByteArray s) !Int !Int !Int

data Mutable m (Labeled' a0 b0) = Mutable_AppT__AppT__ConT_SubHask_Algebra_Labeled'___VarT_a_1627509060____VarT_b_1627509061_ (PrimRef m (Labeled' a b))

data Vector (Labeled' (UVector Symbol n elem) y) = UArray_Labeled'_UVector !ByteArray !Int !Int !Int

type Elem (Labeled' x y) = Elem x

type Scalar (Labeled' x y) = Scalar x

type Actor (Labeled' x y) = x

type Logic (Labeled' x y) = Logic x

Number-like

Classes with one operator

class IsMutable g => Semigroup g where

Minimal complete definition

(+) | (+=)

Methods

(+) :: g -> g -> g infixl 6

(+=) :: PrimBase m => Mutable m g -> g -> m () infixr 5

Instances

Semigroup Double

Semigroup Float

Semigroup Int

Semigroup Integer

Semigroup Ordering

Semigroup Rational

Semigroup ()

Semigroup POrdering

FIXME: there are many semigroups over POrdering; how should we represent the others? newtypes?

Semigroup [a]

Semigroup a => Semigroup (Maybe a)

Semigroup a => Semigroup (Maybe' a)

(Semigroup a0, IsMutable a0) => Semigroup (WithPreludeOrd a)

(Semigroup t0, IsMutable t0) => Semigroup (NonNegative t)

KnownNat n => Semigroup (VedicSquare n)

(Metric v, HasScalar v, ClassicalLogic v) => Semigroup (Ball v)

Semigroup v => Semigroup (Componentwise v)

Semigroup (BArray e)

Unboxable e => Semigroup (UArray e)

Semigroup a => Semigroup (Forward a)

(Lattice v, HasScalar v) => Semigroup (Box v)

(Semigroup a0, IsMutable a0) => Semigroup (Jaccard a)

(Semigroup a0, IsMutable a0) => Semigroup (Hamming a)

(Semigroup a0, IsMutable a0) => Semigroup (Levenshtein a)

(Semigroup s0, IsMutable s0) => Semigroup (Uncompensated s)

(Semigroup a0, IsMutable a0) => Semigroup (Lexical a)

(Semigroup a0, IsMutable a0) => Semigroup (ComponentWise a)

(IsMutable b, Boolean b, ValidLogic b) => Semigroup (Boolean2Ring b)

Semigroup (Seq a)

Semigroup (IntMap e)

Semigroup (IntMap' e)

Ord a => Semigroup (Set a)

Semigroup (LexSet a)

Semigroup (ByteString Char)

(Semigroup a0, IsMutable a0) => Semigroup (PartitionOnNewline a)

Semigroup b => Semigroup (a -> b)

(Semigroup a, Semigroup b) => Semigroup (a, b)

Semigroup (Any Foldable x)

(Semigroup (Z ((^) p0 k0)), IsMutable (Z ((^) p0 k0))) => Semigroup (Galois p k)

Ring r => Semigroup (Polynomial_ r r)

Semigroup ((+>) a b)

KnownNat n => Semigroup (BloomFilter n a)

Ord i => Semigroup (Map i e)

Ord i => Semigroup (Map' i e)

(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)

Ring a => Semigroup (ProofOf * Polynomial_ a)

Semigroup (ProofOf_ cat a) => Semigroup (ProofOf * (IncreasingT cat) a)

(Semigroup a, Quotient k a b) => Semigroup ((/) k a b)

Semigroup (cat a b) => Semigroup (IncreasingT cat a b)

(KnownNat n, Semigroup r, ValidSVector Nat n r) => Semigroup (SVector Nat n r)

(Monoid r, ValidSVector Symbol n r) => Semigroup (SVector Symbol n r)

(Monoid r, Prim r) => Semigroup (UVector Symbol n r)

Semigroup b => Semigroup (Diff 0 a b)

(Semigroup b, Semigroup ((><) * * a b)) => Semigroup (Diff 1 a b)

(Semigroup b, Semigroup ((><) * * a b), Semigroup ((><) * * a ((><) * * a b))) => Semigroup (Diff 2 a b)

Semigroup (HyperLogLog k k p a)

law_Semigroup_associativity :: (Eq g, Semigroup g) => g -> g -> g -> Logic g

defn_Semigroup_plusequal :: (Eq_ g, Semigroup g, IsMutable g) => g -> g -> Logic g

type family Actor s

This type class is only used by the Action class. It represents the semigroup that acts on our type.

Instances

type Actor Double = Double

type Actor Float = Float

type Actor Int = Int

type Actor Integer = Integer

type Actor Rational = Rational

type Actor () = ()

type Actor (WithPreludeOrd a0) = Actor a0

FIXME: for some reason, our deriving mechanism doesn't work on Show here; It causes's Set's show to enter an infinite loop

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (WithPreludeOrd a0) = Actor a0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (NonNegative t0) = Actor t0

type Actor (VedicSquare n0) = Actor (Z n0)

type Actor (VedicSquare n0) = Actor (Z n0)

type Actor (VedicSquare n0) = Actor (Z n0)

type Actor (VedicSquare n0) = Actor (Z n0)

type Actor (VedicSquare n0) = Actor (Z n0)

type Actor (ZIndex a0) = Actor (Z (Order a0))

type Actor (ZIndex a0) = Actor (Z (Order a0))

type Actor (ZIndex a0) = Actor (Z (Order a0))

type Actor (ZIndex a0) = Actor (Z (Order a0))

type Actor (ZIndex a0) = Actor (Z (Order a0))

type Actor (ZIndex a0) = Actor (Z (Order a0))

type Actor (ZIndex a0) = Actor (Z (Order a0))

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Jaccard a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Hamming a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Levenshtein a0) = Actor a0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Uncompensated s0) = Actor s0

type Actor (Lexical a0) = Actor a0

type Actor (Lexical a0) = Actor a0

type Actor (Lexical a0) = Actor a0

type Actor (Lexical a0) = Actor a0

type Actor (Lexical a0) = Actor a0

type Actor (Lexical a0) = Actor a0

type Actor (Lexical a0) = Actor a0

type Actor (Lexical a0) = Actor a0

type Actor (Lexical a0) = Actor a0

type Actor (Lexical a0) = Actor a0

type Actor (ComponentWise a0) = Actor a0

type Actor (ComponentWise a0) = Actor a0

type Actor (ComponentWise a0) = Actor a0

type Actor (ComponentWise a0) = Actor a0

type Actor (ComponentWise a0) = Actor a0

type Actor (ComponentWise a0) = Actor a0

type Actor (ComponentWise a0) = Actor a0

type Actor (ComponentWise a0) = Actor a0

type Actor (ComponentWise a0) = Actor a0

type Actor (ComponentWise a0) = Actor a0

type Actor (Goedel_ r0) = Actor r0

type Actor (Goedel_ r0) = Actor r0

type Actor (Goedel_ r0) = Actor r0

type Actor (Goedel_ r0) = Actor r0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (Boolean2Ring b0) = Actor b0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (PartitionOnNewline a0) = Actor a0

type Actor (a -> b) = a -> Actor b

type Actor (Labeled' x y) = x

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor (Galois p0 k0) = Actor (Z ((^) p0 k0))

type Actor ((/) k a0 b0) = Actor a0

type Actor ((/) k a0 b0) = Actor a0

type Actor ((/) k a0 b0) = Actor a0

type Actor ((/) k a0 b0) = Actor a0

type Actor ((/) k a0 b0) = Actor a0

type Actor ((/) k a0 b0) = Actor a0

class (IsMutable s, Semigroup (Actor s)) => Action s where

Semigroup actions let us apply a semigroup to a set. The theory of Modules is essentially the theory of Ring actions. (See <http://mathoverflow.net/questions/100565/why-are-ring-actions-much-harder-to-find-than-group-actions mathoverflow.) That is why the two classes use similar notation.

See wikipedia for more detail.

FIXME: These types could probably use a more expressive name.

FIXME: We would like every Semigroup to act on itself, but this results in a class cycle.

Minimal complete definition

(.+) | (.+=)

Methods

(.+) :: s -> Actor s -> s infixl 6

(.+=) :: PrimBase m => Mutable m s -> Actor s -> m () infixr 5

Instances

Action Double

Action Float

Action Int

Action Integer

Action Rational

Action ()

Action b => Action (a -> b)

Semigroup x => Action (Labeled' x y)

law_Action_compatibility :: (Eq_ s, Action s) => Actor s -> Actor s -> s -> Logic s

defn_Action_dotplusequal :: (Eq_ s, Action s, Logic (Actor s) ~ Logic s) => s -> Actor s -> Logic s

(+.) :: Action s => Actor s -> s -> s infixr 6

s .+ a = a +. s

class Semigroup g => Cancellative g where

In a cancellative semigroup,

1)

a + b = a + c   ==>   b = c

so > (a + b) - b = a + (b - b) = a

2)

b + a = c + a   ==>   b = c

so > -b + (b + a) = (-b + b) + a = a

This allows us to define "subtraction" in the semigroup. If the semigroup is embeddable in a group, subtraction can be thought of as performing the group subtraction and projecting the result back into the domain of the cancellative semigroup. It is an open problem to fully characterize which cancellative semigroups can be embedded into groups.

See wikipedia for more details.

Minimal complete definition

(-) | (-=)

Methods

(-) :: g -> g -> g infixl 6

(-=) :: PrimBase m => Mutable m g -> g -> m () infixr 5

Instances

Cancellative Double

Cancellative Float

Cancellative Int

Cancellative Integer

Cancellative Rational

Cancellative ()

(Cancellative a0, Semigroup a0) => Cancellative (WithPreludeOrd a)

(Ord t, Group t) => Cancellative (NonNegative t)

Cancellative v => Cancellative (Componentwise v)

Cancellative a => Cancellative (Forward a)

(Cancellative a0, Semigroup a0) => Cancellative (Jaccard a)

(Cancellative a0, Semigroup a0) => Cancellative (Hamming a)

(Cancellative a0, Semigroup a0) => Cancellative (Levenshtein a)

(IsMutable b, Boolean b, ValidLogic b) => Cancellative (Boolean2Ring b)

Cancellative b => Cancellative (a -> b)

(Cancellative a, Cancellative b) => Cancellative (a, b)

(Cancellative (Z ((^) p0 k0)), Semigroup (Z ((^) p0 k0))) => Cancellative (Galois p k)

(ValidLogic r, Ring r) => Cancellative (Polynomial_ r r)

(VectorSpace a, VectorSpace b) => Cancellative ((+>) a b)

(Cancellative a, Cancellative b, Cancellative c) => Cancellative (a, b, c)

(ValidLogic a, Ring a) => Cancellative (ProofOf * Polynomial_ a)

(Cancellative a, Quotient k a b) => Cancellative ((/) k a b)

(KnownNat n, Cancellative r, ValidSVector Nat n r) => Cancellative (SVector Nat n r)

(Monoid r, Cancellative r, ValidSVector Symbol n r) => Cancellative (SVector Symbol n r)

(Monoid r, Cancellative r, Prim r) => Cancellative (UVector Symbol n r)

law_Cancellative_rightminus1 :: (Eq g, Cancellative g) => g -> g -> Bool

law_Cancellative_rightminus2 :: (Eq g, Cancellative g) => g -> g -> Bool

defn_Cancellative_plusequal :: (Eq_ g, Cancellative g) => g -> g -> Logic g

class Semigroup g => Monoid g where

Methods

zero :: g

Instances

Monoid Double

Monoid Float

Monoid Int

Monoid Integer

Monoid Ordering

Monoid Rational

Monoid ()

Monoid POrdering

Monoid [a]

Semigroup a => Monoid (Maybe a)

Semigroup a => Monoid (Maybe' a)

(Monoid a0, Semigroup a0) => Monoid (WithPreludeOrd a)

(Monoid t0, Semigroup t0) => Monoid (NonNegative t)

KnownNat n => Monoid (VedicSquare n)

Monoid v => Monoid (Componentwise v)

Monoid (BArray e)

Unboxable e => Monoid (UArray e)

Monoid a => Monoid (Forward a)

(Monoid a0, Semigroup a0) => Monoid (Jaccard a)

(Monoid a0, Semigroup a0) => Monoid (Hamming a)

(Monoid a0, Semigroup a0) => Monoid (Levenshtein a)

(Monoid s0, Semigroup s0) => Monoid (Uncompensated s)

(Monoid a0, Semigroup a0) => Monoid (Lexical a)

(Monoid a0, Semigroup a0) => Monoid (ComponentWise a)

(IsMutable b, Boolean b, ValidLogic b) => Monoid (Boolean2Ring b)

Monoid (Seq a)

Monoid (IntMap e)

Monoid (IntMap' e)

Ord a => Monoid (Set a)

Ord a => Monoid (LexSet a)

Monoid (ByteString Char)

(Monoid a0, Semigroup a0) => Monoid (PartitionOnNewline a)

Monoid b => Monoid (a -> b)

(Monoid a, Monoid b) => Monoid (a, b)

Monoid (Any Foldable x)

(Monoid (Z ((^) p0 k0)), Semigroup (Z ((^) p0 k0))) => Monoid (Galois p k)

(ValidLogic r, Ring r) => Monoid (Polynomial_ r r)

(VectorSpace a, VectorSpace b) => Monoid ((+>) a b)

KnownNat n => Monoid (BloomFilter n a)

Ord i => Monoid (Map i e)

Ord i => Monoid (Map' i e)

(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)

(ValidLogic a, Ring a) => Monoid (ProofOf * Polynomial_ a)

(Monoid a, Quotient k a b) => Monoid ((/) k a b)

(KnownNat n, Monoid r, ValidSVector Nat n r) => Monoid (SVector Nat n r)

(Monoid r, ValidSVector Symbol n r) => Monoid (SVector Symbol n r)

(Monoid r, Prim r) => Monoid (UVector Symbol n r)

Monoid b => Monoid (Diff 0 a b)

(Monoid b, Monoid ((><) * * a b)) => Monoid (Diff 1 a b)

(Monoid b, Monoid ((><) * * a b), Monoid ((><) * * a ((><) * * a b))) => Monoid (Diff 2 a b)

isZero :: (Monoid g, ValidEq g) => g -> Logic g

FIXME: this should be in the Monoid class, but putting it there requires a lot of changes to Eq

notZero :: (Monoid g, ValidEq g) => g -> Logic g

FIXME: this should be in the Monoid class, but putting it there requires a lot of changes to Eq

law_Monoid_leftid :: (Monoid g, Eq g) => g -> Bool

law_Monoid_rightid :: (Monoid g, Eq g) => g -> Bool

defn_Monoid_isZero :: (Monoid g, Eq g) => g -> Bool

class Semigroup m => Abelian m

Instances

Abelian Double

Abelian Float

Abelian Int

Abelian Integer

Abelian Rational

Abelian ()

(Abelian a0, Semigroup a0) => Abelian (WithPreludeOrd a)

(Abelian t0, Semigroup t0) => Abelian (NonNegative t)

Abelian v => Abelian (Componentwise v)

Abelian a => Abelian (Forward a)

(Abelian a0, Semigroup a0) => Abelian (Jaccard a)

(Abelian a0, Semigroup a0) => Abelian (Hamming a)

(Abelian a0, Semigroup a0) => Abelian (Levenshtein a)

(IsMutable b, Boolean b, ValidLogic b) => Abelian (Boolean2Ring b)

Ord a => Abelian (Set a)

Abelian b => Abelian (a -> b)

(Abelian a, Abelian b) => Abelian (a, b)

(Abelian (Z ((^) p0 k0)), Semigroup (Z ((^) p0 k0))) => Abelian (Galois p k)

(Ring r, Abelian r) => Abelian (Polynomial_ r r)

Abelian ((+>) a b)

(Abelian a, Abelian b, Abelian c) => Abelian (a, b, c)

(Ring a, Abelian a) => Abelian (ProofOf * Polynomial_ a)

Abelian (ProofOf_ cat a) => Abelian (ProofOf * (IncreasingT cat) a)

(Abelian a, Quotient k a b) => Abelian ((/) k a b)

Abelian (cat a b) => Abelian (IncreasingT cat a b)

(KnownNat n, Abelian r, ValidSVector Nat n r) => Abelian (SVector Nat n r)

(Monoid r, Abelian r, ValidSVector Symbol n r) => Abelian (SVector Symbol n r)

(Monoid r, Abelian r, Prim r) => Abelian (UVector Symbol n r)

Abelian (HyperLogLog k k p a)

law_Abelian_commutative :: (Abelian g, Eq g) => g -> g -> Bool

class (Cancellative g, Monoid g) => Group g where

Minimal complete definition

Nothing

Methods

negate :: g -> g

Instances

Group Double

Group Float

Group Int

Group Integer

Group Rational

Group ()

(Group a0, Cancellative a0, Monoid a0) => Group (WithPreludeOrd a)

Group v => Group (Componentwise v)

Group a => Group (Forward a)

(Group a0, Cancellative a0, Monoid a0) => Group (Jaccard a)

(Group a0, Cancellative a0, Monoid a0) => Group (Hamming a)

(Group a0, Cancellative a0, Monoid a0) => Group (Levenshtein a)

(IsMutable b, Boolean b, ValidLogic b) => Group (Boolean2Ring b)

Group b => Group (a -> b)

(Group a, Group b) => Group (a, b)

(Group (Z ((^) p0 k0)), Cancellative (Z ((^) p0 k0)), Monoid (Z ((^) p0 k0))) => Group (Galois p k)

(ValidLogic r, Ring r) => Group (Polynomial_ r r)

(VectorSpace a, VectorSpace b) => Group ((+>) a b)

(Group a, Group b, Group c) => Group (a, b, c)

(ValidLogic a, Ring a) => Group (ProofOf * Polynomial_ a)

(Group a, Quotient k a b) => Group ((/) k a b)

(KnownNat n, Group r, ValidSVector Nat n r) => Group (SVector Nat n r)

(Group r, ValidSVector Symbol n r) => Group (SVector Symbol n r)

(Group r, Prim r) => Group (UVector Symbol n r)

law_Group_leftinverse :: (Eq g, Group g) => g -> Bool

law_Group_rightinverse :: (Eq g, Group g) => g -> Bool

defn_Group_negateminus :: (Eq g, Group g) => g -> g -> Bool

Classes with two operators

class (Abelian r, Monoid r) => Rg r where

A Rg is a Ring without multiplicative identity or negative numbers. (Hence the removal of the i and n from the name.)

There is no standard terminology for this structure. They might also be called "semirings without identity", "pre-semirings", or "hemirings". See this stackexchange question for a discussion on naming.

Minimal complete definition

(*) | (*=)

Methods

(*) :: r -> r -> r infixl 7

(*=) :: PrimBase m => Mutable m r -> r -> m () infixr 5

Instances

Rg Double

Rg Float

Rg Int

Rg Integer

Rg Rational

(Rg a0, Abelian a0, Monoid a0) => Rg (WithPreludeOrd a)

(Rg t0, Abelian t0, Monoid t0) => Rg (NonNegative t)

FreeModule v => Rg (Componentwise v)

Rg a => Rg (Forward a)

(Rg a0, Abelian a0, Monoid a0) => Rg (Jaccard a)

(Rg a0, Abelian a0, Monoid a0) => Rg (Hamming a)

(Rg a0, Abelian a0, Monoid a0) => Rg (Levenshtein a)

(IsMutable b, Boolean b, ValidLogic b) => Rg (Boolean2Ring b)

Rg b => Rg (a -> b)

(Rg (Z ((^) p0 k0)), Abelian (Z ((^) p0 k0)), Monoid (Z ((^) p0 k0))) => Rg (Galois p k)

(ValidLogic r, Ring r) => Rg (Polynomial_ r r)

VectorSpace a => Rg ((+>) a a)

(ValidLogic a, Ring a) => Rg (ProofOf * Polynomial_ a)

(Rg a, Quotient k a b) => Rg ((/) k a b)

law_Rg_multiplicativeAssociativity :: (Eq r, Rg r) => r -> r -> r -> Bool

law_Rg_multiplicativeCommutivity :: (Eq r, Rg r) => r -> r -> Bool

law_Rg_annihilation :: (Eq r, Rg r) => r -> Bool

law_Rg_distributivityLeft :: (Eq r, Rg r) => r -> r -> r -> Bool

theorem_Rg_distributivityRight :: (Eq r, Rg r) => r -> r -> r -> Bool

defn_Rg_timesequal :: (Eq_ g, Rg g) => g -> g -> Logic g

class (Monoid r, Rg r) => Rig r where

A Rig is a Rg with multiplicative identity. They are also known as semirings.

See wikipedia and ncatlab for more details.

Methods

one :: r

the multiplicative identity

Instances

Rig Double

Rig Float

Rig Int

Rig Integer

Rig Rational

(Rig a0, Monoid a0, Rg a0) => Rig (WithPreludeOrd a)

(Rig t0, Monoid t0, Rg t0) => Rig (NonNegative t)

FiniteModule v => Rig (Componentwise v)

Rig a => Rig (Forward a)

(Rig a0, Monoid a0, Rg a0) => Rig (Jaccard a)

(Rig a0, Monoid a0, Rg a0) => Rig (Hamming a)

(Rig a0, Monoid a0, Rg a0) => Rig (Levenshtein a)

(IsMutable b, Boolean b, ValidLogic b) => Rig (Boolean2Ring b)

Rig b => Rig (a -> b)

(Rig (Z ((^) p0 k0)), Monoid (Z ((^) p0 k0)), Rg (Z ((^) p0 k0))) => Rig (Galois p k)

(ValidLogic r, Ring r) => Rig (Polynomial_ r r)

VectorSpace a => Rig ((+>) a a)

(ValidLogic a, Ring a) => Rig (ProofOf * Polynomial_ a)

(Rig a, Quotient k a b) => Rig ((/) k a b)

isOne :: (Rig g, ValidEq g) => g -> Logic g

FIXME: this should be in the Rig class, but putting it there requires a lot of changes to Eq

notOne :: (Rig g, ValidEq g) => g -> Logic g

FIXME: this should be in the Rig class, but putting it there requires a lot of changes to Eq

law_Rig_multiplicativeId :: (Eq r, Rig r) => r -> Bool

type Rng r = (Rg r, Group r)

A Ring without identity.

defn_Ring_fromInteger :: (Eq r, Ring r) => r -> Integer -> Bool

class (Rng r, Rig r) => Ring r where

It is not part of the standard definition of rings that they have a "fromInteger" function. It follows from the definition, however, that we can construct such a function. The "slowFromInteger" function is this standard construction.

See wikipedia and ncatlab for more details.

FIXME: We can construct a Module from any ring by taking (*)=(.*.). Thus, Module should be a superclass of Ring. Currently, however, this creates a class cycle, so we can't do it. A number of type signatures are therefore more complicated than they need to be.

Minimal complete definition

Nothing

Methods

fromInteger :: Integer -> r

Instances

Ring Double

Ring Float

Ring Int

Ring Integer

Ring Rational

(Ring a0, Rng a0, Rig a0) => Ring (WithPreludeOrd a)

FiniteModule v => Ring (Componentwise v)

Ring a => Ring (Forward a)

(Ring a0, Rng a0, Rig a0) => Ring (Jaccard a)

(Ring a0, Rng a0, Rig a0) => Ring (Hamming a)

(Ring a0, Rng a0, Rig a0) => Ring (Levenshtein a)

(IsMutable b, Boolean b, ValidLogic b) => Ring (Boolean2Ring b)

Ring b => Ring (a -> b)

(Ring (Z ((^) p0 k0)), Rng (Z ((^) p0 k0)), Rig (Z ((^) p0 k0))) => Ring (Galois p k)

(ValidLogic r, Ring r) => Ring (Polynomial_ r r)

VectorSpace a => Ring ((+>) a a)

(ValidLogic a, Ring a) => Ring (ProofOf * Polynomial_ a)

(Ring a, Quotient k a b) => Ring ((/) k a b)

indicator :: Ring r => Bool -> r

class Ring a => Integral a where

Integral numbers can be formed from a wide class of things that behave like integers, but intuitively look nothing like integers.

FIXME: All Fields are integral domains; should we make it a subclass? This wouuld have the (minor?) problem of making the Integral class have to be an approximate embedding. FIXME: Not all integral domains are homomorphic to the integers (e.g. a field)

See wikipedia on integral elements, integral domains, and the ring of integers.

Minimal complete definition

toInteger, quotRem, divMod

Methods

toInteger :: a -> Integer

quot :: a -> a -> a infixl 7

truncates towards zero

rem :: a -> a -> a infixl 7

quotRem :: a -> a -> (a, a)

div :: a -> a -> a infixl 7

truncates towards negative infinity

mod :: a -> a -> a infixl 7

divMod :: a -> a -> (a, a)

Instances

Integral Int

Integral Integer

Integral b => Integral (a -> b)

law_Integral_divMod :: (Eq a, Integral a) => a -> a -> Bool

law_Integral_quotRem :: (Eq a, Integral a) => a -> a -> Bool

law_Integral_toFromInverse :: (Eq a, Integral a) => a -> Bool

roundUpToNearest :: Int -> Int -> Int

FIXME: This should be moved into the class hierarchy and generalized.

FIXME: There are more efficient implementations available if you restrict m to powers of 2. Is GHC smart enough to convert rem into bit shifts? See for more possibilities: http://stackoverflow.com/questions/3407012/c-rounding-up-to-the-nearest-multiple-of-a-number

fromIntegral :: (Integral a, Ring b) => a -> b

class Ring r => Field r where

Fields are Rings with a multiplicative inverse.

See wikipedia and ncatlab for more details.

Minimal complete definition

Nothing

Methods

reciprocal :: r -> r

(/) :: r -> r -> r infixl 7

fromRational :: Rational -> r

Instances

Field Double

Field Float

Field Rational

(FiniteModule v, VectorSpace v) => Field (Componentwise v)

Field a => Field (Forward a)

Field b => Field (a -> b)

(Prime p, KnownNat ((^) p k)) => Field (Galois p k)

VectorSpace a => Field ((+>) a a)

class (Field r, Ord r, Normed r, IsScalar r) => OrdField r

Ordered fields are generalizations of the rational numbers that maintain most of the nice properties. In particular, all finite fields and the complex numbers are NOT ordered fields.

See wikipedia for more details.

Instances

OrdField Double

OrdField Float

OrdField Rational

class Field r => RationalField r where

A Rational field is a field with only a single dimension.

FIXME: this isn't part of standard math; why is it here?

Methods

toRational :: r -> Rational

Instances

RationalField Double

RationalField Float

RationalField Rational

convertRationalField :: (RationalField a, RationalField b) => a -> b

toFloat :: RationalField a => a -> Float

FIXME: These functions don't work for Int's, but they should

toDouble :: RationalField a => a -> Double

class (OrdField r, Bounded r) => BoundedField r where

The prototypical example of a bounded field is the extended real numbers. Other examples are the extended hyperreal numbers and the extended rationals. Each of these fields has been extensively studied, but I don't know of any studies of this particular abstraction of these fields.

See wikipedia for more details.

Minimal complete definition

isNaN

Methods

nan :: r

isNaN :: r -> Bool

Instances

BoundedField Double

BoundedField Float

infinity :: BoundedField r => r

negInfinity :: BoundedField r => r

class Ring r => ExpRing r where

Rings augmented with the ability to take exponents.

Not all rings have this ability. Consider the ring of rational numbers (represented by Rational in Haskell). Raising any rational to an integral power results in another rational. But raising to a fractional power results in an irrational number. For example, the square root of 2.

See wikipedia for more detail.

FIXME: This class hierarchy doesn't give a nice way exponentiate the integers. We need to add instances for all the quotient groups.

Methods

(**) :: r -> r -> r infixl 8

logBase :: r -> r -> r

Instances

ExpRing Double

ExpRing Float

(^) :: ExpRing r => r -> r -> r

An alternate form of "(**)" that some people find more convenient.

class (ExpRing r, Field r) => ExpField r where

Fields augmented with exponents and logarithms.

Technically, there are fields for which only a subset of the functions below are meaningful. But these fields don't have any practical computational uses that I'm aware of. So I've combined them all into a single class for simplicity.

See wikipedia for more detail.

Minimal complete definition

exp, log

Methods

sqrt :: r -> r

exp :: r -> r

log :: r -> r

Instances

ExpField Double

ExpField Float

class ExpField r => Real r where

This is a catch-all class for things the real numbers can do but don't exist in other classes.

FIXME: Factor this out into a more appropriate class hierarchy. For example, some (all?) trig functions need to move to a separate class in order to support trig in finite fields (see wikipedia).

FIXME: This class is misleading/incorrect for complex numbers.

FIXME: There's a lot more functions that need adding.

Methods

gamma :: r -> r

lnGamma :: r -> r

erf :: r -> r

pi :: r

sin :: r -> r

cos :: r -> r

tan :: r -> r

asin :: r -> r

acos :: r -> r

atan :: r -> r

sinh :: r -> r

cosh :: r -> r

tanh :: r -> r

asinh :: r -> r

acosh :: r -> r

atanh :: r -> r

Instances

Real Double

Real Float

class (Ring r, Integral s) => QuotientField r s where

A QuotientField is a field with an IntegralDomain as a subring. There may be many such subrings (for example, every field has itself as an integral domain subring). This is especially true in Haskell because we have different data types that represent essentially the same ring (e.g. Int and Integer). Therefore this is a multiparameter type class. The r parameter represents the quotient field, and the s parameter represents the subring. The main purpose of this class is to provide functions that map elements in r to elements in s in various ways.

FIXME: Need examples. Is there a better representation?

See wikipedia for more details.

Methods

truncate :: r -> s

round :: r -> s

ceiling :: r -> s

floor :: r -> s

(^^) :: r -> s -> r

Instances

QuotientField Double Int

QuotientField Double Integer

QuotientField Float Int

QuotientField Float Integer

QuotientField Rational Int

QuotientField Rational Integer

QuotientField b1 b2 => QuotientField (a -> b1) (a -> b2)

Sizes

class (Ord_ (Scalar g), Scalar (Scalar g) ~ Scalar g, Ring (Scalar g)) => Normed g where

FIXME: What constraint should be here? Semigroup?

See ncatlab

Minimal complete definition

size

Methods

size :: g -> Scalar g

sizeSquared :: g -> Scalar g

Instances

Normed Double

Normed Float

Normed Int

Normed Integer

Normed Rational

Normed [a]

Normed (BArray e)

Unbox e => Normed (UArray e)

(Normed a0, Ord_ (Scalar a0), (~) * (Scalar (Scalar a0)) (Scalar a0), Ring (Scalar a0)) => Normed (Jaccard a)

(Normed a0, Ord_ (Scalar a0), (~) * (Scalar (Scalar a0)) (Scalar a0), Ring (Scalar a0)) => Normed (Hamming a)

(Normed a0, Ord_ (Scalar a0), (~) * (Scalar (Scalar a0)) (Scalar a0), Ring (Scalar a0)) => Normed (Levenshtein a)

(Normed s0, Ord_ (Scalar s0), (~) * (Scalar (Scalar s0)) (Scalar s0), Ring (Scalar s0)) => Normed (Uncompensated s)

(Normed a0, Ord_ (Scalar a0), (~) * (Scalar (Scalar a0)) (Scalar a0), Ring (Scalar a0)) => Normed (Lexical a)

(Normed a0, Ord_ (Scalar a0), (~) * (Scalar (Scalar a0)) (Scalar a0), Ring (Scalar a0)) => Normed (ComponentWise a)

Normed (Seq a)

Normed (IntMap e)

Normed (IntMap' e)

Normed (Set a)

Ord a => Normed (LexSet a)

Normed (ByteString Char)

(Normed a0, Ord_ (Scalar a0), (~) * (Scalar (Scalar a0)) (Scalar a0), Ring (Scalar a0)) => Normed (PartitionOnNewline a)

Normed (Any Foldable x)

Normed x => Normed (Labeled' x y)

MatrixField r => Normed ((+>) (SVector k m r) (SVector k n r))

KnownNat n => Normed (BloomFilter n a)

Normed (Map i e)

Normed (Map' i e)

(KnownNat n, VectorSpace r, ValidSVector Nat n r, IsScalar r, ExpField r) => Normed (SVector Nat n r)

(VectorSpace r, ValidSVector Symbol n r, IsScalar r, ExpField r) => Normed (SVector Symbol n r)

(VectorSpace r, Prim r, IsScalar r, ExpField r) => Normed (UVector Symbol n r)

ReifiesConfig k1 p => Normed (HyperLogLog k k p a)

abs :: IsScalar g => g -> g

class (HasScalar v, Eq_ v, Boolean (Logic v), Logic (Scalar v) ~ Logic v) => Metric v where

Metric spaces give us the most intuitive notion of distance between objects.

FIXME: There are many other notions of distance and we should make a whole hierarchy.

Minimal complete definition

distance

Methods

distance :: v -> v -> Scalar v

distanceUB :: v -> v -> Scalar v -> Scalar v

If the distance between two datapoints is less than or equal to the upper bound, then this function will return the distance. Otherwise, it will return some number greater than the upper bound.

Instances

Metric Double

Metric Float

Metric Int

Metric Integer

Metric Rational

(Metric a0, HasScalar a0, Eq_ a0, Boolean (Logic a0), (~) * (Logic (Scalar a0)) (Logic a0)) => Metric (WithPreludeOrd a)

(Metric t0, HasScalar t0, Eq_ t0, Boolean (Logic t0), (~) * (Logic (Scalar t0)) (Logic t0)) => Metric (NonNegative t)

(Lattice_ a, Field (Scalar a), Normed a, (~) * (Logic (Scalar a)) (Logic a), Boolean (Logic a), HasScalar a) => Metric (Jaccard a)

(Foldable a, Eq (Elem a), Eq a, ClassicalLogic (Scalar a), HasScalar a) => Metric (Hamming a)

(Foldable a, Eq (Elem a), Eq a, Show a, HasScalar a, ClassicalLogic (Scalar a), Bounded (Scalar a)) => Metric (Levenshtein a)

Metric x => Metric (Labeled' x y)

(KnownNat n, ValidSVector Nat n r, ExpField r, Normed r, Ord_ r, (~) * (Logic r) Bool, IsScalar r, VectorSpace r, ValidSVector Symbol "dyn" r) => Metric (SVector Nat n r)

(ValidSVector Symbol n r, ExpField r, Normed r, Ord_ r, (~) * (Logic r) Bool, IsScalar r, VectorSpace r) => Metric (SVector Symbol n r)

(Prim r, ExpField r, Normed r, Ord_ r, (~) * (Logic r) Bool, IsScalar r, VectorSpace r) => Metric (UVector Symbol n r)

isFartherThan :: Metric v => v -> v -> Scalar v -> Logic v

Calling this function will be faster on some Metrics than manually checking if distance is greater than the bound.

lb2distanceUB :: (Metric a, ClassicalLogic a) => (a -> a -> Scalar a) -> a -> a -> Scalar a -> Scalar a

This function constructs an efficient default implementation for distanceUB given a function that lower bounds the distance metric.

law_Metric_nonnegativity :: Metric v => v -> v -> Logic v

law_Metric_indiscernables :: (Eq v, Metric v) => v -> v -> Logic v

law_Metric_symmetry :: Metric v => v -> v -> Logic v

law_Metric_triangle :: Metric v => v -> v -> v -> Logic v

Linear algebra

type family Scalar m

Instances

type Scalar Double = Double

type Scalar Float = Float

type Scalar Int = Int

type Scalar Int64 = Int64

type Scalar Integer = Integer

type Scalar Rational = Rational

type Scalar [a] = Int

type Scalar (Maybe a) = Scalar a

type Scalar (Maybe' a) = Scalar a

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (WithPreludeOrd a0) = Scalar a0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (NonNegative t0) = Scalar t0

type Scalar (VedicSquare n0) = Scalar (Z n0)

type Scalar (VedicSquare n0) = Scalar (Z n0)

type Scalar (VedicSquare n0) = Scalar (Z n0)

type Scalar (VedicSquare n0) = Scalar (Z n0)

type Scalar (VedicSquare n0) = Scalar (Z n0)

type Scalar (Ball v) = Scalar v

type Scalar (Componentwise v) = Scalar v

type Scalar (ZIndex a0) = Scalar (Z (Order a0))

type Scalar (ZIndex a0) = Scalar (Z (Order a0))

type Scalar (ZIndex a0) = Scalar (Z (Order a0))

type Scalar (ZIndex a0) = Scalar (Z (Order a0))

type Scalar (ZIndex a0) = Scalar (Z (Order a0))

type Scalar (ZIndex a0) = Scalar (Z (Order a0))

type Scalar (ZIndex a0) = Scalar (Z (Order a0))

type Scalar (BArray e) = Int

type Scalar (UArray e) = Int

type Scalar (Box v) = Scalar v

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Jaccard a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Hamming a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Levenshtein a0) = Scalar a0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Uncompensated s0) = Scalar s0

type Scalar (Lexical a0) = Scalar a0

type Scalar (Lexical a0) = Scalar a0

type Scalar (Lexical a0) = Scalar a0

type Scalar (Lexical a0) = Scalar a0

type Scalar (Lexical a0) = Scalar a0

type Scalar (Lexical a0) = Scalar a0

type Scalar (Lexical a0) = Scalar a0

type Scalar (Lexical a0) = Scalar a0

type Scalar (Lexical a0) = Scalar a0

type Scalar (Lexical a0) = Scalar a0

type Scalar (ComponentWise a0) = Scalar a0

type Scalar (ComponentWise a0) = Scalar a0

type Scalar (ComponentWise a0) = Scalar a0

type Scalar (ComponentWise a0) = Scalar a0

type Scalar (ComponentWise a0) = Scalar a0

type Scalar (ComponentWise a0) = Scalar a0

type Scalar (ComponentWise a0) = Scalar a0

type Scalar (ComponentWise a0) = Scalar a0

type Scalar (ComponentWise a0) = Scalar a0

type Scalar (ComponentWise a0) = Scalar a0

type Scalar (Goedel_ r0) = Scalar r0

type Scalar (Goedel_ r0) = Scalar r0

type Scalar (Goedel_ r0) = Scalar r0

type Scalar (Goedel_ r0) = Scalar r0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Boolean2Ring b0) = Scalar b0

type Scalar (Seq a) = Int

type Scalar (IntMap e) = Int

type Scalar (IntMap' e) = Int

type Scalar (Set a) = Int

type Scalar (LexSet a) = Int

type Scalar (ByteString b) = Int

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (PartitionOnNewline a0) = Scalar a0

type Scalar (a -> b) = Scalar b

type Scalar (a, b) = Scalar a

type Scalar (Any cxt x) = Int

type Scalar (Labeled' x y) = Scalar x

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Galois p0 k0) = Scalar (Z ((^) p0 k0))

type Scalar (Polynomial_ a b) = Scalar b

type Scalar ((+>) a b) = Scalar b

type Scalar (BloomFilter n a) = Int

type Scalar (Map i e) = Int

type Scalar (Map' i e) = Int

type Scalar (a, b, c) = Scalar a

type Scalar ((/) k a0 b0) = Scalar a0

type Scalar ((/) k a0 b0) = Scalar a0

type Scalar ((/) k a0 b0) = Scalar a0

type Scalar ((/) k a0 b0) = Scalar a0

type Scalar ((/) k a0 b0) = Scalar a0

type Scalar ((/) k a0 b0) = Scalar a0

type Scalar (SVector k n r) = Scalar r

type Scalar (UVector k n r) = Scalar r

type Scalar (a, b, c, d) = Scalar a

type Scalar (HyperLogLog k k1 p a) = Integer

type IsScalar r = (Ring r, Ord_ r, Scalar r ~ r, Normed r, ClassicalLogic r, r ~ (r >< r))

A synonym that covers everything we intuitively thing scalar variables should have.

type HasScalar a = IsScalar (Scalar a)

A (sometimes) more convenient version of IsScalar.

type family a >< b :: * infixr 8

Instances

type (><) * * Double Double = Double

type (><) * * Float Float = Float

type (><) * * Int Int = Int

type (><) * * Integer Integer = Integer

type (><) * * Rational Rational = Rational

type (><) * * (Galois p k) Integer = Galois p k

type (><) * * (Polynomial_ r r) r = Polynomial_ r r

type (><) * k (a -> b) c = a -> (><) * k b c

type (><) * k ((+>) a b) c

type (><) * * (SVector k m a) b

type (><) * k ((/) k1 a b) c = (/) k1 ((><) * k a c) b

type (><) * k (UVector k1 n r) a = UVector k1 n ((><) * k r a)

class (Cancellative m, HasScalar m, Rig (Scalar m)) => Cone m where

A Cone is an "almost linear" subspace of a module. Examples include the cone of positive real numbers and the cone of positive semidefinite matrices.

See <http://en.wikipedia.org/wiki/Cone_%28linear_algebra%29 wikipedia for more details.

FIXME: There are many possible laws for cones (as seen in the wikipedia article). I need to explicitly formulate them here. Intuitively, the laws should apply the module operations and then project back into the "closest point" in the cone.

FIXME: We're using the definition of a cone from linear algebra. This definition is closely related to the definition from topology. What is needed to ensure our definition generalizes to topological cones? See wikipedia and ncatlab for more details.

Methods

(*..) :: Scalar m -> m -> m infixl 7

(..*..) :: m -> m -> m infixl 7

class (Abelian v, Group v, HasScalar v, v ~ (v >< Scalar v)) => Module v where

Minimal complete definition

(.*) | (.*=)

Methods

(.*) :: v -> Scalar v -> v infixl 7

Scalar multiplication.

(.*=) :: PrimBase m => Mutable m v -> Scalar v -> m () infixr 5

Instances

Module Double

Module Float

Module Int

Module Integer

Module Rational

Module b => Module (a -> b)

KnownNat ((^) p k) => Module (Galois p k)

IsScalar r => Module (Polynomial_ r r)

(VectorSpace a, VectorSpace b) => Module ((+>) a b)

(Module a, Quotient k a b) => Module ((/) k a b)

(KnownNat n, Module r, ValidSVector Nat n r, IsScalar r) => Module (SVector Nat n r)

(Module r, ValidSVector Symbol n r, IsScalar r) => Module (SVector Symbol n r)

(Module r, Prim r) => Module (UVector Symbol n r)

law_Module_multiplication :: (Eq_ m, Module m) => m -> m -> Scalar m -> Logic m

law_Module_addition :: (Eq_ m, Module m) => m -> Scalar m -> Scalar m -> Logic m

law_Module_action :: (Eq_ m, Module m) => m -> Scalar m -> Scalar m -> Logic m

law_Module_unital :: (Eq_ m, Module m) => m -> Logic m

defn_Module_dotstarequal :: (Eq_ m, Module m) => m -> Scalar m -> Logic m

(*.) :: Module v => Scalar v -> v -> v infixl 7

class Module v => FreeModule v where

Free modules have a basis. This means it makes sense to perform operations elementwise on the basis coefficients.

See wikipedia for more detail.

Minimal complete definition

ones, ((.*.) | (.*.=))

Methods

(.*.) :: v -> v -> v infixl 7

Multiplication of the components pointwise. For matrices, this is commonly called Hadamard multiplication.

See wikipedia for more detail.

FIXME: This is only valid for modules with a basis.

(.*.=) :: PrimBase m => Mutable m v -> v -> m () infixr 5

ones :: v

The identity for Hadamard multiplication. Intuitively, this object has the value "one" in every column.

Instances

FreeModule Double

FreeModule Float

FreeModule Int

FreeModule Integer

FreeModule Rational

FreeModule b => FreeModule (a -> b)

IsScalar r => FreeModule (Polynomial_ r r)

(VectorSpace a, VectorSpace b) => FreeModule ((+>) a b)

(KnownNat n, FreeModule r, ValidSVector Nat n r, IsScalar r) => FreeModule (SVector Nat n r)

(FreeModule r, ValidSVector Symbol n r, IsScalar r) => FreeModule (SVector Symbol n r)

(FreeModule r, Prim r) => FreeModule (UVector Symbol n r)

law_FreeModule_commutative :: (Eq_ m, FreeModule m) => m -> m -> Logic m

law_FreeModule_associative :: (Eq_ m, FreeModule m) => m -> m -> m -> Logic m

law_FreeModule_id :: (Eq_ m, FreeModule m) => m -> Logic m

defn_FreeModule_dotstardotequal :: (Eq_ m, FreeModule m) => m -> m -> Logic m

class (FreeModule v, IxContainer v, Elem v ~ Scalar v, Index v ~ Int, v ~ SetElem v (Elem v)) => FiniteModule v where

If our FreeModule has a finite basis, then we can:

• index into the modules basis coefficients
• provide a dense construction method that's a bit more convenient than "fromIxList".

Methods

dim :: v -> Int

Returns the dimension of the object. For some objects, this may be known statically, and so the parameter will not be "seq"ed. But for others, this may not be known statically, and so the parameter will be "seq"ed.

unsafeToModule :: [Scalar v] -> v

Instances

FiniteModule Double

FiniteModule Float

FiniteModule Int

FiniteModule Integer

FiniteModule Rational

(KnownNat n, FreeModule r, ValidLogic r, ValidSVector Nat n r, IsScalar r) => FiniteModule (SVector Nat n r)

(FreeModule r, ValidLogic r, ValidSVector Symbol n r, IsScalar r) => FiniteModule (SVector Symbol n r)

(FreeModule r, ValidLogic r, Prim r, IsScalar r) => FiniteModule (UVector Symbol n r)

class (FreeModule v, Field (Scalar v)) => VectorSpace v where

Minimal complete definition

(./.) | (./.=)

Methods

(./) :: v -> Scalar v -> v infixl 7

(./.) :: v -> v -> v infixl 7

(./=) :: PrimBase m => Mutable m v -> Scalar v -> m () infixr 5

(./.=) :: PrimBase m => Mutable m v -> v -> m () infixr 5

Instances

VectorSpace Double

VectorSpace Float

VectorSpace Rational

VectorSpace b => VectorSpace (a -> b)

(VectorSpace a, VectorSpace b) => VectorSpace ((+>) a b)

(KnownNat n, VectorSpace r, ValidSVector Nat n r, IsScalar r) => VectorSpace (SVector Nat n r)

(VectorSpace r, ValidSVector Symbol n r, IsScalar r) => VectorSpace (SVector Symbol n r)

(VectorSpace r, Prim r) => VectorSpace (UVector Symbol n r)

class (VectorSpace v, Normed v, Metric v) => Banach v where

A Banach space is a Vector Space equipped with a compatible Norm and Metric.

See wikipedia for more details.

Minimal complete definition

Nothing

Methods

normalize :: v -> v

Instances

Banach Double

Banach Float

Banach Rational

(KnownNat n, VectorSpace r, ValidSVector Nat n r, IsScalar r, ExpField r, Real r, ValidSVector Nat n r, ValidSVector Symbol "dyn" r) => Banach (SVector Nat n r)

(VectorSpace r, ValidSVector Symbol n r, IsScalar r, ExpField r, Real r) => Banach (SVector Symbol n r)

class (Banach v, TensorAlgebra v, Real (Scalar v), OrdField (Scalar v)) => Hilbert v where

Hilbert spaces are a natural generalization of Euclidean space that allows for infinite dimension.

See wikipedia for more details.

FIXME: The result of a dot product must always be an ordered field. This is true even when the Hilbert space is over a non-ordered field like the complex numbers. But the OrdField constraint currently prevents us from doing scalar multiplication on Complex Hilbert spaces. See http://math.stackexchange.com/questions/49348/inner-product-spaces-over-finite-fields and http://math.stackexchange.com/questions/47916/banach-spaces-over-fields-other-than-mathbbc for some technical details.

Methods

(<>) :: v -> v -> Scalar v infix 8

Instances

Hilbert Double

Hilbert Float

(KnownNat n, VectorSpace r, ValidSVector Nat n r, IsScalar r, ExpField r, Real r, OrdField r, MatrixField r, ValidSVector Nat n r, ValidSVector Symbol "dyn" r) => Hilbert (SVector Nat n r)

(VectorSpace r, ValidSVector Symbol n r, IsScalar r, ExpField r, Real r, OrdField r, MatrixField r) => Hilbert (SVector Symbol n r)

innerProductDistance :: Hilbert v => v -> v -> Scalar v

innerProductNorm :: Hilbert v => v -> Scalar v

class (VectorSpace v, VectorSpace (v >< v), Scalar (v >< v) ~ Scalar v, Normed (v >< v), Field (v >< v)) => TensorAlgebra v where

Tensor algebras generalize the outer product of vectors to construct a matrix.

See wikipedia for details.

FIXME: This needs to be replaced by the Tensor product in the Monoidal category Vect

Methods

(><) :: v -> v -> v >< v infixr 8

Take the tensor product of two vectors

vXm :: v -> (v >< v) -> v

"left multiplication" of a square matrix

mXv :: (v >< v) -> v -> v

"right multiplication" of a square matrix

Instances

TensorAlgebra Double

TensorAlgebra Float

TensorAlgebra Rational

(FiniteModule (SVector k n r), VectorSpace (SVector k n r), MatrixField r, ToFromVector (SVector k n r)) => TensorAlgebra (SVector k n r)

Spatial programming

data Any cxt x where

Constructors

Any :: forall cxt x xs. (cxt xs, Elem xs ~ x) => xs -> Any cxt x

Instances

Show x => Show (Any Foldable x)

IsMutable (Any cxt x)

Foldable (Any Foldable x)

Constructible (Any Foldable x)

Normed (Any Foldable x)

Monoid (Any Foldable x)

Semigroup (Any Foldable x)

data Mutable m (Any cxt0 x0) = Mutable_AppT__AppT__ConT_SubHask_Algebra_Any___VarT_cxt_1627508297____VarT_x_1627508298_ (PrimRef m (Any cxt x))

type Elem (Any cxt x) = x

type Scalar (Any cxt x) = Int

type All cxt x = forall xs. (cxt xs, Elem xs ~ x) => xs

The type of all containers satisfying the cxt constraint with elements of type x.

Helper functions

simpleMutableDefn

Arguments

:: (Eq_ a, IsMutable a)

=> (Mutable (ST s) a -> b -> ST s ())

mutable function

-> (a -> b -> a)

create a mutable function using "immutable2mutable"

-> a -> b -> Logic a

the output property

Creates a quickcheck property for a simple mutable operator defined using "immutable2mutable"

module SubHask.Mutable