Question bank — scipy.optimize — minimize, fsolve, curve_fit, linprog

False — it returns a local minimum near the starting guess x0; only for a convex objective (see Convex Optimization) is that local point guaranteed global.

False — a linear program's optimum is always a vertex of the feasible region, so the simplex or interior-point solver walks the corners deterministically; no seed is required.

False — it converges to at most one root, the one whose basin contains x0; other roots need other starting points.

False — squaring both prevents positive and negative errors from cancelling and yields the maximum-likelihood estimate when the noise is Gaussian, so it is principled, not arbitrary.

False — at any smooth minimum the gradient is zero, so minimizing $f$ is root-finding on $\nabla f=0$; that is why Newton's method underlies both APIs.

False in spirit — for a linear model the normal equations have a closed form (this is Least Squares Regression), so the fit is exact in one solve; NumPy polyfit is the direct tool there.

False — linprog only minimizes, so maximizing ${\mathbf{c}}^{\top }\mathbf{x}$ requires passing $-\mathbf{c}$ and then reporting -res.fun.

False — success only means the solver converged, not that it converged to the correct or global point; a bad x0 can converge happily to the wrong root or a saddle.

False — it may be a maximum or a saddle; you need the Hessian to be positive semi-definite there to confirm a minimum.

Error — the constants were dropped; fsolve drives the vector to zero, so you must move everything to one side: [x**2 + y**2 - 25, x - y - 1].

Error — this minimizes $40x_1+30x_2$, giving the worst plan (likely the origin); negate to c=[-40,-30] and read profit as -res.fun.

Error — a nonlinear model needs a starting guess; the default p0=[1,1,...] can land in a flat region and return garbage or raise a runtime error. Supply a physical p0.

Error — minimize drives the sum to its smallest value, which can be very negative rather than zero, so individual equations need not be satisfied; use fsolve (or minimize the sum of squares of the residuals).

Error — res is an OptimizeResult object; the location is res.x, the value is res.fun, and convergence is res.success.

Not wrong per se, but redundant — bounds=[(0,None),...] already enforces $x\ge 0$; duplicating it as an inequality just clutters the model. Prefer bounds.

Error — when the fit is unreliable pcov can contain inf or meaningless values; check convergence and residuals before quoting np.sqrt(np.diag(pcov)) as uncertainties.

The first two follow the local slope/curvature and can only see nearby structure, so where you start decides where you land; a linear program's landscape has a constant gradient with the optimum forced to a corner, so the solver enumerates vertices systematically instead.

Each engine ultimately linearizes a function around the current point and solves that linear model for the next step; that linearize-and-solve loop is Newton's method (see Newton's Method), with the derivative replaced by a Jacobian or Hessian.

A linear function has constant gradient, so it never flattens inside the feasible region — you can always keep sliding downhill along a wall until walls block you on all sides, and that intersection of walls is a vertex.

Squares are smooth and differentiable everywhere (so gradient methods work) and correspond to Gaussian maximum likelihood; absolute values are non-smooth at zero, which is why least squares is the default rather than least-absolute-deviation.

The system has multiple roots, and Newton-type iteration converges to whichever root's basin of attraction contains the seed, so [1,1] and [-5,-5] can land on $(4,3)$ and $(-3,-4)$ respectively.

For a convex objective every local minimum is the global minimum, so a local solver's answer is trustworthy without restarts — this is the whole promise of Convex Optimization.

The diagonal of the covariance matrix gives the variances of the fitted parameters, so np.sqrt of it yields free $1\sigma$ error bars — a fit without uncertainty is only half an answer.

The gradient is already zero, so a pure gradient method may report "converged" and never leave the saddle; the Hessian would reveal it is not a minimum, and a small perturbation of x0 escapes it.

The Newton step $\Delta =-J^{-1}\mathbf{F}$ blows up or fails because you cannot invert a singular Jacobian; the solver may stall or diverge, signalled by ier != 1 from full_output=True.

There is no finite optimum, so linprog reports status "problem is unbounded" — the objective can be driven to $-\infty$ and no vertex is optimal.

linprog returns an infeasibility status because no $\mathbf{x}$ satisfies all constraints at once; there is nothing to optimize.

The problem is underdetermined — infinitely many parameter sets fit exactly, so the solver either fails or returns an arbitrary one, and pcov cannot give meaningful uncertainties.

The gradient is zero everywhere, so the very first point already "satisfies" the stopping test; minimize returns x0 unchanged because no step improves anything.

That parameter's gradient vanishes, so the solver gets no signal to move it and may leave it stuck at the bad guess — a reason to seed p0 in a sensible, active range.

The function value and its slope are both near zero there, so Newton-type steps shrink very slowly (linear instead of quadratic convergence) and may report a near-root with larger residual than expected.