# Minimization problem solving and its step limits

I am trying to solve the following minimization problem:

$$\min\lvert\lvert{x}\rvert\rvert_1 + \beta\lvert\lvert{x}\rvert\rvert^2_2 s.t. \sum_{m = 1}^M (y - \lvert{c}^{H} . x\rvert^2)^2 \le \epsilon$$

• x: my unknown value (input) with complex elements and known size, here (4x1)
• y: the output vector (known)
• c: a 'skaling' vector

I am very new to this so my approach may seem basic. I simply loop over all combination of c (non-redundant) and according to the computed minimization value and condition I update my results.

My questions are the following:

• Is this correct and is there a better approach to this?
• This code fails with a small step due to the huge size of combinations, so how can I solve that?

from itertools import combinations
from random import randint
import numpy as np

return round(((phase*3.14)/180),3)

def excitation(amplitude, phase):

def compute_subject_equation_result(x):
M            = 12
difference   = []
y            = [randint(10, 20) for i in range(M)]

for m in range(0, M):
c  = np.array([randint(0, 9), randint(10,20), randint(0, 9), randint(0,20)]).reshape(4,1)
ch = c.conjugate().T
eq  = (y[m] - (abs(np.dot(ch, x))[0])**2)**2
difference.append(eq**2)
return round(sum(difference)[0], 3)

def compute_main_equation_result(x, beta):
norm1  = np.linalg.norm(x,1)
norm2  = np.linalg.norm(x,2)
return round(norm1 + beta*(norm2**2), 3)

def optimize(x, min_x, min_phi_x):
min_result      = 10**25

# compute the optimization formals and check for the min value
main_equation_result    = compute_main_equation_result(c, beta)
subject_equation_result = compute_subject_equation_result(c)

# update min value if min detected'
if subject_equation_result < epsilon and main_equation_result < min_result:
min_result = main_equation_result
min_x      = x
min_phi_x  = phx
return min_x, min_phi_x

# initialization
phases    = [alpha for alpha in range(0, 361, 90)]
beta      = 1
epsilon   = 10**25
min_x     = np.array([])
min_phi_x = np.array([])

phases_combinations = [list(comb) for comb in combinations(phases, 4)]

# start checking all combinations
for phx in  phases_combinations:
phi1, phi2, phi3, phi4 = phx[0], phx[1], phx[2], phx[3]
# build the hypothesis for the excitations vector c
c = np.array([ excitation(1, phi1), excitation(1, phi2), excitation(1, phi3), excitation(1, phi4) ]).T.reshape(4,1)
min_x, min_phi_x = optimize(c, min_x, min_phi_x)
print('    --------------------------------------------------')
print('-----> new_min_c     = ', list(min_x))
print('-----> new_min_phi_c = ', min_phi_x)


Remark: When trying phases = [alpha for alpha in range(0, 361, 1)] I get a "memory error". I can avoid using a higher step. However I am not sure about my approach in general nor of the step change effect on the accuracy.