I made this a separate Answer because it's a completely different solution to the problem, which doesn't use textplot.

Starting exactly where your original worksheet left off

PrePlot:= %:
dsol:= dsolve(
    {sys11[], z(0)=z0, y(0)=y0}, 
    numeric, parameters= [z0,y0]
):
Dots:= proc(ics)
local k;
    dsol(parameters= eval([z(0),y(0)], ics));
    plot(
        [seq](eval([[z(t), y(t)]], dsol(k)), k= [-1,0,1]),
        color= [green, yellow, red], style= point,
        symbol= soliddiamond, symbolsize= 24, _rest
    )
end proc
:
plots:-display(
    [PrePlot, Dots(ics1, legend= [t=-1, t=0, t=1]), Dots(ics2)]
);

Every if statement must end with one of fi, end, or end if. Every proc statement must end with either end proc or end. So, you can do this:

Fib:= proc(n)
option remember;
    if n=1 then return 1
    elif n=2 then return 2
    else Fib(n-1)+Fib(n-2);
    fi
end proc;

I'll answer the question for another "forked" recursion: computing binomial coefficients from the Pascal's Triangle formula,
C(n,k) = C(n-1, k-1) + C(n-1, k). The first example uses option remember; the second doesn't.

restart:
Bin:= proc(n::nonnegint, k::nonnegint)
option remember;
    if k > n then 0
    elif n=0 or n=k or k=0 then 1
    else thisproc(n-1,k-1) + thisproc(n-1,k)
    fi
end proc
:
CodeTools:-Usage(Bin(120,60));
memory used=0.75MiB, alloc change=0 bytes, cpu time=16.00ms, real time=7.00ms, gc time=0ns
              96614908840363322603893139521372656

restart:
#The only difference is that I commented out the "option remember":
Bin:= proc(n::nonnegint, k::nonnegint)
(* option remember; *)
    if k > n then 0
    elif n=0 or n=k or k=0 then 1
    else thisproc(n-1,k-1) + thisproc(n-1,k)
    fi
end proc
:
CodeTools:-Usage(Bin(25,12)); #Much smaller numbers than above
memory used=1.11GiB, alloc change=0 bytes, cpu time=10.56s, real time=10.71s, gc time=625.00ms
                            5200300

Now, you just need to do the same thing with your procedure Fib.

Note that without option remember, computation of the first 30 Fibonacci numbers will take about 2^30 (~1 billion) procedure calls. So, I recommend that you lower that from 30 to 20 or so.

The command plots:-textplot can be used to plot text at any coordinates, at any angle, and in any color. If that text were an appropriately placed ">", it would look like an arrowhead on the curve.

f:= x-> x^2:
(Xmin,Xmax):= (0, 3):
PrePlot:= plot(f(x), x= Xmin..Xmax, color= red):
(Ymin,Ymax):= (min,max)(op([1,1], PrePlot));
                      Ymin, Ymax := 0., 9.

Angle:= arctan@(D(f)/((Ymax-Ymin)/(Xmax-Xmin))):
plots:-display(
    PrePlot,
    plots:-textplot(
        [seq([k, f(k), ">", rotation= Angle(k)], k= ceil(Xmin)..floor(Xmax))],
        color= red
    )
);

For the angle to work correctly, Ymax-Ymin must be the length of the y-axis and Xmax-Xmin must be the length of the x-axis. The relationship of these quantities to the actual curve is irrelevant.

Your seq could be changed to add or mul, your 1..100 could be changed to 1..77 or 34..58, and your ithprime(i) could be changed to ithprime(i)^2, etc.

It'll be much easier to use calculus than to use Maple's CDF command for this. Indeed, I can do the calculus in my head.

Hint: The integral of any PDF over its support equals 1. (The support of a PDF is the values of its independent variable (x in this case) where the PDF is not 0.) So, it can be done with two lines of Maple code: the first uses solve and int to get the value of c. The second uses int and piecewise to get the final answer.

This is usually a sign of a licensing problem. You'll probably need to directly contact Maplesoft's customer support to get it fixed.

One of the basic techniques of computer algebra is to solve the same problem several times over different prime fields and then "lift" those solutions to the integers. There are several algorithms for the lifting. Here, I use the oldest and most well known: Chinese remaindering (see help page ?chrem).

The code below finds an 20-digit (67-bit) value of d in 2.3 seconds. That's larger than wordsize. This only requires 13 primes, all less than 80. It attempts only 619 factorizations over finite fields and 13 irreducs over the integers.
 

Download ChineseLifting.mw

If the result containing xs were named res, you could do

eval(res, x= x(t))

There are some shorter and cruder possibilities for your particular example, but they won't work for more complicated examples.

When you get a non-smooth implicitplot, the first thing to try is the gridrefine option. It's a positive integer defaulting to 1. Here, I've set gridrefine= 3 for your plot:

The minimum is 0 at a=0; the value of x is irrelevant. It's not a local minimum because a=0 is one of the boundaries. This can be confirmed by simple plotting:

plot3d(f, 2..5, -1..0)

An iron-clad proof that this is the minimum will be harder to obtain.

So, the Optimization package was more accurate in this case.

Here is VV's algorithm as a predicate (i.e., returns true or false) procedure. This doesn't rely on the vertices being numeric and tries to do a minimal amount of copying:

IsOuterplanar:= proc(G::Graph)
uses GT= GraphTheory;
    GT:-IsPlanar(GT:-GraphJoin(G, GT:-PathGraph(1)))
end proc
:

The cases that don't work via a direct built-in distributive property can be done with map:

e:= a <= b;
map(exp, e);
map(`/`, e, -2);

Caution: This works regardless of whether the results are mathematically valid.

Many of these distributive properties are documented at ?evalapply.
 

Using solve(..., parametric), a definitive programmatic solution can be obtained in Maple 2019:

f:= 2*x^5-x^3*y+2*x^2*y^2-x*y^3+2*y^5;
solve({f, x < 0, y < 0}, parametric);
      [ ]

Note that those brackets won't be empty if either or both inequalities are reversed.

The parametric option only works for polynomial systems and systems that can be easily reduced to polynomials.

I find ColumnGraph difficult to use when you have non-categorical horizontal-axis data (such as real-number measurements), and it becomes clear that this wasn't its intended usage. Instead, it can be done with a regular plot command like this:

plot(
   ((x,y)-> [[x,0],[x,y]])~(yr, sle), 
   thickness= 70, xtickmarks= yr, view= [0..0.35, DEFAULT]
); 

The colors can be easily changed if you want.