Unable to solve Convex programming problem

pow_p(p1,y(1)) should not be allowed by CVX, because the 2nd argument is supposed to be a constant. However, CVX allows it and considers it to be a constant. And therefore it allows the iterated inv_pos which would be disallowed, but for CVX’s improperly thinking pow_p(p1,y(1)) is a constant. Not to mention the sqrt would then also be disallowed.

So whatever CVX is sending to the solver based on the 2nd and 3rd constraints is meaningless garbage. Therefore, any results produced by the solver and CVX from your program are meaningless garbage.

You should start with a CONVEX optimization problem. Then input it to CVX according to its DCP rules. Your current program violates CVX rules like it’s going out of style, and you’re rushing to cram as many rules violations into your constraints as you can.

help pow_p
pow_p Positive branch of the power function.
pow_p(X,P) computes a convex or concave branch of the power function:
P < 0: pow_p(X,P) = X.^P if X > 0, +Inf otherwise
0 <= P < 1: pow_p(X,P) = X.^P if X >= 0, -Inf otherwise
1 <= P : pow_p(X,P) = X.^P if X >= 0, +Inf otherwise
Both P and X must be real.

Disciplined convex programming information:
    The geometry of pow_p(X,P) depends on the precise value of P,
    which must be a real constant:
             P < 0: convex  and nonincreasing; X must be concave.
        0 <= P < 1: concave and nondecreasing; X must be concave.
        1 <= P    : convex  and nonmonotonic;  X must be affine.
    In all cases, X must be real.

Other functions named pow_p

help inv_pos
inv_pos Reciprocal of a positive quantity.
inv_pos(X) returns 1./X if X is positive, and +Inf otherwise.
X must be real.

 For matrices and N-D arrays, the function is applied to each element.

  Disciplined convex programming information:
      inv_pos is convex and nonincreasing; therefore, when used in CVX
      specifications, its argument must be concave (or affine).

Other functions named inv_pos

help cvx/sqrt
Discipined convex programming information for sqrt:
sqrt(X) is log-concave and nondecreasing in X. Therefore, when used
in DCPs, X must be concave (or affine).

Disciplined geometric programming information for sqrt:
   sqrt(X) is log-log-affine and nondecreasing in X. Therefore, when
   used in DGPs, X may be log-affine, log-convex, or log-concave.