0. Code

>

restart;

>	txln := `\n____________________________________________________________________________`:

1. Rules of Exponents

Here are some of the main rules of exponents, and their application in Maple.

>	print(cat(txln,`\n1. Product Rule`)); a^n * a^m: %= simplify(%);print(txln);

>	10^5 * 10^2;

>	x^5 * x^4;

>	y^8 * y^5;

>	(x+4)^10 * (x+4)^8;

>	x^4 * y^3; `Note that the bases must be the same to use this rule`;

>	distance^2 * distance^3;

>	print(cat(txln,`\n2. Quotient Rule`));a^n / a^m: %= simplify(%); print(txln);

>	10^9 / 10^6;

>	x^14/x^13;

>	x^20 / x^23;

>	q^100 / q^10;

>	(y + 7)^3 / (y+7)^5;

>	print(cat(txln,`\n3. Zero Power is One`)); `a^0` = expand(a^0);print(txln);

>	13^0;    813^0;      (-29)^0;       (3/19)^0;     (41239)^0;    (3.14159)^0;

>	print(cat(txln,`\n4. Power of One is Identity`));`a^1` =simplify(a^1); print(txln);

>	13^1;    813^1;      (-29)^1;       (3/19)^1;     (41239)^1;    (3.14159)^1;

>	print(cat(txln,`\n5. Power of a Power`));  (a^n)^m = a^(n*m) ;     print(txln);

>

(x^2)^3;

>	(y^10)^5;  `Compare with ...`, (y^10)*(y^5),` power of a power ­ product of powers`;

>	((t - 7)^8 )^3 ;

>	print(cat(txln,`\n6. Power of Product`));  (a*b)^m = (a^n)*(b^m);  print(txln);

>

(3*x)^4;

>

(8*y)^10;

>	print(cat(txln,`\n7. Power of a Product of Powers`));             (a^n*b^m)^m = (a^(n*p))*(b^(m*p));             `(This is a combination of rules 1 and 6.)`; print(txln);

>	(x^3 * y^5) ^ 2;

>	(x^10 * y^20) ^ 5;

>	(17 * M^7) ^ 2;

>	(3 * x^10 * y^7) ^ 4;

>	(a^2 * b^3 * c^4 * d^5 ) ^ 10;

>	print(cat(txln,`\n8. Power of a Quotient`)); (a/b)^n =(a^n)/(b^n); print(txln);

>

(3/4)^3;

>

(x/2)^5;

>

(a/b)^4;

>	(3/(x+5))^9;

>	print(cat(txln,`\n9. Power of a Quotient of Powers`));                  (a^n * b^m)^p =  a^(n*p)*b^(m*p);                `(This is a combination of rules 2 and 8.)`; print(txln);

>	( x^3 / y^ 5)^2;

>	( 1 / pressure^2) ^ 3;

>	(x^10 / 3) ^ 5;

2. Negative Exponents

There are a few more rules which involve negative exponents.

>	print(cat(txln,`\n10.  Negative Exponent is Reciprocal`));                       a^(-n) =  1/a^n;        print(txln);

>

3^(-2);

>	`Note :`, 9*3^(-2), 9*(1/9);

>

x^(-13);

>	(-2)^(-3);

>	(-2)^(-4);

>	(1/7)^(-2);

>	print(cat(txln,`\n11. Reciprocal of a Reciprocal is Original`));                       1/a^(-n) =  a^n;        print(txln);

>	1/(4^(-3));

>	1/y^(-12);

>	1/(3*x + 2)^(-5);

>	`Note : Rules 10 and 11 can both be used on the same problem :`;x^(-4) / y^(-9);

>	print(cat(txln,`\n12. Reciprocal of a Fraction is Flipped`)); (a/b)^(-n) =  (b/a)^n;  print(txln);

>	(2/131)^(-1);

>	(x/y)^(-1);

>	(1000/A)^(-1);

>	( (x+1) / (x+2) )^(-1);

>	( (x^2 + 3*x + 1) / (x^2 + 5*x + 2) )^(-1);

>	(( A/B )^(-1))^(-1);

3. Exponent Problems - Products (Monomials)

When multiplying two monomial expressions, numbers can be multiplied, and the same variables can be multiplied - remember that we learned in Rule #1 that we can only multiply variables with the same base. For example, with two expressions with numbers, x, and y's - you multiply :
         - number by number
         - x term by x term
         - y term by y term

>	(3 * x^7* y^2) * (4 * x^4 * y^9);

>	(5 * x^5 * y^2) * (11 * x^11 * y^(-3));

>	(13 * x^(-3)* y^(-8)) * (4 * x^(-2) * y^(-7));

>	(1440 * x^100* y^100) * (1200 * x^100 * y^(-100));

>	(33 * x^33* y^22) * (4 * x^44 * y^55);

4. Exponent Problems - Products (Using Distributive Property)

When we multiply a term by a sum or difference we need to use the Distributive Property.

>	`Distributive Property`; a*(b+c): % = expand(%);

We distribute the term being multiplied to each of the terms inside the parentheses. Then each of those multiplications is a product of monomials.

>	(12*x^10)*(14*x^3 - 1): % = expand(%);

>	(3*x^2)*(14*x + 21): % = expand(%);

>	(2*x^5)*(4*x^5 - x^2): % = expand(%);

>	(a^5*b^10)*(10*a^10*b^9 - a^8*b^7): % = expand(%);

>	(20*a^5*b)*(13*a^4*b^9 - b^2): % = expand(%);

5. Exponent Problems - Quotients - The Idea

6. Exponent Problems - Quotients - Using Maple

We can do these problems in Maple too - quite quickly. Try these by hand, and then check to see if your answer agrees with Maple's answer, or is mathematically equivalent.

>	(36 * x^4 * y^6 ) / (24 * x^5 * y^5);

>	(75 * x^10 * y^3 ) / (24 * x * y^5);

>	(100 * x * y ) / (45 * x^11 * y^9);

>	(32 * x^14 * y^6 ) / (40 * x^5 * y^5);

>	(10 * x^(-4) * y^(-6) ) / (12 * x^5 * y^5);

>	(33 * x^(-5) * y^6 ) / (22 * x^(-5) * y^(-5));

>	(15 * x^4 * y^(-6) ) / (18 * x^(-4) * y^5);

>	((6 * x^2 * y^3) / (30 * x^4 * y^5 ) ) ^(-1) ;

>	((40*x^2*y^9) / (30*x^(-6)*y^8) )^(-2) ;

>	((27 * x^(-32) * y^19) / (24 * x^(-46) * y^8) )^(-4) ;