Below, I have solved the specific problem of finding the fourth root (over a finite field) of your original matrix. Before I generalize this into a procedure to find, where possible, any root of any matrix over any finite field, I'd like for you to confirm that this meets your needs, that it executes on your version of Maple, etc.

To create the worksheet below, I necessarily had to repeat the code from my previous two Answers to you. I apologize to all readers for the repetition. The last third of the worksheet is entirely new material.

Download Matrix_powers_finite_field.mw

Download frem.mw

Convert the overall list to a set, then convert the vectors to lists and then back to vectors. It can all be done with a single command like this:

`<|>`~(map(convert, {eq[]}, list));

I agree with Markiyan in that I know of no well-defined concept of a spanning tree for a directed graph, unless you mean a spanning tree (or forest) of the underlying undirected graph. Nonetheless, your procedure should return something interesting, even if it couldn't properly be called a spanning tree. My guess is that it'll return the maximal outward-branching tree that can be formed starting at the given vertex. This'll show all vertices reachable from the given vertex, which is inherently interesting.

I found four obvious errors in your code:

1. Replace assigned(visited[]) with assigned(visited[w]).
2. Replace Departures(G,v) with Departures(G,w).
3. In the final return, replace edges with convert(edges, 'set').
   
4. In procedures, you can't rely on packages being loaded, nor is it safe to use with in a procedure. So, package commands should be fully qualified (e.g. GraphTheory:-Graph) or the package name should be declared in a uses clause in the header of the procedure.

Furthermore, indent your code! It'll make errors easier to find. The following is my indenting style. I'm not saying that you should use my style, but that you should have a style.

DiSpanningTree:= proc(G,v)
uses GT= GraphTheory;
local
     comp:= Array([]), edges:= Array([]), visited:= table(),
     recurse:= proc(w)
     local z;
          if assigned(visited[w]) then return false end if;
          comp(numelems(comp)+1):= w;
          visited[w]:= true;
          for z in GT:-Departures(G,w) do
               if recurse(z) then edges(numelems(edges)+1):= [w,z] end if
          end do;
          true
     end proc
;
     recurse(v);
     GT:-Graph(convert(comp,'list'),convert(edges,'set'))
end proc;

I haven't tested the above code; I've only corrected the four obvious errors. 

Those limits are not specific to a GUI; they're set in the kernel with the kernelopts command. For example

kernelopts(cpulimit= 1*Unit(hour)):
kernelopts(datalimit= 1*Unit(gibibyte)):

See ?kernelopts.

The procedure `PDEtools/NumerDenom` is fairly simple, and you may understand it just by reading its code, which can be done via

showstat(`PDEtools/NumerDenom`)

To find out where it is being called from, give the commands

debug(`PDEtools/NumerDenom`);
stopat(`PDEtools/NumerDenom`);

Then issue the command that causes the error. When the debugger starts, give it the command

showstack

My guess is that it'll be very difficult to tell when this kind of coefficient blowup will occur, and even more difficult to tell whether isolate will work better than solve. So I think that what's needed is a way to "normalize" the coefficients after the blowup. My procedure balance below handles this. There're probably cases where it won't work, but this is the kind of thing that's used on an ad hoc basis.

Download balance.mw

By the way, I corrected your Eq1: It had a "naked" y1 which I changed to y1(t).

How about 12 seconds? It's better than your current 32 seconds. Use this:

A:= ImportMatrix(
     "/Imp34462 14.txt",
     source= delimited, delimiter= ";", datatype= float[8]
):

eqn:= diff(y(t),t) = -.25*y(t):
init:= y(0) = 5:
sol:= dsolve({eqn, init}, {y(t)}, numeric):
p:= plots:-odeplot(sol, [t, y(t)], t= 0..50, colour = red):
A:= select(p-> p[2] > 1.5, convert(op([1,1], p), listlist));

Okay, I understand your polynomial-to-integer encoding scheme now. The command to extend an already-extended finite field is Primfield. So, in the worksheet below, I extract the root of your quadratic irreducible in GF(2^8) and give it a representation in GF(2^16). Then I get the other root in the new field.

Download Primfield.mw

You have given minimal information, so I can only give a minimal Answer. To evaluate an expression ex at x=17 do

eval(ex, x= 17);

If you need more help than that, you must post your code.

In Maple, the mathematical constant Pi is spelled with a capital P. If you spell it pi, it is treated as just another variable.

Hmm, I think that you mean a nine-game round of a competition, not a nine-team. How can there be nine games in the first round if there are nine teams? Anyway, here's a one-line procedure for it. The parameter n is the number of games. So, the matrix that you specifically asked for is T(9).

T:= n-> Matrix((op~)~(combinat:-permute([[1,0]$n,[0,1]$n], n)))^%T;

Note that every even-numbered row of the matrix is redundant: It is the exact opposite of the row above it.

I feel that the Answer by Markiyan and the comment by Tom have brought an unnecessary cloud of negativity over this situation. Yet it can be easily and simply solved by Maple when solutions exist.

Here's a worksheet with a procedure for the eigenvalues and a procedure for an associated eigenvector to each eigenvalue. I do an example over a field with a prime number of elements and one over a field with a prime power number of elements.

Download finite_field_eigenvalues.mw

The issue is exactly as Tom Leslie suggests in his fourth point: The lack of spacing in the expression P[B](p-w) causes Maple to interpret it as a function, P[B], whose argument is p-w. You no doubt intended for P[B] to be a coefficient to p-w. To express that multiplication, you need either a space or an explicit multiplication symbol between the two: either P[B] (p-w) or P[B]*(p-w).

This is only an issue when using Maple's odious 2D-input. In 1D-input, both f(x) and f (x) represent function application, and multiplication always requires an explicit symbol. I suggest switching to 1D-input.

The notation D(P[B])(p-w) means the derivative of the unknown (but known to be univariate) function P[B] evaluated at p-w.