Unless I'm mistaken you miss one equation:

• eq1 is of the form

   A*diff(h(r), r$4) + B*diff(h(r), r$4) + LowerOderTerms = 0

  A and B do not contain derivatives of h anq q of order 4

• eq2 is of the form

   C*diff(h(r), r$3) + E*diff(h(r), r$3) + LowerOderTerms = 0

  C and E do not contain derivatives of h anq q of order larger than 2

• Then plugging eq2 into eq1 produces a single ODE of the formeq1 is of the form

   P*diff(h(r), r$4) + Q*diff(h(r), r$4) + LowerOderTerms = 0

  where P and Q do not contain derivatives of h anq q of order larger than 3

So you miss one ODE.
The detailed explanation is given in the attached file.
A toy problem is also provided to help you understand why dsolve doesn't work asyou expected.
 

Download dsolve_mmcdara.mw

A toy_problem dsolve can't find the solution of, but whose solution can be obtained after reparameterisation:

 

Download Toy_Problem.mw

restart:
sys := {x^2*y+x=1, x*y-y^2=0}:
solve(sys);
    {x = 1, y = 0}, 

       /          /  3         \            /  3         \\ 
      { x = RootOf\_Z  + _Z - 1/, y = RootOf\_Z  + _Z - 1/ }
       \                                                  / 
infolevel[solve]:=100:
solve(sys)
Main: Entering solver with 2 equations in 2 variables
Main: attempting to solve as a linear system
Main: attempting to solve as a polynomial system
Main: Polynomial solver successful. Exiting solver returning 1 solution
    {x = 1, y = 0}, 

       /          /  3         \            /  3         \\ 
      { x = RootOf\_Z  + _Z - 1/, y = RootOf\_Z  + _Z - 1/ }
       \                                                  / 

 

This suggests solve calls some polynomial solver.
Searching for it in the help pages returns SolveTools/PolynomialSystem. I don't know if solve calls this procedure (showstat(solve) is hard to browse). Assuming it does:
 

SolveTools:-PolynomialSystem(sys, {x,y});

Main: polynomial system split into 1 parts under preprocessing
Main: trying resultant methods
PseudoResultant: normalize equations, length= 43
PseudoResultant: 353502 [1 3999999986 y 1] 2 2 43 0 3 0
PseudoResultant: normalize equations, length= 13
PseudoResultant: normalize equations, length= 35
PseudoResultant: 30000 [1 100000559 x] 1 1 13 0 3 1
PseudoResultant: normalize equations, length= 3
PseudoResultant: -10 [] 0 0 3 0 3 1
PseudoResultant: 201729 [1 1000012108 y] 2 2 35 1 8 0
PseudoResultant: normalize equations, length= 21
PseudoResultant: 117197 [1 700003740 x] 1 1 21 1 8 0
PseudoResultant: normalize equations, length= 3
PseudoResultant: -10 [] 0 0 3 0 3 0
PseudoResultant: 2 solutions found, now doing backsubstitution
PseudoResultant: backsubstitution of x
PseudoResultant: backsubstitution of y
PseudoResultant: backsubstitution of x
PseudoResultant: backsubstitution of y
    {x = 1, y = 0}, 

       /          /  3         \            /  3         \\ 
      { x = RootOf\_Z  + _Z - 1/, y = RootOf\_Z  + _Z - 1/ }
       \                                                  / 

restart
p := 35*x^8 + 80*x^7 + 140*x^6 + 504*x^5 + 1260*x^4 + 1960*x^3 + 1960*x^2 + 1120*x + 10:
dp := diff(p, x):
fsolve(dp);
                         -1., -1., -1.

But I suspect that you are looking for an answer you can obtain "by hand" aren't you?
Here is, written in Maple, a step-by-step procedure which only requires doing polynomial division (which can be done by hand)
Download ByHand.mw

Details:

• Observe -1 is a root of dp = diff(p, x)
• Thus dp = Pol(x) * (x+1)^r with r >=1 and degree(Pol) <= 6
  Find the value of r this way:
  1. Set Q =Pol(x)
  2.  Divide (can be done by hand) Q by (x+1) and note R the remainder
  3. Go to point 1 until R = 0
• The value of r is the number of times you executed the steps 1 to 3
  Here r=3 ==> dp = Pol(x) * (x+1)^3 with degree(Pol) = 4
• Search if Pol(x) has a real zero Z by applying the procedure given at points 1 to 3.
  Here you recursively divide 4 times Pol(x) by (x-Z) : if the last remainder is 0, then is a root of dp, if not (which is the case) dp has only 1 real root (-1) of multipliciy 3.

Thus p has a only one stationnary point at x=-1 (I don't know if you must answer 1 or 3 ???)

The goal is to produce almost exactly the expressio of the solution you give, thus we have to go beyond the dsolve to reshape the solution Maple provides.
The procedure is described step-by-step

Download OneWay.mw

(1/2, 1/2) is not always a solution, look here

Download solution.mw

Maybe you missed something?

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