COMMENT REDUCE INTERACTIVE LESSON NUMBER 3 David R. Stoutemyer University of Hawaii Update for REDUCE 3.4 Herbert Melenk Konrad-Zuse-Zentrum Berlin COMMENT This is lesson 3 of 7 REDUCE lessons. Please refrain from using variables beginning with the letters F through H during the lesson. Mathematics is replete with many named elementary and not-so- elementary functions besides the set built into REDUCE such as SIN, COS, and LOG, and it is often convenient to utilize expressions containing a functional form such as F(X) to denote an unknown function or a class of functions. Functions are called operators in REDUCE, and by merely declaring their names as such, we are free to use them for functional forms. For example:; operator f; g1 := f(f(cot(f)), f()); COMMENT Note that 1. We can use the same name for both a variable and an operator. (However, this practice often leads to confusion.) 2. We can use the same operator for any number of arguments -- including zero arguments such as for F(). 3. We can assign values to specific instances of functional forms.; pause; COMMENT COT is one of the functions already defined in REDUCE together with a few of its properties. However, you can augment or even override these definitions depending on the needs of a given problem. For example, if you wished to write COT(F) in terms of TAN, you could say:; cot(f) := 1/tan(f); g1 := g1 + cot(h+1); pause; COMMENT Naturally, our assignment for COT(F) did not affect COT(H+1) in our example above. However, we can use a LET rule to make all cotangents automatically be replaced by the reciprocal of the corresponding tangents:; let cot(~f) => 1/tan(f); g1; COMMENT Any variable preceded by a tilde is a dummy variable which is distinct from any other previously or subsequently introduced indeterminate, variable, or dummy variable having the same name outside the rule. The leftmost occurrence of a dummy variable in a rule must be marked with a tilde. The arguments to LET are either single rules or lists (explicitly enclosed in {..} or as variables with list values). All elements of a list have to be rules (i.e., expressions written in terms of the operator "=>") or names of other rule lists. So we could have written the above command either as LET COT(~F) => 1/TAN(F) or as the command sequence RS := {COT(~F) => 1/TAN(F)} LET RS The CLEARRULES command clears one or more rules. They have to be entered in the same form as for LET -- otherwise REDUCE is unable to identify them.; clearrules cot(~f) => 1/tan(f); cot(g+5); COMMENT Alternative forms would have been CLEARRULES {COT(~F) => 1/TAN(F)} or with the above value of RS CLEARRULES RS Note that CLEAR RS would not remove the rule(s) from the system -- it would only remove the list value from the variable RS.; pause; COMMENT The arguments of a functional form on the left-hand side of a rule can be more complicated than mere indeterminates. For example, we may wish to inform REDUCE how to differentiate expressions involving a symbolic function P, whose derivative is expressed in terms of another function Q.; operator p, q; let df(p(~x), x) => q(x)^2; df(3*p(f*g), g); COMMENT Also, REDUCE obviously knows the chain rule.; pause; COMMENT As another example, suppose that we wish to employ the angle-sum identities for SIN and COS:; let {sin(~x+~y) => sin(x)*cos(y) + sin(y)*cos(x), cos(~x+~y) => cos(x)*cos(y) - sin(x)*sin(y)}; cos(5 + f - g); COMMENT Note that: 1. LET can have any number of replacement rules written as a list. 2. There was no need for rules with 3 or more addends, because the above rules were automatically employed recursively, with two of the three addends 5, F, and -G grouped together as one of the dummy variables the first time through. 3. Despite the sub-expression F-G in our example, there was no need to make rules for the difference of two angles, because sub-expressions of the form X-Y are treated as X+(-Y). 4. Built-in rules were employed to convert expressions of the form SIN(-X) or COS(-X) to -SIN(X) or COS(X) respectively. As an exercise, try to implement rules which transform the logarithms of products and quotients respectively to sums and differences of logarithms, while converting the logarithm of a power of a quantity to the power times the logarithm of the quantity.; pause; COMMENT Actually, the left-hand side of a rule also can be somewhat more general than a functional form. The left-hand side can be a power of an indeterminate or of a functional form, or a product of such powers and/or indeterminates or functional forms. For example, we can have the rule SIN(~X)^2 => 1 - COS(~X)^2 or we can have the rule:; let cos(~x)^2 => 1 - sin(~x)^2; g1 := cos(f)^3 + cos(g); pause; COMMENT Note that a replacement takes place wherever the left-hand side of a rule divides a term. With a rule replacing SIN(X)^2 and a rule replacing COS(X)^2 simultaneously in effect, an expression which uses either one will lead to an infinite recursion that eventually exhausts the available storage. (Try it if you wish -- after the lesson). We are also permitted to employ a more symmetric rule using a top level "+" provided that no free variables appear in the rule. However, a rule such as "SIN(~X)^2 + COS(X)^2 => 1" is not permitted. We can get around the restriction against a top-level "+" on the left-hand side though, at the minor nuisance of having to employ an operator whenever we want the rule applied to an expression:; clearrules cos(~x)^2 => 1 - sin(~x)^2; operator trigsimp; trigsimp_rules := { trigsimp(~a*sin(~x)^2 + a*cos(x)^2 + ~c) => a + trigsimp(c), trigsimp(~a*sin(~x)^2 + a*cos(x)^2) => a, trigsimp(sin(~x)^2 + cos(x)^2 + ~c) => 1 + trigsimp(c), trigsimp(sin(~x)^2 + cos(x)^2) => 1, trigsimp(~x) => x }$ g1 := f*cos(g)^2 + f*sin(g)^2 + g*sin(g)^2 + g*cos(g)^2 + 5; g1 := trigsimp(g1) where trigsimp_rules; pause; COMMENT Here we use another syntactical paradigm: the rule list is assigned to a name (here TRIGSIMP_RULES) and it is activated only locally for one evaluation, using the WHERE clause. Why doesn't our rule TRIGSIMP(~X) => X defeat the other more specific ones? The reason is that rules inside a list are applied in the order they are written, with the whole process immediately restarted whenever any rule succeeds. Thus the rule TRIGSIMP(X) = X, intended to make the operator TRIGSIMP eventually evaporate, is tried only after all of the genuine simplification rules have done all they can. For such reasons we usually write rules for an operator in an order which proceeds from the most specific to the most general cases. Experimentation will reveal that TRIGSIMP will not simplify higher powers of sine and cosine, such as COS(X)^4 + 2*COS(X)^2*SIN(X)^2 + SIN(X)^4, and that TRIGSIMP will not necessarily work when there are more than 6 terms. This latter restriction is not fundamental but is a practical one imposed to keep the combinatorial searching associated with the current algorithm under reasonable control. As an exercise, see if you can generalize the rules sufficiently so that 5*COS(H)^2 + 6*SIN(H)^2 simplifies to 5 + SIN(H)^2 or to 6 - COS(H)^2.; pause; COMMENT Rules do not need to have free variables. For example, we could introduce the simplification rule to replace all subsequent instances of M*C^2 by ENERGY:; clear m, c, energy; g1 := (3*m^2*c^2 + m*c^3 + c^2 + m + m*c + m1*c1^2) where m*c^2 => energy; pause; COMMENT Suppose that instead we wish to replace M by ENERGY/C^2:; g1 where m => energy/c^2; COMMENT You may wonder how a rule of the trivial form "indeterminate => ..." differs from the corresponding assignment "indeterminate := ...". The difference is this: 1. The LET rule does not replace any contained bound variables with their values until the rule is actually used for a replacement. 2. The LET rule performs the evaluation of any contained bound variables every time the rule is used. Thus, the rule "X => X + 1" would cause infinite recursion at the first subsequent occurrence of X, as would the pair of rules "{X => Y, Y => X}". (Try it! -- After the lesson.) To illustrate point 1 above, compare the following command sequence with the analogous earlier one in lesson 2, which used assignments throughout:; clear e1, f; e2 := f; let f1 => e1 + e2; f1; e2 := g; f1; pause; COMMENT For a subsequent example, we need to replace E^(I*X) by COS(X)^2 + I*SIN(X)^2 for all X. See if you can successfully introduce this rule. (Without it, the following code will not work correctly!); pause; e^i; COMMENT REDUCE does not match I as an instance of the pattern I*X with X = 1, so if you neglected to include a rule for this degenerate case, do so now.; pause; clear x, n, nminusone; zero := e^(n*i*x) - e^(nminusone*i*x)*e^(i*x); realzero := sub(i=0, zero); imagzero := sub(i=0, -i*zero); COMMENT Regarding the last two assignments as equations, we can solve them to get recurrence relations defining SIN(N*X) and COS(N*X) in terms of angles having lower multiplicity. Can you figure out why I didn't use N-1 rather than NMINUSONE above? Can you devise a similar technique to derive the angle-sum identities that we previously implemented?; pause; COMMENT To implement a set of trigonometric multiple-angle expansion rules, we need to match the patterns SIN(N*X) and COS(N*X) only when N is an integer exceeding 1. We can implement one of the necessary rules as follows:; cos(~n*~x) => cos(x)*cos((n-1)*x) - sin(x)*sin((n-1)*x) when fixp n and n>1; COMMENT Note: 1. In a conditional rule, any dummy variables should appear in the left-hand side of the replacement with a tilde. 2. FIXP, standing for FIX Predicate, is a built-in function which yields true if and only if its argument is an integer. Other useful predicates are NUMBERP, which is true if its argument represents a numeric value, that is an integer, a rational number or a rounded (floating point) number, and EVENP, which is true if its argument is an integer multiple of 2. 3. Arbitrarily-complicated true-false conditions can be composed using the relational operators =, NEQ, <, >, <=, >=, together with the logical operators "AND", "OR", "NOT". 4. The operators < , >, <=, and >= work only when both sides are numbers. 5. The relational operators have higher precedence than "NOT", which has higher precedence than "AND", which has higher precedence than "OR". 6. In a sequence of expressions joined by "AND" operators, testing is done left to right, and testing is discontinued after the first item which is false. 7. In a sequence of expressions joined by "OR" operators, testing is done left to right, and testing is discontinued after the first item which is true. 8. We didn't actually need the "AND N>1" part in the above rule. Can you guess why? Your mission is to complete the set of multiple-angle rules and to test them on the example COS(4*X) + COS(X/3) + COS(F*X).; pause; COMMENT Now suppose that we wish to write a set of rules for doing symbolic integration, such that expressions of the form INTEGRATE(X^P, X) are replaced by X^(P+1)/(P+1) for arbitrary X and P, provided P is independent of X. This will of course be less complete that the analytic integration package available with REDUCE, but for specific classes of integrals it is often a reasonable way to do such integration. Noting that DF(P,X) is 0 if P is independent of X, we can accomplish this as follows:; operator integrate; let integrate(~x^~p, x) => x^(p+1)/(p+1) when df(p, x) = 0; integrate(f^5, f); integrate(g^g, g); integrate(f^g, f); pause; g1 := integrate(g*f^5, f) + integrate(f^5+f^g, f); COMMENT The last example indicates that we must incorporate rules which distribute integrals over sums and extract factors which are independent of the second argument of INTEGRATE. Can you think of rules which accomplish this? It is a good exercise, but this particular pair of properties of INTEGRATE is so prevalent in mathematics that operators with these properties are called linear, and a corresponding declaration is built into REDUCE:; linear integrate; g1; g1 := integrate(f+1, f) + integrate(1/f^5, f); pause; COMMENT We overcame one difficulty and uncovered 3 others. Clearly REDUCE does not consider F to match the pattern F^P as F^1, or 1 to match the pattern as F^0, or 1/F^5 to match the pattern as F^(-1), but we can add additional rules for such cases:; let { integrate(1/~x^~p, x) => x^(1-p)/(1-p) when df(p, x) = 0, integrate(~x, x) => x^2/2, integrate(1, ~x) => x }$ g1; COMMENT A remaining problem is that INTEGRATE(X^-1, X) will lead to X^0/(-1+1), which simplifies to 1/0, which will cause a zero-divide error message. Consequently, we should also include the correct rule for this special case:; let integrate(~x^-1, x) => log(x); integrate(1/x, x); pause; COMMENT We now collect the integration rules so far into one list according to the law that within a rule set a more specific rule should precede the more general one:; integrate_rules := { integrate(1, ~x) => x, integrate(~x, x) => x^2/2, integrate(~x^-1, x) => log(x), integrate(1/~x^~p, x) => x^(1-p)/(1-p) when df(p, x) = 0, integrate(~x^~p, x) => x^(p+1)/(p+1) when df(p, x) = 0 }$ COMMENT Note that there are more elegant ways to match special cases in which variables have the values 0 or 1 by using "double tilde variables" -- see "Advanced use of rule lists" in section 11.3 of the REDUCE User's Manual. This is the end of lesson 3. We leave it as an intriguing exercise to extend this integrator. ;end;