biHdZddlmZddlZddlZddlmZ ddl m Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZd Zd ZdZ dZ!dZ"dZdZdZ#dZ$GddZ%GddZ&y)a2 Copyright 2020 the CVXPY developers Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. )OptionalN)settings)ExpCone)NonNeg) PowCone3D)PSD)SOC)Zero)Solutionfr0+edeqspp3dp3c0eZdZdZedZedZy)Dualizea CVXPY represents cone programs as (P-Opt) min{ c.T @ x : A @ x + b in K } + d, where the corresponding dual is (D-Opt) max{ -b @ y : c = A.T @ y, y in K^* } + d. For some solvers, it is much easier to specify a problem of the form (D-Opt) than it is to specify a problem of the form (P-Opt). The purpose of this reduction is to handle mapping between (P-Opt) and (D-Opt) so that a solver interface can pretend the original problem was stated in terms (D-Opt). Usage ----- Dualize applies to ParamConeProg problems. It accesses (P-Opt) data by calling ``c, d, A, b = problem.apply_parameters()``. It assumes the solver interface has already executed its ``format_constraints`` function on the ParamConeProg problem. A solver interface is responsible for calling both Dualize.apply and Dualize.invert. The call to Dualize.apply should be one of the first things that happens, and the call to Dualize.invert should be one of the last things that happens. The "data" dict returned by Dualize.apply is keyed by s.A, s.B, s.C, and 'K_dir', which respectively provide the dual constraint matrix (A.T), the dual constraint right-hand-side (c), the dual objective vector (-b), and the dual cones (K^*). The solver interface should interpret this data is a new primal problem, just with a maximization objective. Given a numerical solution, the solver interface should first construct a CVXPY Solution object where :math:`y` is a primal variable, divided into several blocks according to the structure of elementary cones appearing in K^*. The only dual variable we use is that corresponding to the equality constraint :math:`c = A^T y`. No attempt should be made to map unbounded / infeasible status codes for (D-Opt) back to unbounded / infeasible status codes for (P-Opt); all such mappings are handled in Dualize.invert. Refer to Dualize.invert for detailed documentation. Assumptions ----------- The problem has no integer or boolean constraints. This is necessary because strong duality does not hold for problems with discrete constraints. Dualize.apply assumes "SOLVER.format_constraints()" has already been called. This assumption allows flexibility in how a solver interface chooses to vectorize a feasible set (e.g. how to order conic constraints, or how to vectorize the PSD cone). Additional notes ---------------- Dualize.invert is written in a way which is agnostic to how a solver formats constraints, but it also imposes specific requirements on the input. Providing correct input to Dualize.invert requires consideration to the effect of ``SOLVER.format_constraints`` and the output of ``problem.apply_parameters``. c |j\}}}}|j}t|jt|j t |jt|jt|jt|ji}tj|j tj"|tj$| d|ddi}tj&|d|j(d|j*j,d|ddi}||fS)NK_dirdualizedT constr_mapx_id)apply_parameters cone_dimsFREEzeroNONNEGnonnegr socrpsdDUAL_EXPexp DUAL_POW3Dp3drATBC OBJ_OFFSETrxid) problemcdr(bKpKddatainv_datas c/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/cvxpy/reductions/cone2cone/affine2direct.pyapplyz Dualize.apply`s--/ 1a    "'' BII   bff    CC CC CC! R    LL! ',, GIILL R   X~c|j}|j}d\}}|tjvrB|j|tj z}|d|j tji}t}|j}|d}d} |tD]X} |t| | | jz} | jdkDr| n| j|| j<| | jz } Zd} |tD]X} |t | | | jz} | jdkDr| n| j|| j<| | jz } Zd} |t"D]G} | j$d} t'j(|t*| | | z} | || j<| | z } It-|t.D] \} } |t0| } | || j<"d} |t2D]9} |t4| | | jz} | || j<| | jz } ;d} |t6D]9} |t8| | | jz} | || j<| | jz } ;n|tj:k(r"tj<}t&j> }n|tj@k(r"tjB}t&j> }n|tj<k(r!tj:}t&j>}nT|tjBk(r!tj@}t&j>}n tjD}t&jF}tI|||||} | S)aB ``solution`` is a CVXPY Solution object, formatted where (D-Opt) max{ -b @ y : c = A.T @ y, y in K^* } + d is the primal problem from the solver's perspective. The purpose of this function is to map such a solution back to the format (P-Opt) min{ c.T @ x : A @ x + b in K } + d. This function handles mapping of primal and dual variables, and solver status codes. The variable "x" in (P-Opt) is trivially populated from the dual variables to the constraint "c = A.T @ y" in (D-Opt). Status codes also map back in a simple way. Details on required formatting of solution.primal_vars ------------------------------------------------------ We assume the dict solution.primal_vars is keyed by string-enums FREE ('fr'), NONNEG ('+'), SOC ('s'), PSD ('p'), and DUAL_EXP ('de'). The corresponding values are described below. solution.primal_vars[FREE] should be a single vector. It corresponds to the (possibly concatenated) components of "y" which are subject to no conic constraints. We map these variables back to dual variables for equality constraints in (P-Opt). solution.primal_vars[NONNEG] should also be a single vector, this time giving the possibly concatenated components of "y" which must be >= 0. We map these variables back to dual variables for inequality constraints in (P-Opt). solution.primal_vars[SOC] is a list of vectors specifying blocks of "y" which belong to the second-order-cone under the CVXPY standard ({ z : z[0] >= || z[1:] || }). We map these variables back to dual variables for SOC constraints in (P-Opt). solution.primal_vars[PSD] is a list of symmetric positive semidefinite matrices which result by lifting the vectorized PSD blocks of "y" back into matrix form. We assign these as dual variables to PSD constraints appearing in (P-Opt). solution.primal_vars[DUAL_EXP] is a vector of concatenated length-3 slices of y, where each constituent length-3 slice belongs to dual exponential cone as implied by the CVXPY standard of the primal exponential cone (see cvxpy/constraints/exponential.py:ExpCone). We map these back to dual variables for exponential cone constraints in (P-Opt). )NNrrr)%statusattrrSOLUTION_PRESENTopt_valr, dual_varsEQ_DUALdict primal_varsZero_objrsizeitemr. NonNeg_objr SOC_objshapenp concatenater enumeratePSD_objr ExpCone_objr$ PowCone_objr& INFEASIBLE UNBOUNDEDinfINFEASIBLE_INACCURATEUNBOUNDED_INACCURATE SOLVER_ERRORnanr )solutionr6r< prob_attrrCr@r? direct_primsricondv block_lensols r7invertzDualize.invert|s+XMM !+ Y Q'' '&&!,,)??G#F+#--aii8:KI#//L!,/JA!(+ !$'!chh,7*,''A+B2779 #&&!SXX  A!*- !&)!AL9*,''A+B2779 #&&!SXX  A!'* IIaL ^^L$5aI $FG$& #&&!Y   $Jw$78 '3!#&q)$& #&&! 'A!+. !(+Aa#((l;$& #&&!SXX  A!+. !*-aCHH =$& #&&!SXX  q|| #[[FvvgG q.. .++FvvgG q{{ "\\FffG q-- -,,FffG^^FffGvw Y J r9N)__name__ __module__ __qualname____doc__ staticmethodr8r_r9r7rr)s24l6bbr9rc eZdZdZedZededeejde dejfdZ edZ y ) Slacksa CVXPY represents mixed-integer cone programs as (Aff) min{ c.T @ x : A @ x + b in K, x[bools] in {0, 1}, x[ints] in Z } + d. Some solvers do not accept input in the form (Aff). A general pattern we find across solver types is that the feasible set is represented by (Dir) min{ f @ y : G @ y <=_{K_aff} h, y in K_dir y[bools] in {0, 1}, y[ints] in Z } + d, where K_aff is built from a list convex cones which includes the zero cone (ZERO), and K_dir is built from a list of convex cones which includes the free cone (FREE). This reduction handles mapping back and forth between problems stated in terms of (Aff) and (Dir), by way of adding slack variables. Notes ----- Support for semidefinite constraints has not yet been implemented in this reduction. If the problem has no integer constraints, then the Dualize reduction should be used instead. Because this reduction is only intended for mixed-integer problems, this reduction makes no attempt to recover dual variables when mapping between (Aff) and (Dir). cr |j\}}}}| }|j}|jr t|D])}|tt t tthvs!tt|vr|jtt|jt |jtt|jt d|jztdt|j zi}tdt |tt|t|t zt |t|t z|tzt|t|t z|tz|t zi} gg} } gg} } d}tt tt tfD]}||}|dkDs| |}||||zddf}||||z}||vr#| j|| j|P||j"z }| j|| j|t$|j&j"t t |vrdn |jtt|vrgn |jt t |vrdn |jt(gt*dtt|vrgn |j t,gi}t t |vr |jndtt|vr |jngt t |vr |jndt(gt|j|ztt|vr |j ngi}t/}| rt0j2j5t7| } t0j2j9|}| rht0j2j5t7| d} t0j2j;| |g| dgg}t=j>| | z}n6t0j2jA| |f}t=j>| }t=j>|t=jB|f}nN| rBt0j2j5t7| d}t=j>| }|}n tE||tFjH<||tFjJ<||tFjL<|j&jNDcgc]}tQ|dc}|tFjR<|j&jTDcgc]}tQ|dc}|tFjV<||d<||d<|jXd}tZj]||j^t<j` |tFjb<tZj]||jdt<j`|tFjf<t/}|j&jh|d <||d<||d<||tFjj<||fScc}wcc}w) a5 "prob" is a ParamConeProg which represents (Aff) min{ c.T @ x : A @ x + b in K, x[bools] in {0, 1}, x[ints] in Z } + d. We return data for an equivalent problem (Dir) min{ f @ y : G @ y <=_{K_aff} h, y in K_dir y[bools] in {0, 1}, y[ints] in Z } + d, where (1) K_aff is built from cone types specified in "affine" (a list of strings), (2) a primal solution for (Dir) can be mapped back to a primal solution for (Aff) by selecting the leading ``c.size`` block of y's components. In the returned dict "data", data[s.A] = G, data[s.B] = h, data[s.C] = f, data['K_aff'] = K_aff, data['K_dir'] = K_dir, data[s.BOOL_IDX] = bools, and data[s.INT_IDX] = ints. The rows of G are ordered according to ZERO, then (as applicable) NONNEG, SOC, and EXP. If "c" is the objective vector in (Aff), then ``y[:c.size]`` should contain the optimal solution to (Aff). The columns of G correspond first to variables in cones FREE, then NONNEG, then SOC, then EXP. The length of the free cone is equal to ``c.size``. Assumptions ----------- The function call ``c, d, A, b = prob.apply_parameters()`` returns (A,b) with rows formatted first for the zero cone, then for the nonnegative orthant, then second order cones, then the exponential cone. Removing this assumption will require adding additional data to ParamConeProg objects. rNcsr)formatrK_affr;r)6rrr#NotImplementedErrorZEROr EXPr POW3Dappendrr!sumr"r%lenr'rErr-rr$r&rBspsparsevstacktuple eye_array block_arrayrJrKhstackzeros ValueErrorrr(r*r+ boolean_idxintBOOL_IDX integer_idxINT_IDXrIrg extend_bounds lower_boundsrR LOWER_BOUNDS upper_bounds UPPER_BOUNDSr.r,)probaffiner0r1r(r2rval cone_lens row_offsetsA_affb_affA_slkb_slk total_slackco_typeco_dimrA_tempb_temprrlr5eyeGhftnum_varsr6s r7r8z Slacks.applys D**, 1a BNN ==&' ' ,C4c599)++ , v  MM$  ).. I$$ Y]]# Y]]" 1s9==))   ! IdO 49V#44 49V#44y~E 9T?Yv%663G)TW.X  2u2u fc36 )Gw'Fz(1QZ<?+1QZf$LL(LL(6;;.KLL(LL(+ ). $&&++ 6)Ay/?/? sf})-- cVm  a &2imm    &(8I$$a #-R #-Q  )..;. EVO9==  v II$$U5\2E))%%k2C ((ue(DII))E3<%*GHNN55=1II$$eS\2NN5)288K#89:A    ue O>ORTRXRXQXYQ^^%33Hd>O>OQSQWQWXQ^^66699!!!"X~!CAs 'X/(X4r bounds_vector fill_valuereturnc|tj||S||jz }tj|tj }tj||gS)zHExtend the bounds vector to be length num_vars, filling with fill_value.)rJfullrErRrK)rrrnew_vars new_boundss r7rzSlacks.extend_boundssU  778Z0 0m000WWXw/ ~~}j9::r9c|jtjvr$|j}|t}|t=|||d<|xj |tj z c_|S)Nr)r<rr>rCrr?r,)rWr6 prim_varsr-s r7r_z Slacks.inverts] ??a00 0 ,,I$A$*+Ihv& 'HQ\\22r9N) r`rarbrcrdr8r~rrJndarrayfloatrr_rer9r7rgrgsw<UUn ; ; + ; ;  ; ;r9rg)'rctypingrnumpyrJscipyrtcvxpyrrcvxpy.constraints.exponentialrrNcvxpy.constraints.nonposrrGcvxpy.constraints.powerrrOcvxpy.constraints.psdrrMcvxpy.constraints.second_orderr rHcvxpy.constraints.zeror rDcvxpy.reductions.solutionr rrnr ror$rpr&rrgrer9r7rss@9<093.          vvrMMr9