       How can I handle Operator Algebra ?

• To: mathgroup at smc.vnet.net
• Subject: [mg6564] How can I handle Operator Algebra ?
• From: "Daitaro Hagihara" <daiyanh at mindspring.com>
• Date: Tue, 1 Apr 1997 19:01:00 -0500 (EST)
• Sender: owner-wri-mathgroup at wolfram.com

```It turned out to be rather non-intuitive.  This is the reverse of
Wouter's fatty acid function posted awhile back.  Anyway, the following
works too (after trying out some ridiculous constructs):

Mma? {-(z (D[#1, y] & )) + y (D[#1, z] & ),
z (D[#1, x] & ) - x (D[#1, z] & ),
-(y (D[#1, x] & )) + x (D[#1, y] & )} //.
{a_ Function[b_]->Function[a b],
a_+Function[b_]->Function[a+b],
Function[Function[b_]]->Function[b]}

{-z D[#1, y] + y D[#1, z] & , z D[#1, x] + -x D[#1, z] & ,

-y D[#1, x] + x D[#1, y] & }

Mma? %[Sqrt[x^2+y^2+z^2]]//Through

{0, 0, 0}

The question is, how can one modify Function in order to do the
simplifications?  I could not modify Function without causing infinite
recursions.  "Collecting" Function heads over pluses and times and even
exponential and other transcendental functions isn't such a bizarre
thing to do.  Moreover, good old Simplify gives the following answer:

Mma? {-(z (D[#1, y] & )) + y (D[#1, z] & ),
z (D[#1, x] & ) - x (D[#1, z] & ),
-(y (D[#1, x] & )) + x (D[#1, y] & )}//Simplify

{(y - z) (0 & ), (-x + z) (0 & ), (x - y) (0 & )}

I cannot think of a situation where collecting Function heads causes
problems.  This ought to be a built-in feature, I think.  Never
realized this before until you posted the question.

Daitaro Hagihara

```

• Prev by Date: Convex Polygons with Their Insides Chomped Out
• Next by Date: Re: Solve and Plot
• Previous by thread: Re: How can I handle Operator Algebra ?