Re: [Axiom-mail] Failure to simplify trig functions of simple rational multiples of %pi

[Martin Rubey]

Dan Hatton <address@hidden> writes:

> knownvaluec2l(someexpression) == subst(someexpression,cos(2*l*%pi) = 1)
> knownvaluec2m(someexpression) == subst(someexpression,cos(2*m*%pi) = 1)
> knownvaluec2n(someexpression) == subst(someexpression,cos(2*n*%pi) = 1)
> knownvalues2l(someexpression) == subst(someexpression,sin(2*l*%pi) = 0)
> knownvalues2m(someexpression) == subst(someexpression,sin(2*m*%pi) = 0)
> knownvalues2n(someexpression) == subst(someexpression,sin(2*n*%pi) = 0)
> knownvaluec1l(someexpression) == subst(someexpression,cos(l*%pi) = (-1)^l)
> knownvaluec1m(someexpression) == subst(someexpression,cos(m*%pi) = (-1)^m)
> knownvaluec1n(someexpression) == subst(someexpression,cos(n*%pi) = (-1)^n)
> knownvalues1l(someexpression) == subst(someexpression,sin(l*%pi) = 0)
> knownvalues1m(someexpression) == subst(someexpression,sin(m*%pi) = 0)
> knownvalues1n(someexpression) == subst(someexpression,sin(n*%pi) = 0)
> knownvals(anexpression) == 
> knownvalues1n(knownvalues1m(knownvalues1l(knownvaluec1n(knownvaluec1m(knownvaluec1l(knownvalues2n(knownvalues2m(knownvalues2l(knownvaluec2n(knownvaluec2m(knownvaluec2l(anexpression))))))))))))

Axiom (FriCAS, OpenAxiom) has quite a powerful pattern matcher.  I think
you'll find it in the book or hyperdoc under "rules and pattern
matching".

important note: functions you use in a suchthat clause in a rule (below:
x | assumedInteger? x) must be declared from EXPR INT to Boolean (or
something similar).

(1) -> l: List EXPR INT := [a,b,c]

   (1)  [a,b,c]
                                              Type: List(Expression(Integer))
(2) -> assumedInteger?(x: EXPR INT): Boolean == member?(x::Symbol, l)
   Function declaration assumedInteger? : Expression(Integer) -> 
      Boolean has been added to workspace.
                                                                   Type: Void
(3) -> r := rule sin(%pi*(x | assumedInteger? x)) == 0
   Compiling function assumedInteger? with type Expression(Integer) -> 
      Boolean 

   (3)  sin(%pi x) == 0
                       Type: RewriteRule(Integer,Integer,Expression(Integer))
(4) -> r sin a

   (4)  sin(a)
                                                    Type: Expression(Integer)
(5) -> r sin(%pi*a)

   (5)  0
                                                    Type:
                                                    Expression(Integer)

Martin