I think it is 1/2.

Evaluate the sum, which is a function in sqrt(x), hence use x^2
instead of x.

evalc(Re(%)) assuming 0 < x;

  -1/2 * x*Im(Psi(1,x*I))

Now plotting indicates the limit and it is 'confirmed' by

x*Im(Psi(1,x*I)); 
MultiSeries:-limit(%, x=infinity);

                                  -1

I think you have to be more specific, so that the problem has a unique solution.

alpha^3-alpha*beta^2-beta*alpha^2+beta^3 = 
  0 + (alpha-beta)*(alpha^2-beta^2)

May be you want the automorphism y |-> alpha + beta
x |-> alpha - beta, write in x,y, lambda1, lambda2 and
now the taylor series in x, p1= constant term while for p2
= (fct - constant)/x and finally substitute back. 

Or similar?

Edited: find attached a small example sheet MP_poly_basechang.mws

Edited2: on a 2nd (sigh) thought the following is more 'natural':
  trans:=solve({x=alpha-beta}, {alpha});
  back:= solve(trans, {x});

@joavr

It is still not clear to me what you did and why you can expect a solution
(because more conditions than variables), but they exist, yes.

I played a bit with some specific parameters (after getting rid of denominators).

For m, n, q, r, t, u, v, w, x, y:= 0,0,0,0,0,0,0,0,0,0; the only condition is
r0 = -x0^2/y0,u0 = -x0, all other variables can be choosen arbitrarily,
HilbertDimension of the system equals 2.

For m, n, q, r, t, u, v, w, x, y:= 1,0,1,0,1,0,1,0,1,0; there are many solution
sets and conditions (up to 7), HilbertDimension of the system equals 7.

For me that says, that depending on you parameters the possible solution
sets may jump heavily and Maple may have no chance to find all.

Can not say something towards Java and memory: I did that in the classical
interface, the other one is a pain for me in for that task.

Edited to upload the sheet MP_parametric_polyn_.mws

Your system has 17 equations, 10 variables and 10 parameters.

What do you expect as solution?
What was your 'other' way exactly and which solution is missing?

Example: lets say you have 8 eqs, 1 variable and 1 parameter -
what would you expect as solution?

http://en.wikipedia.org/wiki/Methods_of_contour_integration

That means to use a contour, a "path" or curve (and the result
may depend on the choosen path).

You have none and ask for an 'anti-derivative'

See ?int/methods

I would consider this as a polynomial equation in cos(t)
(and would work from there, perhaps not that different):

expand(eq);
[solve(%, cos(t))]; evalf(%);

                                        2
                     4 cos(t) + 4 cos(t)  - 2 = 0

Now one has to select the very one between -1 and +1
and arccos gives it.

In addition to Markiyans answer:

For me the help pages are not that clear as I wish. Remembering a former life I
am not aware of Hilbert dimension ... but forgot too much, of course.

Additionally it would be a good thing to add *references* in the help, if I am not
too wrong then it was good practice in former packages, no?


Anyway: if the dimension only drops by 3, than there should be a 'dependency' and
more specific that the irreducible components of 3 eqs already contain those of a
4th one.

This already occures at HilbertDimension([e1,e3,e4]) = 5, while for only two of
those the dim reduces to 5 (as generically one would expect).

That means that e3 = 0 = e4 defines a variety of codimension 2 and intersecting
that thing by e1=0 (some hypersurface) does not change the irreducible components.

Generally irreducible components === varieties of reduced ideals, so one should look
at the primary decomposition (if we are over the Complex numbers).

So something like Rad(e3)*Rad(e4) = Rad(e1) * Rad(e3)*Rad(e4) should hold, where
Rad = radical ideal ( = the very one, which holds all powers as well).

If I remembered correctly ...

Edited to add that one should more carefully say "up to lower dimensional
contributions", since dim = max(in all points)

This is true, if x is a real number:

  ln(exp(x)); simplify(%) assuming x::real;

                                  x

However Maple usually works with complex numbers and then it is false
(and the option 'symbolic' means to ignore rules for that), consider

  y=ln(exp(x)); RootOf(%,x): allvalues(%);

                            y + 2 I Pi _Z1

Here _Z1 (or similar) means "any integer" and indeed:

  ln(exp(x+2*Pi*I*k)); map(expand,%) assuming k::integer;

                              ln(exp(x))

So in general you can not expect to get x for  ln(exp(x)) = ln(exp(x+2*Pi*I*k))

Do not use 4 Digits for all the computations.
You only want a final display

restart;
Digits:=15: # this is kind of standard
 
K1:=1.45*10^(-4); p0:=10^5;p:=200*10^5;
eq1:=K1=((16*beta^2*(2-beta)^2)/(27*(1-beta)^4))*(p0/p)^2;
 
sol2:=fsolve(eq1,beta=0..1);

                      sol2 := 0.507842669086609

evalf[4](sol2); # finally cut down to 4 decimals

                                0.5078

Without looking into details the general reason is, that with
small Digits the are large errors which even may accumulate
and may prevent fsolve to find a solution of (implicitely)
desired accuracy.

I hate that *.mw sheets ...

Being not much used to DE, especially to their numerical solutions, I have not
looked closer how the solution may be improved - it seems to be very slow to
be evaluated.

Just used it (15 Digits):

G:=proc(z) 1.0/HH(z); end proc;
Int(G, 0 .. 10)+Int(G, 10 .. 100)+Int(G, 100 .. 1091.3);
evalf[8](%);
                   4.5667205

Unfortunately one can not use 'method = _d01akc' in a direct way

PS hating: in a real sheet (export as Maple input, *.mpl) it crashes.
Sh... lost patients to work with that.

1. post code, not pictures

either directly or as text file or Maple sheet and upload here (green button at the end of the reply form)

Your question is not understandable without that.

I converted to rationals and looking at the pictures already shown had the idea
to use discont, which resulted in

L := [-345854161/5000000, 345854161/5000000, 
      -(25/12)*sqrt(3062146578), (25/12)*sqrt(3062146578)]

which in magnitude roughly is +- 69 and +- 1E5

Plotting is not possible in classical sheets, so I used the new interface.

Except the last one it was possible to guess the zeros with a shrinking epsilon.

For the last one I looked at the series of G:=eval(task, z=L[4]+t) in t=0.

After numerical evaluation I finally decided to use G/r, r:=residue(G, t=0)
to scale (r ~ 8*1E+376).

Then plot(G/r, t=1e-10 .. 1e-9) looks promissing (Digits = 24).

To solve it one has to increase Digits (and I needed Maple 15):

'G/r'; evalf[1000](%):
t4:=fsolve(%, t=1e-10 .. 1e-9, fulldigits);

Now check:

  [eval( G/r, t=t4- 1e-20), eval( G/r, t=t4), eval( G/r, t=t4 + 1e-20)]:
  evalf[500](%): evalf(%);

    [0.0596500053752879723015548, 
                                 -16
    -9.56406646421124078114154 10   , 

    -0.0596500052757286493533899]

Due to the explosive behaviour that was satisfactory for me.

BTW: all entries in L are poles (use the series in them + evalf), but one (= I)
can not see that directly from the complicated expression.

PS: used a 'Brent solver' with high precision without scaling by the residue
and that worked as well.

It would be good, if you post code to be copied instead of pictures ...

1. A recursive procedure

  B:=proc(n)
  option remember; # check the help for that option
  return thisproc(n-1) + sqrt(3)/12*(2/3)^(2*n-2);
  end proc;
  B(0):=sqrt(3)/4;

Then you have to use 'add'

  add(B(j), j=1 .. 5);
                                     1/2
                              37045 3
                              ----------
                                19683

2. Solving the recurrence and evaluate the Sum (possible here)

  # solve the recurrence
  rsolve({f(n) = f(n-1)+ sqrt(3)/12*(2/3)^(2*n-2), 
          f(0)=sqrt(3)/4}, f);
  a:=unapply(%,n); # now 'a' are summands

  # solve the summation
  Sum(a(n), n=1 .. k); value(%); simplify(%); #combine(%, symbolic);
  A:=unapply(%,k);
                             1/2                k  (-k)
             A := k -> 1/25 3    (10 k - 3 + 3 4  9    )

  # test
  A(5);
                                     1/2
                              37045 3
                              ----------
                                19683


  Sum(a(n), n=1 .. 5); value(%);

                      5
                    ----- /   1/2      1/2      n\
                     \    |2 3      3 3    (4/9) |
                      )   |------ - -------------|
                     /    \  5           20      /
                    -----
                    n = 1


                                     1/2
                              37045 3
                              ----------
                                19683

Besides how Maple can be instructed: would all that not give a false feeling to students (do not know what "inc/dec" is) ?

Yes, but the 'natural' values are imaginary for negative inputs:

[3/5* x^(5/3) , 1/2*x^(2/3)]; 
eval(%, x=-1);
evalf(%);

   [0.3000000001 - 0.5196152422 I, -0.2500000000 + 0.4330127018 I]