Generally speaking, no, there is no way to ensure that the problem is *precisely* feasible. You have to be prepared to accept slight deviations from feasibility. This is the nature of numerical solvers, I am afraid.

But in fact, the real problem with your model. If I may hazard a guess, you’re actually trying to implement a strict inequality `(X*A)' + (X*A) < 0`

. But as the documentation says, CVX cannot differentiate between strict and non-strict feasibilities. So if you had used 0, CVX would simply return the all-zeros value for X.

To fix this, you’ve tried to add a small offset of `-10^-10*eye(n)`

to force strict feasibility. But in that same documentation above, it says this:

Note that the bound needs to be large

enough so that the underlying solver

considers it numerically significant.

Trying to obtain a matrix with values near 10^-10 is simply not practical with the numerical solvers CVX uses, or for that matter, with any numerical solver. In fact, I wouldn’t be surprised if the solvers are effectively driving the entire matrix `X`

to zero, even though you’re *trying* to prevent this from happening.

What you need to do is re-think your model. I understand why X=0 would not be useful to you, but nor is any value of `X`

buried within the noise of a solver’s numerical errors. You need to think about a new constraint to add to your model that forces X to take on “reasonable” values. For instance, consider this:

```
(X*A)' + (X*A) <= -eye(n)
```

Obviously, in perfect arithmetic, this is actually the same as your model, but everything is scaled up by 10^10. But now the problem is much more *numerically* friendly. CVX will produce more reasonable results, and if you *really* want `-10^-10*eye(n)`

, you can just multiply the value of `X`

that comes out of the model by `-10^-10`

to get it back.