Automated Non-Convex to Convex Transformation

• Automated non-convex to convex transformation is a process that converts challenging non-convex optimization problems into convex formulations, enabling efficient use of convex solvers.
• It incorporates methods such as symbolic reasoning with LLM agents, inner-convex approximations, and convex geometric reformulations, exemplified by frameworks like NC2C.
• The automation yields high execution (89.3%) and success (76%) rates, offering promising applications in robotics, neural network verification, and combinatorial optimization.

Automated Non-Convex to Convex Transformation

Automated non-convex to convex transformation refers to algorithmic techniques, frameworks, and pipelines that systematically convert generic or structured non-convex optimization problems into wholly convex forms, enabling the application of efficient convex solvers with formal guarantees or practical performance improvements. This area encompasses both domain-agnostic symbolic automation—using LLMs or programmatic frameworks—and analytic methodologies covering a wide range of problem structures, including polynomial, matrix, conic, and constraint-programming formulations. Recent advances include human-in-the-loop LLM agents, geometric and topological frameworks, convexification via risk aversion, sequential convex programming, and software systems that fully automate the transformation and code-generation process.

1. Taxonomy of Automated Non-Convex to Convex Methods

Automated transformation methods can be categorized by the underlying structural mechanism and the level of automation:

Method Family	Transformation Principle	Scope of Automation
Symbolic Reasoning with LLM Agents	Rule-based and symbolic manipulation	End-to-end (NL→code)
Inner-Convex Approximation (Sequential)	Taylor/majorization-based convex surrogates	Local, iterative
Convexification via Risk-Aversion	Exponential smoothing/regularization	Global, with approximation bounds
Convex Geometric/Conic Reformulation	Domain lifting, facial reduction	Analytic, often exact for structure
Hidden Convexity via Dual Sections	Topological–Lagrangian condition	Structural, in algebraic domains
Convex Relaxations and Restrictions (Heuristic)	Polyhedral or moment relaxations	Automated toolkits

LLM-based systems, such as NC2C, integrate symbolic detection, strategy selection, code synthesis, and validation, while analytic frameworks provide formal transformation recipes for specific algebraic or geometric structures (Peng et al., 8 Jan 2026).

2. LLM-Based End-to-End Automation: The NC2C Framework

NC2C exemplifies a fully automated symbolic pipeline for generic non-convex problems (Peng et al., 8 Jan 2026). It processes natural-language descriptions $\mathcal{D}_p$ and autonomously generates an equivalent convex formulation via the following steps:

1. Problem Modeling: Extract entities and relations to formalize variables, objective $f(\mathbf{x})$, and constraints $g_i, h_j$.
2. Non-Convexity Detection & Classification: Identify non-convex atoms (e.g., bilinear, fractional, integer) and classify by type.
3. Convexification Strategy Selection: Map each non-convex atom $n_\ell$ to an optimal convexification method (e.g., SCA, SDR, change-of-variables).
4. Convexification Execution:
   • Apply successive convex approximation:

   $$\tilde f(\mathbf{x};\mathbf{x}^{(0)}) = f(\mathbf{x}^{(0)}) + \nabla f(\mathbf{x}^{(0)})^\top (\mathbf{x} - \mathbf{x}^{(0)})$$

- Linearize constraints, relax integrality (where needed) using standard relaxations. - Assemble the full convexified problem.

1. Code Generation and Execution: Generate Python code (e.g., for CVXPY), run the solver, and capture execution status.
2. Error Correction and Feasibility Loops: Iteratively adjust code, initial values, or re-convexify to mitigate infeasibility or execution errors.

NC2C’s symbolic loop yields a validated, executable convex program in the majority of tested cases, achieving a 76% success rate (feasible optimum found) and 89.3% execution rate, outperforming LLM baselines and competing frameworks (Peng et al., 8 Jan 2026). This paradigm reduces expert dependency, scales to arbitrary problem classes, and auto-tunes convexification strategy selections.

3. Analytic Sequential and Majorization-Based Transformations

For problems with differentiable structure (or expressible as difference-of-convex), sequential convex programming (SCP) and majorization-minimization (MM) build inner-convex surrogates that guarantee monotonic descent and preserve feasibility (Virgili-Llop et al., 2018, Mayeli, 2019). Core principles include:

• Inner-Convex Approximations: At each iterate $x_e$, construct $g^\text{cvx}_{(x_e)}(x)$ majorizing $f$, matching function value and gradient at $x_e$, and convexity over the domain.
• Taylor-Based Convexification: Decompose higher-order derivatives, retain only convex components ($H^+ \succeq 0$ in the Hessian) in surrogates.
• Convergence Guarantees: Recursive feasibility, monotonic cost descent, convergence to KKT points, and quadratic convergence under regularity.
• Variants: Majorization–minimization schemes (Mayeli, 2019) extend these ideas to non-smooth or structured penalties (e.g., $\ell_1$ minus Moreau envelope).

Iterative automation is straightforward: all surrogate construction steps depend only on the original analytic form, with parameters (e.g., regularization strength, truncation order) computable from data.

4. Geometric, Conic, and Hidden Convexity Frameworks

Structural transformation exploits specific algebraic or geometric properties:

• Convex Geometric Reformulation: Non-convex conic programs (minimize over $K\cap J\cap L$) can be convexified by replacing $K$ with its convex hull, and restricting to a minimal face $J$ exposed by affine constraints $L$ (Kim et al., 2019). The equivalence holds under mild attainment assumptions and recovers completely positive or doubly nonnegative programming for combinatorial and polynomial problems.
• Hidden Convexity via Lagrangian Dual Sections: If the Lagrangian maximization problem admits a continuous section over multipliers, the original non-convex program is equivalent to convex maximization over the convex hull of level-set images (Duff et al., 7 Oct 2025). This applies broadly to QCQP, matrix orbitopes, and certain spectral, inverse, or Procrustes-type problems.
• Convexification via Risk Aversion: Universal transformation applies exponential smoothing to the objective, yielding a convex surrogate with additive approximation bounds (Dvijotham et al., 2014). For any $f$, the risk-averse smoothed surrogate

$$f_\alpha(\theta) = \frac{1}{\alpha} \log \mathbb{E}_{\omega\sim\mathcal N(0,\Sigma)}\left[\exp(\alpha f(\theta+\omega))\right]$$

is convex if $\alpha R \succeq \Sigma^{-1}$.

All these transformations can be algorithmically applied when the requisite structural conditions are detected (e.g., via spectral or moment-based analysis).

5. Automated Convexification for Constraint Systems and Neural Embeddings

• Constraint Automation (NCVX System): For convex-objective, non-convex-feasibility problems, polyhedral relaxations, restrictions (“polishing”), and non-convex ADMM are fully automated in NCVX (Diamond et al., 2016). Projections, relaxations, and neighbor sets are declared via high-level Python variable constructors; all McCormick envelopes, rank relaxations, or neighbor-definitions are constructed at runtime.
• Convexification in Embedded Neural Networks: Tight convex and concave envelopes for neurons with convex or S-shaped activations are recursively constructed, yielding convex hulls for composite activations (affine+nonlinear) in $O(n)$ time per neuron and supporting automated separation and cut-generation for optimization suits (Carrasco et al., 2024).

6. Application Domains and Empirical Evaluation

Automated non-convex to convex transformation frameworks have demonstrated substantial practical impact in diverse domains:

• Real-time Robotics and Control: Sequential convexification is used for non-convex trajectory optimization yielding real-time performance for aerial vehicles and multi-robot consensus (Virgili-Llop et al., 2018, Chen, 2024).
• Polynomial and Combinatorial Optimization: Conic reformulation enables exact solution of binary, cardinality-constrained, and low-rank problems via semidefinite programming (Kim et al., 2019, Diamond et al., 2016).
• Neural Network Verification: Tight recursive convex hulls are used to build cutting-plane-based MIP solvers for neural verification (Carrasco et al., 2024).
• Generic and Natural-Language Specified Problems: LLM-based symbolic toolchains automatically process natural language and algebraic input, generating and validating convex reformulations for general mathematical programming problems (Peng et al., 8 Jan 2026).

Empirical metrics for NC2C on 100 diverse problems: 89.3% execution rate, 76% success at feasible, high-quality convexification, exceeding all baselines (Peng et al., 8 Jan 2026). For specific structural solvers, monotonic descent, recursive feasibility, and quadratic or accelerated convergence are observed in benchmark instances (Virgili-Llop et al., 2018, Lin et al., 2020, Chen, 2024).

7. Limitations, Open Problems, and Future Directions

Current automated frameworks have important limitations:

• The success rate depends on the type and structure of non-convexity; purely data-driven LLMs lack transparency in strategy selection and may introduce approximation gaps (Peng et al., 8 Jan 2026).
• Fully exact equivalence is only guaranteed under structural conditions (e.g., moderate attainment, sectioning, convex hull description); in general, convexified surrogates may only provide global bounds or local optimality (Dvijotham et al., 2014, Kim et al., 2019).
• Computational cost may grow (e.g., enumeration over scenario trees, convex hull representations, conic facial reductions).
• Real-time embedded or high-scale applications may be challenged by the computational burden of repeated convexification or validation rounds.

Open research directions include reinforcing LLMs with retrieval-augmented or reinforcement-based strategy selection, tighter theoretical bounds on approximation gaps and global optimality, further integration of algebraic and geometric reasoning in symbolic pipelines, and extending current techniques to broader classes of infinite-dimensional or non-smooth optimization problems.

---

References

• "NC2C: Automated Convexification of Generic Non-Convex Optimization Problems" (Peng et al., 8 Jan 2026)
• "A recursively feasible and convergent Sequential Convex Programming procedure to solve non-convex problems with linear equality constraints" (Virgili-Llop et al., 2018)
• "Universal Convexification via Risk-Aversion" (Dvijotham et al., 2014)
• "Non-convex optimization via strongly convex majoirziation-minimization" (Mayeli, 2019)
• "A General System for Heuristic Solution of Convex Problems over Nonconvex Sets" (Diamond et al., 2016)
• "Tightening convex relaxations of trained neural networks: a unified approach for convex and S-shaped activations" (Carrasco et al., 2024)
• "A Geometrical Analysis of a Class of Nonconvex Conic Programs for Convex Conic Reformulations of Quadratic and Polynomial Optimization Problems" (Kim et al., 2019)
• "Lagrangian Dual Sections: A Topological Perspective on Hidden Convexity" (Duff et al., 7 Oct 2025)
• "Successive Convexification of Non-Convex Optimal Control Problems and Its Convergence Properties" (Mao et al., 2016)
• "Convex reformulations for a special class of nonlinear MPC problems" (Klädtke et al., 2022)
• "Accelerated Algorithms for Convex and Non-Convex Optimization on Manifolds" (Lin et al., 2020)
• "Multi-Robot Trajectory Generation via Consensus ADMM: Convex vs. Non-Convex" (Chen, 2024)
• "Geometry of quadratic maps via convex relaxation" (Dymarsky et al., 2018)