Skip the assume. It's not needed and may interfere with getting a solution (I didn't check). The assumption is effectively stated in the fsolve command:

fsolve(eq, x= 49.32883964..infinity);
                          198.3826229

As a general rule, making assumptions on variables that are being solved for is not a good idea. Making assumptions on other variables that may appear in equations being solved is another matter.
 

There are many ways to do the problem, and CurveFitting:-ArrayInterpolation wouldn't be my first choice. But, since you've already started with it, I'll finish with it:

restart:
V_Ed13:= <257.184, 230.4, 184.3, 138.2, 92.2, 46.1, 0>:
x_12:= <-149, 208, 567, 925, 1283, 1642, 2000>:
V_Rdc:= 153.25:
CurveFitting:-ArrayInterpolation(
   V_Ed13[(P:= sort(V_Ed13, output= permutation))], x_12[P], V_Rdc
);
                        808.125813449024

The sort is needed because ArrayInterpolation wants the independent-variable values in ascending order. The permutation P is to rearrange the x_12s (which are now the dependent variable) exactly the same way as the sort rearranged the V_Ed13s (maintaining the pairwise correspondence). I realize that in this case I only needed to reverse the order of the array with a minus sign, but I wanted to be more general. So, in this case, this gives the same result:

CurveFitting:-ArrayInterpolation(-V_Ed13, x_12, -V_Rdc);

Both of these sort-and-transpose solutions will only work (i.e., produce correct results) if the interpolating function is monotonic. In this case, it clearly is. 

The easiest way is elementwise operators. These are operators whose operands may be containers such as lists but whose action is on the containers' elements rather than on the containers themselves. All elementwise operators end with the tilde character ~.

A:= [1,2,3,4,5,6,7,8,9,10]:
B:= [10,20,30,40,50,60,70,80,90,100]:
E:= 5:

C:= A*~E/~4*~Pi*~B:

See help page ?elementwise. Note that the operands are not required to be containers. The E, 4, and Pi above are not. 

Any user-defined function or existing Maple function can also be made elementwise by appending ~ to its name:

C:= (A,E,B)-> A*E/4*Pi*B:
DD:= C~(A,E,B);

So, in the above the elementwise operator acts much like zip (a command described in the other Answers). But it is more powerful than zip because it works for any number of operands, not just two.

Keyword parameters can be declared and used in a much easier way than as shown in Christian's Answer. You almost had the syntax right, but the curly braces need to go around the entire parameter declaration:

PlotGraph:= proc(
    func::anything,
    {zoom::list({range(realcons), identical(DEFAULT)}):= [DEFAULT$2]}
)
    plot(func, 'view'= zoom, _rest)
end proc
:

Example usage:

PlotGraph(x^2, x= -7..7, zoom= [DEFAULT, 0..7], color= green);

So, note that by using _rest all other passed arguments are also sent to plot regardless of whether they are keyword parameters.

Keyword parameters are used in the body of the procedure exactly like ordinary parameters. The differences are only in how they are declared and passed. Within the procedure, the parameter's value is only the right side of the passed equation; the value doesn't include the parameter's name or the equals sign.

There are several extensive help pages on parameters. You can start reading at ?parameters. That will contain links to the other pages.

Once the 14 equations (5 primaries, 5 solutions, and 4 intermediates) are entered, it's easy to check whether the equations are satisfied. The technique is shown in the worksheet below. Unfortunately, your proposed solution satisfies 4, but not 5, of the equations (assuming I entered them all correctly, which you should check).

It also easy to get a valid solution, but it won't be simplified through intermediate equations such as the one in your original presentation in the PDF.
 

Download eliminate.mw

Your belief about the cause of the error is spot-on correct. It's trivial to take the positive (or negative) square root of both sides of your ODE, so why don't you try that? 

diff(y(x), x) = y(x)^(-3/2*w-1/2)

It can be done like this:

MulNoK:= (k,n)-> local j: mul(a[k]-a[j], j= {$0..k-1, $k+1..n}):
MulNoK(2,4);
      (a[2] - a[0])*(a[2] - a[1])*(a[2] - a[3])*(a[2] - a[4])

Your first error is that IBC must be passed as a set to pdsolve, so pdsolve(..., {IBC}, ...). Your second error is that the numeric value(s) of phi must be specified before the pdsolve call, so pdsolve(..., eval({IBC}, phi= ...), ...). There are some more errors, but that's what I've worked out so far.

Suggestion: Use more spaces in your code so that it's more readable by a human!

In cylindrical coordinates, the cone is z = r and the paraboloid is z = 12 - r^2. We need the intersection of these surfaces, so

solve(r = 12 - r^2);
                 -4, 3

Note that z = sqrt(x^2 + y^2) implies z >= 0, so we only want the r = 3 solution. So, being "inside" the cone means 0 <= r <= 3, or in Maplese, r= 0..3.

This leads to the plot commands

plots:-display(
    plot3d( #the cone
        [r, theta, r], theta= -Pi..Pi, r= 0..11,
        coords= cylindrical, transparency= 0.7
    ),
    plot3d( #the paraboloid
       [r, theta, 12-r^2], theta= -Pi..Pi, r= 0..3, 
       coords= cylindrical
    )
);

To compute the surface area, I also use cylindrical coordinates: 

f:= (x,y)-> 12-x^2-y^2:
dS:= sqrt(1+D[1](f)(x,y)^2+D[2](f)(x,y)^2);
SA:= Int(sqrt(1+4*r^2)*r, [r= 0..3, theta= -Pi..Pi]);
value(SA);
      Pi/6*(37^(3/2) - 1)

Note the extra factor of r in the integral due to cylindrical coordinates.

How you would "create" the group depends largely on what you want to do with the group. To some extent, all that's needed is the set G of elements and the group operation defined on G. Below, I've used &* as the group operation, and I show that the multiplicative group modulo 42 is not cyclic^[*1] but that it is a direct product of two cyclic subgroups. In other words, it can be generated by 2 elements, but not by 1. 

restart:
G:= select(x-> igcd(x,42)=1, {$1..41});
      G := {1, 5, 11, 13, 17, 19, 23, 25, 29, 31, 37, 41}
`&*`:= (x,y)-> x*y mod 42:
`&^`:= (x,k::integer)-> x^k mod 42:
ord:= proc(x) local k; for k do until x&^k=1; k end proc:  
ord~([G[]]);
              [1, 6, 6, 2, 6, 6, 6, 3, 2, 6, 3, 2]
Show that G can be generated by two elements:
{seq(seq((5&^i)&*(13&^j), i= 1..6), j= 1..2)};
         {1, 5, 11, 13, 17, 19, 23, 25, 29, 31, 37, 41}
But I can't replace 13 with just any element of order 2:
{seq(seq((5&^i)&*(41&^j), i= 1..6), j= 1..2)};
                     {1, 5, 17, 25, 37, 41}
The reason that it doesn't work is that 41 is a power of 5 (mod 42): 5^3 mod 42 = 41. 

I've made the computational techniques above very simplistic in order to help your understanding. These techniques would be very inefficient for a large modulus.

[*1] It is well known that the multiplicative group modulo n is cyclic iff n = 1, 2, 4, p^k, or 2*p^k for p odd prime.

Obviously the OP Rodey Genius is not interested in learning. However, I had this Answer already 80% done at the time that they deleted the Question, so I'd rather not waste what I coded. Maybe someone else could learn from it.

I chose to code determinants by cofactor expansion because it can be used to illustrate a great many features of Maple programming in one short procedure. The algorithm is straightforward to code recursively. I optimized it the way one would do by hand for a sparse matrix: At each iteration, I expand along the row or column with the most 0s.

I think that even most Maple experts will learn something by studying this procedure.

As a bonus, I found an (admittedly, rather obscure) class of matrices for which my procedure significantly outperforms default methods: half-sparse matrices of bivariate rational functions.

Determinant:= proc(
    A::Matrix(square), 
    {method::identical(cofactors, other):= 'other'}
)
uses AT= ArrayTools, St= Statistics, LA= LinearAlgebra;
local k, n, r, c, T, transp, rm1, rp1, a;
    if method='other' then return LA:-Determinant(A) fi;
    
    # method = cofactors:
    n:= upperbound(A)[1];
    if n<2 then return `if`(n=0, 1, A[1,1]) fi; #base cases
    #Count number of non-zero entries in every row and column:
    T:= St:-Tally~([((r,c):= AT:-SearchArray(A))]);
    if nops~(T) <> [n,n] then return 0 fi; #There's a row or column of 0s.
    T:= sort~(T, 'key'= rhs);
    transp:= evalb(rhs(T[1][1]) > rhs(T[2][1])); #expand a row, or a column?
    r:= lhs(T[`if`(transp, 2, 1)][1]);  rm1:= r-1;  rp1:= r+1;
    add(
        if (a:= `if`(transp, A[k,r], A[r,k])) = 0 then 0
        else
            (-1)^(r+k)*a*thisproc(
                A[[[..rm1,rp1..],[..k-1,k+1..]][`if`(transp, [2,1], [1,2])][]], 
                _options
            )
        fi, 
        k= 1..n
    )
end proc
:
#Test case: half-sparse matrix of bivariate rational functions.
A:= LinearAlgebra:-RandomMatrix(
   9, density= 0.5, 
   generator= (()-> randpoly(x, degree=1)/randpoly([x,y], degree= 1))
):
d1:= CodeTools:-Usage(Determinant(A, method= other)):
memory used=23.74MiB, alloc change=0 bytes, cpu time=938.00ms,
real time=482.00ms, gc time=0ns
d2:= CodeTools:-Usage(Determinant(A, method= cofactors)):
memory used=11.99MiB, alloc change=0 bytes, cpu time=109.00ms, 
real time=130.00ms, gc time=0ns
expand(numer(d1-d2)); #Verify equality of results.
                               0
#Verify results are not identically 0:
eval(d2, [x= 0, y= 0]);
           16003080668688229738162772913864379992367
           -----------------------------------------
            86804823806332323196340023957536768000  

There's nothing wrong with Kitonum's Answer, but this alternative form is often useful, especially when n is not integer: For x, y, and n real,

(x+I*y)^n = (x^2+y^2)^(n/2)*exp(I*n*arctan(y,x))

Easy analytic geometry solution:

A:= <1,2,3>:  v:= <1,2,2>:  C:= <10,11,12>:
L:= A+t*v:

We want the point where line L intersects the plane normal to L containing point C:

B:= eval(L, t= solve(L.v = C.v));

Plot:

plots:-display(
    plots:-implicitplot3d(
        <x,y,z>.v = C.v, ([x,y,z]=~ 0..15)[], 
        style= surface, transparency= .2
    ), 
    plots:-pointplot3d([A,B,C], connect, color= red, thickness= 3),
    orientation= [80, 80, 130], axes= frame, labels= [``$3]
);

Download BasicLA.mw

If you use option matrixview, then the vertical-axis tickmarks are indexed -1, -2, ..., -20.