Convex Optimization in Julia

This paper describes Convex, a convex optimization modeling framework in Julia. Convex translates problems from a user-friendly functional language into an abstract syntax tree describing the problem. This concise representation of the global structure of the problem allows Convex to infer whether the problem complies with the rules of disciplined convex programming (DCP), and to pass the problem to a suitable solver. These operations are carried out in Julia using multiple dispatch, which dramatically reduces the time required to verify DCP compliance and to parse a problem into conic form. Convex then automatically chooses an appropriate backend solver to solve the conic form problem.

💡 Research Summary

This paper presents Convex, a convex optimization modeling framework implemented in the Julia programming language. Convex addresses the fundamental challenge in mathematical optimization: bridging the gap between a human-friendly problem formulation and a solver-friendly standard form. It achieves this through an elegant and efficient symbolic representation of optimization problems.

At the heart of Convex is the concept of an “Expression,” which is represented as an Abstract Syntax Tree (AST). The leaves of this tree are Variables or Constants, while the internal nodes are “Atoms” – fundamental mathematical functions like addition, norm, square, or log. Each Atom carries metadata about its mathematical properties: curvature (convex, concave, affine), monotonicity in each argument, and sign. When a user constructs a problem using intuitive Julia syntax (e.g., minimize(norm(x,1))), Convex builds this AST.

The framework then leverages the AST for two critical automated tasks. First, it verifies the problem’s convexity using the rules of Disciplined Convex Programming (DCP). By recursively applying local combination rules at each node of the AST (e.g., a convex, non-decreasing function of a convex expression is convex), Convex can determine if the entire problem is DCP-compliant, ensuring it is mathematically sound and convex. Second, it transforms the verified problem into a standard conic form (e.g., a linear, second-order, or semidefinite cone program). This transformation is crucial because it allows Convex to interface with high-performance, specialized conic solvers like ECOS, SCS, or MOSEK, which are designed to solve these standard forms efficiently.

A key innovation highlighted in the paper is the extensive use of Julia’s “multiple dispatch” feature. Unlike traditional object-oriented programming where method behavior is determined by the object’s class, multiple dispatch chooses the method based on the types of all function arguments. In Convex, this allows for clean, modular, and highly performant code. Operations like DCP verification, curvature propagation, and conic form conversion are implemented as methods dispatched on the specific type of Atom (e.g., +, norm). This design not only makes the code fast – rivalling the performance of C-based parsers – but also incredibly extensible. Adding a new function (Atom) to the framework simply requires defining its mathematical properties and the corresponding methods, after which it is seamlessly integrated into the entire parsing and solving pipeline.

The paper positions Convex within the ecosystem of modeling tools, comparing it to predecessors like CVX (MATLAB) and CVXPY (Python). It argues that by leveraging Julia’s unique language features, Convex achieves a superior combination of ease-of-use, performance, and extensibility. Users can formulate complex convex problems naturally, have their convexity automatically verified, and benefit from state-of-the-art solver performance, all within a high-level, dynamic programming environment. The Convex framework thus serves as a compelling case study demonstrating Julia’s suitability as a powerful language for technical computing and mathematical optimization.