Lesson 5: Newton's method restart;

Newton's method is a method of approximately solving an equation, say LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2J0YrLUYjNiYtRiw2JVEiZkYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RMCZBcHBseUZ1bmN0aW9uO0YnL0Y6USdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGRC8lKXN0cmV0Y2h5R0ZELyUqc3ltbWV0cmljR0ZELyUobGFyZ2VvcEdGRC8lLm1vdmFibGVsaW1pdHNHRkQvJSdhY2NlbnRHRkQvJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZTLUkobWZlbmNlZEdGJDYkLUYjNiQtRiw2JVEieEYnRjZGOUZARkBGQC1GPTYtUSI9RidGQEZCRkVGR0ZJRktGTUZPL0ZSUSwwLjI3Nzc3NzhlbUYnL0ZVRlxvLUkjbW5HRiQ2JFEiMEYnRkBGQEYrRkA=. We start with an initial guess LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYkLUklbXN1YkdGJDYlLUkjbWlHRiQ2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYkLUkjbW5HRiQ2JFEiMEYnL0Y2USdub3JtYWxGJ0Y+LyUvc3Vic2NyaXB0c2hpZnRHRj1GPg==, and Newton's method produces a sequence of numbers LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYkLUklbXN1YkdGJDYlLUkjbWlHRiQ2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYkLUkjbW5HRiQ2JFEiMUYnL0Y2USdub3JtYWxGJ0Y+LyUvc3Vic2NyaXB0c2hpZnRHUSIwRidGPg==, LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYkLUklbXN1YkdGJDYlLUkjbWlHRiQ2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYkLUkjbW5HRiQ2JFEiMkYnL0Y2USdub3JtYWxGJ0Y+LyUvc3Vic2NyaXB0c2hpZnRHUSIwRidGPg==, ... that converges very rapidly to a solution (when things are working well). The formula for Newton's method is LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNictSSVtc3ViR0YkNiUtRiw2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYmRistRiM2Ji1GLDYlUSJuRidGOUY8LUkjbW9HRiQ2LVEiK0YnL0Y9USdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGTi8lKXN0cmV0Y2h5R0ZOLyUqc3ltbWV0cmljR0ZOLyUobGFyZ2VvcEdGTi8lLm1vdmFibGVsaW1pdHNHRk4vJSdhY2NlbnRHRk4vJSdsc3BhY2VHUSwwLjIyMjIyMjJlbUYnLyUncnNwYWNlR0Znbi1JI21uR0YkNiRRIjFGJ0ZKRkpGK0ZKLyUvc3Vic2NyaXB0c2hpZnRHUSIwRictRkc2LVEiPUYnRkpGTEZPRlFGU0ZVRldGWS9GZm5RLDAuMjc3Nzc3OGVtRicvRmluRmVvLUYjNiYtRjQ2JUY2LUYjNiRGQ0ZKRl5vLUZHNi1RKCZtaW51cztGJ0ZKRkxGT0ZRRlNGVUZXRllGZW5GaG4tSSZtZnJhY0dGJDYoLUYjNiZGKy1GIzYmLUYsNiVRImZGJ0Y5RjwtRkc2LVEwJkFwcGx5RnVuY3Rpb247RidGSkZMRk9GUUZTRlVGV0ZZL0ZmblEmMC4wZW1GJy9GaW5GXnEtSShtZmVuY2VkR0YkNiQtRiM2JEZpb0ZKRkpGSkYrRkotRiM2JkYrLUYjNidGKy1GIzYmLUYsNiVRIkRGJy9GOkZORkpGanAtRmFxNiQtRiM2JEZncEZKRkpGSkZqcEZgcUZKRitGSi8lLmxpbmV0aGlja25lc3NHRl1vLyUrZGVub21hbGlnbkdRJ2NlbnRlckYnLyUpbnVtYWxpZ25HRmdyLyUpYmV2ZWxsZWRHRk5GSkYrRkpGK0ZKRitGSg== I defined a function newt to do one iteration of Newton's method: LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYqLUklbXN1YkdGJDYlLUkjbWlHRiQ2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYmLUYvNiVRIm5GJ0YyRjUtSSNtb0dGJDYtUSIrRicvRjZRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0ZFLyUpc3RyZXRjaHlHRkUvJSpzeW1tZXRyaWNHRkUvJShsYXJnZW9wR0ZFLyUubW92YWJsZWxpbWl0c0dGRS8lJ2FjY2VudEdGRS8lJ2xzcGFjZUdRLDAuMjIyMjIyMmVtRicvJSdyc3BhY2VHRlQtSSNtbkdGJDYkUSIxRidGQUZBLyUvc3Vic2NyaXB0c2hpZnRHUSIwRictRj42LVEifkYnRkFGQ0ZGRkhGSkZMRk5GUC9GU1EmMC4wZW1GJy9GVkZcby1GPjYtUSI9RidGQUZDRkZGSEZKRkxGTkZQL0ZTUSwwLjI3Nzc3NzhlbUYnL0ZWRmJvRmhuLUYvNiVRJW5ld3RGJ0YyRjUtSShtZmVuY2VkR0YkNiQtRiM2JC1GLDYlRi4tRiM2JEY6RkFGZW5GQUZBLUY+Ni1RIi5GJ0ZBRkNGRkZIRkpGTEZORlBGW29GXW9GQQ== newt := x -> evalf(x - f(x)/D(f)(x)); This was my function f f:= x -> sin(x) - x/Pi; I rather arbitrarily chose my starting point x[0] := 3; I used a "for loop" to automate the iterations. for count from 0 to 6 do x[count + 1] := newt(x[count]) end do; Some things to notice about the for loop: The whole loop (from "for" to "end do" constitutes one big Maple statement, and must go in one execution group (delineated by the bracket in the left margin). It could all go on one line if it fits, but for better readability it's a good idea to use separate lines, indenting the body of the loop. You can use shift-Enter instead of Enter to make a new line while staying in the same group. Otherwise you get something like this: for count from 2 to 6 do That body could consist of any number of Maple statements, separated by either colons or semicolons. Whether the results are printed depends only on whether there is a colon or semicolon after the final "end do". A "side effect" of the loop is that the loop variable count is left with a value, in this case 7. This can cause trouble if you try to use the same variable as a symbolic variable later. So I try to use names for loop variables that I won't be tempted to use as symbolic variables. Instead of i, j, k I often use ii, jj, kk. In this case Maple seems to have settled on a value: LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSI1RicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdRIjBGJ0ZDRitGQw== was the same as LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSI0RicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdRIjBGJ0ZDRitGQw==, and then all the later LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtRiw2JVEibkYnRjdGOi9GO1Enbm9ybWFsRicvJS9zdWJzY3JpcHRzaGlmdEdRIjBGJ0ZCRitGQg== would have to be the same too. Is this a solution? evalf(f(x[5])); Yes (to within roundoff error). This was an example where Newton's method worked very well. But with other starting points we might not be so lucky. To keep the LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtRiw2JVEibkYnRjdGOi9GO1Enbm9ybWFsRicvJS9zdWJzY3JpcHRzaGlmdEdRIjBGJ0ZCRitGQg== values we just calculated, I'll use a different name for the next table. w[0]:= 5; for count from 0 to 20 do w[count + 1] := newt(w[count]) end do; It's showing no signs of settling down (eventually it does, though). for count from 21 while w[count] <> w[count-1] do w[count + 1] := newt(w[count]) end do: This is a slightly different form of "for loop". Instead of specifying an end value for count, I'm just telling Maple to start at count = 21 and keep going as long as LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2Ji1JJW1zdWJHRiQ2JS1GLDYlUSJ3RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYsNiVRJmNvdW50RidGN0Y6LyUvc3Vic2NyaXB0c2hpZnRHUSIwRictSSNtb0dGJDYtUSUmbmU7RicvRjtRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0ZLLyUpc3RyZXRjaHlHRksvJSpzeW1tZXRyaWNHRksvJShsYXJnZW9wR0ZLLyUubW92YWJsZWxpbWl0c0dGSy8lJ2FjY2VudEdGSy8lJ2xzcGFjZUdRLDAuMjc3Nzc3OGVtRicvJSdyc3BhY2VHRlotRjI2JUY0LUYjNiZGPS1GRDYtUSgmbWludXM7RidGR0ZJRkxGTkZQRlJGVEZWL0ZZUSwwLjIyMjIyMjJlbUYnL0ZmbkZfby1JI21uR0YkNiRRIjFGJ0ZHRkdGQEZHRitGRw==, then stop. Note that when it looks at this condition, Maple already knows LUklbXN1Ykc2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYlLUkjbWlHRiQ2JVEid0YnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GLDYlUSZjb3VudEYnRi9GMi8lL3N1YnNjcmlwdHNoaWZ0R1EiMEYn and LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYlLUkjbWlHRiQ2I1EhRictSSVtc3ViR0YkNiUtRiw2JVEid0YnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYmLUYsNiVRJmNvdW50RidGNUY4LUkjbW9HRiQ2LVEoJm1pbnVzO0YnL0Y5USdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGSC8lKXN0cmV0Y2h5R0ZILyUqc3ltbWV0cmljR0ZILyUobGFyZ2VvcEdGSC8lLm1vdmFibGVsaW1pdHNHRkgvJSdhY2NlbnRHRkgvJSdsc3BhY2VHUSwwLjIyMjIyMjJlbUYnLyUncnNwYWNlR0ZXLUkjbW5HRiQ2JFEiMUYnRkRGRC8lL3N1YnNjcmlwdHNoaWZ0R1EiMEYnRkQ= from the previous iteration. This form of the loop could be a bit dangerous, though, since I don't know for sure that it will ever stop. Well, if necessary I should be able to interrupt Maple by clicking the stop sign. count; w[508], w[509], w[510];

Data structures are ways of storing and organizing data. Maple has lots of data structures. We've seen and used some of them already, though I didn't always mention what they were. It's time I did so. An expression sequence consists of several expressions, separated by commas. For example, this is what solve gives us when it returns more than one solution. restart; E:= solve(x^2 - 4*x + 3); An expression sequence can be assigned as the value of a variable, as above, and we can refer to individual items in the sequence using an index in square brackets, e.g. E[2]; A list is enclosed in square brackets. If there is more than one item inside, the items are separated by commas. L := [a,b,c]; The main difference between an expression sequence and a list is that many commands can deal with a list as a single object, while the members of an expression sequence would be considered as separate inputs to the command. For example, in Lesson 3 when we wanted to plot several different expressions, we were using lists for the expressions to plot and the colours to use. plot([sin(x), cos(x)], x=0 .. 2*Pi, colour=[red,blue]); Again, you can refer to the members of a list L with an index in square brackets. L[2]; You can also assign new values to the individual members of a list, thus changing the list. For example: L[2]:= c; L; (For technical reasons I won't get into, it can't be done this way if the list has more than 100 members) A set is enclosed in curly brackets. Again, if there is more than one item inside, they are separated by commas. S:= {a,b,c}; The main differences between a set and an expresssion sequence or list are that the order of elements in a set is not significant (so {a,b,c} and {a,c,b} are the same set) and duplicate elements are removed (so a set can contain only one copy of any given expression). So this is the same set as S: {b,c,b,a} = S; Once Maple's memory has a particular set in a particular order, it will keep that order. But one sometimes annoying thing about a set, as opposed to a list, is that you can't predict the order beforehand. Even though I entered S as {a,b,c}, it might have come out as {a,c,b}. You could extract a particular member of S with an index in square brackets, just as for an expression sequence or list: S[1]; In this case, having seen S, I know what this will be in this Maple session. But if I open the same worksheet again in a different Maple session, or even restart and re-execute the worksheet, I can't be sure what the result would be. In general, sets should be used in such a way that the order of their elements won't matter. We used a set (containing one element) in the solve command in Lesson 2 solve(a + 3*x = 5, {x}); We could also solve several equations for several variables: S := solve({x + y = b, x - y = c}, {x,y}); The result is returned as a set of equations, one for each variable we're solving for. But what if I want to extract the value of one of the variables, say x, without looking to see what order the set S is in? The trick is to use eval, which, as we saw in Lesson 3, can take a set as its second argument. eval(x,S); eval(y,S); eval([x,y],S);

Newton's method is based on the tangent line approximation. Near LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNiYtRiw2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIj1GJy9GOlEnbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRkQvJSlzdHJldGNoeUdGRC8lKnN5bW1ldHJpY0dGRC8lKGxhcmdlb3BHRkQvJS5tb3ZhYmxlbGltaXRzR0ZELyUnYWNjZW50R0ZELyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGUy1JJW1zdWJHRiQ2JUYzLUYjNiQtSSNtbkdGJDYkUSIwRidGQEZALyUvc3Vic2NyaXB0c2hpZnRHRmhuRkBGK0ZARitGQA== we can approximate the curve LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNictRiw2JVEieUYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIj1GJy9GOlEnbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRkQvJSlzdHJldGNoeUdGRC8lKnN5bW1ldHJpY0dGRC8lKGxhcmdlb3BHRkQvJS5tb3ZhYmxlbGltaXRzR0ZELyUnYWNjZW50R0ZELyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGUy1GIzYmLUYsNiVRImZGJ0Y2RjktRj02LVEwJkFwcGx5RnVuY3Rpb247RidGQEZCRkVGR0ZJRktGTUZPL0ZSUSYwLjBlbUYnL0ZVRmluLUkobWZlbmNlZEdGJDYkLUYjNiQtRiw2JVEieEYnRjZGOUZARkBGQEYrRkBGK0ZARitGQA== by its tangent line at LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNiYtRiw2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIj1GJy9GOlEnbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRkQvJSlzdHJldGNoeUdGRC8lKnN5bW1ldHJpY0dGRC8lKGxhcmdlb3BHRkQvJS5tb3ZhYmxlbGltaXRzR0ZELyUnYWNjZW50R0ZELyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGUy1JJW1zdWJHRiQ2JUYzLUYjNiQtSSNtbkdGJDYkUSIwRidGQEZALyUvc3Vic2NyaXB0c2hpZnRHRmhuRkBGK0ZARitGQA==, which has the equation LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNictRiw2JVEieUYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIj1GJy9GOlEnbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRkQvJSlzdHJldGNoeUdGRC8lKnN5bW1ldHJpY0dGRC8lKGxhcmdlb3BHRkQvJS5tb3ZhYmxlbGltaXRzR0ZELyUnYWNjZW50R0ZELyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGUy1GIzYoRistRiM2Ji1GLDYlUSJmRidGNkY5LUY9Ni1RMCZBcHBseUZ1bmN0aW9uO0YnRkBGQkZFRkdGSUZLRk1GTy9GUlEmMC4wZW1GJy9GVUZbby1JKG1mZW5jZWRHRiQ2JC1GIzYkLUklbXN1YkdGJDYlLUYsNiVRInhGJ0Y2RjktRiM2JC1JI21uR0YkNiRRIjBGJ0ZARkAvJS9zdWJzY3JpcHRzaGlmdEdGXXBGQEZARkAtRj02LVEiK0YnRkBGQkZFRkdGSUZLRk1GTy9GUlEsMC4yMjIyMjIyZW1GJy9GVUZkcC1GIzYnRistRiM2J0YrLUYjNiYtRiw2JVEiREYnL0Y3RkRGQEZnbi1GXm82JC1GIzYkRlpGQEZARkBGZ25GXW9GQC1GPTYtUTEmSW52aXNpYmxlVGltZXM7RidGQEZCRkVGR0ZJRktGTUZPRmpuRlxvLUZebzYkLUYjNiZGZW8tRj02LVEoJm1pbnVzO0YnRkBGQkZFRkdGSUZLRk1GT0ZjcEZlcEZib0ZARkBGQEYrRkBGK0ZARitGQEYrRkA=. That tangent line hits the x axis at LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNictRiw2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIj1GJy9GOlEnbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRkQvJSlzdHJldGNoeUdGRC8lKnN5bW1ldHJpY0dGRC8lKGxhcmdlb3BHRkQvJS5tb3ZhYmxlbGltaXRzR0ZELyUnYWNjZW50R0ZELyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGUy1GIzYmLUklbXN1YkdGJDYlRjMtRiM2JC1JI21uR0YkNiRRIjBGJ0ZARkAvJS9zdWJzY3JpcHRzaGlmdEdGam4tRj02LVEoJm1pbnVzO0YnRkBGQkZFRkdGSUZLRk1GTy9GUlEsMC4yMjIyMjIyZW1GJy9GVUZhby1JJm1mcmFjR0YkNigtRiM2JkYrLUYjNiYtRiw2JVEiZkYnRjZGOS1GPTYtUTAmQXBwbHlGdW5jdGlvbjtGJ0ZARkJGRUZHRklGS0ZNRk8vRlJRJjAuMGVtRicvRlVGYXAtSShtZmVuY2VkR0YkNiQtRiM2JEZYRkBGQEZARitGQC1GIzYmRistRiM2J0YrLUYjNiYtRiw2JVEiREYnL0Y3RkRGQEZdcC1GZHA2JC1GIzYkRmpvRkBGQEZARl1wRmNwRkBGK0ZALyUubGluZXRoaWNrbmVzc0dRIjFGJy8lK2Rlbm9tYWxpZ25HUSdjZW50ZXJGJy8lKW51bWFsaWduR0Zbci8lKWJldmVsbGVkR0ZERkBGK0ZARitGQEYrRkA=, which is what we take for LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIxRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdRIjBGJ0ZDRitGQw==. Then we repeat the process, using the tangent line at LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIxRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdRIjBGJ0ZDRitGQw== to get LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIyRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdRIjBGJ0ZDRitGQw==, etc. I'd like to draw a picture of this process. f:= x -> sin(x) - x/Pi; newt:= x -> evalf(x - f(x)/D(f)(x)); x[0]:= 3; for count from 0 to 6 do x[count+1]:= newt(x[count]) end do; plot([f(x), f(x[0]) + D(f)(x[0])*(x-x[0])], x=2 .. 3, colour=[red,blue]);

The Maple worksheet you submit as homework should contain text explaining what you're doing, as well as Maple input and output. Here's how to do that. Sections help to organize your Maple worksheet. To get a new section, go to the Insert menu and choose Section. To get a new text region, click on the T in the tool bar. Within a text region, in Windows you can switch to LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYqLUkjbW5HRiQ2JFEiMkYnLyUsbWF0aHZhcmlhbnRHUSdub3JtYWxGJy1JI21vR0YkNi1RIn5GJ0YvLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0Y4LyUpc3RyZXRjaHlHRjgvJSpzeW1tZXRyaWNHRjgvJShsYXJnZW9wR0Y4LyUubW92YWJsZWxpbWl0c0dGOC8lJ2FjY2VudEdGOC8lJ2xzcGFjZUdRJjAuMGVtRicvJSdyc3BhY2VHRkctSSNtaUdGJDYlUSJERicvJSdpdGFsaWNHRjhGL0YyLUZLNiVRJU1hdGhGJy9GT1EldHJ1ZUYnL0YwUSdpdGFsaWNGJ0YyLUZLNiVRJW1vZGVGJ0ZTRlVGLw== by pressing Ctrl-R (i.e. the Ctrl and R keys together) or 1D Maple input mode with Ctrl-M, and back to text with Ctrl-T. On a Mac, Ctrl is replaced by Command, the key that looks like this: yIpyIr<K_Tn^T^;N:L`^C:yIu@K\\PqkhpvF:CZ:>DxYqo[;_fiOf_CS;P:FZyYUCN;DJ;D:j;DJ;DZ>VZ<NZ=R;CB;CB;PJ=Pj<Pj<b;Gr;IB<Ir;GR<Mb<OR<MB=SB=S::FZ=VZ=fZ>fZCnZ@F[GV[CV[Gv[Hn[Hn[Iv[F^[F^;Yr=SZFjAlJ@^;:::ZyAr:F\\BBlTx;@jBNZKFZ=F\\;vy>uir;=R:=:;:b:AB;Tj=\\j:`Z;FZ;F:<:;:Z;NZ=^ZJR:LJ<Hj<Dj=Tj?Dk>p:=j;<jBLj<@lRTj=@nbDkj@RKHK>@QD@sJEmKPKeYkRAV[DOEXNrAwjEP;EtSLlTYLF@YsDs[HPTPRMTREUtUXomXq=Ys>HosHR<QPUTOU]lSMNdLpLPmdPS]TQ]]Mf@k:@Z<NZ=>Z<NZ;^Z=Z:R:]b:=d>=SFARN?t>CRR[YV=fB=Wf_syoP@Hj:NZKVZK>ZyRwWvvKWWwhrQUmmubci]igdqXImcgeCWgsXehseXKWEeswOuxdUE_iWSEScuXdQWdmbcGe`wwaoSWUcUeBx[F_WRiUdVUHhIs@AUhsXYidUCvsyq[UqweXttoNawriwPpV`eQQqw>xnApyGYuiIojUwHDrw=MhIwEetpAWXXvbisxPYWpKaPwuaWyXxkxiDhwKQ\\\\igUhiiVyWp[axfx_sqv`yfvWOqxvs]phuMWHvSItoXySxJxYOqar=XrbiCBo?vsiwXmVJKtrAYogusMwRGbnUu`DlylUrAPdmX=Yt`tPs]rIdvKEqRHkEAWgXjI<Y]TLADvOmtwpTqHTOutNQyd`uNDpBQTWeXyiRbGc]^_nwkrNfWNo?fpYyguWjXOwWfxuvochoHqdDPgANem@w:gp[V\\MWsKodO@dwF_^qZkv^Pho=qbVqpeHhbQr=niexxGWgPw^dXuqPp=VqAo[jFlgFrZhgx@wJxclYoWa[y>wGqqtymQNopW[fYumwYwIeux=wYPiwqaLdmXCTqeIQ>ySsuthaJuhOuhYomQi<upYnMlpU\\M^ykdhUKQoV<kPhsxPI=epSfMihu=EjoieuXD_i?UhioYaWRdox]WDoWYPKtCehYMy^sSSSupYYd]heEfqWv@QThCs=syOWIaSXfoyGYUSyqsDTt`RiEtUqx@`UUYvGEpEQWmXXVYxaHOYQpSyP`YTD=rbExLTW]TTdEvHilWMr_aYdtp^ty\\]p:XYtlR`pKDUvtuoUyXZhWPhPcuOMQupuvsAQOeOo\\pomTwQKdiYVUN?<nohNSDNWMxRTlSlUS]QuuWUioliqpuOhyXIITcMoEqlqdxQ=qnQy?dTY`ya`pS]XM`PgLl<TjCYxnYNeQUKDQcTT<DYB@VDeuSipUQl=MscumOYU^LRxPTOiwUwmpokKFoex\\\\GbpXiXxbyUgqWbgv;KYmwoIujMApKmpUy\\ihdU`nIgfuxgAguKIttWro@\\xqthOrLicQVoWHs<gn<PgfNu>FkpIoTVciYbfpcOAdYaxAfoUoi``pxYctOjuPwGN_Mygu@itOqUhbdHnAeAWylcUuMe\\EkLmnPuOpLXLLla<oEUOMivuxNqtsoexXPteUnAyngiOiqu;\\tF@wueo]dki@WQYoXLyw`xPqP:ayixnVmoghQ_ul_mv<pkxtMVtVG\\vWlplhUieTR`SxmuRivw]vcAqXqqRDUsexCtVZtY@IT`Prjiv>AXageX?^O^_H>awAuHFkqgi[A\\Bffk>lIamVo[F@sRX`M^l;OZOi\\Xig<G_J^fPHhVOpdQ^\\VncFZmn^a__lQjcf_eatHFtSGonfw<NyhydqAlLYeHgf^>sCnhRXmPixShoAFpThagxa\\GglalDIlKpb<IysPxdaeYPgjym^wcXG[aQs=AqNO]TxjNG[camJXa@FdpHca^a;_lFAj\\AfHppt?tQ@\\XppkYlG@yL@iVXd>HZGa]_N`_Nrb>dFPhS@y\\ijbvd[>jSFxpar<i\\Z@o:^f^nZvWy\\fnTvnKncMykuFvG^ncXdfar;a\\whiUgloxkxVplNvC`wQHZR^gC?lMFd:nipN\\Q`gOOdeipapddqhio[K@d=yg>Xec^jIhJMdieyEEX@gDpgWNicR_wn]DcAfuUG:?yy`k\\EpKuwKIkhyOb<vTQkPiNMLpCEMSHm@=U>`VSTcawmv?bfFc>VljVhGXZ>>qjWvfvvLVZL`[BX\\SplwFl@?iTivvwxchZyomTy]ZiqgF]wQmwQcpYvvygt?osvkEYq^vy:^qGx`GfiUv_Vf^BX\\Y@[MI^FwsV>yM`k:G_CxhkwvPVja^l:X\\iQsRNZAIarWhQ@]<V_dV\\C_ceYwwF^npsaOvNhZ>WyH`dvVw^@yVY`^vx@idLan[h]DG^b>cdIdZal;xkn_d`Wel^eVieQioup`Yim;wnPNmeOfmN[e`hna`_NyJQa]X\\GygNQiLNm`_oPO_EWfAvxPNlJyd]a]PqolIcEhaQptK^qkp^y_imgkjn^\\hlO^liItrn\\`PwUYeif^oH_E>_kg^afnCG^CO`s^k\\OsjniZAwgypTQspawUIhsP]pIsrhdmhd]pgnhndoohaq[y^^haHwxLGe;GaO`o[_kUottqmCohaYt@_gWWquGofy_PwgH?n\\oq[qdUn\\UP^TVfXI_U>]chdiOpJ`\\\\ApWN^[W^FPvoQqui_Opippmv?xfIk:Hp]FZ:@mX@ivG`a_ld^b;@]HAb]AlfQr_nmKO]Oil<qmK`\\BxdHadSxokX^FhcQhdhGmLFoIHgwI`SFgB^uw?bWHa_XgdWeYgc_?hN^lRWvPqw?VbRImRXe?XlnvpMqwRPeTynthtZ>l>Pk<y\\vF[T@eW^mQG]XP^uioiFicxl?OaFwsDyeSNhEP^gGdZIoVHaS@_pqrSp[sWj:acRVZLo[aWufivN>]HfiRokM?l>HjDGhlN\\VPpAF_kG`KgmpWqqygL?]xWib>hxirc?gAawYQwf@oiyhEodtQiVhb?Nec@tgXf]OeLqaCwaKPmr_cvI\\\\^wmHmVYc]q^Ho\\YI[Zap:piK>_f@vuicsPs;i`P^xeXoon`cXfYAa^GrcikAYprP\\XGf`qfk?lDnrh^cXFmQQ]kGux_ygFlFpl<har@k^Gr>QwU@[;GhQo^_H_aX\\vVa[^l>owTInUxpiQglfiWAaQx[>@opabMW_R_cMP^mww<X_WXuOIcLQupfqny_`Pq\\iaPikSF]eHaw?sU@iGXgmNdygcTA\\Ti_nhpogsoqdjVlYGhkwe?XePo^;vmvY]yGZC`a?oseWbWOw=htdNbQGve?rIV^AIvG@cGIqOWeAHqTWbe_gbyqeW]T@wbQwVvxdO[`V]mQodvmQxdEg_Ch\\JnZ`NhVNfTYiLoltiobyuDHhOwcPo`Y_ge^[Tqh;ptdixofrFhfqVe_^\\c@eiqx?Ylafn]Anpvq?gggP\\baxOHlNf`ONbqW]EavyHhfHesYcbHoVotlHiFo[BitUq]vX`vWyRGwBocVNpFHoDW\\\\RDYPVHq?ENDaja`lBDMVPV[TTZMJBMpBmrlml=`kZdSNyxDUVYExs=r`_xpvZ\\ynnYvOVpb?xDIeF@nfxrrhheqtuvjhGtnqsoGdT?cONkF?xkGrPQxIXxBP\\iakYw`GVw\\ifv`pgFnep\\Uhn?>pDQwJv]kO`sA_cIZnpi?eJmYL?y<MWXYdiigLCGO_EsACMaRweFM]IBKtaOVNITJkV^sccWGpAbj[Wk;CR;BA?wZ[VF]F@wb;kb<_XI=vK_RY]VNufGogQaitADAwspKEMyI:]gXoTH_yqOIdsWcmciwvcKr;URR?uaYewmvc=y?CufuHasYPWR`?VXwU`OFlwcNCFm=V@cvv[fkPjKEms<LvPPDMr=pWO<XR\\YJ<tVUX<`sNhn[MvyXNpHjpAssMW;`RFAvcHXpERM\\tVlJwPSDltcetHiYZpwopPBqnoUKA=nO]ULEpD]uCAx]`Pc<Y@iQVePv`SwHJMqlNIWw`P=eX^tpL]nTPK_uYPUXLXQjtSnuuneXFHKcpVlTwc]RvPQItuC]Rm]jjekjtKdeuO`noeMlHOoptVxPdMmpQqvpJeEUHplD=PxPuIDk>`K^UVM]WPDoDuMEUMuQstUOnhSUQtgiq=YOgtORmOiINZxi>QaPGmjWkyuP?xLIuDYyLmhdcSwGVpGUewwoOiTOg?sghqVw]XReUOQS`EcUcBZGBX;BF]BaOcMmFrKd>ssFQf:CV>Qhc[rD;d`CGK]G`cdy;i[mdGOe@yXViwH_HJeuvEyg[iR?ePEdLOBoWWbMvsGVQ]i@ecTqSqwSa]WQYSOCSCqWWoSqMbs;GIMsuCCKQG?YwcUwE]TdYWgoe^Ci^igeewDWSEmTx;u[OC=qyMOD;IuQQxXwu@GIuoIPGwLMDviFF<Q^Ty\\PWULN[ISSTJM\\QCQLG@PIPwDQUEpyP`toaxhHoTLQUdrmaXilNYqP]aXeMUPxn>LT:EPj=oGIkWupdlxlHUrXym\\ocLuB`OgpvdtYjikMex[hj>pp:pl:UXPtr>LJFIScywoXLqXMWHxVQoDYy?To;eufLyCDPepnmXqrLKamoD]Y`=OD`YIaOjEUk`y\\lVAIMHuRrtS;TV\\eYZ<sV`SyArDTSrdwqixIEoI`XUYr=qyEPtKykSYTo]rnqtTHqXyxudt]\\wdHLDplohlCdPN]TvPrEUj?IW\\QtPPTLlS>TvrPMU`oa`p?HSfdsi\\Q^\\vc]tVTSf<Py\\Le=KaQYNEUdPRJLURaTt\\UCasyPNN\\sXDSQ<WJmJCMosDmkyW:pr_Eqcyr^djIXlYuXZMlhDjREV\\@SdQlu=L?DtplNd\\LH`RFms;TtNMw@`pXQmrlUW=u;unZEyM@lU\\JJlQB`v;yMMqS=Px\\hKweVtMWHiUdpyLDOHLVIMm`IpZIL]iqKEmktYghwyWcmpeeO\\ZXowO]tX\\s>a^@_FqkfY`Di`FX`dgmaHqPOdrxpRGib?h]?`vhfUIZj>nQipG_Z\\Fp[pdC`joYc[@iEqlJV\\tfa__fc@lkgvLi_R_iZAxFa]t`jVGkofa<qj^`^mpdEAnI@[EV\\uYpEHvH>gCnr=grv>bEQvEp_J>o[?y:ff]Fm:xaFa[phnrXbc_gLNcB@Z=OrdfuAoh?Os^p^WpspH]Wf_KHlmFxdV`eWd;ikm``\\yf]vu;^mqqwpix\\_wtn\\TyopNobQxdW_TFb>ynbh^Nxmd_k]Wg=QiHQeYifnWlTVgFWtNp^LGgn^pdal`plFauY_wVImhijafvlNqOGioY_:fsbfabf]=hx]Wh=IaCIpAQdUygvVwCHgP@\\Q?dtatLnjJIllfngPd:n[^FrSVfYwguNmHYjO?gg`mjX_WwanifeO]QPerhpM?eg`gP`dQhfMw_Y`h`^f_nZMwvPnfPXfTYnnyknP]EodcQ[Gfhe@\\pIopgskWo\\XtTOisxslvt<W]cNdYibc>xcvtPFoL@oe_fyUWmHtaFLMXDKdL[d:_DZ;R<ABB;Bj=r<_UlauRIfI]CR_dZeRZAI\\sB\\=I=AsGUEVwRwOIJ[uxUUbwi<_XnYVpaXweBbYRv=htcV@yRuOYlyv=UyBUdmGccQXeCS<]bIsf<]uFGHGMXJcUdEc=HxkLMVDJ<qU<]KM]jeiPTuU_lSKIN_XlD<mLUmyhp=QV@LrOHWTXNwuwVUwM=RA@TQ`rwXn^hR>aqJXq]tMJinqHOYtnY`l`xs:=nAuRMlZqh]YvhaXlgYuX>ocImJwnc^hEAp=>aRX`SVfpwoovpeflepbVg_ooltg^O_`d`nP?p]iZ@Yk:H_CW_;N_X@eMF^VpfqXoggthvmAGwtW[g^q_fpsA[LOk@OZcWsq`[\\Np^XgNvnWXdEHePgfyWo:fu_A__Ivm^r=F_ZW`D@ZRFeB?meFlYxjFPxDA^uAn[ha=Wr_n]Op]=^p:G[_^vJ`nbpnMG_J?aBYiZn\\q>isXpZNkqHlhFZDG]RfZC`tq`tJxm^xmBGaahoV?iH?hBNwixtD_jsihOvwt^t`AdNgffA`InxDykonqLpbZ^]mGmDp]WFidpdWhiaQZUFfDFhoImCF^\\nfBVsuWhAGesXeaphOY_;Gh@PgLgr^H\\j^\\cHnY@wK^tm@]XpgWw_Cxj^hr`hgpnncAeMhgLOpPHe[Al<niXA`XPtrAktwkLGpwFbRomRYuDVvjohxxrshgU?wog]LqxWqlK@ttXqONqo`dnhhCA]nid[N^eg]kqfs^ajQicPtn_dTn_aannhmtPlCac_qohPkOIbH?lEi[tVydfgDvdB_aBOmF`seoaKWetOgUikIgpUqgnnohpgOx\\ngueP__pbZii_``bAb<Olj`ZaQtjO^komwxds>gJ`^@N@Eg][RZaDR=IBMB_;HBqiFQF[Os>aC_sIIIjKTmpXqtywNmjMUygINxQkLItIulIaTUDRgHKXuoNArEAoeUoVxnEMXalS=Ut\\ipiqlYUPkQw?xvhiOJeTQUK_qOdhuhdNphvPEOx=U^qTcDNMXojexvIM[AQLEvq<QeUm?u`MQmkfboOeIPdqVdOWc<?rDNxbFw>fud`iFaZq^t<O\\IOsK?l@`b`pjpPlsHlKWbLgtWGaLWuE_wf@a<ppNAdj`\\SXJ;WJcFOkCcMVr]iW;hDQUHWTQsgbEFLIsj;xZmvjAY\\;S[QilQUIoX_QVO_iqEhoeVYEDWeYDQRtGrJMg<mYLaClAFHoTKardSc`oyqWUQwD\\mwhMWDKE`MrUUdOKgD]GDGDL=Us;Eu;FjmrDqx>mBwmGyawFwCbyhR=GMwTeQRSoxWQrUiwnEScKeF_dOYf<=VLkFBKVrwefsDPUiImT`QvAStuwr^cX?SENgsgUdk?WJOGGccrwhNqw@MbtuSnuwWqfXAUUSCTqhUUfiitn?WeOx>SUS=HGObrkRPyVwaSGsEBGDpqRNAgUUd:usqWHLEXKEw;=rC[W@EhjCenUY]ghcif@KcNaeLIvMGeKObUgen[gMkJ?`r=tK^MjoTUPaJt=K]`LSPxu=TCpM\\DTSdS:IMSxKD<nk]pg`RneJd\\YBLN<XLwPQOlTWan_qpS@tUpK[xUt<p>PqvHpE\\nFxSA@KU\\uhTPo<XtyxUaVceScdrouOZApuiwcpVLmR[pSIPmuUl^pkrAm>QryG_H?qOQkogvJItgFcgWlLQvlI^V?bN`ruXfF_t@vjQ_ebxd_io[Ou^?fUnelvwFUMKUGeWemi<WfhedsMTvGSY]XNUccYWbQwMeTIadUEWPCCDYda;srMrJOVF]F>OB^GcCmusWVV?D_MFlAV\\IH<KGN_F_=vIcV^KfCKBmqRQsDkuILgTWYvBUiiEfIIU<uu@EW^kssQhcyctMWWAe`uh@IXoOCWESEaUwYiUWD`WEvUydQhxEtd=UnovVwXoIdskEYwx]avkcVQGUReW`Ad`igFwibUGhOeXUXWCepUtfGea]iV[wtorgOCAqWq?DiOH?_goAScOR^MitaSP?bJecSYC`sFCegOqXsGi\\og]SIjYUXueJiGsqGLeW@MUiQcM=GGUdFMcvqtFiVrsCe_E\\ecYCVnotWWEwUxgMTTouSMGegGg]fMIfq]uwOb_oEaod_=YNoFoOD\\kb:[e\\Mff_C@Qhf=bPCUICwJ=bPcB_AVoCccadNWVCAC`CVKEtXUWGewusS<aDRcFgmECCeBqeNGsQ]e^OR<Mdsac>?FiyI:uXuMSNSwG_FruFG_HPEdw?W`QW_OtKUh\\cvcGWcMiWEsFuSfAXtaYucgeyXIoykKwHmdgowFWEGEhhqVMkT`igiUyDQEhsDqKdVgWcEEBMwUwwK_T\\WxN[FlKbq]crasUcstuDOOeDgRgOSTyVZmCl[e]WFS;HaouKKvrUiZUrvOv^_HrQtZeyjQgAmyjKHLEihkhyQsbOtMebGoeMwrm_h[?t;cUouWlmiMUgfyU;CXwseR]DYGb`UFAMyMUh_yF:;E_WsKgfLcFMmBKWe?ot\\KcVGWeIFPIwTCxcQhLMCLmbrmvjQb__dnYxpiwwcXMychgh`UW?Awjgg`AcFcFOuCLsutqFdIbFgD_[s=;ChExwiVL?YIORoNh_hcl@j@Nt>`Zc@?MBLwB>Ecl]DdIIOusVWDhew>?ikCEvyff=RcceuSB:abkCea[U<QvLiV[CSWMB>[ejARdmewSBnMYJcfhav[_W:Oxa_dQKSv?Ui[i>CUJas;=IZkuTytqmh`eDOIf<GEIKe:=bPicEcICOdP_Tc[vKyx\\aF;efxgYwsDZAX_=ccgfY]U=Isc=yBab>ah<yxTyvI[fyCwAOYvuuf[daWwq]en?xFQHQIc`MR:qujOy`[CcQyd=c<yRyavcAcPGgqgxpcWUwWpWUcCGOiCFctpMfL_hMAU;?rCGxGgV=YBtuyGqtYegtOwheSIGtb_gFAi?Qgl=v=_spkWEMR^;rZKxZ]bNcICmR:IHIksvsf:CX<wI=wID;EDmfj?eLIix[V=ocZqGqUg]EcCWDosipys@sRLkiB]xOYrAwBI[ij[ccUVJ_e?QWMedPcD>[Y:oVP;y<WgacFyCbmUcBmsgoh>?veetPQtLiIj_rcQgdaSIMBBSw^;He=yqmbleWswHbatnGB^CSQ[Il[ELCVQ[Vtey>Cvm=y>oBR]SZYX@[Ys;BE=bjutKWCV?rjMCmaII;W;Sc;_CB=uwSH:Ix:sCbWrJWxGOFAKsjmCjISMeCi@urTMWILsXtFUPkalGiNniXCLOHenZLvClMj`u@dXOdJZin@qlO`mPeJvMxNQv[HLwun@EyQULNYuR<mEAkuEWyLYR`KOLm\\<Ochr>DPJ=kl<WR]MsLOKIpMHpHTOCyTlDkpik>IJreu^xK?XP@`k]dLptRTeN_LL=ffA@p>YduntaA\\BOdx?dBqxX>hGncM_l;H^F`kIYpv>vM^ZnWoS^^Hwbl@ZDN[B^^bvxkawhQj]XyVWnpIgdIbVoiSA_jWryAZ<OtWItXxd?XnZxfpIrdQmYoxdyrfyy:FoTNhoVouViVorRG[HHlY`gypdnfj;fZa^na`]:Y^Y>tZw[:GlAI]ZWaZi\\a^pHIi[__>OZ@XtvvcHvuKak?FhcXwwqvw`cpHoohcZabr`mCIkwOlRV\\[y]DpoJ_\\X^wY_utwwdWtNPkda`LIoePcmo_sFvco^V_j]OgXIpep`U_cwi[ahb;axHQov`Z_Nrk>w;GxJFicVhrI^BOmWOgvOyO`hSHnmPt;Pr=_x]IdV`vOaal?m=A[b@\\rVhYp]jOZvf^QHv:?[v_ZRVZ`>[sv[^wZMQw@VfYFrD`ZtfnvFjHA^m^j_Haj?`=NZ<OdAyl;Ns:nsvGnb?wwvv:PScXeMTlCE:[CHAF?]Es?WbObU=G_sS_Ieo[VSSYH=X?ebpsVdeEDgGgOvgmTPMrb_DyegEsD>aG[my:mRTGtoWeGafRAYNGEhchdQXXEWIecGOGwmu=;Gv[YH?SJ;Yb[CXGdU_xXwdgcVguufgxeOgamwcYBL]fD[vCAr[CUP_E`=XoKRUcX_cGr_DLsVjyV<AI?EdGmwi?yocxZaukUi_IvAmiagF]_yoGBSqtwABNou^eYBEtReXwqRW?GWWHd_gQecEGGcAdEuCPqipWcjaHW;fIefGcfFGFOOil=VxMT]Me]adRqgU[iUUbI_XpOYueHEOUm=hooib_wjeWgicH[ulivLoeA_tPmGIQh>KtLUe:?i_CU\\=BIEY?wfNuUIaeY]XU;gpUuOMgecehQVMotnOwwAfVUwwCd`oe>Ou<MgR?WgcY;YrXMbICRCESEMV<Ar?iX[yqOHN`xXy@rdYkwUPHUUQIy]POypPgqrQhosPud=obqoGApXtNOTrJMY:mxCExC<jB]r=]sj<pYpTtppH@vwqMmxTSAwhaPiPnXPNSEtXURo<ksaToInlPUPilN=N;UjrDMF]NqPK;ERiqY[lRDMSt=TIXpQlpb@oNtqsdTglRdmN^Exa\\K?ELSAU?eJgdRgQR:QvOdpvDWa@jNHKa=L`iuwHnf\\uW<rlavjdn`PoelsFMxFuS=YnR=ltXQ]XPGQwruKCqT@`opmNcIOAMRRDWfXT^pYnLSymyfTxG]Q>eQdMKMPoVDxa\\mc=LaMNNajuHXrAv;<Jt`R:^rl_m:vnCPvH>hW^Zlaa:XVsSFGxV;hakh=YHsCy;WEX;D=Qt[iwfoG:kUssfk[u:WdVGCRIyw?YZSvvcfvuRi[v;?rXCCXsfYkbVoCFaBlaB][RqiEeUT=ugxWVdKc=gVZsYS;eIKR_cdpwtVShNcxfaS\\gI`OvdiwqOTpeigwhQOeUcBuIGNMe\\EtoMuxOhnscsQfIesnMWPMwgCDkWfKCdKiuocwjoTUeUhmuc=udwGOgtn]XtYIcuFhwC^ktg[XXWGH_E_qFK[iucFXeg_oyXgcfSdoGypuw`eyCutMYTOaud=gngUoCGDuBJ[WuIdMyEhad:[wMECDItdUdWwvtUhgohyaReWgnou\\Syxch[afxouZ_y\\Ui`EveIWiuxqcutiYESssiT^ixoWCaESosvUgFXGscqx@gEiyxActTwgtQBvaxtgh@oeaMybKctEXI_wiMXnoWYChDKWCwcRyGW=SLOR:;D:AeXAupqCOMyHQUdUyXeFYsxHqd_qTiub;ef?Udf_xeggh]ETmu:gBnCWmcGG_IZQINuRQwC@gxFEI]kijYWoqTRuunotR=tnuHuiXAuUKqUoKGowYbexSSmdlWOEkfiONPnV`lcLWPmUC<Rgyq:HL>PQ`=yXmUHQqtHXiTOiqlWQtgPtOpTAdo[duy<PuuwLykYetQXMd`Y?dUhiwo`TTpVUyw^ANYLK;QONpopTy_pMGHwSeSyHxx@UpquTPmLXybXjnQqM]thlVOQPWermUshxjS\\ncex<pNO_vCI_Cg]gn^_^mf^qopok@q?^qGY[lg[lp^ZY\\N@yCVi\\^dK`[@_ZM`rY`gAA_dflXiqDg_PQ]ug\\mFntXsmimi^ZVXdH_kPWiaF_>Ouo`olypwf`byo]hg`VyNws=os`fgFafqPd^vaZ_uA`w]pa[pwiXyWycR@y_o^c?g\\wbxF`cP\\Yq^JNaHpZdwa`NhKFe_g_?Owx>xGqan`ttW_<G`cphuqgef\\=OoohcgGttx\\Wgi\\P\\eahNgqdNdDad^OaxxdBviO@gQg`HxmZPtnQmxhylWfFGedFoRVoWgdSarMqZ?Ob<>tUijLGx]I_F>f?PaYGecgge?bupmK`tnNaDHjE^_uhd:?wk?_jof?xn<VlgA\\BYl`Y`_alVokaH[jyZjAbBh[=^aaxm;IZKqlMgvIQq:>f\\q^u_r;Vjq@\\mWZr>n:wcxpiVQ^=FZXnu=Nph>Z;H]J^[rXi\\^fQO]<AvV>ohgjE>xMQv^qkdod=Oq_>e?x^FxvRQfDvvlgZOOtLioqnb`V_MitX?n_o^lF[^nikfjLgkPXueii\\PnSQgqHdqpcwIrIaixxt[>^tnpUxrEY_sieZFcZffF`^;qgeGfVoumy]lYluYm=_nEwmVN^Bqlmp`QIZMQw:WcInpDa]yFpTPeaf_jW_=_ubFoqYmOi^ufxGg`JgokWfTO]TOjCwZ>Gw;aau_bWWd_ovTAt^hj[FcT?hNxkQ_uGXi^gomFy:_hIq[RiZb>]=X`@X\\fqj<wbQ`glPndhqGWdLYaLObdyegG[EwkcX^_had?ZO>l>^jlqjFO_tOsaP_dimbHeThmKGdAvp>hfYg\\>`n?@_^Ncm_vAFw:_FewhmwPKwtSUcYtpKeAiiS_V`]Vs_SbeHBastct[suMeue]Tteg]khokvncGgMdL?Ttof<yucECIsWO]Y`CtwYTNoRXEXEODVwfbAgFquRSuFWheyHcmTGGrbahxyDJwXwoIwaTDqePuXeWXFUtKUeDYD`qrNYH^cBfsFL[bl=y[WsGug_sXqieWehhUw\\ggmKipoWJaDKKUDOw<ixp[VxEXOogt[bh[tP_DS[V^?YHkVhYXa=G]ku\\QsUccQKyuQcWuVkIEVUePOwjGgEeB=KYMmceoXMSXxaSteROSYNcRBYRr;i<CRZiRPYCa=yEWv@QRTgWkUy:mYOoEiuXTYiPAHQihC=IdQGdMU[eb<sCccyFYTLST`cYbAR\\CHa?IPEUV;RCCXvMF^CcZCsVyFfgEJkBF?rRSBKygOABrGCVYXvkGjWBSQt>qxB;BWWVH=ivmG`=bCstssSoQXx[f;SBfAiv;vjWBp;g`OH[_dNqgNMGWgg^?WXQHDCUNeyUWgc=wogVJWCeKWvAy_cUSEd>_b^cDJKT`_T\\KH=;uFeYGwyf]ttqdZMwQoDD?FoEFWsyaECeWRAmgKmuTwr@YbTUoKUUhxPqEL]LtwQUBXStUuSIlvQxjpWG`tnEmfd\\KoalvcVFiR`ompqQaiYPdSviHPsY>vGi_Sfvx`\\_FxoIpypy_PcNNd]Pofiel^myAZdig<PhN@cNOlY@dWG_:`[PAqVas;PCECvEtJEiGoGoUVZEYqwBOKf:OetYXrOv[cbuwBdMyCMyG?R:AB>CbyKC;KIoixDufPetQkTs?DcoeLSHj;BsGBNablItZUfgWWIksmmsx=UZ]BquFLuvGCgeeTUSgCgWcwrt?tC?CQaU<YFRIVcwVLuUEKiRAydcX_SEx=t=EV^mF;miVwYXauQ[E][YoayPICNch;kXSwGfocoOt[_BJAhuEX^ufdCCOYblSHywElahDYTNouYqXYedYmwqWGoiDBEYxgxachgovLEVKechCyt;D;OcfmVgCBh;D@ayrirk=IIAwxAYgiUqQER[houW@EDTwUq?guSIqwBneyteTAERWQC<MYKysP;EwCbvcF]Quy;RdSy_eRqifpQduYVootp[UGESAaVMsXwaFU]wM?GGYxO]H_SCg=dt\\R^hOOILCXJY@qGmMQeO^@KQxKQ=K=TTv@X:yVUmQK@J@TXstsr<N\\MTL@qVHSBtJjHP]UpsHV>@j>\\VCAmI]KJ=VSXlILPZ\\plAL=IjEEUNTkfTYt@x:hJeYoAtlFeTMlVDMXeEx]DX@Yr[EkderbumNhTJHQM<l;uXY@TxuScQuQUUQeS_yXiMSHlMa<pa<QHinjMP_uUgiuCdVLIN^EnEaOuPQDLYLUXLISJhQdYpCxo?PuqxvtdpbmPUawNQtlAWTMSPhVSTJMpOMUpTxMPxwZMJrmsrmkK\\naiohDyX\\nyTT_yKjC@Eiimrv[D^uSJoI_]VvurN=E^wyrSG@?H?OI;aV\\]fB=Ei_e\\AfNssFmYJ;Sw=E_aI>=DbMFCcJsynjhYR=OGEofaQM`N<<KEHMSXX@Akn`WOIN@MyCaLk@Jj=LNpX^atNUWgtw_ItPHtaQnO\\r[prKDkiDqc\\SHHSCPUI<rnhnDTK:EWtLYoDYgQQEERoYw[]TL<jBmVL<jJpxSPrBptTptdtVXEtHQY=apdUL^QlSHLAak\\lNFpXgeyp]NCpktPMtHXUlw]ILaEjylPhimd\\n>ltpdv\\xvDxJChQVtnF<MGEOhptdIVOUsPYs=MLOYNj]m\\eVHXX^yN@Tni`TD<QB]MHAqIIM:XPdPX\\YxRDV:HP@`naajw<L@dnLELstV]<jfQROHqI]M:MV`=QH]yrEV:LvF=rSHv\\Mr:`tKtmbXNdDNcToNMRLQKNHykYyJ@r^twOQwixObXyb\\LoALRunHlmKdlplnr=x^LSjEMu]xhlSdeSgIR`@oQlVopVciW:ak;=OuMpy=JW\\s`EYdAyliTuYQaHMtirdpKC@tcMskeVo]kvht<`lXDVmpL^hUOpkQLWVLxsAonILkqRSmNwPpNXYlqMBItXpXtluYEOHtug]lyHRTLukTSvaqryuWXtw<WIetx@ng\\tN`pO\\LoxTWtQMEtHEXc`XcLuLQs=>bZa^;@rAi_pPprihQIcaGlpwoKoxaP\\>hefhtNQ[:y\\TFwwWZXf]_n^=GuSnys_sY?vxPvEipiq_=Pqng^Qntcntc`iOIbf>_MxsFI[Y^]nwmWwghvhaap[IfKQgEff;A_Wg^mwc_Hc?igcX_FgqZ@mXQh?Amuv\\TY`Tg];Gc^VsSpaRInWiu]_gLqxtWw?qscpncf_nqsxFxT_n:NbaO`I?w[Y\\r>`QGwIvcmVhdptUVnbplXVqh>odHlAXhZot<>v:ivJAt<wZfQn@wo?xsrPaKihIia;obyAZMg_Gq_gHadvb[nrKonNflEOwKwdnQr[X^CXrQ`fZA\\Sv\\O>^^G`m>sSVhN`\\d_]L_f<?i\\Gcs>xW>l<ophy[M?qLXulPeH_^Snh[ak>Nn=XeXAg:YboWwj?Z^VtXH^x>e:Qr_gbspsFQ[t`^rffl^pSv]=@_s@`OHdho[Y@o:Na]al_XbjQlB>yA?;[C__tqSUwCTXib?gTcwY<ct]UifGvJ_GAOdsqdPeDlCwmWyJ=cN;b:atk?F];Bfmbv;x:CV:MO@<mx]n;DKmXPXhQvxRl@OHPwELlbiOEEWDHjTum:lVA@MGQn\\PWdETrHVIAKDXWNyT@\\OPXs_pV[dug<tMIOFmsdyL>xxRTnjdWwYKQYSopya@qHxNVXUIDOAyMX@yIqxcLrmxoPlXtyo]dOyARcMKnDo[PoeypiQoSDKJlLv@NpaJBqrR@V^=RsDMlaq\\YNMTLaXnNXX<AoIUMVysQLw:EvypPDumaqyfQtKmkUAVEIvUiwyttuXpdiLgXw\\`oTAnqlofiKmDtjen=ykpxkBeMrnpjQlLq^C?lkfhnYmu_`dwa>WuKViHn_IIcuGti_org\\ewoi>`=xY]bOiFKqW:[RtUwwMbiaX_YBdyWqqYX?d_Gi]sx\\eUm_b`KsucgU_dEst>GyniFNYtUSdVywogxy;r[MtwoHDqxoCwu[dXucS?w`ITIgURAWFytcQsPMGakWccWDigYcbkyeZWhPwYTOH;QguKItIYkUSqQYsmfkSX_QTXEWVmGLQxy;RHSEYGTAiSoaecWHqKseqT_mdSieNOy<uVQgwogTk;unchm=w\\UuLSvDUwfcdjarG;DNOR^cDfOxGSvxGeroeTuX?UguoYCQvZctCWg`_ipqbeGgC;D__bN]gpGsRkuVgyPmDioeYgVcSSQQY@iGIYy;oEZycf]f:acWafpUXEcYYiwtUTIcE:[HqMgt=x>afUECjYt>Cc^CdTUeDuDUgIYETWqsn=CnOD]cxSaX\\sbb_GPgd^cFwYT:_i]as_Ks=;vAKsdIhj_DmyI:gs:PLAQJ;@p[`KymS:dQsImv=l>UQuAnhhnOEkX<pkXsQTPrdjghTgLnZESR=L;<QkamZtJ@xOQMKcqjddMcURLPJDdvv@PV`j@TMXMWP<kC@qr`nxaQHiurhYryZuInw?cd>hn@vQXsLWa_Or;FvWxtexZaAoSydFGk\\>fpYr`N[WhuQPdSQxgAsEvl?he`ObvwrR^f;akdO[uXsDPikpuoHlmIgS^^lOZ;Vb`OhPX`[A\\agwpyqc`cSaxOPa`QqqiZWGrkhr`xs?xZTifGNmOYfgo^IXxVWtpi`qfk<gjW?tDQd<_ieGmWnmKf\\wnpgFsJypNal;fvnXZb?cDYbNP^M_haQjl?]Kpso^jw_ak>^[_l_@x:yfwpowyrNqjynmt`]yGpTTFQHYsbW[YZqgyMWvIhvWik;dy?IGCYQaLfMK<\\Y]`SFPKPtU>@jLQVLpVO`xKTSBpkN]LQAPtXW=`KVEoQQxRUOgyoZTyL=vJmJ?UxlIuWAOu<qYAoJqPDQm_NmUPgGO[aarvIrDwcr_jJV[IqnGY_Qw`fNq@Xvd?hYNmdGoBVobwhIh_lww@H^THsuxkbYrpW_ew]iXtQWiHvnc?eonbdw\\?GdLAanoqHxkUyrwnqmwfGoiR`fGYdjXiOQnPYvqiopxqJopQQsrHdMOm@aZrxjbXsLxwHx`[AiHXtgi\\uPamiecwvvNoGwcYob]Ae`nk_hfZWc;hgjifRNqiYoLWwrgcgoi^x`HVuJY_UInup`KP^NgjMAoxIsoH\\uAeIoocqiTwuEO^OQwPil_F_vHwtotLIoA^]ahhdHkYFflas]XhiIyFxeDptmPiIXue>nCOiti_E`d:pfoxpS^dsQ\\;wcvWvMgwgpfvqpToxgHfaxggfnUifTQmotLII@ee=CsmeG;QhioSMEgRQXICW=chf_GYiW>SSl_bkkdk[FX=SR;CR]Ck=FBYTt=t:EcFoFiuDPMSDscM?C:wd:Ge?;tjCg=;sV?v[KF:curSscgFImUJyRCQeBGtNaR@AYHYH@;rdMwJSWm_DkQHA_EZ_VPOCCCgw=uBSFbGS[ghpUuUoGLUEgeFHAg[;BMkF=iFJAi`QIVWy?IWZ_UZifc[xOObWSB^EcxEiKae_ugKkipQrRcdgQieGWd=S;_ITKioITlAdYES^kXOYcZcS`UtNktjQGNMesghe;C>wU>kCeUvC]ySGfIkx=?FZEyB=BJUuWWiQCwIaXSYBvGe_SfvyX;oS;=uH=htovYgitMx[iY>IgBOy`WsegCRAuqoBS;ssWRPaB>qroSxx;U;gXLuID=R[=EmkFb;E^aSI[XAOIskEJsr[sxUcBHCwM]f_uCn]RiAtbciQ[WTSeTUYBCEoKGPMYNmGN[cx]yjERdurJkWkgG]Miduu>oEWcXcIXDcSege]MgWaEd[wOogl=tBwY:YYHWWtGdXQhuScpWXPyWOyI:qWTIgJsFnqxe_HLwSOWbbiwmkX=EdBIhyWTHyh]ewnmigGUUiDtYDowDaYRHITcUixOX^mVlqY;ExcsdNGdN?ubMhVuE`GxEeyieRewuy\\s`YwxaJVisy^pdiacFonff=ofDohdpkdhkavnMVx[H^>n[wGdEygeIu=qoyhgig^PgkSauUwb<ggtQto`tpvmEv_gf\\c>lvVb;xb]akaAiQiepGve?ewAdhgZs@cQNeDW[UAfEao_^dHahlQmtFlIXxkxfYIigYmkqtgXwaVoUWZ?I_w@uhp\\LyoNXv;g\\Gnkr?n_xeN^hYHiFQfyAZXGxQgaIhipNxnan\\vmMGdpVv:`ZlPyvij\\ybZQqMvx]_ntYwsWhyh_aX[xnkwaghxbWgaEocpHqJ^pbF_`vbYNlBwrUY]Eq\\ZovUiwrn^XNc;Y`lVZKVrsIl;?rGG[LPbmHyk`jFAxL^vZfjnn[@hmJOwQpcWGuDQ[=GqtxlbisZfwwV_LxovH\\B_rI@k?F]cfe<qfN>kHpuTirl`sMavGWyCh]=>xE@gjAnqGmRPlgfoxny^p\\wF`=wfgow\\PuFVll^ad_rvqfeN_WxhDxswvgpVygho>glbV_`@hI^dtOvuqbMO_OqoRGcxG^x>aaGZdNnWY_<Pc?fcmvg?@fcHfF>khwtdodyAZ]fqBOgYW_`qySAwQgvIwy:>dLisaiwCXsVg^tG^:ik^ixBG[JPa`yrIxxMvn[Nof?qLqw@of]G`YxpRVu]VjMpxvG`J>fnoinFymYkNNfWwrHFeF^rjVjLnw:^sXV`@Q[nVa]vmj@bBv_tHiB>j:AvfA]?WZdYZhYZx>s;NZjVrZAjNvvX`aFIbJYnZFZNHywAyZhvtxpTXdINc[xlAVcF`q=>k]>kc>dZVjfQjcfwSGwyAZ]ghCIhGIdoPapop_HrovtMQdDP]LHisatxPdahw@xie^atofWIdxqwwYluxjOgniQmU`bx`qJOtdW]sPtapyHGowNhpq_m^hLYyYXwyAZgvc`XtP@hOyahyuVQkIf`WI]i`hpIocW\\lIge?twqo[Xb@HfpyvuI^VnxxqqoXtYgpFHwdhaaNy>Ht[yu_pxhXwUOcVQseiw;Vq]`^avkiifgNhwFoHXiyoekivsxxVPo@nk[PtOpmDomsHwt`vZOeYwm>?vm>spxvPXh`Y^YHxWyg`pvmAgl`gUisrpxx?joN[hh_C>ieNmEgywAb^Vsxh`qFuXPqOIq`gxmvi[?c?Ou@isJ?l?NyA_dLanr_lrp\\avuTvmU_s`_yaY[xVkNqeYXo<_epVwMhhLHwGGac_ZIstQB_AwVQi_YelIX>Kgeocn=yMqTVuyuOd^arMOT?eXsEF^Ob\\_W`sbfUvsSSpGf\\IWXOfTofOCW>UDL?rPKtj?XZIFYME[?fbmgl_yceBIsG:AYZOX:orpayI;BdSV?ssSSSfiFS=rD=d^;F;KwLQWBwFV=bLORO;V`;b:IT<;tCohuYWfYiNyr]gyk?tXuypQdKmuTEv_EgQ_ywAWo[BreUiYv=We\\aXfeUMgfpOcK_RHGD^oeTGDBmfwARp;RbeB:QX@]BkEhlYrL?yRar]=yS[yJ;CnkiCuEh=HFkSI]CCsvFGb<]cEMF_AYqGH:;Is;vkAC\\AIHAb>wWpAE\\UI\\GBAmcMIEDAb:aiascR=V[=yagohDph`WZ\\JQlqx<uS=jchVHtjS@K:duSIxfeK:=Wk=wZd^=@y:QsSf[qXkgVkK?pcghWNkUAoc?k@qmaAcGQe_vy:N_OPcJNr;`txHlwVadQj]qkgWxTOigHsMxdZGot?j<xicHn?wqTar>qndGjNyehaxMqccxrnpf^ydUilwq^Dxx@gtTwZ[vvMqlPga_p^knitotaYt_odqQnW_uMitdnhWXo@_o_`g<xlggl[o[K^smPdUva;>`xaaiNx^gqgiqOQaLwmDaqcYsGDgyf@wxc[eCAu^;F?sYVoUpmRuOCGugqGGgwGDWIgYDigG[QFwExDCCCQHk?VJsfRUy]UUmqeXUTuqRp=Wq_InUYkcdMQC:oFcUSfaSZmFBYf]CcxQyL_YpAuPegYsVhEWg[HQMit]fZogP]u<QH[=vx]XhcGeuHUySG_tj_F<[EWAIo=R^CHMkeR_wHasB?CLEXPSFX;tGUyWkybeYBIvs_F[QhyQUcAGIegjitSKgviuichx?dhMdoguBwY;MIt[wdESGIfBMwZkf\\Wh<qhe?sJSC;IG[?BgiD=GECICF?U[KFe;R<KW<CyVWX:odDCv[Qv>cVb[fXOeC]ElSRHAXB?tA;I=kW>UiZcRB[iKks>McakUkGRCwiC_EHkv:AHb;y=YEWCdAub>AXBqX;KXR=HIIUB?H:;HswWNYhEMHJSRH[yskS:IvVCC^SgMIS\\;F@aeA[b;EbmmTRSF:?XvYhhKC?]IkqIK=DnMwAmw?mb;ECQGbFkiRCIDer<_f^MRD?SKCBmQD]=hj?CBor`QegQXPEV=aDbSu_eed=UOOTcATOkRvaY`KyQIh?mYP=IJOyMCtxaCXaIA_GOyHgQelyfJMcDavOSt=QUOMEVQHp=G@MyEUrMEG]yI:MWIArtORGqSN?WgUia[y>?YTQvZYspOs=IE`]XXaBxAcayxoghhYTgEiMuhgITogtqUhkcWwgie]V\\MxxEtJie[OTXmIT_DqiFuAuIEHg]iDyhciGq?dIqxGycLch@UTJ?toovmEFWigHIDdyb>uSiGrY]W[Yy?orQUt=ewpMVPsY^uCLWu?]XuqysoXkQbi=yskeHEWckVyixcWsFcfQiY@?XWmfjSXhOeOSspyI:OiQmVscUxogf?HfquYACWkI_ce]guCcc`_W[MI>ky>acmQsCOyXqhEMRbcHdWFBsINWRUshN]u<IBf;hEWug=brWYr;Rfir:If]ADZsC[?bkWi<;ye<RfpWZeN\\PXIEMvEl<qReMtjam_HKBdl`<OLHPRHMa@KsLKKitt]ysTjF@Nn]tZ]O^MXKLXNpNZLsmmsWmv:DTJMPAXn\\YyjmJAtJlAtQXPxDm;EKnEmH`ojuV?lMWDMIILC`Q\\HJAHrIQfb_hmWvR@jJVhCvs=^\\Vf]>FfF@v@v\\hV\\jVZeaakqZ@?h<Nw@^iA@[=FZAaj:NjIH]]?aJOfVNdF?t\\@[R>cBAr^NqJOei_gugnpit=Wi_@aTVg?X`O?_Znv^NwN?^lnvPAwGq^fom^`hrOtPYt_Xlw`h_Ne]guKpw;w]AGwdGosO\\cIweIyCQcVWfVvp:iu`axYaoiNmLixrXeToyWPorPwkQc`aoLQy\\PnhPjWPuDQaP?oThoa@qKWtQ?aSa`NawnppOpc^xmgN_DOltOq^Xo\\_mxycX>oLGZaOcgYhHn[cvtqosY@wHokjFs<pjpv^OiqtnnEp\\PI]_gag_iYhr^H^MxZTii^hxnwrDYtu^dcqvogrjIfwyvR`FEYamWwKEpKdQQfpIVCsVguHvYDyURF_UaWD<[haQwNwVZoX_AUHwuQyt;yI:EvjIcNcFtyWOMDywXuitx;diueLGfMAwNCWIetCaYWewQUi;mYwOSAWvbaVcuUO=rEaWaOwB;vx=diueLR^GWiedCyTkwWo_BHuYbydICGkMHo_EUwcdaFBgsoOEfyI:ksWYXd]sXurKQrGOWbwVpUYNSyxAdiuULIvRKWnOUw_tIgsHcTYqW\\sex]f=IXNMwgoEdYdsqgTqwKoXEaitCtHubKGw\\ehLyUGqxOyVxpUrivy=jJAXfeXRHOw`T=HpoTMOyqnUkvQYIpKAAT=qQdxj`uodyktqRxdyAuj^=WTHtdEnyPmgXoYLyAmQwybAAd:ixJwaoVaOGuvYfYoa]Xrk`tZfiN_[pXndwqTiamQwvVaWVbEfxJO`Tiidx]eq]sixTf]QXo[xuOWZmyco@ayAZVXiaatrohtfjaQibXrrqnTaoyns?Wxda`uf]<wxYhdY^vUPgAPyAqqwobA`fdA\\chxKoyCohd`ixQtivmKOnpqe[XiYQoxW]AgpWwm@ibmQWWTlexquUwYdyKdwOGYYdpEtvOqgTUa@TKItdiKOqlQiPuEUhQs>eJ\\ixwqwmTsa@xvXJ]HwvDsaYt`mnvmRkUQWxspim^xQSqPyYTTioTiRPtXU<UYYUOyXgmVbQsbpuu`PgQnL@UZtOGap\\pmCLmHAJiyuNpmhtqjhl>USRyyf;:3:\"\{\}LSUlUk9PVEc2Jy0lKUJPVU5EU19YRzYjJCIiISEiIi0lKUJPVU5EU19ZR0YnLSUtQk9VTkRTX1dJRFRIRzYjJCIlK0JGKi0lLkJPVU5EU19IRUlHSFRHNiMkIiUrP0YqLSUpQ0hJTERSRU5HNiI= Yes, you can insert images too (Insert, Image...). Alternatively, you can type the math in text mode and then convert it to 2D math by highlighting it with the mouse and choosing Format, Convert To, 2D Math. The next section shows, among other things, how Maple can be used as a "mathematical assistant" in writing up a proof. If you want non-Maple people to read it, you can hide the Maple input: choose View, Show/Hide Contents, and remove the checkmark from Input.

LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYjLUkjbWlHRiQ2I1EhRic= Suppose the function LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNiYtRiw2JVEiZkYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RMCZBcHBseUZ1bmN0aW9uO0YnL0Y6USdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGRC8lKXN0cmV0Y2h5R0ZELyUqc3ltbWV0cmljR0ZELyUobGFyZ2VvcEdGRC8lLm1vdmFibGVsaW1pdHNHRkQvJSdhY2NlbnRHRkQvJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZTLUkobWZlbmNlZEdGJDYkLUYjNiQtRiw2JVEieEYnRjZGOUZARkBGQEYrRkBGK0ZA is twice differentiable and has a zero at LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNiYtRiw2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RIj1GJy9GOlEnbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRkQvJSlzdHJldGNoeUdGRC8lKnN5bW1ldHJpY0dGRC8lKGxhcmdlb3BHRkQvJS5tb3ZhYmxlbGltaXRzR0ZELyUnYWNjZW50R0ZELyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGUy1GLDYlUSJyRidGNkY5RkBGK0ZARitGQA==. If we start Newton's method at LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIwRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdGQkZDRitGQw==, the first step takes us to LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNictSSVtc3ViR0YkNiUtRiw2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYkLUkjbW5HRiQ2JFEiMUYnL0Y9USdub3JtYWxGJ0ZFLyUvc3Vic2NyaXB0c2hpZnRHUSIwRictSSNtb0dGJDYtUSI9RidGRS8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGUC8lKXN0cmV0Y2h5R0ZQLyUqc3ltbWV0cmljR0ZQLyUobGFyZ2VvcEdGUC8lLm1vdmFibGVsaW1pdHNHRlAvJSdhY2NlbnRHRlAvJSdsc3BhY2VHUSwwLjI3Nzc3NzhlbUYnLyUncnNwYWNlR0Zpbi1GIzYmLUY0NiVGNi1GIzYkLUZCNiRGSUZFRkVGRy1GSzYtUSgmbWludXM7RidGRUZORlFGU0ZVRldGWUZlbi9GaG5RLDAuMjIyMjIyMmVtRicvRltvRmhvLUkmbWZyYWNHRiQ2KC1GIzYmRistRiM2Ji1GLDYlUSJmRidGOUY8LUZLNi1RMCZBcHBseUZ1bmN0aW9uO0YnRkVGTkZRRlNGVUZXRllGZW4vRmhuUSYwLjBlbUYnL0Zbb0ZocC1JKG1mZW5jZWRHRiQ2JC1GIzYkRl5vRkVGRUZFRitGRS1GIzYmRistRiM2Ji1GLDYlUSNmJ0YnRjlGPEZkcEZqcEZFRitGRS8lLmxpbmV0aGlja25lc3NHRkQvJStkZW5vbWFsaWduR1EnY2VudGVyRicvJSludW1hbGlnbkdGanEvJSliZXZlbGxlZEdGUEZFRitGRUYrRkVGK0ZF. I want to estimate how the "error" LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNiYtSSVtc3ViR0YkNiUtRiw2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYkLUkjbW5HRiQ2JFEiMUYnL0Y9USdub3JtYWxGJ0ZFLyUvc3Vic2NyaXB0c2hpZnRHUSIwRictSSNtb0dGJDYtUSgmbWludXM7RidGRS8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGUC8lKXN0cmV0Y2h5R0ZQLyUqc3ltbWV0cmljR0ZQLyUobGFyZ2VvcEdGUC8lLm1vdmFibGVsaW1pdHNHRlAvJSdhY2NlbnRHRlAvJSdsc3BhY2VHUSwwLjIyMjIyMjJlbUYnLyUncnNwYWNlR0Zpbi1GLDYlUSJyRidGOUY8RkVGK0ZFRitGRQ== compares to LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNiYtSSVtc3ViR0YkNiUtRiw2JVEieEYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1GIzYkLUkjbW5HRiQ2JFEiMEYnL0Y9USdub3JtYWxGJ0ZFLyUvc3Vic2NyaXB0c2hpZnRHRkQtSSNtb0dGJDYtUSgmbWludXM7RidGRS8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGTy8lKXN0cmV0Y2h5R0ZPLyUqc3ltbWV0cmljR0ZPLyUobGFyZ2VvcEdGTy8lLm1vdmFibGVsaW1pdHNHRk8vJSdhY2NlbnRHRk8vJSdsc3BhY2VHUSwwLjIyMjIyMjJlbUYnLyUncnNwYWNlR0Zobi1GLDYlUSJyRidGOUY8RkVGK0ZFRitGRQ==. Taylor's theorem says restart; f(r) = f(x[0]) + `f'`(x[0])*(r-x[0]) + `f''`(c)*(r-x[0])^2/2; for some c between r and LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIwRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdGQkZDRitGQw==. But our assumption is that LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNidGKy1GIzYmLUYsNiVRImZGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtb0dGJDYtUTAmQXBwbHlGdW5jdGlvbjtGJy9GPFEnbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRkYvJSlzdHJldGNoeUdGRi8lKnN5bW1ldHJpY0dGRi8lKGxhcmdlb3BHRkYvJS5tb3ZhYmxlbGltaXRzR0ZGLyUnYWNjZW50R0ZGLyUnbHNwYWNlR1EmMC4wZW1GJy8lJ3JzcGFjZUdGVS1JKG1mZW5jZWRHRiQ2JC1GIzYkLUYsNiVRInJGJ0Y4RjtGQkZCRkItRj82LVEiPUYnRkJGREZHRklGS0ZNRk9GUS9GVFEsMC4yNzc3Nzc4ZW1GJy9GV0Zeby1JI21uR0YkNiRRIjBGJ0ZCRkJGK0ZCRitGQg==. So we can turn (4.1) around to say isolate(eval(%,f(r)=0),f(x[0])); and substitute that in to the expression for LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIxRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdRIjBGJ0ZDRitGQw==: eval(x[1] = x[0] - f(x[0])/`f'`(x[0]), %); Now subtract both sides from r and simplify: factor(r-lhs(%) = r-rhs(%)); If f is a smooth function and LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNidGKy1GIzYmLUYsNiVRI2YnRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEwJkFwcGx5RnVuY3Rpb247RicvRjxRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0ZGLyUpc3RyZXRjaHlHRkYvJSpzeW1tZXRyaWNHRkYvJShsYXJnZW9wR0ZGLyUubW92YWJsZWxpbWl0c0dGRi8lJ2FjY2VudEdGRi8lJ2xzcGFjZUdRJjAuMGVtRicvJSdyc3BhY2VHRlUtSShtZmVuY2VkR0YkNiQtRiM2JC1GLDYlUSJyRidGOEY7RkJGQkZCLUY/Ni1RJSZuZTtGJ0ZCRkRGR0ZJRktGTUZPRlEvRlRRLDAuMjc3Nzc3OGVtRicvRldGXm8tSSNtbkdGJDYkUSIwRidGQkZCRitGQkYrRkI=, LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJm1mcmFjR0YkNigtRiM2JkYrLUYjNiYtRiw2JVEkZicnRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEwJkFwcGx5RnVuY3Rpb247RicvRj9RJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0ZJLyUpc3RyZXRjaHlHRkkvJSpzeW1tZXRyaWNHRkkvJShsYXJnZW9wR0ZJLyUubW92YWJsZWxpbWl0c0dGSS8lJ2FjY2VudEdGSS8lJ2xzcGFjZUdRJjAuMGVtRicvJSdyc3BhY2VHRlgtSShtZmVuY2VkR0YkNiQtRiM2JC1GLDYlUSJjRidGO0Y+RkVGRUZFRitGRS1GIzYmRistRiM2Ji1GLDYlUSNmJ0YnRjtGPkZBLUZmbjYkLUYjNiQtSSVtc3ViR0YkNiUtRiw2JVEieEYnRjtGPi1GIzYkLUkjbW5HRiQ2JFEiMEYnRkVGRS8lL3N1YnNjcmlwdHNoaWZ0R0ZjcEZFRkVGRUYrRkUvJS5saW5ldGhpY2tuZXNzR1EiMUYnLyUrZGVub21hbGlnbkdRJ2NlbnRlckYnLyUpbnVtYWxpZ25HRltxLyUpYmV2ZWxsZWRHRklGRUYrRkU= will be close to the constant LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJm1mcmFjR0YkNigtRiM2JkYrLUYjNiYtRiw2JVEkZicnRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEwJkFwcGx5RnVuY3Rpb247RicvRj9RJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0ZJLyUpc3RyZXRjaHlHRkkvJSpzeW1tZXRyaWNHRkkvJShsYXJnZW9wR0ZJLyUubW92YWJsZWxpbWl0c0dGSS8lJ2FjY2VudEdGSS8lJ2xzcGFjZUdRJjAuMGVtRicvJSdyc3BhY2VHRlgtSShtZmVuY2VkR0YkNiQtRiM2JC1GLDYlUSJyRidGO0Y+RkVGRUZFRitGRS1GIzYmRistRiM2Ji1GLDYlUSNmJ0YnRjtGPkZBRmVuRkVGK0ZFLyUubGluZXRoaWNrbmVzc0dRIjFGJy8lK2Rlbm9tYWxpZ25HUSdjZW50ZXJGJy8lKW51bWFsaWduR0Zpby8lKWJldmVsbGVkR0ZJRkVGK0ZF when LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIwRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdGQkZDRitGQw== is close to r. This says that for LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIwRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdGQkZDRitGQw== in some interval around r the error in LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIxRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdRIjBGJ0ZDRitGQw== is approximately some constant times the square of the error in LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIwRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdGQkZDRitGQw==. Since the square of something small is extremely small, this tells us that if the initial guess LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1JJW1zdWJHRiQ2JS1GLDYlUSJ4RicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUYjNiQtSSNtbkdGJDYkUSIwRicvRjtRJ25vcm1hbEYnRkMvJS9zdWJzY3JpcHRzaGlmdEdGQkZDRitGQw== is close enough to the solution r, the result of the first step of Newton's method will be much closer to r. This will again be true for subsequent steps, so we get very rapid convergence to the solution. On the other hand, if LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNidGKy1GIzYmLUYsNiVRI2YnRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEwJkFwcGx5RnVuY3Rpb247RicvRjxRJ25vcm1hbEYnLyUmZmVuY2VHUSZmYWxzZUYnLyUqc2VwYXJhdG9yR0ZGLyUpc3RyZXRjaHlHRkYvJSpzeW1tZXRyaWNHRkYvJShsYXJnZW9wR0ZGLyUubW92YWJsZWxpbWl0c0dGRi8lJ2FjY2VudEdGRi8lJ2xzcGFjZUdRJjAuMGVtRicvJSdyc3BhY2VHRlUtSShtZmVuY2VkR0YkNiQtRiM2JC1GLDYlUSJyRidGOEY7RkJGQkZCLUY/Ni1RIj1GJ0ZCRkRGR0ZJRktGTUZPRlEvRlRRLDAuMjc3Nzc3OGVtRicvRldGXm8tSSNtbkdGJDYkUSIwRidGQkZCRitGQkYrRkI=, this equation is not so useful because the denominator could be very close to 0. As you'll see in a later homework question, the convergence could be quite slow in this case.

I used restart because I didn't want to keep the definition of f from previous sections. To get LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1GLDYlUSNmJ0YnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy9GOFEnbm9ybWFsRidGK0Y6 or LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JC1GLDYlUSRmJydGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRicvRjhRJ25vcm1hbEYnRitGOg== as a Maple name, I enclosed it in back-quotes (to the left of 1 on the keyboard). You can make basically anything into a name by enclosing it in back-quotes. I used isolate rather than solve, because the thing I wanted to "solve" for was the expression LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNiYtRiw2JVEiZkYnLyUnaXRhbGljR1EldHJ1ZUYnLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGJy1JI21vR0YkNi1RMCZBcHBseUZ1bmN0aW9uO0YnL0Y6USdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGRC8lKXN0cmV0Y2h5R0ZELyUqc3ltbWV0cmljR0ZELyUobGFyZ2VvcEdGRC8lLm1vdmFibGVsaW1pdHNHRkQvJSdhY2NlbnRHRkQvJSdsc3BhY2VHUSYwLjBlbUYnLyUncnNwYWNlR0ZTLUkobWZlbmNlZEdGJDYkLUYjNiQtSSVtc3ViR0YkNiUtRiw2JVEieEYnRjZGOS1GIzYkLUkjbW5HRiQ2JFEiMEYnRkBGQC8lL3N1YnNjcmlwdHNoaWZ0R0Zgb0ZARkBGQEYrRkBGK0ZA, not just a variable. This will usually work when you want to put a certain subexpression on the left side of the equation by simple algebraic operations. After subtracting the left and right sides of the equation from r, some algebraic simplification was needed. There are several commands that could be used, including expand, simplify and factor. I used factor because the others would leave me with something involving LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNipGKy1GIzYkLUklbXN1cEdGJDYlLUYsNiVRInJGJy8lJ2l0YWxpY0dRJXRydWVGJy8lLG1hdGh2YXJpYW50R1EnaXRhbGljRictSSNtbkdGJDYkUSIyRicvRj9RJ25vcm1hbEYnLyUxc3VwZXJzY3JpcHRzaGlmdEdRIjBGJ0ZFLUkjbW9HRiQ2LVEoJm1pbnVzO0YnRkUvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRlAvJSlzdHJldGNoeUdGUC8lKnN5bW1ldHJpY0dGUC8lKGxhcmdlb3BHRlAvJS5tb3ZhYmxlbGltaXRzR0ZQLyUnYWNjZW50R0ZQLyUnbHNwYWNlR1EsMC4yMjIyMjIyZW1GJy8lJ3JzcGFjZUdGaW4tRiM2KEZBLUZLNi1RMSZJbnZpc2libGVUaW1lcztGJ0ZFRk5GUUZTRlVGV0ZZRmVuL0ZoblEmMC4wZW1GJy9GW29GYm9GOEZeby1JJW1zdWJHRiQ2JS1GLDYlUSJ4RidGO0Y+LUYjNiQtRkI2JEZJRkVGRS8lL3N1YnNjcmlwdHNoaWZ0R0ZJRkUtRks2LVEiK0YnRkVGTkZRRlNGVUZXRllGZW5GZ25Gam4tRiM2JC1JKG1zdWJzdXBHRiQ2J0Znb0Zqb0ZBRkdGXnBGRUYrRkVGK0ZFRitGRQ== instead of LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNiQtSSVtc3VwR0YkNiUtSShtZmVuY2VkR0YkNiQtRiM2Ji1GLDYlUSJyRicvJSdpdGFsaWNHUSV0cnVlRicvJSxtYXRodmFyaWFudEdRJ2l0YWxpY0YnLUkjbW9HRiQ2LVEoJm1pbnVzO0YnL0ZCUSdub3JtYWxGJy8lJmZlbmNlR1EmZmFsc2VGJy8lKnNlcGFyYXRvckdGTC8lKXN0cmV0Y2h5R0ZMLyUqc3ltbWV0cmljR0ZMLyUobGFyZ2VvcEdGTC8lLm1vdmFibGVsaW1pdHNHRkwvJSdhY2NlbnRHRkwvJSdsc3BhY2VHUSwwLjIyMjIyMjJlbUYnLyUncnNwYWNlR0Zlbi1JJW1zdWJHRiQ2JS1GLDYlUSJ4RidGPkZBLUYjNiQtSSNtbkdGJDYkUSIwRidGSEZILyUvc3Vic2NyaXB0c2hpZnRHRmNvRkhGSC1GYW82JFEiMkYnRkgvJTFzdXBlcnNjcmlwdHNoaWZ0R0Zjb0ZIRitGSEYrRkg=. expand((x+a)*(x+b)); factor(%); To get the LUklbXJvd0c2Iy9JK21vZHVsZW5hbWVHNiJJLFR5cGVzZXR0aW5nR0koX3N5c2xpYkdGJzYmLUkjbWlHRiQ2I1EhRictRiM2JkYrLUYjNiZGKy1JI21vR0YkNi1RJSZuZTtGJy8lLG1hdGh2YXJpYW50R1Enbm9ybWFsRicvJSZmZW5jZUdRJmZhbHNlRicvJSpzZXBhcmF0b3JHRjwvJSlzdHJldGNoeUdGPC8lKnN5bW1ldHJpY0dGPC8lKGxhcmdlb3BHRjwvJS5tb3ZhYmxlbGltaXRzR0Y8LyUnYWNjZW50R0Y8LyUnbHNwYWNlR1EsMC4yNzc3Nzc4ZW1GJy8lJ3JzcGFjZUdGS0YrRjdGK0Y3RitGNw== sign, I used <>.

for ... from ... to ... do ... end do -> unapply diff D