@C_R has pointed out many of the things I might have mentioned. Here a few more comments along the same lines.

Q1. To me, your formulation uses matrices, but is not very matrixy. That's hard to define and probably largely intuitive on my part. Your matrices are almost all involved in dot products or quadratic forms (a^T.M.x), which produce scalars that you then involve in non-matrix equations. The power of matrices is in setting up matrix equations (I suppose a few vectors are allowed) and solving the matrix equations - often just a linear equation solving of Ax = b, but perhaps AX + XB = C, AXB = C or some nonlinear ones.

Specifically (but vaguely), the entries of r don't look like they have a simple matrix origin - we have square roots of entries, and while the denominators themselves might be matrixy, division is not a matrix thing so the denominators might better be in scalars outside the matrix. For the numerators, there are only diagonal elements of S, so where did the off-diagonals go?

The key point was given by @C_R: "but for that we have to see the structure of the equations in the first place".

Q2. I would say no here. Try to set things up without components, even if later you need to be explicit about them. For example to take a small part of your equations. q[1] = w^T.S.e[1], q[2] = w^T.S.e[2], q[3] = w^T.S.e[3] . So q[1], q[2], q[3] are the first, second and third components of w^T.S, so this is just q^T = w^T.S or q = S^T.w. The w[i]^2 seem to make this type of analysis harder (not matrixy?).

According to the help page, rsolve requires A(n), not A[n]. (But see @acer's answer.)

Download ask_recrusive_sequence_of_A[n].mw

It seems to me that case (I) covers all sign combinations of lambda and mu. Case (II) looks incorrect to me - just putting the negative in doesn't work unless lambda and mu are redefined.

Download dsolve.mw

I don't understand the seed issue, but have some other answers.

My understanding is that Maple does some preprocessing and then calls the actual NAG compiled code.

Numerical_integration_Using_MC_methods.mw

I didn't have the patience to wait for your code to finish to diagnose the results. (I'd guess Equal doesn't try too hard for very complicated entries.) The main issue here is that the inverse of a matrix with symbolic entries is too complicated to be useful, except for very small matrices. But if you have numeric entries, you can easily verify the relationship works. Here's how I would do that. I used integer entries to avoid numerical roundoff issues, but for floating point entries it can be faster.

Download Kronecker.mw

Maple uses indexed RootOfs to distinguish the roots - these are in a specific order - see the ?RootOf/indexed help page. Solve gives a generic RootOf, but you can use allvalues to get all the values, and it tracks the different possibilities by default (see the dependent option). An example for a polynomial system is given below.

Edit: For commands like irreduc, the default field for the coefficients is the rationals, but Maple can handle extension fields through evala and its subcommands. As @Carl Love notes, the indexed RootOfs are for all the complex roots.

I'm not sure I have fully understand your question. If you give a more specific example of what you want to achieve or what didn't work as you expected, I'll try to clarify.

Download Rootof.mw

Maple has some algorithm to find the best set of points to use for plotting a function (not just at equal intervals across the x-axis), and here it seems to be getting confused. You can fix this by using adaptive=false or numpoints=2000.

I'm not sure how integration by parts would apply here. You can just exchange the sum and integration:

Download integral.mw

@one man @vv I found plex wasn't much slower than tdeg and put all the pieces together. RationalUnivariateRepresentation should allow fsolve to work on a single polynomial but there are numerical and speed issues.

(I originally tried these polynomial systems with SolveTools:-PolynomialSystem, but it was much slower and I gave up.)

nonlinear2.mw

Edit: I wasn't substituting back into the correct original equations; now fixed.

Download directly_integrable.mw

Depends on the exact type of question. But Maple's geometry package might be able to help. Or you can set up relevant equations in Maple and then solve them.

You can't use B[1] or B[2] as parameter names - use B1, B2 instead. Note: if you were using 1-D input, you would receive a more intelligible error message about unexpected [ and the cursor would point you to the offending [

In your first approach notice that there is an infinity at the end, so Maple is telling you the result is +/- infinity. Within the signum function, there two terms that might have different signs. Assuming n>1 would not be enough to resolve this. To check the infinity part, you could put in some numerical values for all but gamma, and plot vs gamma.

So for the second part, you will get the same result, but now the X and lambda are more complicated, and deciding the signs of things is also more complicated, so it will take much longer to decide if it can.

Your question is not very specific about what you want to do, so maybe this doesn't answer your question. The LinearAlgebra:-Generic package allows you to define generic field operations, but for extensions of Q you can do many basic things just with the LinearAlgebra package.

Download Field.mw

"I tried converting an outupt to a string which removed all the backslashes in the file path. Maybe there is a dedicated command that I overlooked."

SplitPath does this, in a way that doesn't care whether the separator is \\ or /

Other related manipulations are in the FileTools package

Download SpliPath.mw