Optimization backend (corneto.backend)

class corneto.backend.Backend(default_solver=None, sparse_class=<class 'scipy.sparse._csr.csr_array'>)

Bases: ABC

Parameters:

• default_solver (str | None)

• sparse_class (Callable)

Acyclic(g, P, indicator_positive_var_name=None, indicator_negative_var_name=None, acyclic_var_name='_dag_layer', max_parents=None, vertex_lb_dist=None, vertex_ub_dist=None)

Create Acyclicity Constraint.

This function creates acyclicity constraints, ensuring that the selected edges form an acyclic graph, meaning there are no cycles on the given property. Acyclicity can be applied, for example, over flow constraints or signal properties.

Parameters:

• g (BaseGraph) – The graph that defines the problem.

• P (ProblemDef) – The problem definition.

• indicator_positive_var_name (str) – The name of the indicator variable, i.e., which edges are selected. Default is EXPR_NAME_FLOW_IPOS.

• indicator_negative_var_name (str, optional) – The name of the indicator variable for negative flows. Default is None. If a negative flow appears, the source and target nodes of the edge are reversed. For example, A->B with positive flow implies order(B) > order(A), with negative flow it implies order(A) > order(B).

• acyclic_var_name (str, optional) – The name of the acyclic variable. Default is VAR_DAG.

• max_parents (Optional[Union[int, Dict[Any, int]]], optional) – The maximum number of parents per node. If an integer is provided, the maximum number of parents is the same for all nodes. If a dictionary is provided, the maximum number of parents can be different for each node. Default is None.

• vertex_lb_dist (Optional[List[Dict[Any, int]]], optional) – A list (one entry per experiment) of dictionaries that assign a lower bound (minimum layer/distance) for each vertex.

• vertex_ub_dist (Optional[List[Dict[Any, int]]], optional) – A list (one entry per experiment) of dictionaries that assign an upper bound (maximum layer/distance) for each vertex.

• Returns

• -------

• ProblemDef – The problem definition with acyclic constraints.

• Raises

• ------

• NotImplementedError – If hyperedges are used.

Return type:

ProblemDef

Acyclic0(g, P, indicator_positive_var_name=None, indicator_negative_var_name=None, acyclic_var_name='_dag_layer', max_parents=None, vertex_lb_dist=None, vertex_ub_dist=None)

Create Acyclicity Constraint.

This function creates acyclicity constraints, ensuring that the selected edges form an acyclic graph, meaning there are no cycles on the given property. Acyclicity can be applied, for example, over flow constraints or signal properties.

Parameters:

• g (BaseGraph) – The graph that defines the problem.

• P (ProblemDef) – The problem definition.

• indicator_positive_var_name (str) – The name of the indicator variable, i.e., which edges are selected. Default is EXPR_NAME_FLOW_IPOS.

• indicator_negative_var_name (str, optional) – The name of the indicator variable for negative flows. Default is None. If a negative flow appears, the source and target nodes of the edge are reversed. For example, A->B with positive flow implies order(B) > order(A), with negative flow it implies order(A) > order(B).

• acyclic_var_name (str, optional) – The name of the acyclic variable. Default is VAR_DAG.

• max_parents (Optional[Union[int, Dict[Any, int]]], optional) – The maximum number of parents per node. If an integer is provided, the maximum number of parents is the same for all nodes. If a dictionary is provided, the maximum number of parents can be different for each node. Default is None.

• Returns

• -------

• ProblemDef – The problem definition with acyclic constraints.

• Raises

• ------

• NotImplementedError – If hyperedges are used.

• vertex_lb_dist (List[Dict[Any, int]] | None)

• vertex_ub_dist (List[Dict[Any, int]] | None)

Return type:

ProblemDef

AcyclicFlow(g, lb=0, ub=10, values=False, max_parents=None, vertex_lb_dist=None, varname='_flow', alias_flow='flow', alias_flow_ipos='positive_flow', alias_flow_ineg='negative_flow', alias_nonzero_flow='with_flow', indicator_tolerance=0.0001)

Parameters:

• g (BaseGraph)

• lb (float | ndarray)

• ub (float | ndarray)

• values (bool)

• max_parents (int | Dict[Any, int] | None)

• vertex_lb_dist (ndarray | None)

• varname (str)

• alias_flow (str)

• alias_flow_ipos (str)

• alias_flow_ineg (str)

• alias_nonzero_flow (str)

• indicator_tolerance (float)

Return type:

ProblemDef

abstractmethod Constant(value, name=None)

Parameters:

• value (Any)

• name (str | None)

Return type:

CSymbol

Flow(g, lb=0, ub=10, n_flows=1, values=False, shared_bounds=False, varname='_flow', create_nonzero_indicators=False, alias_flow='flow', alias_flow_ipos='positive_flow', alias_flow_ineg='negative_flow', alias_nonzero_flow='with_flow', indicator_tolerance=0.0001)

Parameters:

• g (BaseGraph)

• lb (float | List | ndarray | None)

• ub (float | List | ndarray | None)

• n_flows (int)

• values (bool)

• shared_bounds (bool)

• varname (str)

• create_nonzero_indicators (bool)

• alias_flow (str)

• alias_flow_ipos (str)

• alias_flow_ineg (str)

• alias_nonzero_flow (str)

• indicator_tolerance (float)

Return type:

ProblemDef

Indicator(V, indexes=None, suffix='_i', name=None)

Parameters:

• V (CSymbol)

• indexes (Tuple | List | ndarray | None)

• suffix (str)

• name (str | None)

Return type:

ProblemDef

Indicators(V, tolerance=0.001, positive=True, negative=True, suffix_pos='_ipos', suffix_neg='_ineg')

Parameters:

V (CSymbol)

Return type:

ProblemDef

NonZeroIndicator(V, *args, indexes=None, suffix_pos='_ipos', suffix_neg='_ineg', tolerance=0.001)

Parameters:

• V (CSymbol)

• indexes (int | slice | Tuple | List | ndarray | None)

• suffix_pos (str)

• suffix_neg (str)

• tolerance (float)

Return type:

ProblemDef

abstractmethod Parameter(name=None, shape=None, value=None)

Parameters:

• name (str | None)

• shape (Tuple[int, ...] | None)

• value (Any)

Return type:

CSymbol

Problem(constraints=None, objectives=None, expressions=None, weights=None, direction=Direction.MIN)

Parameters:

• constraints (CExpression | List[CExpression] | None)

• objectives (CExpression | List[CExpression] | None)

• expressions (Dict[str, CExpression] | None)

• weights (float | List[float] | None)

• direction (Direction)

Return type:

ProblemDef

abstractmethod Variable(name=None, shape=None, lb=None, ub=None, vartype=VarType.CONTINUOUS)

Create a variable for optimization.

This method defines an optimization variable with optional bounds, type, and additional graph-related properties.

Parameters:

• name (Optional[str]) – The name of the variable. Defaults to None.

• shape (Optional[Tuple[int, ...]]) – The shape of the variable as a tuple. Defaults to None.

• lb (Optional[Union[float, np.ndarray]]) – The lower bound of the variable. Can be a scalar or an array. Defaults to None.

• ub (Optional[Union[float, np.ndarray]]) – The upper bound of the variable. Can be a scalar or an array. Defaults to None.

• vartype (VarType) – The type of the variable (e.g., continuous, integer). Defaults to VarType.CONTINUOUS.

Returns:

The created variable symbol, to be used in further expressions or constraints.

Return type:

CSymbol

Xor(x, y, varname='_xor')

Parameters:

• x (CExpression)

• y (CExpression)

abstractmethod available_solvers()

Return type:

List[str]

abstractmethod build(p)

Parameters:

p (ProblemDef)

Return type:

Any

static get_symbols(expressions)

Parameters:

expressions (Iterable[CExpression])

Return type:

Set[CSymbol]

hstack(arg_list)

Parameters:

arg_list (Iterable[CExpression])

Return type:

CExpression

is_available()

Return type:

bool

linear_and(x, axis=None, varname='and')

Parameters:

• x (CExpression)

• axis (int | None)

Return type:

ProblemDef

linear_or(x, axis=None, varname='or', ignore_type=False)

Parameters:

• x (CExpression)

• axis (int | None)

Return type:

ProblemDef

linear_xor(x, axis=None, varname='xor', ignore_type=False)

Parameters:

• x (CExpression)

• axis (int | None)

Return type:

ProblemDef

solve(p, solver=None, max_seconds=None, warm_start=False, verbosity=0, **options)

Parameters:

• p (ProblemDef)

• solver (str | Solver | None)

• max_seconds (int | None)

• warm_start (bool)

• verbosity (int)

version()

Return type:

str

vstack(arg_list)

Parameters:

arg_list (Iterable[CExpression])

Return type:

CExpression

zero_function()

Return type:

CExpression

class corneto.backend.VarType(value)

Bases: str, Enum

INTEGER = 'integer'

CONTINUOUS = 'continuous'

BINARY = 'binary'

class corneto.backend.CvxpyBackend(default_solver=None, sparse_class=<class 'scipy.sparse._csr.csr_array'>)

Bases: Backend

Parameters:

• default_solver (str | None)

• sparse_class (Callable)

Constant(value, name=None)

Parameters:

• value (Any)

• name (str | None)

Return type:

CSymbol

Parameter(name=None, shape=None, value=None)

Parameters:

• name (str | None)

• shape (Tuple[int, ...] | None)

• value (Any)

Return type:

CSymbol

Variable(name=None, shape=None, lb=None, ub=None, vartype=VarType.CONTINUOUS)

Create a variable for optimization.

This method defines an optimization variable with optional bounds, type, and additional graph-related properties.

Parameters:

• name (Optional[str]) – The name of the variable. Defaults to None.

• shape (Optional[Tuple[int, ...]]) – The shape of the variable as a tuple. Defaults to None.

• lb (Optional[Union[float, np.ndarray]]) – The lower bound of the variable. Can be a scalar or an array. Defaults to None.

• ub (Optional[Union[float, np.ndarray]]) – The upper bound of the variable. Can be a scalar or an array. Defaults to None.

• vartype (VarType) – The type of the variable (e.g., continuous, integer). Defaults to VarType.CONTINUOUS.

Returns:

The created variable symbol, to be used in further expressions or constraints.

Return type:

CSymbol

available_solvers()

Return type:

List[str]

build(p)

Parameters:

p (ProblemDef)

Return type:

Any

class corneto.backend.PicosBackend(default_solver=None)

Bases: Backend

Parameters:

default_solver (str | None)

Constant(value, name=None)

Parameters:

• value (Any)

• name (str | None)

Return type:

CSymbol

Parameter(name=None, shape=None, value=None)

Parameters:

• name (str | None)

• shape (Tuple[int, ...] | None)

• value (Any)

Return type:

CSymbol

Variable(name=None, shape=None, lb=None, ub=None, vartype=VarType.CONTINUOUS, variable=True)

Create a variable for optimization.

This method defines an optimization variable with optional bounds, type, and additional graph-related properties.

Parameters:

• name (Optional[str]) – The name of the variable. Defaults to None.

• shape (Optional[Tuple[int, ...]]) – The shape of the variable as a tuple. Defaults to None.

• lb (Optional[Union[float, np.ndarray]]) – The lower bound of the variable. Can be a scalar or an array. Defaults to None.

• ub (Optional[Union[float, np.ndarray]]) – The upper bound of the variable. Can be a scalar or an array. Defaults to None.

• vartype (VarType) – The type of the variable (e.g., continuous, integer). Defaults to VarType.CONTINUOUS.

• variable (bool)

Returns:

The created variable symbol, to be used in further expressions or constraints.

Return type:

CSymbol

available_solvers()

Return type:

List[str]

build(p)

Parameters:

p (ProblemDef)

Return type:

Any