simplification.ruleset

# Version: 1.6.5

# Operator elimination (de-sugar)
RULESET
    count()       -> 0
    count(x,[xs]) -> 1 + count([xs])  # Comment test
    +x            -> x
    $x            -> x
    --x           -> x
    x%            -> x / 100
    (x/y)/z       -> x / (y*z)
    x/y           -> x * y^(-1)
    log(x, y)     -> ln(x)/ln(y)
    tan(x)        -> sin(x) / cos(x)
    sqrt(x)       -> x^0.5
    exp(x)        -> e^x
    root(x, y)    -> x^(1/y)
    avg([xs])     -> sum([xs]) / count([xs])   # Comment test

   # var(x,[xs])   -> (sum(x,[xs]) -  count(x,[xs]) * avg(x,[xs])) / count(x,[xs])

# Deriv elimination
RULESET
    # For performance
    x*0                 -> 0
    0*x                 -> 0
    x+0                 -> x
    0+x                 -> x
    1*x                 -> x
    x*1                 -> x

    deriv(x, x)         -> 1
    deriv(x, z)         -> 0               WHERE type(x) != OP
    deriv(cx*y, y)      -> cx              WHERE type(cx) == CONST
    deriv(y^cx, y)      -> cx*y^(cx-1)     WHERE type(cx) == CONST
    deriv(cx * z^cy, z) -> cx*cy*z^(cy-1)  WHERE type(cx) == CONST ; type(cy) == CONST
    deriv(-x, z)        -> -deriv(x, z)
    deriv(x + y, z)     -> deriv(x, z) + deriv(y, z)
    deriv(x - y, z)     -> deriv(x, z) - deriv(y, z)
    deriv(x*y, z)       -> deriv(x, z)*y + x*deriv(y, z)
    deriv(x/y, z)       -> deriv(x*(y^(-1)), z)
    deriv(sin(x), z)    -> cos(x) * deriv(x, z)
    deriv(cos(x), z)    -> -sin(x) * deriv(x, z)
    deriv(tan(x), z)    -> deriv(x, z) * cos(x)^-2
    deriv(asin(x), z)   -> deriv(x, z) / sqrt(1 - x^2)
    deriv(acos(x), z)   -> -deriv(x, z) / sqrt(1 - x^2)
    deriv(atan(x), z)   -> deriv(x, z) / (x^2 + 1)
    deriv(e^y, z)       -> deriv(y, z)*e^y
    deriv(x^y, z)       -> (y * deriv(x, z) * x^-1 + deriv(y, z) * ln(x)) * x^y
    deriv(ln(x), z)     -> deriv(x, z)*x^(-1)

# Normal form
RULESET
    x-y    -> x+(-y)
    -(x+y) -> -x+(-y)
    -(x*y) -> (-x)*y
    # Flatten products
    x*y                          -> prod(x,y)
    prod([xs], prod([ys]), [zs]) -> prod([xs], [ys], [zs])
    prod([xs])*prod([ys])        -> prod([xs], [ys])
    x*prod([xs])                 -> prod(x, [xs])
    prod([xs])*x                 -> prod([xs], x)
    # Flatten sums
    x+y                        -> sum(x,y)
    sum([xs], sum([ys]), [zs]) -> sum([xs], [ys], [zs])
    sum([xs])+sum([ys])        -> sum([xs], [ys])
    x+sum([xs])                -> sum(x, [xs])
    sum([xs])+x                -> sum([xs], x)

# Main simplification DONT USE INFIX + AND - HERE!
RULESET
    # Flatten again and easy simplification
    prod()                       -> 1
    prod(x)                      -> x
    sum()                        -> 0
    sum(x)                       -> x
    prod([xs], 0, [ys])          -> 0
    prod([xs], 1, [ys])          -> prod([xs], [ys])
    sum([xs], 0, [ys])           -> sum([xs], [ys])
    sum([xs], sum([ys]), [zs])   -> sum([xs], [ys], [zs])
    prod([xs], prod([ys]), [zs]) -> prod([xs], [ys], [zs])

    # Misc.
    --x -> x
    x/0 -> 0/0 WHERE x != 0

    # Operator ordering
    # Products before powers
    sum([xs], x^y, [ys], prod([yys]), [zs]) -> sum([xs], prod([yys]), [ys], x^y, [zs])
    # Sums before powers
    prod([xs], x^y, [ys], sum([yys]), [zs]) -> prod([xs], sum([yys]), [ys], x^y, [zs])

    # Multiplication of constants
    prod(cx, [xs], sum(cy, [xxs]), [zs])    -> prod([xs], sum(cx*cy, prod(cx, sum([xxs]))), [zs]) WHERE type(cx)==CONST ; type(cy)==CONST

    # Simplify sums
    sum([xs], x, [ys], y, [zs]) -> sum([xs], [ys], [zs])  WHERE equal(y,-x) || equal(x,-y)


    # Pull minus into sum
    -sum(x,[xs])                 -> sum(-x,-sum([xs]))

    # Products sign is determined by its first factor
    # i.e. No minuses before a product or after first factor
    -prod(x, [xs])               -> prod(-x, [xs])
    prod(y, [xs], -x, [zs])      -> prod(-y, [xs], x, [zs])

    # Products within sum
    sum([xs], prod(x, y), [ys], y, [zs]) -> sum([xs], prod(x + 1, y), [ys], [zs])
    sum([xs], prod(y, x), [ys], y, [zs]) -> sum([xs], prod(x + 1, y), [ys], [zs])
    sum([xs], y, [ys], prod(x, y), [zs]) -> sum([xs], prod(x + 1, y), [ys], [zs])
    sum([xs], y, [ys], prod(y, x), [zs]) -> sum([xs], prod(x + 1, y), [ys], [zs])
    # Same for negative
    sum([xs], prod(x, y), [ys], -y, [zs]) -> sum([xs], prod(x - 1, y), [ys], [zs])
    sum([xs], prod(y, x), [ys], -y, [zs]) -> sum([xs], prod(x - 1, y), [ys], [zs])
    sum([xs], -y, [ys], prod(x, y), [zs]) -> sum([xs], prod(x - 1, y), [ys], [zs])
    sum([xs], -y, [ys], prod(y, x), [zs]) -> sum([xs], prod(x - 1, y), [ys], [zs])

    # Sum of two equal values
    sum([xs], x, [ys], x, [zs]) -> sum([xs], prod(2,x), [ys], [zs])
    # Two products with common element (Zusammenfassen)
    sum([xs], prod([xxs], x, [yys]), [ys], prod([xxxs], x, [yyys]), [zs]) -> sum([xs], prod(sum(prod([xxs], [yys]), prod([xxxs], [yyys])), x), [ys], [zs])

    # Binomische Formel für Summe mit Konstante
    sum(x, y)^2 -> sum(prod(2,x,y), x^2, y^2)     WHERE type(x) == CONST
    # Binomische Formel rückwärts für alle anderen Fälle
    sum(prod(2, x, y), x^2, y^2) -> sum(x, y)^2   WHERE type(x) != CONST
    sum(prod(2, y, x), x^2, y^2) -> sum(x, y)^2   WHERE type(x) != CONST
    sum(x^2, prod(2, x, y), y^2) -> sum(x, y)^2   WHERE type(x) != CONST
    sum(x^2, y^2, prod(2, y, x)) -> sum(x, y)^2   WHERE type(x) != CONST

    # Powers
    x^0                              -> 1
    x^1                              -> x
    (x^y)^z                          -> x^prod(y, z)

    prod([xs], x^cy, [ys], x^cz, [zs]) -> prod([xs], x^sum(cy,cz), [ys], [zs]) WHERE type(cy)==CONST ; type(cz)==CONST
    prod([xs], cy^x, [ys], cz^x, [zs]) -> prod([xs], (cy*cz)^x, [ys], [zs]) WHERE type(cy)==CONST ; type(cz)==CONST
    prod([xs], x, [ys], x, [zs])     -> prod([xs], x^2, [ys], [zs])
    prod([xs], x, [ys], x^y, [zs])   -> prod([xs], x^sum(y,1), [ys], [zs])
    prod(x, y)^z                     -> prod(x^z, y^z)
    prod([xs], x^y, [ys], x, [zs])   -> prod([xs], x^sum(y,1), [ys], [zs])
    prod([xs], x^z, [ys], x^y, [zs]) -> prod([xs], x^sum(y,z), [ys], [zs])

    prod([xs], sum([xxs], x^y, [yys]), [ys], x^z, [zs]) -> sum(prod([xs], sum([xxs], [yys]), [ys], x^z, [zs]), x^sum(y,z))

    # Trigonometrics
    sum([xs], cos(x)^2, [ys], sin(x)^2, [zs])   -> sum(1, [xs], [ys], [zs])
    sum([xs], sin(x)^2, [ys], cos(x)^2, [zs])   -> sum(1, [xs], [ys], [zs])
    prod([xs], sin(x), [ys], cos(x)^-1, [zs])   -> prod([xs], tan(x), [ys], [zs])
    prod([xs], sin(x)^y, [ys], cos(x)^-y, [zs]) -> prod([xs], tan(x)^y, [ys], [zs])
    prod(sin(atan(x)), cos(atan(x))^-1) -> x

    # Some special ops
    min([xs], x, [ys], x, [zs]) -> min([xs], x, [ys], [zs])
    max([xs], x, [ys], x, [zs]) -> max([xs], x, [ys], [zs])

    (-x)^y -> x^y WHERE (y mod 2) == 0

    # Ordering trick: Move constants to the left and fold them again in a + or * term
    # Since this RULESET will not affect + and *, the term will be evaluated eventually
    sum([xs],cX,[ys],cY,[zs])  -> sum(cX+cY,[xs],[ys],[zs])   WHERE type(cX) == CONST ; type(cY) == CONST
    sum(x+y,[xs],cX,[ys])      -> sum(x+y+cX,[xs],[ys])       WHERE type(cX) == CONST
    sum(x,[xs],cX,[ys])        -> sum(cX,x,[xs],[ys])         WHERE type(cX) == CONST
    prod([xs],cX,[ys],cY,[zs]) -> prod(cX*cY,[xs],[ys],[zs])  WHERE type(cX) == CONST ; type(cY) == CONST
    prod(x*y,[xs],cX,[ys])     -> prod(x*y*cX,[xs],[ys])      WHERE type(cX) == CONST
    prod(x,[xs],cX,[ys])       -> prod(cX,x,[xs],[ys])        WHERE type(cX) == CONST

    # Inverse functions
    tan(atan(x)) -> x

# Fold flattened operators again
RULESET
    sum(x)                                  -> x
    prod(x)                                 -> x

    prod(-x, [xs])                          -> -prod(x, [xs])
    sum([xs],-prod([xxs]),[ys])             -> sum([xs],[ys])-prod([xxs])
    -sum([xs], x)                           -> -sum([xs])-x
    sum([xs], x)                            -> sum([xs])+x
    prod([xs], x)                           -> prod([xs])*x

    sum([xs], prod([xxs], -x, [yys]), [ys]) -> sum([xs], [ys]) - prod([xxs],x,[yys])
    prod()                                  -> 1
    sum()                                   -> 0

# Make output pretty (sugarfy)
RULESET
    0*x           -> 0
    1*x           -> x
    0+x           -> x
    x^(-y)        -> 1/(x^y)
    x^0.5         -> sqrt(x)
    x^1           -> x
    -(x+y)        -> x-y
    (-1)*x        -> -x

    x*(y/z)       -> (y*x)/z       WHERE type(y) == CONST
    x+((-y)/z)    -> x-(y/z)
    x+(-y*z)      -> x-y*z
    z*(x+y)       -> z*x + z*y     WHERE type(z) == CONST
    --x           -> x
    (-1)*x        -> -x
    x+(-y)        -> x-y
    (-x)+y        -> y-x
    -(x*y)        -> (-x)*y
    root(x, 2)    -> sqrt(x)
    x^(1/y)       -> root(x, y)

    x+(y+z)       -> x+y+z
    x*(y*z)       -> x*y*z

    sin(x)/cos(x) -> tan(x)

    x/0           -> 1/0    WHERE !equal(x,1)

# Ordering
RULESET
    #x*y      -> y*x     WHERE type(x) != CONST ; type(y) == CONST
    #x+y      -> y+x     WHERE type(x) != CONST ; type(y) == CONST
    x*(-y)    -> -y*x    WHERE type(x) != CONST ; type(y) == CONST