Bounds and constraints in SciPy - Cheat Sheet & Quick Revision

Recall & Review

beginner

What are bounds in optimization problems?

Bounds are limits set on the values that variables can take during optimization. They restrict variables to stay within a specific range, like setting a minimum and maximum value.

beginner

How do constraints differ from bounds in optimization?

Constraints are rules that variables must satisfy, which can be equalities or inequalities. Bounds are a simple type of constraint that only limit variable ranges, while constraints can be more complex conditions.

intermediate

How do you define bounds in scipy.optimize.minimize?

Bounds are defined as a sequence of (min, max) pairs for each variable. For example, bounds=[(0, 10), (None, 5)] means the first variable is between 0 and 10, and the second variable has no lower bound but max 5.

intermediate

What types of constraints can scipy.optimize.minimize handle?

It can handle 'eq' (equality) constraints where a function equals zero, and 'ineq' (inequality) constraints where a function is greater than or equal to zero.

beginner

Why are bounds and constraints important in real-life optimization?

They ensure solutions are realistic and safe. For example, in manufacturing, constraints can keep material usage within limits, and bounds can keep temperatures within safe ranges.

In scipy.optimize.minimize, how do you specify that a variable x must be between 1 and 5?

A bounds=[(1, 5)]

B constraints={'type': 'eq', 'fun': lambda x: x-1}

C bounds=[(None, None)]

D constraints={'type': 'ineq', 'fun': lambda x: 5-x}

Bounds are given as pairs (min, max) for each variable. So bounds=[(1, 5)] restricts x between 1 and 5.

Which constraint type in scipy.optimize.minimize means the function must equal zero?

A 'ineq'

B 'min'

C 'eq'

D 'bound'

'eq' constraints require the function to be exactly zero.

What happens if you set bounds=[(0, None)] for a variable?

A Variable must be greater than or equal to 0

B Variable has no limits

C Variable must be less than 0

D Variable must be exactly 0

None means no limit, so (0, None) means variable ≥ 0 with no upper limit.

Which of these is a valid inequality constraint in scipy.optimize.minimize?

A {'type': 'min', 'fun': lambda x: x[0]}

B {'type': 'eq', 'fun': lambda x: x[0] + 2}

C {'type': 'bound', 'fun': lambda x: x[0]}

D {'type': 'ineq', 'fun': lambda x: x[0] - 2}

'ineq' constraints require the function to be ≥ 0, so x[0] - 2 ≥ 0 means x[0] ≥ 2.

Why might you use constraints instead of just bounds?

A Bounds are always ignored

B Constraints can express complex relationships between variables

C Constraints are faster to compute

D Bounds only work for integer variables

Constraints can express conditions involving multiple variables or nonlinear relations, beyond simple variable limits.

Explain the difference between bounds and constraints in optimization problems.

Think about simple limits versus more complex rules.

Describe how to set bounds and constraints in scipy.optimize.minimize with an example.

Recall the syntax for bounds and constraints in scipy.

Practice

1. What is the main purpose of bounds in scipy.optimize functions?

easy

A. To set the maximum number of iterations

B. To define the objective function to minimize

C. To limit the range of values each variable can take

D. To specify the initial guess for variables

Solution

1. Step 1: Understand the role of bounds

   Bounds restrict each variable to a specific range, for example, between 0 and 1.

2. Step 2: Differentiate bounds from other parameters

   Bounds are not about the objective function, initial guess, or iteration limits; they only limit variable values.

3. Final Answer:

   To limit the range of values each variable can take -> Option C

4. Quick Check:

   Bounds = variable limits [OK]

Hint: Bounds always restrict variable ranges, not function or iterations [OK]

Common Mistakes:

• Confusing bounds with constraints
• Thinking bounds set initial guesses
• Assuming bounds limit iterations

2. Which of the following is the correct way to define bounds for two variables x and y where x is between 0 and 5, and y is between -1 and 1 in scipy.optimize.minimize?

easy

A. bounds = [(0, 5), (-1, 1)]

B. bounds = {0:5, -1:1}

C. bounds = [0, 5, -1, 1]

D. bounds = (0, 5, -1, 1)

Solution

1. Step 1: Recall bounds format in scipy.optimize

   Bounds are given as a list of tuples, each tuple for one variable's (min, max).

2. Step 2: Check each option's format

   bounds = [(0, 5), (-1, 1)] uses a list of tuples correctly. Options A (flat list), B (dictionary), and D (flat tuple) are invalid formats.

3. Final Answer:

   bounds = [(0, 5), (-1, 1)] -> Option A

4. Quick Check:

   Bounds = list of (min, max) tuples [OK]

Hint: Use list of (min, max) tuples for bounds [OK]

Common Mistakes:

• Using dictionary instead of list
• Passing flat list instead of tuples
• Confusing tuple and list syntax

3. What will be the output of the following code snippet?

from scipy.optimize import minimize

func = lambda x: (x[0]-1)**2 + (x[1]+2)**2
bounds = [(0, 2), (-3, -1)]
result = minimize(func, x0=[0, 0], bounds=bounds)
print(result.x)

medium

A. [0.5 -1.5]

B. [0. -3.]

C. [2. -1.]

D. [1. -2.]

Solution

1. Step 1: Understand the objective function and bounds

   The function is minimized when x[0] = 1 and x[1] = -2. Bounds allow x[0] between 0 and 2, and x[1] between -3 and -1.

2. Step 2: Check if the minimum is within bounds

   Since (1, -2) is inside the bounds, the optimizer will find this point.

3. Final Answer:

   [1. -2.] -> Option D

4. Quick Check:

   Minimum inside bounds = [1, -2] [OK]

Hint: Minimum inside bounds is the solution [OK]

Common Mistakes:

• Ignoring bounds and picking unconstrained minimum
• Confusing bounds order
• Assuming initial guess is final answer

4. Identify the error in the following code that uses bounds in scipy.optimize.minimize:

from scipy.optimize import minimize

func = lambda x: x[0]**2 + x[1]**2
bounds = [0, 1, 0, 1]
result = minimize(func, x0=[0.5, 0.5], bounds=bounds)
print(result.x)

medium

A. Initial guess x0 is outside bounds

B. Bounds should be a list of tuples, not a flat list

C. Objective function must return a scalar

D. Bounds must be specified as a dictionary

Solution

1. Step 1: Check bounds format

   The code uses bounds = [0, 1, 0, 1], which is a flat list. scipy expects a list of tuples for bounds.

2. Step 2: Confirm other parameters

   Initial guess is inside bounds, function returns scalar, and bounds as dictionary is not required.

3. Final Answer:

   Bounds should be a list of tuples, not a flat list -> Option B

4. Quick Check:

   Bounds = list of tuples, not flat list [OK]

Hint: Use list of tuples for bounds, not flat list [OK]

Common Mistakes:

• Using flat list instead of list of tuples
• Setting initial guess outside bounds
• Misunderstanding bounds format

5. You want to minimize the function f(x, y) = (x-3)^2 + (y+1)^2 with the constraints that x + y = 2 and bounds 0 ≤ x ≤ 4, -2 ≤ y ≤ 2. Which of the following correctly sets up the constraints and bounds for scipy.optimize.minimize?

hard

A. constraints = {'type': 'eq', 'fun': lambda v: v[0] + v[1] - 2}; bounds = [(0, 4), (-2, 2)]

B. constraints = [{'type': 'ineq', 'fun': lambda v: v[0] + v[1] - 2}]; bounds = [(0, 4), (-2, 2)]

C. constraints = {'type': 'eq', 'fun': lambda v: v[0] - v[1] - 2}; bounds = [(0, 4), (-2, 2)]

D. constraints = [{'type': 'eq', 'fun': lambda v: v[0] + v[1] - 2}]; bounds = [(0, 2), (-2, 2)]

Solution

1. Step 1: Define the equality constraint

   The constraint is x + y = 2, so the function should return zero when this holds: lambda v: v[0] + v[1] - 2. It must be an equality constraint ('eq').

2. Step 2: Set the correct bounds

   Bounds are 0 ≤ x ≤ 4 and -2 ≤ y ≤ 2, so bounds = [(0, 4), (-2, 2)].

3. Final Answer:

   constraints = {'type': 'eq', 'fun': lambda v: v[0] + v[1] - 2}; bounds = [(0, 4), (-2, 2)] -> Option A

4. Quick Check:

   Equality constraint + correct bounds = constraints = {'type': 'eq', 'fun': lambda v: v[0] + v[1] - 2}; bounds = [(0, 4), (-2, 2)] [OK]

Hint: Equality constraint returns zero when condition met [OK]

Common Mistakes:

• Using inequality instead of equality constraint
• Swapping bounds limits
• Incorrect constraint function expression