Writing A=F''(1)+3, and AS for its (formal) series representation, it could go like:

AS:=Sum(a[n]*R^n,n=1..infinity);
solve(series(AS,R,4) = A, R);
                                    2
          1       a[2]   2   -2 a[2]  + a[3] a[1]  3      4
         ---- A - ----- A  - -------------------- A  + O(A )
         a[1]         3                 5
                  a[1]              a[1]

It sounds like the package submitted in this thread could be useful.

The plot of the map (Y1,Y2)->(U1,U2) by U1=F1(Y1,Y2), U2=F2(Y1,Y2) can be ploted as a map of coordinate lines on the plane, like in this linear map:

addcoords(F,[Y1,Y2],[Y1+Y2,Y1-Y2]);
plots:-coordplot(F,[-1..1,-1..1],scaling=constrained,axes=normal,
labelling = true);

is with differential operators:

with(DEtools):
_Envdiffopdomain:=[Dx,x]:
ode:=p(x,a)* diff(w(x),x$2) + q(x,a)* diff(w(x),x) + r(x,a)* w(x);

                    / 2      \
                    |d       |           /d      \
     ode := p(x, a) |--- w(x)| + q(x, a) |-- w(x)| + r(x, a) w(x)
                    |  2     |           \dx     /
                    \dx      /

dop:=de2diffop(ode,w(x));

                               2
              dop := p(x, a) Dx  + q(x, a) Dx + r(x, a)

coeff(dop,Dx,2);

                               p(x, a)

It would be the same error with:

F:=proc(L)
L:=1:
end proc;

Without the assignment it works:

F:=proc(L)
subsop(1=NULL,L);
end proc;

L:=[x,y,z,d];
F(L);
                              [y, z, d]

if you post your commands in text form and/or upload your worksheet.

What I find strange is the difference in implementation. While in:

x-Vector(2, [1, 0]);

after the arguments to `-` are checked as vectors, the operation is dispatched to 'LinearAlgebra'/rtable routines (LinearAlgebra:-Multiply, LinearAlgebra:-LA_Main:-VectorAdd, etc), but for

x=Vector(2, [1, 0]);

'LinearAlgebra:-Equal' or something like that is not called.

See this thread. It is for Spanish Win XP but may be similar for German

It is a command included in the Maple Advisor Database library.

An example, from errorbar help page:

errorbar([seq([i,i^2,10/i],i=1..10)]);

a:=plot(Heaviside(x), x=-1..1);
A:= op(1, op(1, a));

I get in A a list of [x,y] lists, in the range -1<=x<=1, using both Maple 9.5 and Maple 12.

See ?plot,options, for option adaptive false.

Ie using the new '%' inertization prefix, and a function representation for `-`, some control on the display seems possible though:

eval(%cos(subs(m=`-`,m(beta,alpha))));

                          %cos(beta - alpha)

value(%);

                          cos(-beta + alpha)

In a fresh session I get instead:

cos(beta-alpha); 
                          cos(-beta + alpha)

cos(alpha-beta); 

                          cos(-beta + alpha)

This is due to automatic simplification to a (session dependent) unique representative form of these equivalent expressions. As this is at the basis of the design of Maple, I do not see very much to do against.

PS However, for display only purposes, you can use this empty name trick:

cos(alpha*``-beta); 
                         cos(alpha   - beta)

by setting a value for Q, you can do something like:

f:=18^2-y^2 = Q*(ln((3000*(18-y))*sqrt(0.412e-4))-ln(sqrt(x)))/(0.412e-4*Pi);
g:=solve(f,x);
plot(subs(Q=1,g),y=0..10);

This help page states:

The warning indicates that the solve command cannot confirm that the solution set returned is complete.
Solution: Try to reformulate the problem.
For additional assistance, contact Maple Technical Support or post your problem on MaplePrimes.

Then it gives a single example of this problem:

solve(sin(y*x) < 0, x);

Warning, solutions may have been lost

_SolutionsMayBeLost;
                                    true

But I find it incomplete as it does not show how to reformulate this problem. I beleive that some more complete examples would be very useful.

For something simpler:

use RealDomain in int(1/x,x) end use;

		ln(x)

Should the output be ln(abs(x)) ? or a piecewise: ln(x) for x>0 and undefined for x<=0 ?

Note, ?RealDomain states:

Results returned by procedures are postprocessed by discarding values containing any detectable non-real answers or replacing them with undefined where appropriate.