On Nov. 21, Robert Dodier wrote:
------------------------
> OK, here's my attempt at a solution.
>
> I used defrule instead of tellsimpafter to define rules.
> I chose defrule in order to work around a tellsimpafter
> idiosyncrasy; namely that multiple tellsimpafter rules are not all
> executed -- there is a flag AFTERFLAG* or something like that
> which, I guess, is supposed to prevent infinite loops, but also prevents
> multiple rules for the same operator from firing.
>
> I'd be happy to explain the rules in more detail (assuming they work
> as intended). I think the built-in rule machinery is the best way to
> go here -- doing stuff like factoring out scalars by hand is essentially
> just reinventing stuff that already exists in the rule code.
--------------------------------
Thanks for the great example of using the defrule approach.
I will take the code for a test drive.
-----------------------------
On Nov. 22, Leo Butler wrote:
--
> I agree about the virtue of re-using code.
> And using defrule is better than using tellsimp.* because the programmer
> gets to choose where things happen, rather than the simplifier.
>
> However, if you write your rules in such a way that your operators
> don't know who/what their operands are, then
> you can't instantiate multiple Lie algebras ==> you can't easily look
> at representations or homomorphisms or any other derived structure.
--------
I see a simple commutator algebra utility, in which the user is only
interested
in simplifying power series involving comm(a,b) == a.b - b.a,
without concern at the expansion stage with the nature of the
Lie algebra structure constants, as being
a limited tool, but useful for some Maxima users.
More powerful utilities with a variety of abilities to manipulate
Lie algebra group elements and the algebra generators and
representations would of course also be of use for
some Maxima users.
Ted