Use the ImportData() command to launch a dialog/assistant that will read your data file into a Matrix. Then follow the instructions given by Preben.

Having only one equation, you can only solve for one variable per invocation of solve:

solve(equation1, {p[1]});

solve(equation1, {p[2]});

Also, looking closely at the end of your equation, I see that it is fourth order in p[2]. This may have been a typo on your part, since you said the equation was quadratic. It is still solvable, but the solutions are very large, and take about a minute to be generated.

It is unfortunate that solve does not simply give an error message when one asks for solutions for more variables than there are equations. Instead one gets the confusing "Warning: Solutions may have been lost".

     if given a permutation group

     1 2 3

     2 1 3

To me, that's a single permutation, not a whole permutation group. But perhaps you mean the group generated by the permutation.

The cycle factorization of the permutation can be done via

convert([2,1,3], disjcyc);
                            [[1, 2]]

But I don't know if that satisfies your questions about the "type" of permutation group and about polya counting. Let me know.

I think that what you want is

plots:-spacecurve([seq]([x[k],y[k],z[k]], k= 1..200));

But I don't know if that's "in the three-dimensional phase domain", and it's certainly not a "phase plane".

Anyway, please let me know if the spacecurve is what you want.

You need to make some assumptions for the IsDefinite to work.

assume(w1 >= 0, w2 >= 0, w3 >= 0, w4 >= 0, w5 >= 0, w6 >= 0);

I don't know if the overall program will work after these assumptions are made (you didn't attach the uploaded file), but that's the first hurdle.

Note that L(w1,w2,w3,w4,w5,w6,lam) is evaluated before being passed to NLPSolve. Thus, the fact that you did specify the nonnegativity assumptions in the call to NLPSolve does not cause those assumptions to be used while evaluating the arguments to NLPSolve.

This is a bit tricky; perhaps not suitable for the Maple beginner.

F:= (N::evaln(list(`=`)))-> (convert(N, `local`)@lhs = rhs) ~ (eval(N)):

u:= [a=x, b=w]:
p:= [1=4, 3=2, 5=2]:
F(u), F(p);
      [u(a) = 1, u(b) = w], [p(1) = 4, p(3) = 2, p(5) = 2]

seq(Matrix([[seq(a[k], k = x+m .. y+m)]]), m = 0 .. 2);

^^^^^^^

Obviously, the result of such a command is a sequence of Matrices, not a Matrix.

Here's my shortest code:

< seq(< a[x+m..y+m] >^%T, m= 0..2 ) >;

In particular, note the for any list L and valid indices a and b,

[seq(L[k], k= a..b)]

is the same thing as simply

L[a..b]

In Maple, when a negative real number is raised to a fractional power with an odd denominator, the result is not real. As it says at ?arithop or ?^,

For non-integer (complex) numeric powers y and (complex) numeric x, the expression x^y is evaluated as exp(y*ln(x)), where ln(x) is evaluated using the principal branch of the logarithm.

The function surd can be used to compute real odd roots of negative real numbers.  See ?surd for more information.

Since ln(-1) = I*Pi, the upshot of that first sentence is that for integer n, (-1)^(1/n) = cos(Pi/n) + I*sin(Pi/n):

radsimp((-1)^(1/3));
                         1   1    (1/2)
                         - + - I 3     
                         2   2      

cos(Pi/3)+I*sin(Pi/3);
                         1   1    (1/2)
                         - + - I 3     
                         2   2         
But

surd(-1, 3);
                               -1

or

use RealDomain in (-1)^(1/3) end use;
                               -1

(see ?RealDomain).

In this case, you need to circumvent the automatic simplification of x^0 to 1. You do this with

coeff(b, x, 0).

We make Points1 into an (M+1) x (N+1) x 3 listlistlist:

A:= [seq](Points1[(M+1)*k+1..(M+1)*(k+1)], k= 0..N);

plots:-surfdata(A);

And you can add the same options that you used for the pointplot3d command.

Please remove the with(linalg) from your worksheet. It works without it.

If they can be considered the same thing and also be considered the same as 1, then it is trivial:

Re ~ (sol);

Then proceed with whatever else you were doing with the repetitions.

If your goal is simply to remove the repetitions from a list L, and you don't care about the order, then it is trivial: convert to a set:

{L[]};

If you want to keep it a list, but you still don't care about the order, it is still trivial: convert to a set, then convert back to a list:

[{L[]}[]];

When order doesn't matter, removing repetitions, whether or not they exist, is much easier than detecting or finding them: The former can be done entirely in Maple's kernel.

An rtable is a Matrix, Vector, or Array. A list is not an rtable. FindRepetitions returns a list (so converting it to a list doesn't do anything). Why don't you use the numelems command that acer recommended? If your Maple version is less than 15, use nops for a list.

If the implicit-form solution can be solved for the independent variable, as it can in this case, then there are several more very easy ways to get it.  Here's three: (Sorry, explicit uploading of worksheets seems broken right now, so I am uploading this in plaintext (prettyprint=1).)

restart;
ode:= x - y(x)/diff(y(x), x) = y(x);
                            y(x)         
                      x - -------- = y(x)
                           d             
                          --- y(x)       
                           dx            
(1)
dsolve(ode);
                       /        /     x    \      \
             y(x) = exp|LambertW|- --------| + _C1|
                       \        \  exp(_C1)/      /

isolate(subs(y(x)= y, %), x);
                     x = -y (-_C1 + ln(y))

(2) The name of the conversion below is y_x regardless of the names actually used in the ODE.

convert(ode, y_x);
                       d              x(y)
                      --- x(y) = -1 + ----
                       dy              y  
dsolve(%);
                    x(y) = (-ln(y) + _C1) y

(3) The order of  the substitutions below is significant.

subs(diff(y(x),x)= 1/diff(X(y),y), y(x)= y, x= x(y), X= x,  ode);
                             / d      \    
                    x(y) - y |--- x(y)| = y
                             \ dy     /    
dsolve(%);
                    x(y) = (-ln(y) + _C1) y

Download implicit_dsolve.mw

For any complex y, y*conjugate(y) = |y|^2 (although I would've guessed that you already knew this identity). The identity can be applied automatically via

simplify(z);

The resulting equation can be solved for abs(y) via

solve(%, abs(y));

indicating that there is a circle of solutions in the complex plane.