Probably a hideous way to proceed

Using  result := ssystem("tasklist <opts>"), where < opts >depends on what OS you use (Windows only) you can get a table (iin Windows sense) which contains all the PIDs.
This require to "postprocess" resultto display only the PIDs associated to a mserver.exeprocess

When you run xmaple, open a worksheet run the previous command to get the mserver's PIDs.
Proceed this way ach time you open a new worksheet: by comparing the new PID's list to the one of the previously opened worksheet you will get the PID associated to your current worksheet.
This can be useful is the stopbutton doesn't cancel the computations and if you can't close the current document.

Unfortunately I don't know how to identify to what node a mserverprocess belongs to when I distribute the computations over several nodes while using the GridPackage (being able to kill the computations on a specific node is something I would really like to have, all the more so that even after leaving Maple the process still exists and keeps using memory).

The command which generates output (4) is incorrect:

• You use = instead of := 
• You use exp^(...) instead of exp(...) 

Here is the correction (done with Maple 2015 whichh doesn't accept this awfull notation C(x, t) := ...)

 

Download easy_way_mmcdara.mw

L:=[[3, 2], [2, 1], [1, 2], [1, 2], [2, 3], [2, 1], [1, 2], [1, 1], [2, 1], [1, 2], [1, 1], [2, 1], [1, 1], [1, 3], [1, 2], [2, 1], [1, 3], [1, 3], [1, 3], [1, 2], [2, 2], [2, 3]]: 

Ls := convert~(L0, set): 
L1 := map(u -> [[u[]], ListTools:-Occurrences(u, Ls)], {Ls[]}): 
Lk := map(u -> if numelems(u[1])=1 then [[u[1][1]$2], u[2]] else u end if, L1)

{[[1, 1], 3], [[1, 2], 11], [[1, 3], 4], [[2, 2], 1], [[2, 3], 3]}

L2 := [map(u -> [add(op(u[1])), u[2]], Lk)[]]

           [[2, 3], [3, 11], [4, 1], [4, 4], [5, 3]]

answer :=(`*`@op)( (`*`@op)~(L2))

                             190080

If you want to find the argument which minimizes the sum of the norms for a given value of lambda, this is quite simple:

w[opt] := (X^+ . X + lambda*~J)^(-1) . X^+ . Y

where X is a N by P matrix, Y a column vector of length N and J the identity matrix of dimension N.

But maybe you are talking about Ridge regression where you seek fot the couple (w[opt], lambda[opt]) which minimizes thz sum of the norms???

Several things are weird or incorrect:

• Do you really need this weird Digits:=100???
  It works quite the same with Digits:=10.
   
• p(t) is a nonsense, for the integration is done over t and thus its result cannot depend on t:

  p := int(f(t)*exp(-lambda^2*t), t=0..L)
                                       -134
                        -4.804438634 10    
  

• As p is a constant, C(x, t) is a function of x alone.
  The message 
  Error, (in sum) summation variable previously assigned, second argument evaluates to 200. = 1 .. 500
  is clear: you have previously assigned n to 200.
  The cure: protect n by writing 'n' =1..500

  C := x -> sum((2/L*sin(n*Pi*x/L)*exp(1)*sin(n*Pi*x/L))*p, 'n' = 1 .. 500):
  C(1);
                                       -136
                        -1.871559740 10    
  

With these correction the worksheet doesn't contain any error...
But are you sure that the integral

int(f(t)*exp(-lambda^2*t), t=0..L)

is the one you wanted to write???

In Maple 2015.2 SumTools doesn't offer a procedure Change as IntegrationTools does.
So the idea to transform the sum/Sum into Int, to apply Change, and to go back to the sum/Sum.

S := sum(a[k]*(k+r)*(k+r-1)*x^(k+r-1), k = 0 .. infinity): 
J := Int(op(S)): 
IntegrationTools:-Change(J, k=j+1, j):
IntegrationTools:-Change(%, j=k, k): 
Sum(op(%))
         infinity                                     
          -----                                       
           \                                          
            )                                  (k + r)
           /     a[k + 1] (k + 1 + r) (k + r) x       
          -----                                       
          k = -1                                      

@sursumCorda 

You're right.
Here is another way based on the following principle:

• Let A some term in rules.
• Set B = eval(A, R) where R denotes the rules with element removed
• Keep proceeding this way while B <> A after setting R=R \ B and A=B.

I initially removed elements of the form b=b (trivial 1-cycles).
 

Download cycles_1.mw


EDITED
to get all the cycles without permutations removed, replace the last for..do..end do structure by
 

# AEC stands for All Elementary Cycles (rotations removed) 

AEC := NULL:
for i from 1 to numelems(rules) do
  LocalCycle := cycle(i):
  if `not`(has(convert~([AEC], set), {convert(LocalCycle, set)})) then
    AEC := AEC, LocalCycle;   end if:   printf("from = %a : cycle = %a\n", rules[i], LocalCycle);
end do:
from = g = d : cycle = [g = d, d = c, c = g]
from = e = a : cycle = [e = a, a = e]
from = a = b : cycle = []
from = f = d : cycle = [f = d, d = c, c = f]
from = c = g : cycle = [c = g, g = d, d = c]
from = d = c : cycle = [d = c, c = g, g = d]
from = c = f : cycle = [c = f, f = d, d = c]
from = a = e : cycle = [a = e, e = a]
from = f = g : cycle = [f = g, g = d, d = c, c = f]

print~({AEC} minus {[]}):
                         [e = a, a = e]
                     [f = d, d = c, c = f]
                     [g = d, d = c, c = g]
                  [f = g, g = d, d = c, c = f]

The words you used made me think of your problem in terms of a graph.
The underlying idea is to represent your list of rules by a directed graph and then search for "directed cycles'.

I'm using Maple 2015.2 right now, which means I miss some recent features of GraphTheory (for instance single loops are nort allowed).
The code above finds:

• 1-cycles, corresponding for instance to a rule such that a=a
• 2-cycles, corresponding for instance to a couple of rules such that a=b, b=a
• and FUNDAMENTAL cycles of higher lengths through the procedure CycleBasis (applied to the underlying undirected graph).

This means that some cycles may be missed, for instance those that could be created by a composition of cycles in the cycle basis.

Maybe someone will be interested in this alternative approach?

Download cycles.mw

@Carl Love is right.
But, one may infer the solution this way:

• Replace 2014 by 2 (and ths 2015 by 3 and 2013 by 1)
• Solving this 2 by 2 system gives x1=x2=1/2
• First inference: could it be that x1=x2...=x2014=1/2014 ?
• Second inference (used below): could it be that x1=x2...=x2014=x, wher "x" is to de determined
   

Answer:  x1 = x2 ... = x2014 = 1/2014

Download InferedSolution.mw

The x label is conform to what you want but the construction is quite complex (it uses MathML).

• "&#x28;" codes the left parenthesis
• "&#x29;" codes the right one
•  mo("-",mathcolor="white") is a trick to introduce a space
•  msup(mo("x"),mo("n")) generates xⁿ

Don't focus ob what the y label looks like: you need to execute the code to get a correct display.

Download TwoWays.mw

For your system to be a PDE system it has to contain partial derivatives wrt both x AND t.
As no derivative wrt t is present, you have a simple ODE system.

You already noticed that writting eq3 and eq4, and then did right solving this system.
If what puzzles you is that the solution doesn't depend on arbtrary functions of t you can do somethinh like that:
in the file below f(t) and g(t) are arbitrary functions of t, those who Maple would name _F1(t) and _F2(t)
 

Download Solve_as_an_ODE_system.mw

When I get some "counter-contuitive" result, I use to try and figure out what could have happened, for instance by seeking to the problem otherwise (please don't take this as a critic).
In your case I would have done this:

• Seek if there exist real solutions by checking if the operands under each square root are positive on a non empty interval.
• If not, replace x by y*I*z and operate explicitely in the  C field.
• Observe the solutions.
  Evaluate y*I*z for these solutions.

You will see that the result of this last step (1/9 and 2) is exactely the result that Maple gave you.
So I guess thet Maple takes the same path that I described above (?)

Download Another_POV.mw

Finally:

eval(y+I*z, sol[1]), eval(y+I*z, sol[2]);
                                 1
                              2, -
                                 9

If you really want the term within the parenthesis to  be of the form x^n-1*((n+1)*x-2n), you can do this

map(collect, simplify(eval(f, x^n='x'*x^(n-1)), size), x)

                                      (n - 1)
                   ((n + 1) x - 2 n) x       

"Proof" is within the worksheet

Download roots.mw

If I understand correctly, here is a solution
(I sorted the selected columns: if you don't want to sort them modify my code accordingly)

Download ChooseColumns.mw

BTW, did you succeed in loading the PLS_PCR_Linnerund.mw file ? 
(see my las t replyy to the related thread).