Documentation

List all possible valuations of an expression (potentially infinite). In pseudo-Haskell:

take 3 $ grounds (lookupTiers preludeInstances) ((x + x) + y)
  == [(0 + 0) + 0, (0 + 0) + 1, (1 + 1) + 0]

Note this function will return an empty list when a Listable instance is not found in the Instances list.

List all possible variable bindings to an expression

take 3 $ groundBinds (lookupTiers preludeInstances) ((x + x) + y)
  == [ [("x",0),("y",0)]
     , [("x",0),("y",1)]
     , [("x",1),("y",0)] ]

Are two expressions equal for a given number of tests?

Are two expressions less-than-or-equal for a given number of tests?

Are two expressions less-than for a given number of tests?

Are two expressions inequal for *all* variable assignments? Note this is different than not . equal.

Is a boolean expression true for all variable assignments?

Is an expression ALWAYS false? This is *NOT* the same as not true.

Are two expressions equal under a given condition for a given number of tests?

Are two expressions equal under a given condition for a given number of tests and a minimum amount of tests

Under a maximum number of tests, returns the ratio for which an expression holds true.

O(n). Turn all variables in an expression into fake constants.

> vars (xx -+- yy)
[x :: Int, y :: Int]

> constify (xx -+- yy)
x + y :: Int

> vars (constify (xx -+- yy))
[]

O(n). Returns a list with all possible permutations of variables in the given expression, all constifyed into fake constants.

> constifications (xx -+- yy)
[ x + y :: Int
, y + x :: Int ]

> constifications (xx -:- xxs)
[ x:xs :: [Int] ]

Types are respected.

This is useful for checking ground-joinability in term rewriting.