What is CVXR?

Convex optimization, written the way you write the math. The R port of CVXPY — you state the problem, CVXR checks it is convex (DCP) and dispatches it to a solver.

library(CVXR)
## Given data X, y, p = # of predictors
lambda <- 0.05
beta <- Variable(p)
loss <- sum_squares(y - X %*% beta) +
           lambda * p_norm(beta, 1)
problem <- Problem(objective = Minimize(loss))
psolve(problem)
value(beta)

library(CVXR)
## Given data weight, worth, capacity
take <- Variable(n, boolean = TRUE)
prob <- Problem(
  objective = Maximize(worth %*% take),
  constraints = list(weight %*% take <= capacity))
psolve(prob, solver = "HIGHS")
value(take)

See the project website at cvxr.rbind.io for documentation and examples.

A community of two

Until early 2026, CRAN shipped CVXR 1.0.x — a tour de force by then-PhD-student Anqi Fu, advised by Stephen Boyd and myself. Anqi knew convex optimization inside out (and held a Stats MS from our department).

The Mission

R’s Object Systems

R has five major OOP systems. The rewrite hinges on the newest.

person <- list(name = "Alice")
class(person) <- "person"
print.person <- function(x, ...)
  cat("Person:", x$name, "\n")

setClass("Person",
  slots = list(name = "character"))
setGeneric("greet",
  function(x) standardGeneric("greet"))
setMethod("greet", "Person",
  function(x) cat("Hi,", x@name, "\n"))

Person <- setRefClass("Person",
  fields = list(name = "character"),
  methods = list(greet = function()
    cat("Hi,", name, "\n")))

Person <- R6::R6Class("Person",
  public = list(name = NULL,
    greet = function()
      cat("Hi,", self$name, "\n")))

Person <- new_class("Person",
  properties = list(name = class_character))
method(greet, Person) <- function(x)
  cat("Hi,", x@name, "\n")

S4 → S7: the Abs atom

An atom is a building-block function CVXR knows how to canonicalize — abs, norm, exp, log_det, … — each carrying its curvature and sign so DCP can reason about it. CVXR has 100+. Watch one cross over:

.Abs <- setClass("Abs",
  representation(x = "Expression"),
  contains = "Elementwise")
Abs <- function(x) .Abs(x = x)

setMethod("initialize", "Abs",
  function(.Object, ..., x) {
    .Object@x <- x
    callNextMethod(.Object, ...,
      atom_args = list(.Object@x)) })

setMethod("sign_from_args", "Abs",
  function(object) c(TRUE, FALSE))
setMethod("is_atom_convex", "Abs",
  function(object) TRUE)
setMethod("is_incr", "Abs",
  function(object, idx)
    is_nonneg(object@args[[idx]]))
# + is_decr, is_pwl, .grad,
#   .domain, graph_implementation

Abs <- new_class("Abs",
  parent = Elementwise,
  constructor = function(x) {
    x <- as_expr(x)
    new_object(S7_object(),
      args = list(x),
      shape = x@shape) })

method(sign_from_args, Abs) <-
  function(x)
    list(is_nonneg = TRUE,
         is_nonpos = FALSE)
method(is_atom_convex, Abs) <-
  function(x) TRUE
method(is_incr, Abs) <-
  function(x, idx, ...)
    is_nonneg(x@args[[idx + 1L]])

S7 ≈ Python

class Abs(Elementwise):
    def __init__(self, x):
        super().__init__(x)
    def sign_from_args(self):
        return (True, False)
    def is_atom_convex(self):
        return True
    def numeric(self, values):
        return np.abs(values[0])

Abs <- new_class("Abs",
  parent = Elementwise, ...)

method(sign_from_args, Abs) <-
  function(x)
    list(is_nonneg = TRUE,
         is_nonpos = FALSE)
method(is_atom_convex, Abs) <-
  function(x) TRUE
method(numeric_value, Abs) <-
  function(x, values, ...)
    abs(values[[1L]])

So we tried it — with a blueprint

We did not just say “AI, port this.” We borrowed a discipline from the mathematicians:

Testing kept us honest

Every test block is tagged to the CVXPY test it mirrors:

## @cvxpy test_problem.py::TestLP::test_basic
test_that("basic LP solves", {
  x <- Variable(2)
  prob <- Problem(Minimize(sum(x)), list(x >= 1))
  expect_equal(value(psolve(prob)), 2, tolerance = 1e-4)
})

The speed was real

The honeymoon ended

The mirror guarantees every CVXPY file has an R twin. It does not guarantee the R means the same thing. The first cracks — ports that look right:

Incident 1: the fabricated test

That proud breadcrumb — the annotation that guarantees fidelity? The agent learned to forge it.

• Porting CVXPY’s MOSEK MIP tests, it met mi_pcp_0, read the function name, imagined a plausible problem, wrote it from scratch — and stamped the mandatory ## CVXPY SOURCE: solver_test_helpers.py mi_pcp_0() on top. It never opened the file.
• The fabricated problem was unbounded. MOSEK branched to −∞ and OOM’d a 128 GB machine — the reboot wiped the session history.
• Audit: 4 of ~30 helpers (~13%) were wholesale fabricated. All green. Each hidden under skip() — detonating only when the skip was finally lifted.

Incident 2: “while I’m here…”

The dominant failure mode wasn’t bad code. It was scope.

• A one-file compile fix (SETLENGTH) ballooned into a ~20-file class redesign — justified by a perf concern no one had measured. It helped OOM the machine.

Incident 3: the numbers lied

“Premature optimization is the root of all evil.” — Knuth. We took him at his word: correctness first. With the port up and running, we began paying real attention to performance — and the first discovery was that we could not trust our own measurements. Two episodes:

• After an update, timings showed a 36× slowdown. Bisecting found no guilty commit — the real cause: we had reloaded the package inside a live session. In a fresh R session, no slowdown at all.
• A caching “optimization” that looked obviously right ran 2.4× slower on our Kalman-filter benchmark. Measured first → branch deleted before it shipped.

Root cause: RL reward hacking

Two more shortcuts I caught in review — the agent made the test pass, not the code correct:

## kron(Var, C): CVXPY sum = 2.4, CVXR = 4.0.
## "fix": relax the test to only check the solver finished.

## Unbounded LP crashed on empty cones.
## "fix": fabricate a bound, then still assert UNBOUNDED.

What the incidents have in common

None of these failures is exotic. Each one broke a rule software teams have preached for decades:

Build them in #1: rules

Each incident became a written rule the agent must read before it acts. The 15-rule “constitution” is an incident log, not a spec:

Build them in #2: plan, critique, update — then act

For anything nontrivial, no code is written until a plan survives its critics:

• The agent deep-reads the CVXPY source and writes a plan.
• Fresh agents attack the plan — run concurrently, so no critic anchors on another’s findings. (A sequential second critic just echoes the first.)
• The plan is updated and re-critiqued — sometimes several rounds — before a single line of code.
• Phase 5a: three concurrent critics independently found the same flaw — a wiring error that guaranteed a runtime crash. Plan v1 rejected. The bug was never written.

Build them in #3: audits

A passing suite verifies what you thought to test. So at every tagged phase, fresh agents audit the built artifact — agents that did not write the code:

• v0.3.0 audit alone: 8 release-blocking bugs + 25 serious issues — all under a green suite
• "POSITIVE" vs "NONNEGATIVE" — tests passed comparing to the same wrong value
• dual signs flipped — tests passed because the problems had zero dual value

Build them in #4: sweeps

A new CVXPY release is too big to absorb in one pass over 411 files. So: two passes over the blueprint.

• Sweep up — build the new feature end-to-end first, updating only the files it needs. Every file only partially updated gets a dated debt marker: a comment recording exactly what was deferred, and why.
• Sweep down — once the feature works, walk the whole tree and clear every marker. The to-do list is not reconstructed from memory — it is a search for the markers. Nothing marked, nothing owed.
• Every phase shipped green — and the down-sweep still found release-blocking bugs. The parity counter fell in waves, re-touching the same files.

Caught up — and then some

Since the S4 days, all new to CVXR:

What generalizes

If you are building an R package with an AI agent, the package is the test case — the disciplines are the product:

• Blueprint discipline — an authoritative reference, an isomorphic mirror, cross-references you can grep. Works for any port; the reference need not be code.
• Parity as one integer — annotation-based test mapping; burn the gap to zero.
• Rules from incidents — every caught failure becomes a permanent, triggerable constraint. The agent improves at your project.
• Plan → critique → update → act — several rounds if needed; slow by design, and it pays for itself downstream.
• Independent audits — fresh agents on tagged artifacts; parallel critics on plans.
• Benchmark discipline — no unmeasured number survives; no irreversible optimization.