The use of f(x) and df(x) is confusing in this context. And the print is redundant. Just use:

restart;
f:=x^2-3;
df:=diff(f,x);
x:=1.;  #use floating point here
for i from 2 to 5 by 1 do
    x:=x-(f/df);
    end do;

Your second approach works if you use solve:

Download linear.mw

If I paste your code into an execution group and hit enter, I see the cursor just before R on the line starting: locals R (It's quite hard to see). This will be near the error, which is that "locals" should be local. Continuing and fixing some missing semicolons gives a syntax error free code:

 # ctrl + del to delete a Maple cell
 # golden search implementation
 # chapra 7th ed
 golden_search := proc(f, xl, xu, es100, maxiter)
 description "find the optimal point using golden-search optimization method";
 local R, d, xopt, x1, x2, f1, f2, iter, ea, xint;
 R := (sqrt(5)-1)/2;
 d := R*(xu-xl);
 x1 := xl + d;
 x2 := xu - d;
 f1 := evalf(eval(f, x = x1));
 f2 := evalf(eval(f, x = x2));
 # declare iterator and ea
 iter := 1;
 ea := 1.00;
 # start while
 while ea*100 > es100 and iter < maxiter do
     d := R*d; # new golden ratio
     xint := xu - xl;
     if f1 > f2 then
         xopt := x1;
         fx := f1;
         x1 := x2;
         x2 := x1;
         x1 := x1 + d;
         f2 := f1;
         f1 := evalf(eval(f, x = x1));
     else
         xopt := x2;
         fx := f2;
         xu := x1;
         x1 := x2;
         x2 := xu - d;
         f1 := f2;
         f2 := evalf(eval(f, x = x2));
     end if;
     # calculate new ea
     if xopt <> 0 then
         ea := (1 - R)* abs(xint/xopt);
     end if;
     iter = iter + 1;
 end do;
 # return xopt and fx here
 xopt;
 end proc:

Typing ?while will bring up the help for the Repetition statement, or search for while in the search box under help/Maple help.

As @vv says, there a probably too many solutions, but Groebner gives a way of systematically finding them. You would first want to make all the coefficients rational. As a toy example that finds four real solutions for two equations see below. If you eliminate ones that are unphysical as you go (perhaps negative solutions?), you might be able to find your solution relatively efficiently.

Groebner.mw

(I'm having a problem pasting the contents of the worksheet)

At t=0, you have x(0)=0 and D(x))(0) = 500. Substituting these into eqn gives 0 = 2*500^2, which can't be true. So the equation and the initial conditions are inconsistent at the initial point.

for example, for

f:=(x,y)->x^2;

op(1,eval(f));
gives the sequence of parameters x,y and nops can then be used to count them:

nops([op(1,eval(f))]);

gives 2

sprintf("%.4f",0.0141); gives "0.0141"

The format parameters give finer control about width, precision etc see ?sprintf

If you right-click on the first definition of f, and use 2-D math/convert/convert to 1-D math input you will see:

f:=k->;sum(k*x(n), n = 2 .. 3);f(1);

There is an unwanted something (appears as a semicolon here, but that's prob not what you entered) after the arrow and before the sum, i.e., this line is corrupted somehow.

A parametric plot is an alternative to Kitonum's implicit plot, and is general for switching axes:

plot([-4.918231636*z^3+2.486861786*z^2+.8573483099*z+2.341623514,z,z=-0.5..0.8]);

and use the view option to define the plot area.

Assuming that your x should be t, then

Download powerseries.mw

There is a problem having the page breaks in the file "The Lattice Package Users Guide.mw" - if you remove them then you can load it into a workbook.

I figured this out by assembling the workbook by hand, and it might be instructive to do this. I would install a package from the cloud ("Orbitals" would be my choice but I'm biased) and look at the workbook structure to figure things out.

To make it a package in the cloud just save the workbook to the cloud from the file menu. Then you can install it from the cloud.

The help page ?worksheet,cloud,creatingPackages is quite good on the details of the process

gives  Pi^2*_Z1~^2/L^2 and then about(_Z1) tells you it is an integer.

(Edit: Didn't see Carl's solution until after I submitted this.)

There are n*(n-1) = 64 {0,1} adjacency matrices with zeroes on the main diagonal (loopless graphs), so for this case, an indexing function for generating the matrices can help:
 

Download graphs.mw

If the bugs go away, and you generate a list of the digraphs, then you can categorize into the groups (equivalence classes) that are isomorphic using

[ListTools:-Categorize(IsIsomorphic,graphlist)]