Most of the information that you need to understand this can be found at ?rtable_eval. You may need to read that page slowly and carefully 10 to 20 times (like I did) to understand it. Also read the seventh and twelfth paragraphs of Description at ?eval. What you also need to know to understand this:

• Most expressions fully evaluate when used at the command line (in any GUI).
• Most expressions evaluate to only one level (equivalent to eval(..., 1)) when they're used in a procedure.
• rtables never evaluate unless that's forced with a specific evaluation command.

To avoid obfuscation, first understand what is happening without the list conversion. To answer your Question about intention: yes, this behavior (before list conversion) is certainly intended. Whether the behavior after the list conversion is intended or correct or should be considered a bug: I don't know---it's a very fine judgement call. Certainly that behavior can be removed by adding an eval to `convert/list`.

A few examples:

Download rtable_eval.mw

But I still don't understand this: What is the difference between rtable_eval(A, inplace) and map[inplace](eval, A)?

You're probabaly better off using LinearAlgebra:-LinearSolve as in Preben's Answer, but this is possible using solve as in your Question. But your multiply is meaningless, and solve deals with sets or lists of algebraic expressions or equations but not with matrices. However, converting between the forms is straightforward. Additionally, your construction of the matrices could be simplified. This works:

restart:
A1:= Matrix((3,3), symbol= a);
A2:= <A, B, C>;
A3:= <15, 0, 0>;
solve(convert(A1.A2 - A3, set), {A,B,C});

(Of course, this solution is only valid when the determinant is nonzero.)

You don't show the results of your second attempt. When I do it (in Maple 18), I get your desired result:

restart:
sol:= solve(combine(sin(x)^2)=1/4, x, AllSolutions);

     sol := -(1/3)*Pi*_B1+(1/6)*Pi+Pi*_Z1

This procedure will expand any positive integer power of any Sum.

Download SumPower.mw

You simply need to include the option maxfun= 0 in the dsolve call. This actually sets the maximum allowed number of function evaluations to infinity.

The command is member(c, A), which is built-in and returns type truefalse.

The problem with Kitonum's Answer is that the solve is executed for each iteration. The (potential) problem with Tom Leslie's Answer is that it isn't a single statement. The solution to both problems is the oft-neglected $ sequencing operator. It works very much like seq except that, like most Maple commands (but unlike seq), its arguments are evaluated before being passed.

{b=j, eval(solve({x+b*y=0, b*x-y=10}, {x,y}), b= j)[]} $ j= 10..20;

     {b = 10, x = 100/101, y = -10/101}, {b = 11, x = 55/61, y = -5/61}, {b = 12, x = 24/29, y = -2/29},
     {b = 13, x = 13/17, y = -1/17}, {b = 14, x = 140/197, y = -10/197}, {b = 15, x = 75/113, y = -5/113},
     {b = 16, x = 160/257, y = -10/257}, {b = 17, x = 17/29, y = -1/29}, {b = 18, x = 36/65, y = -2/65},
     {b = 19, x = 95/181, y = -5/181}, {b = 20, x = 200/401, y = -10/401}

The example structure C that you showed is not a set: it's a sequence: its order matters, and members may be repeated. If you want to subtract a member from a set, then use the Answer by Thomas Dean. If you want to remove all occurences of a member B from a sequence C, then use

remove(`=`, [C], B)[];

Note that the f is not enclosed in { } in the solve command below.

Sol:= [solve(f, omega)];
min(select(`>`, Sol, 0));

Here's a procedure that will cancel the lowest floating-point power of 10 (positive or negative) in any fraction:

Cancel10s:= (E::algebraic)->
     `if`(
          hastype(E,And(float,Not(identical(0.)))),
          `/`((numer,denom)(E)/~10^ilog10~(indets(E,And(float,Not(identical(0.)))))[1]),
          E
      )
;

(Note that ilog10 also works for negative floats.) If the input is not a single fraction, it'll be rearranged to one. An expression mathematically equivalent to the input is returned in all cases, although it may not be the desired result if the expression contains nested floats. 

@smith_alpha 

Here are five methods for creating and filling a list. I've listed them in increasing order by the amount of computational resources that they take. Never use #5: It's very wasteful and never necessary. I only include it because it's the way that most people come up with on their own instead of #3 or #4. There are many situations where you can't use #1 or #2 and must resort to #3 or #4.

#1
f:= [seq(i, i= 1..3)];

#2
f:= ['i' $ 'i'= 1..3];

#3
f:= Vector():
for i to 3 do f(i):= i end do:
f:= convert(f, list);

#4
f:= table():
for i to 3 do f[i]:= i end do:
f:= convert(f, list);

#5
f:= []:
for i to 3 do f:= [op(f), i] end do;

There must be something additional known about u (other than about its degree of differentiability) in order for the identity to be true. Proof: Suppose u(x,y,z,w) = x. This u satisfies any possible degree-of-differentiability requirement. Since there are no derivatives taken with respect to x3 or y3, we can ignore any factors that depend only on those variables. (Alternatively, we could suppose, without loss of generality, that x3-y3 = 1.) Then the expression that you're taking the derivatives of is equivalent to w below. Execute the following Maple code:

u:= (x,y,z,w)-> x:
w:= add((x||k - y||k)^2, k= 1..3)^(-1/2)*u(x3*y1-x1*y3+x2-y2, 0, 0, 0):
diff(w,x1,y2)-diff(w,y1,x2):
eval(%, [x1=1,x2=2,x3=3,y1=4,y2=5,y3=2]);

Maple returns a number other than 0.

So, what are the assumptions made on u in the paper?

First do the permutations of the lists, then convert the lists to Arrays, for example like this:

Array~(combinat:-permute([1,2,3]));

Never use array (with a lowercase a); it's deprecated. Use Array instead. Likewise for matrix and vector.

Yes, it certainly seems like a bug. Here's a quick workaround:

fsolve(evalf(P), complex);

evalindets(eq, fraction, evalf);