-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Common types for mathematical domain reasoners
--   
--   This package provides common datatypes and utility functions for
--   mathematical domain reasoners that are based on the <a>ideas</a>
--   software package. The package is currently used by our logic tutors
--   (dnf/cnf normal forms, equational proofs, axiomatic proofs, inductive
--   proofs), the statistics tutor that provides feedback on the structure
--   of hypothesis tests, and the analyzers of the Advise-Me project.
--   Contact the package maintainers for further information about the
--   package.
@package ideas-math-types
@version 1.1


module Domain.Algebra.Group

-- | The class of monoids (types with an associative binary operation that
--   has an identity). Instances should satisfy the following laws:
--   
--   <ul>
--   <li><pre>x <a>&lt;&gt;</a> <a>mempty</a> = x</pre></li>
--   <li><pre><a>mempty</a> <a>&lt;&gt;</a> x = x</pre></li>
--   <li><tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) = (x <a>&lt;&gt;</a>
--   y) <a>&lt;&gt;</a> z</tt> (<a>Semigroup</a> law)</li>
--   <li><pre><a>mconcat</a> = <a>foldr</a> '(&lt;&gt;)'
--   <a>mempty</a></pre></li>
--   </ul>
--   
--   The method names refer to the monoid of lists under concatenation, but
--   there are many other instances.
--   
--   Some types can be viewed as a monoid in more than one way, e.g. both
--   addition and multiplication on numbers. In such cases we often define
--   <tt>newtype</tt>s and make those instances of <a>Monoid</a>, e.g.
--   <tt>Sum</tt> and <tt>Product</tt>.
--   
--   <b>NOTE</b>: <a>Semigroup</a> is a superclass of <a>Monoid</a> since
--   <i>base-4.11.0.0</i>.
class Semigroup a => Monoid a

-- | Identity of <a>mappend</a>
mempty :: Monoid a => a

-- | An associative operation
--   
--   <b>NOTE</b>: This method is redundant and has the default
--   implementation <tt><a>mappend</a> = '(&lt;&gt;)'</tt> since
--   <i>base-4.11.0.0</i>.
mappend :: Monoid a => a -> a -> a

-- | Fold a list using the monoid.
--   
--   For most types, the default definition for <a>mconcat</a> will be
--   used, but the function is included in the class definition so that an
--   optimized version can be provided for specific types.
mconcat :: Monoid a => [a] -> a

-- | An associative operation.
(<>) :: Semigroup a => a -> a -> a
infixr 6 <>

-- | Minimal complete definition: inverse or appendInverse
class Monoid a => Group a
inverse :: Group a => a -> a
appendInv :: Group a => a -> a -> a
(<>-) :: Group a => a -> a -> a
infixl 6 <>-
class Monoid a => MonoidZero a
mzero :: MonoidZero a => a
data WithZero a
fromWithZero :: WithZero a -> Maybe a
class CoMonoid a
isEmpty :: CoMonoid a => a -> Bool
isAppend :: CoMonoid a => a -> Maybe (a, a)
class CoMonoid a => CoGroup a
isInverse :: CoGroup a => a -> Maybe a
isAppendInv :: CoGroup a => a -> Maybe (a, a)
class CoMonoid a => CoMonoidZero a
isMonoidZero :: CoMonoidZero a => a -> Bool
associativeList :: CoMonoid a => a -> [a]
instance GHC.Base.Applicative Domain.Algebra.Group.WithZero
instance Data.Foldable.Foldable Domain.Algebra.Group.WithZero
instance GHC.Base.Functor Domain.Algebra.Group.WithZero
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Algebra.Group.WithZero a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Algebra.Group.WithZero a)
instance Domain.Algebra.Group.CoMonoid a => Domain.Algebra.Group.CoMonoidZero (Domain.Algebra.Group.WithZero a)
instance Domain.Algebra.Group.CoMonoid [a]
instance Domain.Algebra.Group.CoMonoid (Data.Set.Internal.Set a)
instance Domain.Algebra.Group.CoMonoid a => Domain.Algebra.Group.CoMonoid (Domain.Algebra.Group.WithZero a)
instance GHC.Base.Semigroup a => GHC.Base.Semigroup (Domain.Algebra.Group.WithZero a)
instance GHC.Base.Monoid a => GHC.Base.Monoid (Domain.Algebra.Group.WithZero a)
instance GHC.Base.Monoid a => Domain.Algebra.Group.MonoidZero (Domain.Algebra.Group.WithZero a)
instance Data.Traversable.Traversable Domain.Algebra.Group.WithZero


module Domain.Algebra.Field
class SemiRing a
(|+|) :: SemiRing a => a -> a -> a
zero :: SemiRing a => a
sum :: SemiRing a => [a] -> a
(|*|) :: SemiRing a => a -> a -> a
one :: SemiRing a => a
product :: SemiRing a => [a] -> a
infixl 6 |+|
infixl 7 |*|
class SemiRing a => Ring a
plusInverse :: Ring a => a -> a
(|-|) :: Ring a => a -> a -> a
infixl 6 |-|
class Ring a => Field a
timesInverse :: Field a => a -> a
(|/|) :: Field a => a -> a -> a
infixl 7 |/|
newtype Additive a
Additive :: a -> Additive a
[fromAdditive] :: Additive a -> a
newtype Multiplicative a
Multiplicative :: a -> Multiplicative a
[fromMultiplicative] :: Multiplicative a -> a
data SafeNum a
safeNum :: SafeNum a -> Either String a
class CoSemiRing a
isPlus :: CoSemiRing a => a -> Maybe (a, a)
isZero :: CoSemiRing a => a -> Bool
isTimes :: CoSemiRing a => a -> Maybe (a, a)
isOne :: CoSemiRing a => a -> Bool
class CoSemiRing a => CoRing a
isNegate :: CoRing a => a -> Maybe a
isMinus :: CoRing a => a -> Maybe (a, a)
class CoRing a => CoField a
isRecip :: CoField a => a -> Maybe a
isDivision :: CoField a => a -> Maybe (a, a)
instance Test.QuickCheck.Arbitrary.CoArbitrary a => Test.QuickCheck.Arbitrary.CoArbitrary (Domain.Algebra.Field.Multiplicative a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Algebra.Field.Multiplicative a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Algebra.Field.Multiplicative a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Algebra.Field.Multiplicative a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Algebra.Field.Multiplicative a)
instance Test.QuickCheck.Arbitrary.CoArbitrary a => Test.QuickCheck.Arbitrary.CoArbitrary (Domain.Algebra.Field.Additive a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Algebra.Field.Additive a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Algebra.Field.Additive a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Algebra.Field.Additive a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Algebra.Field.Additive a)
instance Domain.Algebra.Field.CoField a => Domain.Algebra.Group.CoGroup (Domain.Algebra.Field.Multiplicative a)
instance Domain.Algebra.Field.CoRing a => Domain.Algebra.Group.CoGroup (Domain.Algebra.Field.Additive a)
instance Domain.Algebra.Field.CoSemiRing a => Domain.Algebra.Group.CoMonoid (Domain.Algebra.Field.Additive a)
instance Domain.Algebra.Field.CoSemiRing a => Domain.Algebra.Group.CoMonoid (Domain.Algebra.Field.Multiplicative a)
instance Domain.Algebra.Field.CoSemiRing a => Domain.Algebra.Group.CoMonoidZero (Domain.Algebra.Field.Multiplicative a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Algebra.Field.SafeNum a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Algebra.Field.SafeNum a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Algebra.Field.SafeNum a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Algebra.Field.SafeNum a)
instance GHC.Base.Functor Domain.Algebra.Field.SafeNum
instance GHC.Base.Applicative Domain.Algebra.Field.SafeNum
instance GHC.Base.Monad Domain.Algebra.Field.SafeNum
instance GHC.Num.Num a => GHC.Num.Num (Domain.Algebra.Field.SafeNum a)
instance (GHC.Classes.Eq a, GHC.Real.Fractional a) => GHC.Real.Fractional (Domain.Algebra.Field.SafeNum a)
instance GHC.Num.Num a => Domain.Algebra.Field.SemiRing (Domain.Algebra.Field.SafeNum a)
instance GHC.Num.Num a => Domain.Algebra.Field.Ring (Domain.Algebra.Field.SafeNum a)
instance (GHC.Classes.Eq a, GHC.Real.Fractional a) => Domain.Algebra.Field.Field (Domain.Algebra.Field.SafeNum a)
instance GHC.Base.Functor Domain.Algebra.Field.Multiplicative
instance GHC.Base.Applicative Domain.Algebra.Field.Multiplicative
instance Domain.Algebra.Field.SemiRing a => GHC.Base.Semigroup (Domain.Algebra.Field.Multiplicative a)
instance Domain.Algebra.Field.SemiRing a => GHC.Base.Monoid (Domain.Algebra.Field.Multiplicative a)
instance Domain.Algebra.Field.Field a => Domain.Algebra.Group.Group (Domain.Algebra.Field.Multiplicative a)
instance Domain.Algebra.Field.SemiRing a => Domain.Algebra.Group.MonoidZero (Domain.Algebra.Field.Multiplicative a)
instance GHC.Base.Functor Domain.Algebra.Field.Additive
instance GHC.Base.Applicative Domain.Algebra.Field.Additive
instance Domain.Algebra.Field.SemiRing a => GHC.Base.Semigroup (Domain.Algebra.Field.Additive a)
instance Domain.Algebra.Field.SemiRing a => GHC.Base.Monoid (Domain.Algebra.Field.Additive a)
instance Domain.Algebra.Field.Ring a => Domain.Algebra.Group.Group (Domain.Algebra.Field.Additive a)


module Domain.Algebra.Boolean
class BoolValue a
true :: BoolValue a => a
false :: BoolValue a => a
fromBool :: BoolValue a => Bool -> a
isTrue :: BoolValue a => a -> Bool
isFalse :: BoolValue a => a -> Bool
class BoolValue a => Boolean a
(<&&>) :: Boolean a => a -> a -> a
(<||>) :: Boolean a => a -> a -> a
complement :: Boolean a => a -> a
ands :: Boolean a => [a] -> a
ors :: Boolean a => [a] -> a
implies :: Boolean a => a -> a -> a
equivalent :: Boolean a => a -> a -> a
class BoolValue a => CoBoolean a
isAnd :: CoBoolean a => a -> Maybe (a, a)
isOr :: CoBoolean a => a -> Maybe (a, a)
isComplement :: CoBoolean a => a -> Maybe a
conjunctions :: CoBoolean a => a -> [a]
disjunctions :: CoBoolean a => a -> [a]
class MonoidZero a => DualMonoid a
(><) :: DualMonoid a => a -> a -> a
dualCompl :: DualMonoid a => a -> a
newtype And a
And :: a -> And a
[fromAnd] :: And a -> a
newtype Or a
Or :: a -> Or a
[fromOr] :: Or a -> a
instance Test.QuickCheck.Arbitrary.CoArbitrary a => Test.QuickCheck.Arbitrary.CoArbitrary (Domain.Algebra.Boolean.Or a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Algebra.Boolean.Or a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Algebra.Boolean.Or a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Algebra.Boolean.Or a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Algebra.Boolean.Or a)
instance Test.QuickCheck.Arbitrary.CoArbitrary a => Test.QuickCheck.Arbitrary.CoArbitrary (Domain.Algebra.Boolean.And a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Algebra.Boolean.And a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Algebra.Boolean.And a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Algebra.Boolean.And a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Algebra.Boolean.And a)
instance Domain.Algebra.Boolean.CoBoolean a => Domain.Algebra.Group.CoMonoid (Domain.Algebra.Boolean.Or a)
instance Domain.Algebra.Boolean.CoBoolean a => Domain.Algebra.Group.CoMonoidZero (Domain.Algebra.Boolean.Or a)
instance GHC.Base.Functor Domain.Algebra.Boolean.Or
instance GHC.Base.Applicative Domain.Algebra.Boolean.Or
instance Ideas.Common.Classes.Boolean a => GHC.Base.Semigroup (Domain.Algebra.Boolean.Or a)
instance Ideas.Common.Classes.Boolean a => GHC.Base.Monoid (Domain.Algebra.Boolean.Or a)
instance Ideas.Common.Classes.Boolean a => Domain.Algebra.Group.MonoidZero (Domain.Algebra.Boolean.Or a)
instance Ideas.Common.Classes.Boolean a => Domain.Algebra.Boolean.DualMonoid (Domain.Algebra.Boolean.Or a)
instance Domain.Algebra.Boolean.CoBoolean a => Domain.Algebra.Group.CoMonoid (Domain.Algebra.Boolean.And a)
instance Domain.Algebra.Boolean.CoBoolean a => Domain.Algebra.Group.CoMonoidZero (Domain.Algebra.Boolean.And a)
instance GHC.Base.Functor Domain.Algebra.Boolean.And
instance GHC.Base.Applicative Domain.Algebra.Boolean.And
instance Ideas.Common.Classes.Boolean a => GHC.Base.Semigroup (Domain.Algebra.Boolean.And a)
instance Ideas.Common.Classes.Boolean a => GHC.Base.Monoid (Domain.Algebra.Boolean.And a)
instance Ideas.Common.Classes.Boolean a => Domain.Algebra.Group.MonoidZero (Domain.Algebra.Boolean.And a)
instance Ideas.Common.Classes.Boolean a => Domain.Algebra.Boolean.DualMonoid (Domain.Algebra.Boolean.And a)


module Domain.Algebra.Law
data Law a
data LawSpec a
(:==:) :: a -> a -> LawSpec a
infix 1 :==:
law :: LawBuilder l a => String -> l -> Law a
lawAbs :: (Different b, Arbitrary b, Show b) => (b -> LawSpec a) -> LawSpec a
mapLaw :: (b -> a) -> (a -> b) -> Law a -> Law b
propertyLaw :: (Arbitrary a, Show a, Testable b) => (a -> a -> b) -> Law a -> Property
rewriteLaw :: (Different a, IsTerm a, Arbitrary a, Show a) => Law a -> RewriteRule a
instance Domain.Algebra.Law.LawBuilder (Domain.Algebra.Law.LawSpec a) a
instance Domain.Algebra.Law.LawBuilder (Domain.Algebra.Law.Law a) a
instance Domain.Algebra.Law.LawBuilder b a => Domain.Algebra.Law.LawBuilder (a -> b) a
instance GHC.Show.Show (Domain.Algebra.Law.Law a)
instance (GHC.Show.Show a, GHC.Classes.Eq a, Test.QuickCheck.Arbitrary.Arbitrary a) => Test.QuickCheck.Property.Testable (Domain.Algebra.Law.Law a)
instance (Test.QuickCheck.Arbitrary.Arbitrary a, Ideas.Common.Rewriting.Term.IsTerm a, GHC.Show.Show a, Ideas.Common.Rewriting.RewriteRule.Different a) => Ideas.Common.Rewriting.RewriteRule.RuleBuilder (Domain.Algebra.Law.LawSpec a) a


module Domain.Algebra.GroupLaws
associative :: Monoid a => Law a
leftIdentity :: Monoid a => Law a
rightIdentity :: Monoid a => Law a
identityLaws :: Monoid a => [Law a]
monoidLaws :: Monoid a => [Law a]
commutativeMonoidLaws :: Monoid a => [Law a]

-- | Not all monoids are idempotent (see: idempotentFor)
idempotent :: Monoid a => Law a
leftInverse :: Group a => Law a
rightInverse :: Group a => Law a
doubleInverse :: Group a => Law a
inverseIdentity :: Group a => Law a
inverseDistrFlipped :: Group a => Law a
inverseLaws :: Group a => [Law a]
groupLaws :: Group a => [Law a]
appendInverseLaws :: Group a => [Law a]
commutative :: Monoid a => Law a
inverseDistr :: Group a => Law a
abelianGroupLaws :: Group a => [Law a]
leftZero :: MonoidZero a => Law a
rightZero :: MonoidZero a => Law a
zeroLaws :: MonoidZero a => [Law a]
monoidZeroLaws :: MonoidZero a => [Law a]
associativeFor :: (a -> a -> a) -> Law a
commutativeFor :: (a -> a -> a) -> Law a
idempotentFor :: (a -> a -> a) -> Law a
leftDistributiveFor :: (a -> a -> a) -> (a -> a -> a) -> Law a
rightDistributiveFor :: (a -> a -> a) -> (a -> a -> a) -> Law a


module Domain.Algebra.FieldLaws
leftDistributive :: SemiRing a => Law a
rightDistributive :: SemiRing a => Law a
distributiveLaws :: SemiRing a => [Law a]
semiRingLaws :: SemiRing a => [Law a]
leftNegateTimes :: Ring a => Law a
rightNegateTimes :: Ring a => Law a
negateTimesLaws :: Ring a => [Law a]
ringLaws :: Ring a => [Law a]
commutativeRingLaws :: Ring a => [Law a]
distributiveSubtractionLaws :: Ring a => [Law a]
exchangeInverses :: Field a => Law a
fieldLaws :: Field a => [Law a]
fromAdditiveLaw :: Law (Additive a) -> Law a
fromMultiplicativeLaw :: Law (Multiplicative a) -> Law a
propsField :: [Property]


module Domain.Algebra.BooleanLaws
andOverOrLaws :: Boolean a => [Law a]
orOverAndLaws :: Boolean a => [Law a]
complementAndLaws :: Boolean a => [Law a]
complementOrLaws :: Boolean a => [Law a]
absorptionAndLaws :: Boolean a => [Law a]
absorptionOrLaws :: Boolean a => [Law a]
deMorganAnd :: Boolean a => Law a
deMorganOr :: Boolean a => Law a
doubleComplement :: Boolean a => Law a
complementTrue :: Boolean a => Law a
complementFalse :: Boolean a => Law a
booleanLaws :: Boolean a => [Law a]
fromAndLaw :: Law (And a) -> Law a
fromOrLaw :: Law (Or a) -> Law a
propsBoolean :: [Property]


module Domain.Algebra.SmartGroup
newtype Smart a
Smart :: a -> Smart a
[fromSmart] :: Smart a -> a
newtype SmartZero a
SmartZero :: a -> SmartZero a
[fromSmartZero] :: SmartZero a -> a
newtype SmartGroup a
SmartGroup :: a -> SmartGroup a
[fromSmartGroup] :: SmartGroup a -> a
newtype SmartField a
SmartField :: a -> SmartField a
[fromSmartField] :: SmartField a -> a
(.+.) :: (CoField a, Field a) => a -> a -> a
infixl 6 .+.
(.-.) :: (CoField a, Field a) => a -> a -> a
infixl 6 .-.
neg :: (CoField a, Field a) => a -> a
(.*.) :: (CoField a, Field a) => a -> a -> a
infixl 7 .*.
(./.) :: (CoField a, Field a) => a -> a -> a
infixl 7 ./.
(.&&.) :: (Boolean a, CoBoolean a) => a -> a -> a
infixr 5 .&&.
(.||.) :: (Boolean a, CoBoolean a) => a -> a -> a
infixr 4 .||.
instance Domain.Algebra.Field.CoField a => Domain.Algebra.Field.CoField (Domain.Algebra.SmartGroup.SmartField a)
instance Domain.Algebra.Field.CoRing a => Domain.Algebra.Field.CoRing (Domain.Algebra.SmartGroup.SmartField a)
instance Domain.Algebra.Field.CoSemiRing a => Domain.Algebra.Field.CoSemiRing (Domain.Algebra.SmartGroup.SmartField a)
instance (Domain.Algebra.Group.MonoidZero a, Domain.Algebra.Group.CoGroup a, Domain.Algebra.Group.Group a) => Domain.Algebra.Group.MonoidZero (Domain.Algebra.SmartGroup.SmartGroup a)
instance Domain.Algebra.Group.CoMonoidZero a => Domain.Algebra.Group.CoMonoidZero (Domain.Algebra.SmartGroup.SmartGroup a)
instance Domain.Algebra.Group.CoGroup a => Domain.Algebra.Group.CoGroup (Domain.Algebra.SmartGroup.SmartGroup a)
instance Domain.Algebra.Group.CoMonoid a => Domain.Algebra.Group.CoMonoid (Domain.Algebra.SmartGroup.SmartGroup a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Algebra.SmartGroup.SmartGroup a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Algebra.SmartGroup.SmartGroup a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Algebra.SmartGroup.SmartGroup a)
instance Domain.Algebra.Group.CoMonoidZero a => Domain.Algebra.Group.CoMonoidZero (Domain.Algebra.SmartGroup.SmartZero a)
instance Domain.Algebra.Group.CoMonoid a => Domain.Algebra.Group.CoMonoid (Domain.Algebra.SmartGroup.SmartZero a)
instance (Domain.Algebra.Group.MonoidZero a, Domain.Algebra.Group.CoMonoidZero a) => Domain.Algebra.Group.MonoidZero (Domain.Algebra.SmartGroup.SmartZero a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Algebra.SmartGroup.SmartZero a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Algebra.SmartGroup.SmartZero a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Algebra.SmartGroup.SmartZero a)
instance Domain.Algebra.Group.CoMonoidZero a => Domain.Algebra.Group.CoMonoidZero (Domain.Algebra.SmartGroup.Smart a)
instance (Domain.Algebra.Group.MonoidZero a, Domain.Algebra.Group.CoMonoid a) => Domain.Algebra.Group.MonoidZero (Domain.Algebra.SmartGroup.Smart a)
instance Domain.Algebra.Group.CoMonoid a => Domain.Algebra.Group.CoMonoid (Domain.Algebra.SmartGroup.Smart a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Algebra.SmartGroup.Smart a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Algebra.SmartGroup.Smart a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Algebra.SmartGroup.Smart a)
instance GHC.Base.Functor Domain.Algebra.SmartGroup.SmartField
instance GHC.Base.Applicative Domain.Algebra.SmartGroup.SmartField
instance (Domain.Algebra.Field.CoField a, Domain.Algebra.Field.Field a) => Domain.Algebra.Field.SemiRing (Domain.Algebra.SmartGroup.SmartField a)
instance (Domain.Algebra.Field.CoField a, Domain.Algebra.Field.Field a) => Domain.Algebra.Field.Ring (Domain.Algebra.SmartGroup.SmartField a)
instance (Domain.Algebra.Field.CoField a, Domain.Algebra.Field.Field a) => Domain.Algebra.Field.Field (Domain.Algebra.SmartGroup.SmartField a)
instance GHC.Base.Functor Domain.Algebra.SmartGroup.SmartGroup
instance GHC.Base.Applicative Domain.Algebra.SmartGroup.SmartGroup
instance (Domain.Algebra.Group.CoGroup a, Domain.Algebra.Group.Group a) => GHC.Base.Semigroup (Domain.Algebra.SmartGroup.SmartGroup a)
instance (Domain.Algebra.Group.CoGroup a, Domain.Algebra.Group.Group a) => GHC.Base.Monoid (Domain.Algebra.SmartGroup.SmartGroup a)
instance (Domain.Algebra.Group.CoGroup a, Domain.Algebra.Group.Group a) => Domain.Algebra.Group.Group (Domain.Algebra.SmartGroup.SmartGroup a)
instance GHC.Base.Functor Domain.Algebra.SmartGroup.SmartZero
instance GHC.Base.Applicative Domain.Algebra.SmartGroup.SmartZero
instance (Domain.Algebra.Group.CoMonoidZero a, Domain.Algebra.Group.MonoidZero a, GHC.Base.Semigroup a) => GHC.Base.Semigroup (Domain.Algebra.SmartGroup.SmartZero a)
instance (Domain.Algebra.Group.CoMonoidZero a, Domain.Algebra.Group.MonoidZero a) => GHC.Base.Monoid (Domain.Algebra.SmartGroup.SmartZero a)
instance (Ideas.Common.Classes.Boolean a, Domain.Algebra.Boolean.CoBoolean a) => Ideas.Common.Classes.Boolean (Domain.Algebra.SmartGroup.Smart a)
instance GHC.Base.Functor Domain.Algebra.SmartGroup.Smart
instance GHC.Base.Applicative Domain.Algebra.SmartGroup.Smart
instance (Domain.Algebra.Group.CoMonoid a, GHC.Base.Semigroup a) => GHC.Base.Semigroup (Domain.Algebra.SmartGroup.Smart a)
instance (Domain.Algebra.Group.CoMonoid a, GHC.Base.Monoid a) => GHC.Base.Monoid (Domain.Algebra.SmartGroup.Smart a)
instance Ideas.Common.Classes.BoolValue a => Ideas.Common.Classes.BoolValue (Domain.Algebra.SmartGroup.Smart a)


module Domain.Logic.Formula

-- | The type LogicAlg is the algebra for the data type Logic | Used in the
--   fold for Logic.
type LogicAlg b a = (b -> a, a -> a -> a, a -> a -> a, a -> a -> a, a -> a -> a, a -> a, a, a)

-- | For simple use, we assume the variables to be strings
type SLogic = Logic ShowString

-- | The data type Logic is the abstract syntax for the domain | of logic
--   expressions.
data Logic a
Var :: a -> Logic a
(:->:) :: Logic a -> Logic a -> Logic a
(:<->:) :: Logic a -> Logic a -> Logic a
(:&&:) :: Logic a -> Logic a -> Logic a
(:||:) :: Logic a -> Logic a -> Logic a
Not :: Logic a -> Logic a
T :: Logic a
F :: Logic a
infixr 4 :||:
infixr 2 :<->:
infixr 3 :->:
infixr 5 :&&:

-- | foldLogic is the standard fold for Logic.
foldLogic :: LogicAlg b a -> Logic b -> a

-- | Pretty-printer for propositions
ppLogic :: Show a => Logic a -> String
ppLogicPrio :: Show a => Int -> Logic a -> String

-- | The monadic join for logic
catLogic :: Logic (Logic a) -> Logic a

-- | evalLogic takes a function that gives a logic value to a variable, |
--   and a Logic expression, and evaluates the boolean expression.
evalLogic :: (a -> Bool) -> Logic a -> Bool

-- | eqLogic determines whether or not two Logic expression are logically |
--   equal, by evaluating the logic expressions on all valuations.
eqLogic :: Eq a => Logic a -> Logic a -> Bool
tautology :: Eq a => Logic a -> Bool
isNot :: Logic a -> Bool

-- | A Logic expression is atomic if it is a variable or a constant True or
--   False.
isAtomic :: Logic a -> Bool

-- | Functions isDNF, and isCNF determine whether or not a Logix expression
--   | is in disjunctive normal form, or conjunctive normal form,
--   respectively.
isDNF :: Logic a -> Bool

-- | Functions isDNF, and isCNF determine whether or not a Logix expression
--   | is in disjunctive normal form, or conjunctive normal form,
--   respectively.
isCNF :: Logic a -> Bool

-- | Count the number of equivalences
countEquivalences :: Logic a -> Int

-- | Function varsLogic returns the variables that appear in a Logic
--   expression.
varsLogic :: Eq a => Logic a -> [a]
trueSymbol :: Symbol
falseSymbol :: Symbol
notSymbol :: Symbol
impliesSymbol :: Symbol
equivalentSymbol :: Symbol
andSymbol :: Symbol
orSymbol :: Symbol
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Logic.Formula.Logic a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Logic.Formula.Logic a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Logic.Formula.Logic a)
instance GHC.Base.Functor Domain.Logic.Formula.Logic
instance Data.Foldable.Foldable Domain.Logic.Formula.Logic
instance Data.Traversable.Traversable Domain.Logic.Formula.Logic
instance Ideas.Common.Classes.BoolValue (Domain.Logic.Formula.Logic a)
instance Ideas.Common.Classes.Boolean (Domain.Logic.Formula.Logic a)
instance Domain.Algebra.Boolean.CoBoolean (Domain.Logic.Formula.Logic a)
instance Ideas.Common.Classes.Container Domain.Logic.Formula.Logic
instance Ideas.Text.Latex.ToLatex a => Ideas.Text.Latex.ToLatex (Domain.Logic.Formula.Logic a)
instance Data.Generics.Uniplate.Operations.Uniplate (Domain.Logic.Formula.Logic a)
instance Ideas.Common.Rewriting.RewriteRule.Different (Domain.Logic.Formula.Logic a)
instance Ideas.Common.Rewriting.Term.IsTerm a => Ideas.Common.Rewriting.Term.IsTerm (Domain.Logic.Formula.Logic a)


module Domain.Logic.Generator
generateLogic :: Gen SLogic
generateLevel :: Difficulty -> (Gen SLogic, (Int, Int))

-- | Equality modulo associativity of operators
equalLogicA :: Eq a => Logic a -> Logic a -> Bool

-- | Equality modulo associativity<i>commutativity</i>idempotency of
--   operators, and there units/absorbing elements
equalLogicACI :: Ord a => Logic a -> Logic a -> Bool
normalizeLogicA :: Logic a -> Logic a
instance Test.QuickCheck.Arbitrary.Arbitrary Domain.Logic.Formula.SLogic
instance Test.QuickCheck.Arbitrary.CoArbitrary Domain.Logic.Formula.SLogic


module Domain.Logic.Views
(.<->.) :: Logic a -> Logic a -> Logic a
infixr 2 .<->.
(.->.) :: Logic a -> Logic a -> Logic a
infixr 3 .->.
(.&&.) :: (Boolean a, CoBoolean a) => a -> a -> a
infixr 5 .&&.
(.||.) :: (Boolean a, CoBoolean a) => a -> a -> a
infixr 4 .||.
simplify :: Logic a -> Logic a
pushNot :: Logic a -> Logic a
pushNotWith :: (a -> Logic a) -> Logic a -> Logic a
orView :: View (Logic a) [a]
andView :: View (Logic a) [a]


module Domain.Math.Data.Interval
data Interval a
data Endpoint a
Excluding :: a -> Endpoint a
Including :: a -> Endpoint a
Unbounded :: Endpoint a
empty :: Interval a
point :: a -> Interval a
unbounded :: Ord a => Interval a
open :: Ord a => a -> a -> Interval a
closed :: Ord a => a -> a -> Interval a
leftOpen :: Ord a => a -> a -> Interval a
rightOpen :: Ord a => a -> a -> Interval a
greaterThan :: Ord a => a -> Interval a
greaterThanOrEqualTo :: Ord a => a -> Interval a
lessThan :: Ord a => a -> Interval a
lessThanOrEqualTo :: Ord a => a -> Interval a
true :: BoolValue a => a
false :: BoolValue a => a
except :: Ord a => a -> Interval a
union :: Ord a => Interval a -> Interval a -> Interval a
intersect :: Ord a => Interval a -> Interval a -> Interval a
complement :: Boolean a => a -> a
segments :: Interval a -> [(Endpoint a, Endpoint a)]
isIn :: Ord a => a -> Interval a -> Bool
testMe :: TestSuite
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Math.Data.Interval.Interval a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Math.Data.Interval.Segment a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Math.Data.Interval.Endpoint a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Math.Data.Interval.Endpoint a)
instance GHC.Classes.Ord a => Ideas.Common.Classes.BoolValue (Domain.Math.Data.Interval.Interval a)
instance GHC.Classes.Ord a => Ideas.Common.Classes.Boolean (Domain.Math.Data.Interval.Interval a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Math.Data.Interval.Interval a)
instance (Test.QuickCheck.Arbitrary.Arbitrary a, GHC.Classes.Ord a) => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Math.Data.Interval.Interval a)
instance (Test.QuickCheck.Arbitrary.CoArbitrary a, GHC.Classes.Ord a) => Test.QuickCheck.Arbitrary.CoArbitrary (Domain.Math.Data.Interval.Interval a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Math.Data.Interval.Segment a)
instance (Test.QuickCheck.Arbitrary.CoArbitrary a, GHC.Classes.Ord a) => Test.QuickCheck.Arbitrary.CoArbitrary (Domain.Math.Data.Interval.Segment a)
instance GHC.Base.Functor Domain.Math.Data.Interval.Endpoint
instance (Test.QuickCheck.Arbitrary.Arbitrary a, GHC.Classes.Ord a) => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Math.Data.Interval.Endpoint a)
instance (Test.QuickCheck.Arbitrary.CoArbitrary a, GHC.Classes.Ord a) => Test.QuickCheck.Arbitrary.CoArbitrary (Domain.Math.Data.Interval.Endpoint a)


module Domain.Math.Data.MixedFraction
data MixedFraction

-- | Always positive
wholeNumber :: MixedFraction -> Integer

-- | Always positive
fractionPart :: MixedFraction -> Rational

-- | Always positive
numerator :: MixedFraction -> Integer

-- | Always positive
denominator :: MixedFraction -> Integer
instance GHC.Real.RealFrac Domain.Math.Data.MixedFraction.MixedFraction
instance GHC.Real.Real Domain.Math.Data.MixedFraction.MixedFraction
instance GHC.Real.Fractional Domain.Math.Data.MixedFraction.MixedFraction
instance GHC.Num.Num Domain.Math.Data.MixedFraction.MixedFraction
instance GHC.Classes.Ord Domain.Math.Data.MixedFraction.MixedFraction
instance GHC.Classes.Eq Domain.Math.Data.MixedFraction.MixedFraction
instance GHC.Show.Show Domain.Math.Data.MixedFraction.MixedFraction


module Domain.Math.Data.OrList
data OrList a
data OrSet a
true :: BoolValue a => a
false :: BoolValue a => a

-- | An associative operation.
(<>) :: Semigroup a => a -> a -> a
infixr 6 <>
isTrue :: BoolValue a => a -> Bool
isFalse :: BoolValue a => a -> Bool
fromBool :: BoolValue a => Bool -> a
toOrList :: [a] -> OrList a

-- | Remove duplicates
noDuplicates :: Eq a => OrList a -> OrList a
catOrList :: OrList (OrList a) -> OrList a
oneDisjunct :: Monad m => (a -> m (OrList a)) -> OrList a -> m (OrList a)
orListView :: View (Logic a) (OrList a)
orSetView :: Ord a => View (OrList a) (OrSet a)
instance Domain.Algebra.Group.CoMonoidZero (Domain.Math.Data.OrList.OrSet a)
instance Domain.Algebra.Group.CoMonoid (Domain.Math.Data.OrList.OrSet a)
instance GHC.Classes.Ord a => Domain.Algebra.Group.MonoidZero (Domain.Math.Data.OrList.OrSet a)
instance GHC.Classes.Ord a => GHC.Base.Monoid (Domain.Math.Data.OrList.OrSet a)
instance GHC.Classes.Ord a => GHC.Base.Semigroup (Domain.Math.Data.OrList.OrSet a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Math.Data.OrList.OrSet a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Math.Data.OrList.OrSet a)
instance Domain.Algebra.Group.CoMonoidZero (Domain.Math.Data.OrList.OrList a)
instance Domain.Algebra.Group.CoMonoid (Domain.Math.Data.OrList.OrList a)
instance Domain.Algebra.Group.MonoidZero (Domain.Math.Data.OrList.OrList a)
instance GHC.Base.Monoid (Domain.Math.Data.OrList.OrList a)
instance GHC.Base.Semigroup (Domain.Math.Data.OrList.OrList a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Math.Data.OrList.OrList a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Math.Data.OrList.OrList a)
instance (GHC.Show.Show a, GHC.Classes.Ord a) => GHC.Show.Show (Domain.Math.Data.OrList.OrSet a)
instance GHC.Classes.Ord a => Ideas.Common.Classes.BoolValue (Domain.Math.Data.OrList.OrSet a)
instance Ideas.Common.Classes.Container Domain.Math.Data.OrList.OrSet
instance GHC.Base.Functor Domain.Math.Data.OrList.OrList
instance Data.Foldable.Foldable Domain.Math.Data.OrList.OrList
instance Data.Traversable.Traversable Domain.Math.Data.OrList.OrList
instance Ideas.Common.Classes.BoolValue (Domain.Math.Data.OrList.OrList a)
instance Ideas.Common.Classes.Container Domain.Math.Data.OrList.OrList
instance Ideas.Common.Rewriting.Term.IsTerm a => Ideas.Common.Rewriting.Term.IsTerm (Domain.Math.Data.OrList.OrList a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Math.Data.OrList.OrList a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Math.Data.OrList.OrList a)


module Domain.Math.Data.Primes

-- | All prime numbers smaller than 1000
--   
--   An infinite list of prime numbers
primes :: [Int]

-- | Testing for primality
isPrime :: Int -> Bool

-- | Two numbers are coprime if they do not share a prime factor
coprime :: Int -> Int -> Bool

-- | All prime factors of a number
primeFactors :: Int -> [Int]

-- | All factors of a (positive) number
factors :: Int -> [Int]
testPrimes :: TestSuite


module Domain.Math.Data.PrimeFactors
data PrimeFactors
splitPower :: Int -> PrimeFactors -> (PrimeFactors, PrimeFactors)
greatestPower :: Integer -> Maybe (Integer, Integer)
allPowers :: Integer -> [(Integer, Integer)]
instance GHC.Show.Show Domain.Math.Data.PrimeFactors.PrimeFactors
instance GHC.Classes.Eq Domain.Math.Data.PrimeFactors.PrimeFactors
instance GHC.Classes.Ord Domain.Math.Data.PrimeFactors.PrimeFactors
instance GHC.Num.Num Domain.Math.Data.PrimeFactors.PrimeFactors
instance GHC.Enum.Enum Domain.Math.Data.PrimeFactors.PrimeFactors
instance GHC.Real.Real Domain.Math.Data.PrimeFactors.PrimeFactors
instance GHC.Real.Integral Domain.Math.Data.PrimeFactors.PrimeFactors


module Domain.Math.Data.Relation
class Functor f => Relational f
leftHandSide :: Relational f => f a -> a
rightHandSide :: Relational f => f a -> a
flipSides :: Relational f => f a -> f a
constructor :: Relational f => f a -> b -> b -> f b
isSymmetric :: Relational f => f a -> Bool
data Relation a
relationType :: Relation a -> RelationType
data RelationType
EqualTo :: RelationType
NotEqualTo :: RelationType
LessThan :: RelationType
GreaterThan :: RelationType
LessThanOrEqualTo :: RelationType
GreaterThanOrEqualTo :: RelationType
Approximately :: RelationType
relationSymbols :: [(RelationType, (String, Symbol))]
notRelation :: Relation a -> Relation a
eval :: (Ord a, Num a) => RelationType -> a -> a -> Bool
makeType :: RelationType -> a -> a -> Relation a
(.==.) :: a -> a -> Relation a
infix 1 .==.
(./=.) :: a -> a -> Relation a
infix 1 ./=.
(.<.) :: a -> a -> Relation a
infix 1 .<.
(.>.) :: a -> a -> Relation a
infix 1 .>.
(.<=.) :: a -> a -> Relation a
infix 1 .<=.
(.>=.) :: a -> a -> Relation a
infix 1 .>=.
(.~=.) :: a -> a -> Relation a
infix 1 .~=.
type Equations a = [Equation a]
data Equation a
(:==:) :: a -> a -> Equation a
infix 1 :==:
equationView :: View (Relation a) (Equation a)
data Inequality a
(:<:) :: a -> a -> Inequality a
(:>:) :: a -> a -> Inequality a
(:<=:) :: a -> a -> Inequality a
(:>=:) :: a -> a -> Inequality a
infix 1 :<:
infix 1 :>:
infix 1 :<=:
infix 1 :>=:
inequalityView :: View (Relation a) (Inequality a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Math.Data.Relation.Equation a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Math.Data.Relation.Equation a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Math.Data.Relation.Relation a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Math.Data.Relation.Relation a)
instance GHC.Enum.Enum Domain.Math.Data.Relation.RelationType
instance GHC.Classes.Ord Domain.Math.Data.Relation.RelationType
instance GHC.Classes.Eq Domain.Math.Data.Relation.RelationType
instance GHC.Show.Show Domain.Math.Data.Relation.RelationType
instance GHC.Show.Show a => GHC.Show.Show (Domain.Math.Data.Relation.Inequality a)
instance GHC.Base.Functor Domain.Math.Data.Relation.Inequality
instance Data.Foldable.Foldable Domain.Math.Data.Relation.Inequality
instance Data.Traversable.Traversable Domain.Math.Data.Relation.Inequality
instance Domain.Math.Data.Relation.Relational Domain.Math.Data.Relation.Inequality
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Math.Data.Relation.Inequality a)
instance Test.QuickCheck.Arbitrary.CoArbitrary a => Test.QuickCheck.Arbitrary.CoArbitrary (Domain.Math.Data.Relation.Inequality a)
instance Ideas.Common.Rewriting.Term.IsTerm a => Ideas.Common.Rewriting.Term.IsTerm (Domain.Math.Data.Relation.Inequality a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Math.Data.Relation.Equation a)
instance GHC.Base.Functor Domain.Math.Data.Relation.Equation
instance Data.Foldable.Foldable Domain.Math.Data.Relation.Equation
instance Data.Traversable.Traversable Domain.Math.Data.Relation.Equation
instance Domain.Math.Data.Relation.Relational Domain.Math.Data.Relation.Equation
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Math.Data.Relation.Equation a)
instance Test.QuickCheck.Arbitrary.CoArbitrary a => Test.QuickCheck.Arbitrary.CoArbitrary (Domain.Math.Data.Relation.Equation a)
instance Ideas.Common.Rewriting.Term.IsTerm a => Ideas.Common.Rewriting.Term.IsTerm (Domain.Math.Data.Relation.Equation a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Math.Data.Relation.Relation a)
instance GHC.Base.Functor Domain.Math.Data.Relation.Relation
instance Data.Foldable.Foldable Domain.Math.Data.Relation.Relation
instance Data.Traversable.Traversable Domain.Math.Data.Relation.Relation
instance Domain.Math.Data.Relation.Relational Domain.Math.Data.Relation.Relation
instance Ideas.Common.Rewriting.Term.IsTerm a => Ideas.Common.Rewriting.Term.IsTerm (Domain.Math.Data.Relation.Relation a)
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Math.Data.Relation.Relation a)
instance Test.QuickCheck.Arbitrary.CoArbitrary a => Test.QuickCheck.Arbitrary.CoArbitrary (Domain.Math.Data.Relation.Relation a)
instance Test.QuickCheck.Arbitrary.Arbitrary Domain.Math.Data.Relation.RelationType
instance Test.QuickCheck.Arbitrary.CoArbitrary Domain.Math.Data.Relation.RelationType


module Domain.Math.Data.WithBool
data WithBool a
fromWithBool :: WithBool a -> Either Bool a

-- | The <a>join</a> function is the conventional monad join operator. It
--   is used to remove one level of monadic structure, projecting its bound
--   argument into the outer level.
--   
--   <h4><b>Examples</b></h4>
--   
--   A common use of <a>join</a> is to run an <a>IO</a> computation
--   returned from an <a>STM</a> transaction, since <a>STM</a> transactions
--   can't perform <a>IO</a> directly. Recall that
--   
--   <pre>
--   <a>atomically</a> :: STM a -&gt; IO a
--   </pre>
--   
--   is used to run <a>STM</a> transactions atomically. So, by specializing
--   the types of <a>atomically</a> and <a>join</a> to
--   
--   <pre>
--   <a>atomically</a> :: STM (IO b) -&gt; IO (IO b)
--   <a>join</a>       :: IO (IO b)  -&gt; IO b
--   </pre>
--   
--   we can compose them as
--   
--   <pre>
--   <a>join</a> . <a>atomically</a> :: STM (IO b) -&gt; IO b
--   </pre>
--   
--   to run an <a>STM</a> transaction and the <a>IO</a> action it returns.
join :: Monad m => m (m a) -> m a
instance Test.QuickCheck.Arbitrary.Arbitrary a => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Math.Data.WithBool.WithBool a)
instance GHC.Base.Functor Domain.Math.Data.WithBool.WithBool
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Math.Data.WithBool.WithBool a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Math.Data.WithBool.WithBool a)
instance GHC.Show.Show a => GHC.Show.Show (Domain.Math.Data.WithBool.WithBool a)
instance Ideas.Common.Classes.BoolValue (Domain.Math.Data.WithBool.WithBool a)
instance Ideas.Common.Classes.Container Domain.Math.Data.WithBool.WithBool
instance GHC.Base.Applicative Domain.Math.Data.WithBool.WithBool
instance GHC.Base.Monad Domain.Math.Data.WithBool.WithBool
instance Data.Foldable.Foldable Domain.Math.Data.WithBool.WithBool
instance Data.Traversable.Traversable Domain.Math.Data.WithBool.WithBool
instance Ideas.Common.Rewriting.Term.IsTerm a => Ideas.Common.Rewriting.Term.IsTerm (Domain.Math.Data.WithBool.WithBool a)


-- | Exports relevant OpenMath symbols
module Domain.Math.Expr.Symbols
plusSymbol :: Symbol
timesSymbol :: Symbol
minusSymbol :: Symbol
divideSymbol :: Symbol
rationalSymbol :: Symbol
rootSymbol :: Symbol
gcdSymbol :: Symbol
lcmSymbol :: Symbol
powerSymbol :: Symbol
negateSymbol :: Symbol
sinSymbol :: Symbol
cosSymbol :: Symbol
lnSymbol :: Symbol
diffSymbol :: Symbol
piSymbol :: Symbol
lambdaSymbol :: Symbol
listSymbol :: Symbol
absSymbol :: Symbol
signumSymbol :: Symbol
logSymbol :: Symbol
expSymbol :: Symbol
tanSymbol :: Symbol
asinSymbol :: Symbol
atanSymbol :: Symbol
acosSymbol :: Symbol
sinhSymbol :: Symbol
tanhSymbol :: Symbol
coshSymbol :: Symbol
asinhSymbol :: Symbol
atanhSymbol :: Symbol
acoshSymbol :: Symbol
bottomSymbol :: Symbol
fcompSymbol :: Symbol
mixedFractionSymbol :: Symbol
isPlus :: (WithFunctions a, MonadPlus m) => a -> m (a, a)
isTimes :: (WithFunctions a, MonadPlus m) => a -> m (a, a)
isMinus :: (WithFunctions a, MonadPlus m) => a -> m (a, a)
isDivide :: (WithFunctions a, MonadPlus m) => a -> m (a, a)
isPower :: (WithFunctions a, MonadPlus m) => a -> m (a, a)
isNegate :: (WithFunctions a, MonadPlus m) => a -> m a
isRoot :: (WithFunctions a, MonadPlus m) => a -> m (a, a)
isPowerSymbol :: Symbol -> Bool
isRootSymbol :: Symbol -> Bool
isLogSymbol :: Symbol -> Bool
isDivideSymbol :: Symbol -> Bool
isMixedFractionSymbol :: Symbol -> Bool
(^) :: WithFunctions a => a -> a -> a
infixr 8 ^
root :: WithFunctions a => a -> a -> a
mixed :: (Num a, WithFunctions a) => Integer -> Integer -> Integer -> a


module Domain.Math.Expr.Data
data Expr
(:+:) :: Expr -> Expr -> Expr
(:*:) :: Expr -> Expr -> Expr
(:-:) :: Expr -> Expr -> Expr
Negate :: Expr -> Expr
Nat :: Integer -> Expr
(:/:) :: Expr -> Expr -> Expr
Sqrt :: Expr -> Expr
Number :: Double -> Expr
Var :: String -> Expr
Sym :: Symbol -> [Expr] -> Expr
toExpr :: IsTerm a => a -> Expr
fromExpr :: (MonadPlus m, IsTerm a) => Expr -> m a
fromDouble :: Double -> Expr
instance GHC.Classes.Eq Domain.Math.Expr.Data.Associativity
instance GHC.Show.Show Domain.Math.Expr.Data.Associativity
instance GHC.Classes.Ord Domain.Math.Expr.Data.Expr
instance GHC.Classes.Eq Domain.Math.Expr.Data.Expr
instance GHC.Num.Num Domain.Math.Expr.Data.Expr
instance GHC.Real.Fractional Domain.Math.Expr.Data.Expr
instance GHC.Float.Floating Domain.Math.Expr.Data.Expr
instance Ideas.Common.Rewriting.Term.WithFunctions Domain.Math.Expr.Data.Expr
instance Ideas.Common.Rewriting.Term.WithVars Domain.Math.Expr.Data.Expr
instance Data.Generics.Uniplate.Operations.Uniplate Domain.Math.Expr.Data.Expr
instance Test.QuickCheck.Arbitrary.Arbitrary Domain.Math.Expr.Data.Expr
instance GHC.Show.Show Domain.Math.Expr.Data.Expr
instance Domain.Algebra.Field.SemiRing Domain.Math.Expr.Data.Expr
instance Domain.Algebra.Field.Ring Domain.Math.Expr.Data.Expr
instance Domain.Algebra.Field.Field Domain.Math.Expr.Data.Expr
instance Domain.Algebra.Field.CoSemiRing Domain.Math.Expr.Data.Expr
instance Domain.Algebra.Field.CoRing Domain.Math.Expr.Data.Expr
instance Domain.Algebra.Field.CoField Domain.Math.Expr.Data.Expr
instance Ideas.Common.Rewriting.RewriteRule.Different Domain.Math.Expr.Data.Expr
instance Ideas.Common.Rewriting.Term.IsTerm Domain.Math.Expr.Data.Expr


module Domain.Math.Expr.Parser
parseExpr :: String -> Either String Expr
parseExprM :: Monad m => String -> m Expr
pExpr :: Parser Expr
pRelExpr :: Parser (Relation Expr)
parseEqExpr :: String -> Either String (Equation Expr)
parseBoolEqExpr :: String -> Either String (WithBool (Equation Expr))
parseRelExpr :: String -> Either String (Relation Expr)
parseOrsEqExpr :: String -> Either String (OrList (Equation Expr))
parseOrsRelExpr :: String -> Either String (OrList (Relation Expr))
parseLogicRelExpr :: String -> Either String (Logic (Relation Expr))
parseExprTuple :: String -> Either String [Expr]
instance GHC.Read.Read Domain.Math.Expr.Data.Expr
instance Ideas.Common.Environment.Reference Domain.Math.Expr.Data.Expr


-- | Support for a clipboard, on which expressions can be placed. The
--   clipboard is part of the environment (terms that are placed in a
--   context)
module Domain.Math.Expr.Clipboard
data Clipboard
addToClipboard :: String -> Expr -> Context a -> Context a
removeClipboard :: String -> Context a -> Context a
lookupClipboard :: String -> Context b -> Maybe Expr
addToClipboardG :: IsTerm a => String -> a -> Context b -> Context b
lookupClipboardG :: IsTerm a => String -> Context b -> Maybe a
instance GHC.Show.Show Domain.Math.Expr.Clipboard.Clipboard
instance GHC.Read.Read Domain.Math.Expr.Clipboard.Clipboard
instance Ideas.Common.Rewriting.Term.IsTerm Domain.Math.Expr.Clipboard.Clipboard
instance Ideas.Common.Environment.Reference Domain.Math.Expr.Clipboard.Clipboard


module Domain.Math.Expr.Views
(.^.) :: Expr -> Expr -> Expr
infixr 8 .^.
plusView :: View Expr (Expr, Expr)
timesView :: View Expr (Expr, Expr)
divView :: View Expr (Expr, Expr)
sumView :: Isomorphism Expr [Expr]
simpleSumView :: Isomorphism Expr [Expr]
productView :: Isomorphism Expr (Bool, [Expr])
simpleProductView :: Isomorphism Expr (Bool, [Expr])
selectVar :: Expr -> Maybe String
(.+.) :: (CoField a, Field a) => a -> a -> a
infixl 6 .+.
(.-.) :: (CoField a, Field a) => a -> a -> a
infixl 6 .-.
neg :: (CoField a, Field a) => a -> a
(.*.) :: (CoField a, Field a) => a -> a -> a
infixl 7 .*.
(./.) :: (CoField a, Field a) => a -> a -> a
infixl 7 ./.


module Domain.Math.Expr


module Domain.Math.Safe
class Num a => SafeDiv a
safeDiv :: SafeDiv a => a -> a -> Maybe a
safeRecip :: SafeDiv a => a -> Maybe a
safeDivFractional :: (Eq a, Fractional a) => a -> a -> Maybe a
class Num a => SafePower a
safePower :: SafePower a => a -> a -> Maybe a
safeSqrt :: SafePower a => a -> Maybe a
safeRoot :: SafePower a => a -> a -> Maybe a
instance Domain.Math.Safe.SafePower GHC.Integer.Type.Integer
instance GHC.Real.Integral a => Domain.Math.Safe.SafePower (GHC.Real.Ratio a)
instance Domain.Math.Safe.SafePower GHC.Types.Double
instance Domain.Math.Safe.SafeDiv GHC.Integer.Type.Integer
instance Domain.Math.Safe.SafeDiv GHC.Types.Double
instance GHC.Real.Integral a => Domain.Math.Safe.SafeDiv (GHC.Real.Ratio a)


module Domain.Math.Data.SquareRoot
data SquareRoot a
imaginary :: SquareRoot a -> Bool
imaginaryUnit :: Num a => SquareRoot a
con :: (Eq a, Num a) => a -> SquareRoot a
toList :: SquareRoot a -> [(a, Integer)]
scale :: (Eq a, Num a) => a -> SquareRoot a -> SquareRoot a
fromSquareRoot :: Num a => SquareRoot a -> Maybe a
sqrt :: Num a => Integer -> SquareRoot a
sqrtRational :: (Eq a, Fractional a) => Rational -> SquareRoot a
isqrt :: Integer -> Integer
eval :: Floating a => SquareRoot a -> a
instance GHC.Classes.Ord a => GHC.Classes.Ord (Domain.Math.Data.SquareRoot.SquareRoot a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Domain.Math.Data.SquareRoot.SquareRoot a)
instance (GHC.Show.Show a, GHC.Classes.Eq a, GHC.Num.Num a) => GHC.Show.Show (Domain.Math.Data.SquareRoot.SquareRoot a)
instance GHC.Base.Functor Domain.Math.Data.SquareRoot.SquareRoot
instance (GHC.Classes.Eq a, GHC.Num.Num a) => GHC.Num.Num (Domain.Math.Data.SquareRoot.SquareRoot a)
instance (GHC.Classes.Eq a, GHC.Real.Fractional a) => Domain.Math.Safe.SafeDiv (Domain.Math.Data.SquareRoot.SquareRoot a)
instance (GHC.Classes.Eq a, GHC.Real.Fractional a) => GHC.Real.Fractional (Domain.Math.Data.SquareRoot.SquareRoot a)
instance (GHC.Classes.Eq a, GHC.Real.Fractional a) => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Math.Data.SquareRoot.SquareRoot a)


module Domain.Math.Data.Polynomial
data Polynomial a
toPolynomial :: (Eq a, Num a) => [a] -> Polynomial a
fromPolynomial :: (Eq a, Num a) => Polynomial a -> [a]
var :: (Eq a, Num a) => Polynomial a
con :: (Eq a, Num a) => a -> Polynomial a

-- | Raise all powers by a constant (discarding negative exponents)
raise :: (Eq a, Num a) => Int -> Polynomial a -> Polynomial a
degree :: (Eq a, Num a) => Polynomial a -> Int
lowestDegree :: (Eq a, Num a) => Polynomial a -> Int
coefficient :: (Eq a, Num a) => Int -> Polynomial a -> a
isRoot :: (Eq a, Num a) => Polynomial a -> a -> Bool
positiveRoots :: (Eq a, Num a) => Polynomial a -> Int
negativeRoots :: (Eq a, Num a) => Polynomial a -> Int
derivative :: (Eq a, Num a) => Polynomial a -> Polynomial a
eval :: (Eq a, Num a) => Polynomial a -> a -> a
polynomialGCD :: (Eq a, Fractional a) => Polynomial a -> Polynomial a -> Polynomial a
factorize :: Polynomial Rational -> [Polynomial Rational]
testPolynomials :: TestSuite
instance (GHC.Classes.Eq a, GHC.Num.Num a) => GHC.Classes.Eq (Domain.Math.Data.Polynomial.Polynomial a)
instance (GHC.Classes.Eq a, GHC.Show.Show a, GHC.Num.Num a) => GHC.Show.Show (Domain.Math.Data.Polynomial.Polynomial a)
instance (GHC.Classes.Eq a, GHC.Real.Fractional a) => Domain.Math.Safe.SafeDiv (Domain.Math.Data.Polynomial.Polynomial a)
instance GHC.Base.Functor Domain.Math.Data.Polynomial.Polynomial
instance Data.Foldable.Foldable Domain.Math.Data.Polynomial.Polynomial
instance Data.Traversable.Traversable Domain.Math.Data.Polynomial.Polynomial
instance (GHC.Classes.Eq a, GHC.Num.Num a) => GHC.Num.Num (Domain.Math.Data.Polynomial.Polynomial a)
instance (GHC.Classes.Eq a, Test.QuickCheck.Arbitrary.Arbitrary a, GHC.Num.Num a) => Test.QuickCheck.Arbitrary.Arbitrary (Domain.Math.Data.Polynomial.Polynomial a)


module Domain.Math.Data.DecimalFraction

-- | Data type for decimal fractions
newtype DecimalFraction
DF :: Rational -> DecimalFraction

-- | Approximation of a double, with a precision of 8 digits
fromDouble :: Double -> DecimalFraction

-- | Tests whether it is safe to divide by this fraction: it is safe to
--   divide if its numerator(!) is a product of two's and five's.
validDivisor :: DecimalFraction -> Bool

-- | number of decimal digits
digits :: DecimalFraction -> Int
instance Test.QuickCheck.Arbitrary.Arbitrary Domain.Math.Data.DecimalFraction.DecimalFraction
instance GHC.Real.Real Domain.Math.Data.DecimalFraction.DecimalFraction
instance GHC.Num.Num Domain.Math.Data.DecimalFraction.DecimalFraction
instance GHC.Classes.Ord Domain.Math.Data.DecimalFraction.DecimalFraction
instance GHC.Classes.Eq Domain.Math.Data.DecimalFraction.DecimalFraction
instance GHC.Show.Show Domain.Math.Data.DecimalFraction.DecimalFraction
instance GHC.Real.Fractional Domain.Math.Data.DecimalFraction.DecimalFraction
instance Domain.Math.Safe.SafeDiv Domain.Math.Data.DecimalFraction.DecimalFraction
instance Domain.Math.Safe.SafePower Domain.Math.Data.DecimalFraction.DecimalFraction


module Domain.Math.Numeric.Views

-- | Non-negative numbers only, also for intermediate results
naturalView :: View Expr Integer
naturalNF :: View Expr Integer
integerView :: View Expr Integer
integerNF :: View Expr Integer
decimalFractionView :: View Expr DecimalFraction

-- | like the original defintion, except that this view now also converts
--   floating point numbers (using an exact approximation)
rationalView :: View Expr Rational
rationalNF :: View Expr Rational
rationalRelaxedForm :: View Expr Rational
fractionForm :: View Expr (Integer, Integer)
rationalApproxView :: View Expr Rational
mixedFractionView :: View Expr MixedFraction
mixedFractionNF :: View Expr MixedFraction
doubleView :: View Expr Double
doubleNF :: View Expr Double