Equality : Creates a constraint ``self == other``.

Atom representing :math:`x^T P x`.

Inequality : Creates an inequality constraint ``self <= other``.

Make an alias for Python 3.x */

Expression : Sum two expressions.

Expression : Called for Number / Expression.

Returns a string with information about the constraint.

PSD : Creates a negative semidefinite inequality.

Expression : Called for Number * Expression.

Raise base to the power of this expression (base ** self). Uses the identity: a**x = exp(x * log(a)) Parameters ----------

PSD : Creates a positive semidefinite inequality.

Expression : The difference of two expressions.

Returns a string showing the mathematical expression.

Create a list of constraints.

Add finite variable bounds as explicit inequality rows. The rows are inserted right after the existing NonNeg (LEQ) block so the cone partiti

Whether canonicalize_tree result for ``expr`` depends on affine_above. Returns True when ``expr`` itself or any descendant could take the

Cast scalars/arrays to ``Constant`` while leaving Expressions intact.

Bisect `problem` on the parameter `t`.

Broadcast batch dimensions for ND matrix multiplication. For A @ B where A has shape (...a, m, k) and B has shape (...b, k, n),

This function assumes "data" is formatted according to MOSEK.apply when the problem features no integer constraints. This dictionary

Build the stacked interleaved matrix for a batch-varying parametric mul (C @ X). For C (B, m, k) @ X (B, k, n) where C depends on Parameters

Build the stacked interleaved matrix for a batch-varying parametric rmul (X @ C). For X (B, m, k) @ C (B, k, n) where C depends on Parameter

Build the NLP reduction chain and return (SolvingChain, kwargs). Solver selection may mutate kwargs (e.g., Knitro algorithm, Uno preset).

Recursively build a balanced binary tree for PowConeND decomposition.

This function assumes "data" is formatted by MOSEK.apply, and is only intended when the problem has integer constraints. As of MOSEK

Build all SOC lifts aux_i + A[row,:]@x = b[row] in one CSR matrix. Returns ------- A_lift : csr_array or None Sha

Build a reduction chain for a specific solver. The chain is assembled in three stages: 1. **Solver context** — ``SolverInfo`` is derived fro

Assemble A_work and equality row bounds for eq/ineq + SOC lifts.

Raises an error due to chained constraints.

Check that promoted bounds are feasible. Validates: no -inf upper bounds, no +inf lower bounds, lb <= ub, no NaN, and structural zero

Collect x-component duals from leaf cones into pre-allocated array.

Compute block indices for reducing along specified axes (Fortran order). Parameters ---------- shape : tuple Shape of input array

Compute both the QP-filtered and full cone sets. All QUAD_CANON_METHODS atoms canonicalize to SOC, so the only possible difference be

Compute cone sets for a DGP problem. DGP atoms map to different DCP atoms than their standard DCP canonicalization. For example, norm

Key a Constant in one of three ways, in order of preference: 1. Small array (<= 64 elements): value hash. Catches the case where two struc

Contract a pair of operands by elementwise multiplication and summation. This function performs the core contraction operation between two tensor

Convert a single constraint, following the conversion chain transitively. Returns a list of constraints in conversion order (for dual recover

Create a list of variables.

Define data parts from the data reference.

Check if the original value has boolean dtype.

Implements the dual cone of the second-order cone See Pg 85 of the MOSEK modelling cookbook for more information

Method for modelling problems with the dual cone of `Cone` If the user simply calls the method without any arguments, then the dual c

Implements the dual cone of the PSD cone See Pg 85 of the MOSEK modelling cookbook for more information

Map the stacked ``[eq; ineq]`` dual vector to a CVXPY dual dict. Shared by the optimal duals and the infeasibility (Farkas) certificate,

Return a copy of an empty float64 array.

Extract W and z duals from raw 3D cone duals using tree structure.

Recursively extract W duals from the tree. For each node: - SingleVarNode: the variable's dual comes from the parent cone's x (row 0) o

Draw a shape of exactly `ndim` positive dimensions whose product equals `size`. Algorithm: for each of the first ndim-1 slots, sample any di

Last-resort: try every installed solver, warn, or raise.

Finds an interval for bisection.

Get all constraint IDs from a tree, including SpecialNode cases.

Get the original dimension of a tree.

Get the contraction path for the einsum operation. This function determines the order in which pairs of tensors should be contracted to minim

Get the t-component dual (lambda) from the root cone.

Internal function that computes the row indices corresponding to the sum along a specified axis.

Compute row mapping for axis-specific sum. Returns array where row_map[i] is the output row for input row i.

Get a descriptive message about unsupported cones.

Gives the (sub/super)gradient of the atom w.r.t. each argument. Matrix expressions are vectorized, so the gradient is a matrix. Args

Gives the (sub/super)gradient of elementwise multiply. For z = multiply(x, y), we have z[i] = x[i] * y[i]. Gradient is diagonal: grad

Compute gradient matrices for all batch elements. Returns an array of shape (*batch, n, n) where each (n, n) slice is the (sub)gradie

Map CPLEX MIP solution status codes to non-MIP status codes.

Check if any variable has an Expression (parametric) bound.

Best-effort conversion of a ``get_data()`` entry to a hashable form.

Reduce operands with repeated indices by taking diagonal elements. This function handles the case where a subscript pattern contains repeated

Check if an argument is a valid boolean logic input.

Return True if *filename* belongs to cvxpy internals (not tests).

Look up installed QP and conic instances for a solver name. Returns (qp_inst | None, conic_inst | None). GP mode suppresses QP.

COO for -x_0^2 + sum_{i>0} x_i^2 <= 0 (cuOpt Lorentz / CVXPY SOC).

Build a hashable structural key for an Expression subtree. Returns None if a safe key cannot be built, in which case the caller skips

The maximum number of dimensions of the sub-expression.

Batch-varying constant @ variable: use interleaved matrix structure. When the constant has batch dimensions (e.g., C(B,m,k) @ X(B,k,