ORTools CP-Sat Solver Channeling Constraint dependant of x

Question

I try to add the following constraints to my model. my problem: the function g() expects x as a binary numpy array. So the result arr_a depends on the current value of x in every step of the optimization! Afterwards, I want the max of this array times x to be smaller than 50.

How can I add this constraint dynamically so that arr_a is always rightfully calculated with the value of x at each iteration while telling the model to keep the constraint arr_a * x <= 50 ? Currently I am getting an error when adding the constraint to the model because g() expects x as numpy array to calculate arr_a, arr_b, arr_c ( g uses np.where(x == 1) within its calculation).

#Init model
from ortools.sat.python import cp_model
model = cp_model.CpModel()
# Declare the variables
x = []
for i in range(self.ds.n_banks):
   x.append(model.NewIntVar(0, 1, "x[%i]" % (i)))   
#add bool vars
a = model.NewBoolVar('a')    
arr_a, arr_b, arr_c = g(df1,df2,df3,x)        
model.Add((arr_a.astype('int32') * x).max() <= 50).OnlyEnforceIf(a)
model.Add((arr_a.astype('int32') * x).max() > 50).OnlyEnforceIf(a.Not())

Afterwards i add the target function that naturally also depends on x.

model.Minimize(target(x))

def target(x):
   arr_a, arr_b, arr_c = g(df1,df2,df3,x)
   return  (3 * arr_b * x + 2 * arr_c * x).sum()

EDIT:

My problem changed a bit and i managed to get it work without issues. Nevertheless, I experienced that the constraint is never actually met! self-defined-function is a highly non-linear function that expects the indices where x==1 and where x == 0 and returns a numpy array. Also it is not possible to re-build it with pre-defined functions of the sat.solver.

#Init model
model = cp_model.CpModel()

# Declare the variables
x = [model.NewIntVar(0, 1, "x[%i]" % (i)) for i in range(66)]
# add hints
[model.AddHint(x[i],np.random.choice(2, 1, p=[0.4, 0.6])[0]) for i in range(66)]

open_elements = [model.NewBoolVar("open_elements[%i]" % (i)) for i in range(66)]
closed_elements = [model.NewBoolVar("closed_elements[%i]" % (i)) for i in range(6)]
        

# open indices as bool vars
for i in range(66):
     model.Add(x[i] == 1).OnlyEnforceIf(open_elements[i])
     model.Add(x[i] != 1).OnlyEnforceIf(open_elements[i].Not())
     model.Add(x[i] != 1).OnlyEnforceIf(closed_elements[i])
     model.Add(x[i] == 1).OnlyEnforceIf(closed_elements[i].Not())

model.Add((self-defined-function(np.where(open_elements), np.where(closed_elements), some_array).astype('int32') * x - some_vector).all() <= 0)

Even when I apply a simpler function, it will not work properly.

model.Add((self-defined-function(x, some_array).astype('int32') * x - some_vector).all() <= 0)

I also tried the following:

arr_indices_open = []
arr_indices_closed = []
for i in range(66):
  if open_elements[i] == True:
     arr_indices_open.append(i)
  else:
     arr_indices_closed.append(i)

# final Constraint
arr_ = self-defined-function(arr_indices_open, arr_indices_closed, some_array)[0].astype('int32')
        
for i in range(66):
     model.Add(arr_[i] * x[i] <= some_other_vector[i])

Some minimal example for the self-defined-function, with which I simply try to say that n_closed shall be smaller than 10. Even that condition is not met by the solver:

def self_defined_function(arr_indices_closed)
     return len(arr_indices_closed)

arr_ = self-defined-function(arr_indices_closed)
            
for i in range(66):
   model.Add(arr_ < 10)

Answer 1

I'm not sure I fully understand the question, but generally, if you want to optimize a function g(x), you'll have to implement it in using the solver's primitives (docs).

It's easier to do when your calculation coincides with an existing solver function, e.g.: if you're trying to calculate a linear expression; but could get harder to do when trying to calculate something more complex. However, I believe that's the only way.