diff --git a/.gitignore b/.gitignore
index 712d1d8..626ae56 100644
--- a/.gitignore
+++ b/.gitignore
@@ -61,4 +61,11 @@ diagnose*.py
 test_scalability.py
 test_scipy_scalability.py
 # Profiling scripts (local analysis only)
-profile_*.py
\ No newline at end of file
+profile_*.py
+
+dense*.py
+
+setup_*.py
+
+benchmarks_be*.txt
+benchmarks_af*.txt
\ No newline at end of file
diff --git a/CHANGELOG.md b/CHANGELOG.md
index e2ec414..18ae3c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,44 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2026-04-07
+
+### Added
+- **Mixed-Integer Linear Programming (MILP)**: `BinaryVariable`, `IntegerVariable`, and `VectorVariable(domain="binary"|"integer")` with automatic routing to SciPy's HiGHS backend via `scipy.optimize.milp()`.
+- **`VariableDict`**: Dict-indexed variables keyed by strings, with `.prod(costs)` weighted sums and `.sum(keys=subset)` aggregation.
+- **Sparse LP support**: `Problem.subject_to(A @ x <= b)` supports matrix blocks directly, with `as_matrix(...)` enabling `scipy.sparse` inputs for industrial-scale LP.
+- **`as_matrix(storage="auto"|"dense"|"sparse")`**: explicit storage override for matrix blocks, including automatic CSR conversion for large low-density dense arrays.
+- **Solver callbacks**: `SolverProgress` dataclass and `callback=` parameter on `solve()` for progress monitoring and early termination.
+- **Time limits**: `time_limit=` parameter on `solve()` for wall-clock budgets.
+- **LP export**: `Problem.write("model.lp")` exports linear/quadratic models in LP format.
+- **Solution serialization**: `Solution.to_dict()`, `Solution.to_json()`, and `Solution.from_json()` for logging and auditing.
+- **`Expression.between(lb, ub)`**: Range constraints in one call.
+- **Generator support in `subject_to()`**: `prob.subject_to(x[i] >= 0 for i in range(n))`.
+- **`Problem` context manager**: `with Problem() as p: ...` syntax.
+- **`Problem.remove_constraint()`**: Incremental model modification.
+- **`Problem.reset()`**: Clear solver cache and warm-start state.
+- **Warm starts**: Re-solves automatically use the previous solution as starting point.
+- **Per-element array bounds**: `VectorVariable("x", 3, lb=np.array([0, 0.5, 0.2]))`.
+- **Fancy indexing**: `x[[0, 2, 5]]` returns a subset vector expression.
+- **`Solution.mip_gap`** and **`Solution.best_bound`**: MILP optimality reporting.
+- **`Solution.is_optimal`** and **`Solution.is_feasible`**: Convenience status checks.
+- **`SolverStatus.TERMINATED`**: New status for callback-initiated stops.
+
+### Changed
+- **VectorGradientPattern**: Detects expressions with vectorizable gradient structure (∇f = Ax + b) for O(1) gradient compilation.
+- **NarySum / NaryProduct**: Flatten deep loop-built trees to O(1) depth, keeping memory layout flat regardless of sequential assignment length.
+- **VectorBinaryOp**: Preserves vector structure for element-wise operations.
+- **Sparse Jacobian compilation**: Reduces memory from O(m×n) to O(nnz) for constraint Jacobians.
+- **Sparse NLP routing**: large sparse constrained NLPs bias toward `trust-constr`, matrix blocks now flow through SciPy's linear-constraint API, and batched sparse Jacobians are compiled lazily only when that path is used.
+- **SciPy objective gradients**: sparse objective structure is now evaluated with O(nnz) derivative work while returning dense vectors directly to SciPy.
+- **DotProduct fast-path**: O(1) variable extraction for `x.dot(x)` expressions.
+
+### Performance
+- **LP Overhead**: ~1.1x vs raw SciPy (near parity for VectorVariable)
+- **CQP Overhead**: ~1.2-2.2x vs raw SciPy (with exact Jacobians)
+- **Cache Speedup**: 2x-900x for repeated solves (larger problems benefit more)
+- **Rosenbrock**: 0.83x — exact gradients help complex optimization landscapes
+
 ## [1.2.4] - 2026-02-08
 
 ### Fixed
@@ -131,8 +169,8 @@ This patch release completes the v1.2.0 release. Due to an incomplete merge, sev
 - Cache invalidation is now centralized via `Problem._invalidate_caches()`.
 
 ### Performance
-- **LP Overhead**: ~0.94-1.15x vs raw SciPy (near parity)
-- **NLP Overhead**: ~1.4-2.2x vs raw SciPy with gradients
+- **LP Overhead**: ~1.1x vs raw SciPy (near parity for VectorVariable)
+- **CQP Overhead**: ~1.2-2.2x vs raw SciPy (with exact Jacobians)
 - **Cache Speedup**: 2x-900x for repeated solves (larger problems benefit more)
 - **Rosenbrock**: 0.83x - exact gradients help complex optimization landscapes
 
diff --git a/README.md b/README.md
index 3efd0e2..b7cd7ff 100644
--- a/README.md
+++ b/README.md
@@ -5,10 +5,10 @@
 [![PyPI](https://img.shields.io/pypi/v/optyx.svg)](https://pypi.org/project/optyx/)
 [![Python 3.12+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
-[![CI](https://github.com/daggbt/optyx/actions/workflows/ci.yml/badge.svg)](https://github.com/daggbt/optyx/actions/workflows/ci.yml)
-[![Docs](https://img.shields.io/badge/docs-online-blue.svg)](https://daggbt.github.io/optyx/)
+[![CI](https://github.com/optyx-dev/optyx/actions/workflows/ci.yml/badge.svg)](https://github.com/optyx-dev/optyx/actions/workflows/ci.yml)
+[![Docs](https://img.shields.io/badge/docs-online-blue.svg)](https://optyx-dev.github.io/optyx/)
 
-📚 **[Documentation](https://daggbt.github.io/optyx/)** · 🚀 **[Quickstart](https://daggbt.github.io/optyx/getting-started/quickstart.html)** · 💡 **[Examples](https://daggbt.github.io/optyx/examples/portfolio.html)**
+📚 **[Documentation](https://optyx-dev.github.io/optyx/)** · 🚀 **[Quickstart](https://optyx-dev.github.io/optyx/getting-started/quickstart.html)** · 💡 **[Examples](https://optyx-dev.github.io/optyx/examples/portfolio.html)**
 
 <table>
 <tr>
@@ -79,11 +79,11 @@ Optyx is young and opinionated. It's **not** a replacement for specialized tools
 
 | Need | Use Instead |
 |------|-------------|
-| MILP at scale | Pyomo, OR-Tools, Gurobi |
+| Large-scale MILP with custom branching | Pyomo, OR-Tools, Gurobi |
 | Convex guarantees | CVXPY |
 | Maximum performance | Raw solver APIs |
 
-But if you want readable optimization code that just works for most problems, Optyx might be for you.
+Optyx does support MILP (via HiGHS), sparse LPs with 100k+ variables, and solver callbacks—but if you need industrial-grade MIP with cutting planes, a dedicated solver is the right choice.
 
 ---
 
@@ -93,7 +93,7 @@ But if you want readable optimization code that just works for most problems, Op
 pip install optyx
 ```
 
-Requires Python 3.12+, NumPy ≥2.0, SciPy ≥1.6.
+Requires Python 3.12+, NumPy ≥2.0, SciPy ≥1.7.
 
 ---
 
@@ -152,6 +152,27 @@ df = gradient(f, x)  # Symbolic: 3x² + 4x - 5
 print(df.evaluate({"x": 2.0}))  # 15.0
 ```
 
+### Mixed-Integer Programming
+
+```python
+from optyx import BinaryVariable, VectorVariable, Problem
+import numpy as np
+
+# Binary knapsack: select items to maximize value within weight limit
+n = 5
+x = VectorVariable("x", n, domain="binary")
+values = np.array([10, 20, 15, 25, 30])
+weights = np.array([5, 10, 8, 12, 15])
+
+solution = (
+    Problem()
+    .maximize(x.dot(values))
+    .subject_to(x.dot(weights) <= 30)
+    .solve()
+)
+# Automatically routes to HiGHS MILP solver
+```
+
 ---
 
 ## Features at a Glance
@@ -160,11 +181,17 @@ print(df.evaluate({"x": 2.0}))  # 15.0
 |---------|-------------|
 | **Natural syntax** | `x + y >= 1` instead of constraint dictionaries |
 | **Automatic gradients** | Symbolic differentiation—no manual derivatives |
-| **Smart solver selection** | HiGHS for LP, SLSQP/BFGS for NLP |
-| **Fast re-solve** | Cached compilation, up to 900x speedup |
+| **Smart solver selection** | HiGHS for LP/MILP, SLSQP/BFGS for NLP |
+| **Mixed-integer programming** | `BinaryVariable`, `IntegerVariable`, automatic MILP routing |
+| **Vector & matrix variables** | `VectorVariable`, `MatrixVariable`, `VariableDict` for scalable models |
+| **Sparse LP support** | `subject_to(A @ x <= b)` with `as_matrix(..., storage="auto"|"dense"|"sparse")` — 100k+ variables |
+| **Solver callbacks** | Monitor progress, enforce time limits, early termination |
+| **LP format export** | `Problem.write("model.lp")` for interop with other solvers |
+| **Solution serialization** | `to_json()` / `from_json()` for logging and auditing |
+| **Fast re-solve** | Cached compilation + warm starts, up to 900x speedup |
 | **Debuggable** | Inspect expression trees, understand your model |
 
-See the [documentation](https://daggbt.github.io/optyx/) for the full API reference, tutorials, and real-world examples.
+See the [documentation](https://optyx-dev.github.io/optyx/) for the full API reference, tutorials, and real-world examples.
 
 ---
 
@@ -172,25 +199,25 @@ See the [documentation](https://daggbt.github.io/optyx/) for the full API refere
 
 Optyx is actively evolving:
 
-- **Vector/Matrix variables** — Handle thousands of decision variables cleanly
-- **JIT compilation** — Faster execution for complex models  
+- **MIQP / MINLP support** — Quadratic and nonlinear MIP via native HiGHS or Gurobi
+- **MPS format I/O** — Import and export MPS files for solver interop
 - **More solvers** — IPOPT integration for large-scale NLP
 - **Better debugging** — Infeasibility diagnostics and model inspection
 
-See the [roadmap](https://daggbt.github.io/optyx/contributing.html) for details.
+See the [roadmap](https://optyx-dev.github.io/optyx/contributing.html) for details.
 
 ---
 
 ## Contributing
 
 ```bash
-git clone https://github.com/daggbt/optyx.git
+git clone https://github.com/optyx-dev/optyx.git
 cd optyx
 uv sync
 uv run pytest
 ```
 
-Contributions welcome! See our [contributing guide](https://daggbt.github.io/optyx/contributing.html).
+Contributions welcome! See our [contributing guide](https://optyx-dev.github.io/optyx/contributing.html).
 
 ---
 
diff --git a/benchmarks/README.md b/benchmarks/README.md
index 3e516b9..7a1e1ae 100644
--- a/benchmarks/README.md
+++ b/benchmarks/README.md
@@ -126,8 +126,8 @@ prob.subject_to(np.sum(x) >= 1)   # Sum constraint
 | Category       | Target                                    | Status |
 | -------------- | ----------------------------------------- | ------ |
 | Validation     | All problems converge to known optima     | ✅     |
-| LP overhead    | < 1.5x vs SciPy linprog                   | ✅ ~0.94-1.15x |
-| NLP overhead   | < 3x vs raw SciPy (with gradients)        | ✅ ~1.4-2.2x |
+| LP overhead    | < 1.5x vs SciPy linprog                   | ✅ ~1.1-1.6x |
+| CQP overhead   | < 3x vs raw SciPy (with Jacobians)        | ✅ ~1.2-2.2x |
 | Cache benefit  | > 2x speedup on repeated solve            | ✅ 2x-900x |
 | Gradient error | < 1e-5 vs finite difference               | ✅ < 1e-10 |
 
@@ -141,12 +141,9 @@ prob.subject_to(np.sum(x) >= 1)   # Sum constraint
 
 ## Updating Documentation
 
-When regenerating benchmark plots, copy them to the docs folder:
+When regenerating benchmark plots, the runner syncs benchmark artifacts to the docs folder automatically:
 
 ```bash
 # Regenerate plots
 uv run python benchmarks/run_benchmarks.py
-
-# Copy to docs assets
-cp benchmarks/results/*.png docs/assets/benchmarks/
 ```
diff --git a/benchmarks/accuracy/gradient_validation.py b/benchmarks/accuracy/gradient_validation.py
index 4f070e0..3381f02 100644
--- a/benchmarks/accuracy/gradient_validation.py
+++ b/benchmarks/accuracy/gradient_validation.py
@@ -1,6 +1,7 @@
 """Accuracy benchmark: Gradient validation.
 
-Validates Optyx autodiff gradients against finite difference approximations.
+Validates Optyx autodiff gradients against finite difference approximations
+AND hand-derived analytical formulas.
 Target: < 1e-6 relative error.
 """
 
@@ -9,6 +10,8 @@
 import numpy as np
 
 from optyx import Variable, Problem, sin, cos, exp, log, sqrt
+from optyx.core.autodiff import compile_jacobian
+from optyx.core.optimizer import flatten_expression
 
 import sys
 
@@ -32,6 +35,20 @@ def finite_difference_gradient(
     return grad
 
 
+def _optyx_gradient(prob: Problem) -> callable:
+    """Compile the Optyx gradient for a problem's objective.
+
+    Returns a callable ``(x) -> 1-d gradient array``.
+    """
+    obj_expr = prob.objective
+    if prob.sense == "maximize":
+        obj_expr = -obj_expr  # type: ignore[operator]
+    obj_expr = flatten_expression(obj_expr)
+    variables = prob.variables
+    jac_fn = compile_jacobian([obj_expr], variables)
+    return lambda x: jac_fn(x).flatten()
+
+
 class TestPolynomialGradients:
     """Test gradients of polynomial expressions."""
 
@@ -43,16 +60,14 @@ def test_quadratic_gradient(self):
         prob = Problem()
         prob.minimize(x**2 + 2 * x * y + 3 * y**2)
 
-        # Get compiled gradient from solver cache
         variables = prob.variables
         var_names = [v.name for v in variables]
+        optyx_grad = _optyx_gradient(prob)
 
-        # Build equivalent numpy function
         def f(vals):
             v = dict(zip(var_names, vals))
             return v["x"] ** 2 + 2 * v["x"] * v["y"] + 3 * v["y"] ** 2
 
-        # Test at multiple points
         test_points = [
             np.array([1.0, 2.0]),
             np.array([0.5, -0.3]),
@@ -61,13 +76,15 @@ def f(vals):
 
         for point in test_points:
             fd_grad = finite_difference_gradient(f, point)
-
-            # Analytical gradient: [2x + 2y, 2x + 6y]
             x_val, y_val = point
             analytical_grad = np.array([2 * x_val + 2 * y_val, 2 * x_val + 6 * y_val])
+            ox_grad = optyx_grad(point)
+
+            error_fd = np.linalg.norm(fd_grad - analytical_grad)
+            assert error_fd < 1e-5, f"FD vs analytical error at {point}: {error_fd}"
 
-            error = np.linalg.norm(fd_grad - analytical_grad)
-            assert error < 1e-5, f"Gradient error at {point}: {error}"
+            error_ox = np.linalg.norm(ox_grad - analytical_grad)
+            assert error_ox < 1e-5, f"Optyx vs analytical error at {point}: {error_ox}"
 
     def test_cubic_gradient(self):
         """f(x) = x³ - 3x + 1"""
@@ -75,6 +92,7 @@ def test_cubic_gradient(self):
 
         prob = Problem()
         prob.minimize(x**3 - 3 * x + 1)
+        optyx_grad = _optyx_gradient(prob)
 
         def f(vals):
             return vals[0] ** 3 - 3 * vals[0] + 1
@@ -83,11 +101,14 @@ def f(vals):
 
         for point in test_points:
             fd_grad = finite_difference_gradient(f, point)
-            # Analytical: 3x² - 3
             analytical = np.array([3 * point[0] ** 2 - 3])
+            ox_grad = optyx_grad(point)
 
-            error = np.abs(fd_grad[0] - analytical[0])
-            assert error < 1e-5, f"Gradient error at {point}: {error}"
+            error_fd = np.abs(fd_grad[0] - analytical[0])
+            assert error_fd < 1e-5, f"FD vs analytical error at {point}: {error_fd}"
+
+            error_ox = np.abs(ox_grad[0] - analytical[0])
+            assert error_ox < 1e-5, f"Optyx vs analytical error at {point}: {error_ox}"
 
 
 class TestTranscendentalGradients:
@@ -99,6 +120,7 @@ def test_sin_cos_gradient(self):
 
         prob = Problem()
         prob.minimize(sin(x) + cos(x))
+        optyx_grad = _optyx_gradient(prob)
 
         def f(vals):
             return np.sin(vals[0]) + np.cos(vals[0])
@@ -107,11 +129,14 @@ def f(vals):
 
         for point in test_points:
             fd_grad = finite_difference_gradient(f, point)
-            # Analytical: cos(x) - sin(x)
             analytical = np.array([np.cos(point[0]) - np.sin(point[0])])
+            ox_grad = optyx_grad(point)
+
+            error_fd = np.abs(fd_grad[0] - analytical[0])
+            assert error_fd < 1e-5, f"FD vs analytical error at {point}: {error_fd}"
 
-            error = np.abs(fd_grad[0] - analytical[0])
-            assert error < 1e-5, f"Gradient error at {point}: {error}"
+            error_ox = np.abs(ox_grad[0] - analytical[0])
+            assert error_ox < 1e-5, f"Optyx vs analytical error at {point}: {error_ox}"
 
     def test_exp_gradient(self):
         """f(x,y) = exp(x) + exp(-y)"""
@@ -120,6 +145,7 @@ def test_exp_gradient(self):
 
         prob = Problem()
         prob.minimize(exp(x) + exp(-y))
+        optyx_grad = _optyx_gradient(prob)
 
         def f(vals):
             return np.exp(vals[0]) + np.exp(-vals[1])
@@ -132,11 +158,14 @@ def f(vals):
 
         for point in test_points:
             fd_grad = finite_difference_gradient(f, point)
-            # Analytical: [exp(x), -exp(-y)]
             analytical = np.array([np.exp(point[0]), -np.exp(-point[1])])
+            ox_grad = optyx_grad(point)
 
-            error = np.linalg.norm(fd_grad - analytical)
-            assert error < 1e-5, f"Gradient error at {point}: {error}"
+            error_fd = np.linalg.norm(fd_grad - analytical)
+            assert error_fd < 1e-5, f"FD vs analytical error at {point}: {error_fd}"
+
+            error_ox = np.linalg.norm(ox_grad - analytical)
+            assert error_ox < 1e-5, f"Optyx vs analytical error at {point}: {error_ox}"
 
     def test_log_gradient(self):
         """f(x) = log(x) + x*log(x)"""
@@ -144,6 +173,7 @@ def test_log_gradient(self):
 
         prob = Problem()
         prob.minimize(log(x) + x * log(x))
+        optyx_grad = _optyx_gradient(prob)
 
         def f(vals):
             return np.log(vals[0]) + vals[0] * np.log(vals[0])
@@ -152,11 +182,14 @@ def f(vals):
 
         for point in test_points:
             fd_grad = finite_difference_gradient(f, point)
-            # Analytical: 1/x + log(x) + 1
             analytical = np.array([1 / point[0] + np.log(point[0]) + 1])
+            ox_grad = optyx_grad(point)
+
+            error_fd = np.abs(fd_grad[0] - analytical[0])
+            assert error_fd < 1e-5, f"FD vs analytical error at {point}: {error_fd}"
 
-            error = np.abs(fd_grad[0] - analytical[0])
-            assert error < 1e-5, f"Gradient error at {point}: {error}"
+            error_ox = np.abs(ox_grad[0] - analytical[0])
+            assert error_ox < 1e-5, f"Optyx vs analytical error at {point}: {error_ox}"
 
     def test_sqrt_gradient(self):
         """f(x,y) = sqrt(x² + y²)"""
@@ -165,6 +198,7 @@ def test_sqrt_gradient(self):
 
         prob = Problem()
         prob.minimize(sqrt(x**2 + y**2))
+        optyx_grad = _optyx_gradient(prob)
 
         def f(vals):
             return np.sqrt(vals[0] ** 2 + vals[1] ** 2)
@@ -178,11 +212,14 @@ def f(vals):
         for point in test_points:
             fd_grad = finite_difference_gradient(f, point, eps=1e-6)
             r = np.sqrt(point[0] ** 2 + point[1] ** 2)
-            # Analytical: [x/r, y/r]
             analytical = np.array([point[0] / r, point[1] / r])
+            ox_grad = optyx_grad(point)
 
-            error = np.linalg.norm(fd_grad - analytical)
-            assert error < 1e-4, f"Gradient error at {point}: {error}"
+            error_fd = np.linalg.norm(fd_grad - analytical)
+            assert error_fd < 1e-4, f"FD vs analytical error at {point}: {error_fd}"
+
+            error_ox = np.linalg.norm(ox_grad - analytical)
+            assert error_ox < 1e-4, f"Optyx vs analytical error at {point}: {error_ox}"
 
 
 class TestCompositeGradients:
@@ -195,6 +232,7 @@ def test_rosenbrock_gradient(self):
 
         prob = Problem()
         prob.minimize((1 - x) ** 2 + 100 * (y - x**2) ** 2)
+        optyx_grad = _optyx_gradient(prob)
 
         def f(vals):
             x, y = vals
@@ -209,16 +247,19 @@ def f(vals):
         for point in test_points:
             fd_grad = finite_difference_gradient(f, point)
             x, y = point
-            # Analytical: [-2(1-x) - 400x(y-x²), 200(y-x²)]
             analytical = np.array(
                 [
                     -2 * (1 - x) - 400 * x * (y - x**2),
                     200 * (y - x**2),
                 ]
             )
+            ox_grad = optyx_grad(point)
+
+            error_fd = np.linalg.norm(fd_grad - analytical)
+            assert error_fd < 1e-4, f"FD vs analytical error at {point}: {error_fd}"
 
-            error = np.linalg.norm(fd_grad - analytical)
-            assert error < 1e-4, f"Gradient error at {point}: {error}"
+            error_ox = np.linalg.norm(ox_grad - analytical)
+            assert error_ox < 1e-4, f"Optyx vs analytical error at {point}: {error_ox}"
 
     def test_mixed_expression_gradient(self):
         """f(x,y) = x*sin(y) + exp(x*y)"""
@@ -227,6 +268,7 @@ def test_mixed_expression_gradient(self):
 
         prob = Problem()
         prob.minimize(x * sin(y) + exp(x * y))
+        optyx_grad = _optyx_gradient(prob)
 
         def f(vals):
             x, y = vals
@@ -241,16 +283,19 @@ def f(vals):
         for point in test_points:
             fd_grad = finite_difference_gradient(f, point)
             x, y = point
-            # Analytical: [sin(y) + y*exp(xy), x*cos(y) + x*exp(xy)]
             analytical = np.array(
                 [
                     np.sin(y) + y * np.exp(x * y),
                     x * np.cos(y) + x * np.exp(x * y),
                 ]
             )
+            ox_grad = optyx_grad(point)
+
+            error_fd = np.linalg.norm(fd_grad - analytical)
+            assert error_fd < 1e-4, f"FD vs analytical error at {point}: {error_fd}"
 
-            error = np.linalg.norm(fd_grad - analytical)
-            assert error < 1e-4, f"Gradient error at {point}: {error}"
+            error_ox = np.linalg.norm(ox_grad - analytical)
+            assert error_ox < 1e-4, f"Optyx vs analytical error at {point}: {error_ox}"
 
 
 class TestConstraintGradients:
@@ -265,15 +310,25 @@ def test_linear_constraint_gradient(self):
         prob.minimize(x**2 + y**2)
         prob.subject_to(2 * x + 3 * y >= 5)
 
+        # Compile Optyx constraint Jacobian
+        c_expr = prob.constraints[0].expr
+        c_expr = flatten_expression(c_expr)
+        variables = prob.variables
+        c_jac_fn = compile_jacobian([c_expr], variables)
+
         def g(vals):
             return 2 * vals[0] + 3 * vals[1] - 5
 
         point = np.array([1.0, 1.0])
         fd_grad = finite_difference_gradient(g, point)
         analytical = np.array([2.0, 3.0])
+        ox_grad = c_jac_fn(point).flatten()
 
-        error = np.linalg.norm(fd_grad - analytical)
-        assert error < 1e-6, f"Gradient error: {error}"
+        error_fd = np.linalg.norm(fd_grad - analytical)
+        assert error_fd < 1e-6, f"FD vs analytical error: {error_fd}"
+
+        error_ox = np.linalg.norm(ox_grad - analytical)
+        assert error_ox < 1e-6, f"Optyx vs analytical error: {error_ox}"
 
     def test_nonlinear_constraint_gradient(self):
         """g(x,y) = x² + y² - 1"""
@@ -284,6 +339,12 @@ def test_nonlinear_constraint_gradient(self):
         prob.minimize(x + y)
         prob.subject_to(x**2 + y**2 <= 1)
 
+        # Compile Optyx constraint Jacobian
+        c_expr = prob.constraints[0].expr
+        c_expr = flatten_expression(c_expr)
+        variables = prob.variables
+        c_jac_fn = compile_jacobian([c_expr], variables)
+
         def g(vals):
             return vals[0] ** 2 + vals[1] ** 2 - 1
 
@@ -296,9 +357,13 @@ def g(vals):
         for point in test_points:
             fd_grad = finite_difference_gradient(g, point)
             analytical = 2 * point
+            ox_grad = c_jac_fn(point).flatten()
+
+            error_fd = np.linalg.norm(fd_grad - analytical)
+            assert error_fd < 1e-5, f"FD vs analytical error at {point}: {error_fd}"
 
-            error = np.linalg.norm(fd_grad - analytical)
-            assert error < 1e-5, f"Gradient error at {point}: {error}"
+            error_ox = np.linalg.norm(ox_grad - analytical)
+            assert error_ox < 1e-5, f"Optyx vs analytical error at {point}: {error_ox}"
 
 
 if __name__ == "__main__":
diff --git a/benchmarks/comparison/bench_vs_cvxpy.py b/benchmarks/comparison/bench_vs_cvxpy.py
index 11e3180..5bb7119 100644
--- a/benchmarks/comparison/bench_vs_cvxpy.py
+++ b/benchmarks/comparison/bench_vs_cvxpy.py
@@ -1,6 +1,8 @@
-"""Comparison benchmark: Optyx vs CVXPY.
+"""Ecosystem reference benchmark: Optyx vs CVXPY.
 
-Compares Optyx against CVXPY for convex problems.
+These timings are informative ecosystem references for convex problems.
+They are not strict apples-to-apples overhead claims because CVXPY has its
+own canonicalization pipeline and solver backend behavior.
 CVXPY is an optional dependency - tests gracefully skip if not installed.
 
 Install with: uv sync --extra benchmarks
@@ -31,7 +33,7 @@
 
 
 class TestLPComparison:
-    """Compare Optyx vs CVXPY for linear programs."""
+    """Reference timing comparison between Optyx and CVXPY LP workflows."""
 
     def test_small_lp(self):
         """Small LP: 2 variables, 2 constraints."""
@@ -70,7 +72,7 @@ def cvxpy_run():
             return cvxpy_prob.value
 
         result = compare_timing(optyx_run, cvxpy_run, n_warmup=3, n_runs=20)
-        print(f"\nSmall LP - Optyx vs CVXPY:\n{result}")
+        print(f"\nSmall LP Reference Timing - Optyx vs CVXPY:\n{result}")
 
     def test_medium_lp(self):
         """Medium LP: 20 variables, 15 constraints (VectorVariable)."""
@@ -111,11 +113,13 @@ def cvxpy_run():
             return cvxpy_prob.value
 
         result = compare_timing(optyx_run, cvxpy_run, n_warmup=3, n_runs=20)
-        print(f"\nMedium LP (n=20) - Optyx VectorVariable vs CVXPY:\n{result}")
+        print(
+            f"\nMedium LP Reference Timing (n=20) - Optyx VectorVariable vs CVXPY:\n{result}"
+        )
 
 
 class TestQPComparison:
-    """Compare Optyx vs CVXPY for quadratic programs."""
+    """Reference timing comparison between Optyx and CVXPY QP workflows."""
 
     def test_simple_qp(self):
         """Simple QP: min x² + y² s.t. x + y >= 1."""
diff --git a/benchmarks/comparison/bench_vs_pyomo.py b/benchmarks/comparison/bench_vs_pyomo.py
index af5e0d4..4d33d8e 100644
--- a/benchmarks/comparison/bench_vs_pyomo.py
+++ b/benchmarks/comparison/bench_vs_pyomo.py
@@ -1,6 +1,8 @@
-"""Comparison benchmark: Optyx vs Pyomo.
+"""Ecosystem reference benchmark: Optyx vs Pyomo.
 
-Compares Optyx against Pyomo for NLP problems.
+These timings are informative ecosystem references for NLP and LP workflows.
+They are not strict apples-to-apples overhead claims because Pyomo depends on
+its own modeling pipeline and whichever backend solver is available.
 Pyomo is an optional dependency - tests gracefully skip if not installed.
 
 Install with: uv sync --extra benchmarks
@@ -59,7 +61,7 @@ def get_pyomo_solver():
 
 
 class TestNLPComparison:
-    """Compare Optyx vs Pyomo for nonlinear programs."""
+    """Reference timing comparison between Optyx and Pyomo NLP workflows."""
 
     def test_rosenbrock(self):
         """Rosenbrock function comparison."""
@@ -98,7 +100,7 @@ def pyomo_run():
             return value(model.obj)
 
         result = compare_timing(optyx_run, pyomo_run, n_warmup=2, n_runs=10)
-        print(f"\nRosenbrock - Optyx vs Pyomo:\n{result}")
+        print(f"\nRosenbrock Reference Timing - Optyx vs Pyomo:\n{result}")
 
     def test_constrained_nlp(self):
         """Constrained NLP comparison (vectorized)."""
@@ -135,11 +137,11 @@ def pyomo_run():
             return value(model.obj)
 
         result = compare_timing(optyx_run, pyomo_run, n_warmup=2, n_runs=10)
-        print(f"\nConstrained NLP - Optyx vs Pyomo:\n{result}")
+        print(f"\nConstrained NLP Reference Timing - Optyx vs Pyomo:\n{result}")
 
 
 class TestLPComparison:
-    """Compare Optyx vs Pyomo for linear programs."""
+    """Reference timing comparison between Optyx and Pyomo LP workflows."""
 
     def test_simple_lp(self):
         """Simple LP comparison (vectorized)."""
@@ -177,7 +179,7 @@ def pyomo_run():
             return value(model.obj)
 
         result = compare_timing(optyx_run, pyomo_run, n_warmup=2, n_runs=10)
-        print(f"\nSimple LP - Optyx vs Pyomo:\n{result}")
+        print(f"\nSimple LP Reference Timing - Optyx vs Pyomo:\n{result}")
 
 
 class TestSyntaxComparison:
diff --git a/benchmarks/comparison/bench_vs_scipy.py b/benchmarks/comparison/bench_vs_scipy.py
index 7bdd0af..50331da 100644
--- a/benchmarks/comparison/bench_vs_scipy.py
+++ b/benchmarks/comparison/bench_vs_scipy.py
@@ -1,8 +1,11 @@
-"""Comparison benchmark: Optyx vs SciPy with vectorized operations.
+"""Cached solve comparison: Optyx vs SciPy with vectorized operations.
+
+These benchmarks focus on solve-path performance after problem construction.
+They are useful for cached solve throughput and syntax comparisons, but they
+are not end-to-end build+solve benchmarks.
 
-Direct comparison with raw SciPy for both LP and NLP problems.
 Uses VectorVariable and MatrixVariable for optimal performance.
-Generates plots comparing performance across problem sizes.
+Generates plots comparing cached solve performance across problem sizes.
 
 Key features demonstrated:
 1. VectorVariable: Efficient 1D variable arrays with @ syntax
@@ -151,15 +154,15 @@ class TestScalingComparison:
     """Generate scaling comparison plots."""
 
     def test_lp_scaling_plot(self):
-        """Generate LP scaling comparison plot using VectorVariable.
+        """Generate cached LP solve scaling plot using VectorVariable.
 
         Scales up to n=2,000 for plot (larger sizes shown in text output).
         """
         sizes = [100, 500, 1000, 2000]
-        data = ScalingData(label="LP (VectorVariable)")
+        data = ScalingData(label="LP (VectorVariable, cached solve-only)")
 
         print("\n" + "=" * 70)
-        print("LP SCALING PLOT: Optyx VectorVariable vs SciPy (n up to 2,000)")
+        print("LP CACHED SOLVE SCALING: Optyx VectorVariable vs SciPy (n up to 2,000)")
         print("=" * 70)
 
         for n in sizes:
@@ -177,12 +180,10 @@ def test_lp_scaling_plot(self):
             for i in range(m):
                 prob.subject_to(A[i] @ x <= b[i])
 
-            prob.solve()  # Warm cache
-
             # Reduce runs for large problems (solve time dominates)
             n_runs = 5 if n <= 2000 else 3 if n <= 5000 else 2
             optyx_timing = time_function(
-                lambda: prob.solve(), n_warmup=1, n_runs=n_runs
+                lambda: prob.solve(), n_warmup=2, n_runs=n_runs
             )
 
             # SciPy
@@ -191,28 +192,37 @@ def test_lp_scaling_plot(self):
                 lambda c=c, A=A, b=b, bounds=bounds: linprog(
                     -c, A_ub=A, b_ub=b, bounds=bounds, method="highs"
                 ),
-                n_warmup=1,
+                n_warmup=2,
                 n_runs=n_runs,
             )
 
+            optyx_spread = max(
+                optyx_timing.median_ms - optyx_timing.p05_ms,
+                optyx_timing.p95_ms - optyx_timing.median_ms,
+            )
+            scipy_spread = max(
+                scipy_timing.median_ms - scipy_timing.p05_ms,
+                scipy_timing.p95_ms - scipy_timing.median_ms,
+            )
+
             data.add_point(
                 n,
-                optyx_timing.mean_ms,
-                optyx_timing.std_ms,
-                scipy_timing.mean_ms,
-                scipy_timing.std_ms,
+                optyx_timing.median_ms,
+                optyx_spread,
+                scipy_timing.median_ms,
+                scipy_spread,
             )
 
-            ratio = optyx_timing.mean_ms / scipy_timing.mean_ms
+            ratio = optyx_timing.median_ms / scipy_timing.median_ms
             print(
-                f"n={n:5d}: Optyx={optyx_timing.mean_ms:8.1f}ms, "
-                f"SciPy={scipy_timing.mean_ms:8.1f}ms, "
-                f"ratio={ratio:.2f}x"
+                f"n={n:5d}: Optyx median={optyx_timing.median_ms:8.1f}ms, "
+                f"SciPy median={scipy_timing.median_ms:8.1f}ms, "
+                f"median ratio={ratio:.2f}x"
             )
 
         plot_scaling_comparison(
             data,
-            title="LP Scaling: Optyx VectorVariable vs SciPy (n up to 2,000)",
+            title="LP Cached Solve Scaling: Optyx VectorVariable vs SciPy",
             save_path=RESULTS_DIR / "scipy_lp_scaling.png",
         )
 
@@ -221,12 +231,12 @@ class TestOverheadBreakdown:
     """Analyze overhead by problem type."""
 
     def test_overhead_breakdown_plot(self):
-        """Generate overhead breakdown plot across problem types."""
+        """Generate cached solve overhead breakdown plot across problem types."""
         categories = []
         overheads = []
 
         print("\n" + "=" * 70)
-        print("OVERHEAD BREAKDOWN BY PROBLEM TYPE")
+        print("CACHED SOLVE OVERHEAD BREAKDOWN BY PROBLEM TYPE")
         print("=" * 70)
 
         # Small LP
@@ -239,7 +249,6 @@ def test_overhead_breakdown_plot(self):
         prob.subject_to(A[0] @ x <= b[0])
         prob.subject_to(A[1] @ x <= b[1])
 
-        prob.solve()
         optyx_t = time_function(lambda: prob.solve(), n_warmup=2, n_runs=50)
         scipy_t = time_function(
             lambda: linprog(
@@ -249,9 +258,9 @@ def test_overhead_breakdown_plot(self):
             n_runs=50,
         )
         categories.append("Small LP (n=2)")
-        overheads.append(optyx_t.mean_ms / scipy_t.mean_ms)
+        overheads.append(optyx_t.median_ms / scipy_t.median_ms)
         print(
-            f"Small LP (n=2): {optyx_t.mean_ms:.2f}ms vs {scipy_t.mean_ms:.2f}ms = {overheads[-1]:.2f}x"
+            f"Small LP (n=2): median {optyx_t.median_ms:.2f}ms vs {scipy_t.median_ms:.2f}ms = {overheads[-1]:.2f}x"
         )
 
         # Medium LP with VectorVariable
@@ -266,7 +275,6 @@ def test_overhead_breakdown_plot(self):
         for i in range(m):
             prob.subject_to(A_mat[i] @ x <= b_vec[i])
 
-        prob.solve()
         optyx_t = time_function(lambda: prob.solve(), n_warmup=2, n_runs=20)
         bounds = [(0, 1)] * n
         scipy_t = time_function(
@@ -277,9 +285,9 @@ def test_overhead_breakdown_plot(self):
             n_runs=20,
         )
         categories.append("Medium LP (n=500)")
-        overheads.append(optyx_t.mean_ms / scipy_t.mean_ms)
+        overheads.append(optyx_t.median_ms / scipy_t.median_ms)
         print(
-            f"Medium LP (n=500): {optyx_t.mean_ms:.2f}ms vs {scipy_t.mean_ms:.2f}ms = {overheads[-1]:.2f}x"
+            f"Medium LP (n=500): median {optyx_t.median_ms:.2f}ms vs {scipy_t.median_ms:.2f}ms = {overheads[-1]:.2f}x"
         )
 
         # Large LP with VectorVariable
@@ -294,20 +302,19 @@ def test_overhead_breakdown_plot(self):
         for i in range(m):
             prob.subject_to(A_mat[i] @ x <= b_vec[i])
 
-        prob.solve()
-        optyx_t = time_function(lambda: prob.solve(), n_warmup=1, n_runs=10)
+        optyx_t = time_function(lambda: prob.solve(), n_warmup=2, n_runs=10)
         bounds = [(0, 1)] * n
         scipy_t = time_function(
             lambda c=c, A_mat=A_mat, b_vec=b_vec, bounds=bounds: linprog(
                 -c, A_ub=A_mat, b_ub=b_vec, bounds=bounds, method="highs"
             ),
-            n_warmup=1,
+            n_warmup=2,
             n_runs=10,
         )
         categories.append("Large LP (n=2000)")
-        overheads.append(optyx_t.mean_ms / scipy_t.mean_ms)
+        overheads.append(optyx_t.median_ms / scipy_t.median_ms)
         print(
-            f"Large LP (n=2000): {optyx_t.mean_ms:.2f}ms vs {scipy_t.mean_ms:.2f}ms = {overheads[-1]:.2f}x"
+            f"Large LP (n=2000): median {optyx_t.median_ms:.2f}ms vs {scipy_t.median_ms:.2f}ms = {overheads[-1]:.2f}x"
         )
 
         # Print results
@@ -319,16 +326,16 @@ def test_overhead_breakdown_plot(self):
         plot_overhead_breakdown(
             categories,
             overheads,
-            title="Optyx Overhead vs SciPy by Problem Type",
+            title="Optyx Cached Solve Overhead vs SciPy by Problem Type",
             save_path=RESULTS_DIR / "bench_vs_scipy_overhead_breakdown.png",
         )
 
 
 class TestPortfolioComparison:
-    """Portfolio optimization syntax and performance comparison."""
+    """Portfolio optimization syntax and cached solve comparison."""
 
     def test_portfolio_vectorized(self):
-        """Portfolio LP optimization with VectorVariable at scale.
+        """Portfolio LP cached solve comparison with VectorVariable at scale.
 
         Tests linear portfolio optimization (maximize expected return)
         to demonstrate VectorVariable performance. Uses LP formulation
@@ -337,7 +344,7 @@ def test_portfolio_vectorized(self):
         sizes = [50, 100, 200, 500, 1000]
 
         print("\n" + "=" * 70)
-        print("PORTFOLIO LP: Optyx VectorVariable vs SciPy (maximize return)")
+        print("PORTFOLIO LP CACHED SOLVE: Optyx VectorVariable vs SciPy")
         print("=" * 70)
 
         for n in sizes:
@@ -365,9 +372,6 @@ def test_portfolio_vectorized(self):
 
             n_runs = 15 if n <= 200 else 10 if n <= 500 else 5
 
-            # Warmup
-            prob.solve()
-
             optyx_timing = time_function(
                 lambda p=prob: p.solve(), n_warmup=2, n_runs=n_runs
             )
@@ -383,10 +387,10 @@ def test_portfolio_vectorized(self):
                 n_runs=n_runs,
             )
 
-            ratio = optyx_timing.mean_ms / scipy_timing.mean_ms
+            ratio = optyx_timing.median_ms / scipy_timing.median_ms
             print(
-                f"n={n:4d} assets: Optyx={optyx_timing.mean_ms:8.1f}ms, "
-                f"SciPy={scipy_timing.mean_ms:8.1f}ms, ratio={ratio:.2f}x"
+                f"n={n:4d} assets: Optyx median={optyx_timing.median_ms:8.1f}ms, "
+                f"SciPy median={scipy_timing.median_ms:8.1f}ms, median ratio={ratio:.2f}x"
             )
 
 
@@ -430,11 +434,11 @@ def build_vector():
         print("-" * 70)
 
     def test_lp_solve_comparison(self):
-        """Compare VectorVariable solve performance vs SciPy."""
+        """Compare cached VectorVariable solve performance vs SciPy."""
         sizes = [100, 500, 1000, 2000]
 
         print("\n" + "=" * 70)
-        print("LP SOLVE COMPARISON: VectorVariable vs SciPy")
+        print("LP CACHED SOLVE COMPARISON: VectorVariable vs SciPy")
         print("=" * 70)
         print(f"{'n':>6} | {'Optyx':>10} | {'SciPy':>10} | {'Ratio':>10}")
         print("-" * 70)
@@ -455,10 +459,7 @@ def test_lp_solve_comparison(self):
             for i in range(m):
                 prob_vec.subject_to(A[i] @ x_vec <= b[i])
 
-            # Warm up
-            prob_vec.solve()
-
-            # Time solves
+            # Time solves (n_warmup handles cache warming)
             vector_timing = time_function(
                 lambda: prob_vec.solve(), n_warmup=2, n_runs=10
             )
@@ -468,11 +469,11 @@ def test_lp_solve_comparison(self):
                 n_runs=10,
             )
 
-            ratio = vector_timing.mean_ms / scipy_timing.mean_ms
+            ratio = vector_timing.median_ms / scipy_timing.median_ms
 
             print(
-                f"{n:>6} | {vector_timing.mean_ms:>9.2f}ms | "
-                f"{scipy_timing.mean_ms:>9.2f}ms | {ratio:>9.2f}x"
+                f"{n:>6} | {vector_timing.median_ms:>9.2f}ms | "
+                f"{scipy_timing.median_ms:>9.2f}ms | {ratio:>9.2f}x"
             )
 
         print("-" * 70)
@@ -548,14 +549,14 @@ def build_symmetric():
 
 
 class TestLargeScaleLP:
-    """Large-scale LP benchmarks up to n=5,000."""
+    """Large-scale LP cached solve benchmarks up to n=5,000."""
 
     def test_very_large_lp_vectorvariable(self):
-        """Solve very large LP using VectorVariable."""
+        """Benchmark very large cached LP solves using VectorVariable."""
         sizes = [500, 1000, 2000, 5000]
 
         print("\n" + "=" * 70)
-        print("LARGE-SCALE LP: VectorVariable vs SciPy (n up to 5,000)")
+        print("LARGE-SCALE LP CACHED SOLVE: VectorVariable vs SciPy")
         print("=" * 70)
         print(f"{'n':>8} | {'m':>6} | {'Build':>10} | {'Solve':>10} | {'SciPy':>10}")
         print("-" * 70)
@@ -582,22 +583,21 @@ def test_very_large_lp_vectorvariable(self):
                 prob.subject_to(A[i] @ x <= b[i])
 
             # Solve timing (reduce runs for large n)
-            prob.solve()  # Warm up
             n_runs = 3 if n <= 2000 else 2
             solve_timing = time_function(
-                lambda: prob.solve(), n_warmup=1, n_runs=n_runs
+                lambda: prob.solve(), n_warmup=2, n_runs=n_runs
             )
 
             # SciPy timing
             scipy_timing = time_function(
                 lambda: linprog(-c, A_ub=A, b_ub=b, bounds=bounds_list, method="highs"),
-                n_warmup=1,
+                n_warmup=2,
                 n_runs=n_runs,
             )
 
             print(
                 f"{n:>8} | {m:>6} | {build_start.mean_ms:>9.1f}ms | "
-                f"{solve_timing.mean_ms:>9.1f}ms | {scipy_timing.mean_ms:>9.1f}ms"
+                f"{solve_timing.median_ms:>9.1f}ms | {scipy_timing.median_ms:>9.1f}ms"
             )
 
         print("-" * 70)
@@ -616,11 +616,11 @@ class TestPortfolioVectorized:
     """Portfolio optimization with VectorVariable and MatrixParameter."""
 
     def test_portfolio_scaling(self):
-        """Portfolio optimization at various scales."""
+        """Portfolio cached solve benchmark at various scales."""
         sizes = [10, 50, 100, 200, 500]
 
         print("\n" + "=" * 70)
-        print("PORTFOLIO OPTIMIZATION: VectorVariable Scaling")
+        print("PORTFOLIO OPTIMIZATION: Cached Solve Scaling")
         print("=" * 70)
         print(f"{'n assets':>10} | {'Build':>10} | {'Solve':>10} | {'SciPy':>10}")
         print("-" * 70)
@@ -676,7 +676,7 @@ def grad(weights):
 
             print(
                 f"{n:>10} | {build_timing.mean_ms:>9.1f}ms | "
-                f"{solve_timing.mean_ms:>9.1f}ms | {scipy_timing.mean_ms:>9.1f}ms"
+                f"{solve_timing.median_ms:>9.1f}ms | {scipy_timing.median_ms:>9.1f}ms"
             )
 
         print("-" * 70)
diff --git a/benchmarks/performance/overhead_analysis.py b/benchmarks/performance/overhead_analysis.py
index daa7c5e..33b1669 100644
--- a/benchmarks/performance/overhead_analysis.py
+++ b/benchmarks/performance/overhead_analysis.py
@@ -2,7 +2,10 @@
 
 Measures the overhead of using Optyx compared to calling SciPy directly.
 Uses numpy vectorization for optimal performance.
-Target: < 1.5x overhead for LP (cached), < 2x for NLP.
+
+Acceptance thresholds in this file:
+- small LP and NLP reference cases: < 3.0x median overhead
+- medium LP cached case: < 2.0x median overhead
 """
 
 from __future__ import annotations
@@ -53,10 +56,10 @@ def scipy_solve():
 
         result = compare_timing(optyx_solve, scipy_solve, n_warmup=3, n_runs=20)
 
-        print(f"\nSmall LP Overhead:\n{result}")
-        assert (
-            result.overhead_ratio < 3.0
-        ), f"Too much overhead: {result.overhead_ratio:.2f}x"
+        print(f"\nSmall LP Cached Overhead Reference:\n{result}")
+        assert result.overhead_ratio < 3.0, (
+            f"Too much overhead: {result.overhead_ratio:.2f}x"
+        )
 
     def test_medium_lp_overhead(self):
         """Medium LP (20 vars, 15 constraints) with vectorized operations."""
@@ -86,10 +89,10 @@ def scipy_solve():
 
         result = compare_timing(optyx_solve, scipy_solve, n_warmup=3, n_runs=20)
 
-        print(f"\nMedium LP Overhead:\n{result}")
-        assert (
-            result.overhead_ratio < 2.0
-        ), f"Too much overhead: {result.overhead_ratio:.2f}x"
+        print(f"\nMedium LP Cached Overhead Reference:\n{result}")
+        assert result.overhead_ratio < 2.0, (
+            f"Too much overhead: {result.overhead_ratio:.2f}x"
+        )
 
 
 class TestNLPOverhead:
@@ -125,13 +128,13 @@ def scipy_solve():
 
         result = compare_timing(optyx_solve, scipy_solve, n_warmup=3, n_runs=20)
 
-        print(f"\nRosenbrock Overhead:\n{result}")
+        print(f"\nRosenbrock Cached Overhead Reference:\n{result}")
 
         # NLP overhead is justified (autodiff vs manual gradients)
         # But should still be reasonable
-        assert (
-            result.overhead_ratio < 3.0
-        ), f"Too much overhead: {result.overhead_ratio:.2f}x"
+        assert result.overhead_ratio < 3.0, (
+            f"Too much overhead: {result.overhead_ratio:.2f}x"
+        )
 
     def test_constrained_nlp_overhead(self):
         """Constrained NLP overhead."""
@@ -174,11 +177,11 @@ def scipy_solve():
 
         result = compare_timing(optyx_solve, scipy_solve, n_warmup=3, n_runs=20)
 
-        print(f"\nConstrained NLP Overhead:\n{result}")
+        print(f"\nConstrained NLP Cached Overhead Reference:\n{result}")
 
-        assert (
-            result.overhead_ratio < 3.0
-        ), f"Too much overhead: {result.overhead_ratio:.2f}x"
+        assert result.overhead_ratio < 3.0, (
+            f"Too much overhead: {result.overhead_ratio:.2f}x"
+        )
 
 
 if __name__ == "__main__":
diff --git a/benchmarks/performance/resolve_timing.py b/benchmarks/performance/resolve_timing.py
index 0fe08e1..7b07799 100644
--- a/benchmarks/performance/resolve_timing.py
+++ b/benchmarks/performance/resolve_timing.py
@@ -1,7 +1,7 @@
 """Performance benchmark: Repeated solve timing.
 
 Measures the benefit of caching when solving the same problem multiple times.
-Target: > 3x speedup on repeated solves.
+Target: > 2x minimum speedup on repeated solves, with > 3x as the aspirational goal.
 """
 
 from __future__ import annotations
@@ -23,7 +23,7 @@ class TestLPResolveTiming:
     def test_lp_cache_benefit(self):
         """Measure cache benefit on LP repeated solves.
 
-        Target: > 3x speedup on cached solves.
+        Target: > 2x minimum speedup on cached solves, with > 3x aspirational.
         """
         n, m = 20, 15
         np.random.seed(42)
@@ -51,15 +51,20 @@ def test_lp_cache_benefit(self):
             sol = prob.solve()
             times_cached.append((time.perf_counter() - start) * 1000)
 
-        mean_cached = np.mean(times_cached)
-        std_cached = np.std(times_cached)
+        times_cached_arr = np.array(times_cached)
+        median_cached = float(np.median(times_cached_arr))
+        p05_cached = float(np.percentile(times_cached_arr, 5))
+        p95_cached = float(np.percentile(times_cached_arr, 95))
 
-        speedup = first_solve_ms / mean_cached if mean_cached > 0 else float("inf")
+        speedup = first_solve_ms / median_cached if median_cached > 0 else float("inf")
 
         print("\nLP Cache Benefit:")
         print(f"  First solve: {first_solve_ms:.3f} ms")
-        print(f"  Cached mean: {mean_cached:.3f} ± {std_cached:.3f} ms")
-        print(f"  Speedup: {speedup:.2f}x")
+        print(
+            f"  Cached median: {median_cached:.3f} ms "
+            f"(p05-p95: {p05_cached:.3f}-{p95_cached:.3f} ms)"
+        )
+        print(f"  Median speedup: {speedup:.2f}x")
 
         assert sol.is_optimal
         assert speedup > 2.0, f"Cache speedup too low: {speedup:.2f}x"
@@ -97,10 +102,12 @@ def test_lp_vs_nlp_resolve(self):
         print("\nLP vs NLP Resolve:")
         print(f"  LP:  {lp_timing}")
         print(f"  NLP: {nlp_timing}")
-        print(f"  LP advantage: {nlp_timing.mean_ms / lp_timing.mean_ms:.2f}x faster")
+        print(
+            f"  LP advantage: {nlp_timing.median_ms / lp_timing.median_ms:.2f}x faster"
+        )
 
         # LP should be faster than NLP due to caching
-        assert lp_timing.mean_ms < nlp_timing.mean_ms
+        assert lp_timing.median_ms < nlp_timing.median_ms
 
 
 class TestNLPResolveTiming:
@@ -128,15 +135,20 @@ def test_nlp_compiled_cache(self):
             sol = prob.solve(x0=x0)
             times_cached.append((time.perf_counter() - start) * 1000)
 
-        mean_cached = np.mean(times_cached)
-        std_cached = np.std(times_cached)
+        times_cached_arr = np.array(times_cached)
+        median_cached = float(np.median(times_cached_arr))
+        p05_cached = float(np.percentile(times_cached_arr, 5))
+        p95_cached = float(np.percentile(times_cached_arr, 95))
 
-        speedup = first_solve_ms / mean_cached if mean_cached > 0 else float("inf")
+        speedup = first_solve_ms / median_cached if median_cached > 0 else float("inf")
 
         print("\nNLP Compiled Cache Benefit:")
         print(f"  First solve: {first_solve_ms:.3f} ms")
-        print(f"  Cached mean: {mean_cached:.3f} ± {std_cached:.3f} ms")
-        print(f"  Speedup: {speedup:.2f}x")
+        print(
+            f"  Cached median: {median_cached:.3f} ms "
+            f"(p05-p95: {p05_cached:.3f}-{p95_cached:.3f} ms)"
+        )
+        print(f"  Median speedup: {speedup:.2f}x")
 
         assert sol.is_optimal
 
diff --git a/benchmarks/performance/scaling_analysis.py b/benchmarks/performance/scaling_analysis.py
index cc1115f..db83f90 100644
--- a/benchmarks/performance/scaling_analysis.py
+++ b/benchmarks/performance/scaling_analysis.py
@@ -122,8 +122,7 @@ def test_lp_vs_scipy_scaling(self):
             for i in range(m):
                 prob.subject_to(A[i] @ x <= b[i])
 
-            # Warm up and time
-            prob.solve()  # Warm cache
+            # Warm up and time (n_warmup handles cache warming for both)
             optyx_timing = time_function(lambda: prob.solve(), n_warmup=2, n_runs=20)
 
             # SciPy
@@ -360,8 +359,7 @@ def test_all_problem_types_scaling(self):
             for i in range(m):
                 prob.subject_to(A[i] @ x <= b[i])
 
-            prob.solve()  # Warm
-            timing = time_function(lambda: prob.solve(), n_warmup=0, n_runs=10)
+            timing = time_function(lambda: prob.solve(), n_warmup=2, n_runs=10)
             lp_data.add_point(n, timing.mean_ms, timing.std_ms)
 
         # Quadratic NLP data
diff --git a/benchmarks/performance/sparse_solve_end_to_end.py b/benchmarks/performance/sparse_solve_end_to_end.py
new file mode 100644
index 0000000..6c9f6d4
--- /dev/null
+++ b/benchmarks/performance/sparse_solve_end_to_end.py
@@ -0,0 +1,192 @@
+"""Performance benchmark: end-to-end sparse solve path.
+
+This benchmark exercises the sparse trust-constr Jacobian path through the
+solver runtime on a sparse chain-constrained quadratic problem.
+
+It compares two solver paths on the same sparse NLP model:
+- trust-constr: uses Optyx's vector-valued sparse Jacobian path
+- SLSQP: uses the scalar constraint callback path
+
+This is a solver-path reference benchmark, not a strict apples-to-apples
+algorithm comparison.
+
+Usage:
+    uv run python benchmarks/performance/sparse_solve_end_to_end.py
+
+Outputs:
+    - sparse_solve_end_to_end.png
+    - sparse_solve_end_to_end_results.json
+    - sparse_solve_end_to_end_metadata.json
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy import sparse
+
+from optyx import Problem, Variable
+from optyx.solvers.scipy_solver import _build_solver_cache
+
+sys.path.insert(0, str(__file__).rsplit("/", 2)[0])
+from utils import RESULTS_DIR, time_function, write_benchmark_metadata
+
+
+def build_sparse_chain_problem(n: int) -> tuple[Problem, np.ndarray]:
+    """Build a sparse nonlinear chain-constrained problem."""
+    variables = [Variable(f"x{i}", lb=0.0, ub=2.0) for i in range(n)]
+
+    prob = Problem(name=f"sparse_chain_{n}")
+    prob.minimize(sum((var - 1.0) ** 2 for var in variables))
+
+    for i in range(n - 1):
+        prob.subject_to(variables[i + 1] - variables[i] >= 0)
+    prob.subject_to(variables[0] <= 0.5)
+    prob.subject_to(variables[-1].eq(1.0))
+
+    x0 = np.linspace(0.2, 1.0, n)
+    return prob, x0
+
+
+def inspect_sparse_jacobian(n: int) -> tuple[str, int, float]:
+    """Inspect the cached sparse Jacobian format for a given sparse problem."""
+    prob, x0 = build_sparse_chain_problem(n)
+    cache = _build_solver_cache(prob, prob.variables)
+    jac = cache["sparse_constraint_jac_fn"](x0)
+
+    if sparse.issparse(jac):
+        nnz = int(jac.nnz)
+        density = (
+            nnz / (jac.shape[0] * jac.shape[1])
+            if jac.shape[0] and jac.shape[1]
+            else 0.0
+        )
+        return type(jac).__name__, nnz, density
+
+    nnz = int(np.count_nonzero(jac))
+    density = nnz / jac.size if jac.size else 0.0
+    return type(jac).__name__, nnz, density
+
+
+def measure_cold_end_to_end(method: str, n: int, n_runs: int = 3):
+    """Measure cold build+solve timing for a solver path."""
+
+    def build_and_solve():
+        prob, x0 = build_sparse_chain_problem(n)
+        sol = prob.solve(method=method, x0=x0, warm_start=False)
+        assert sol.is_optimal
+        return sol
+
+    return time_function(build_and_solve, n_warmup=0, n_runs=n_runs)
+
+
+def measure_warm_cached(method: str, n: int, n_runs: int = 5):
+    """Measure cached solve timing for a solver path."""
+    prob, x0 = build_sparse_chain_problem(n)
+    sol = prob.solve(method=method, x0=x0, warm_start=False)
+    assert sol.is_optimal
+
+    return time_function(
+        lambda p=prob, x0=x0: p.solve(method=method, x0=x0, warm_start=False),
+        n_warmup=1,
+        n_runs=n_runs,
+    )
+
+
+def main() -> None:
+    """Run the sparse solver-path benchmark."""
+    RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    metadata_path = write_benchmark_metadata(
+        RESULTS_DIR,
+        file_name="sparse_solve_end_to_end_metadata.json",
+        extra={"benchmark_suite": "sparse_solve_end_to_end"},
+    )
+
+    sizes = [20, 40, 80, 120]
+    results: list[dict[str, float | int | str]] = []
+
+    trust_cold = []
+    trust_warm = []
+    slsqp_cold = []
+    slsqp_warm = []
+
+    print("=" * 72)
+    print("SPARSE SOLVE END-TO-END BENCHMARK")
+    print("=" * 72)
+    print("trust-constr uses the sparse batched Jacobian path.")
+    print("SLSQP uses the scalar constraint callback path.")
+    print(f"Metadata saved to: {metadata_path}")
+    print()
+    print(
+        f"{'n':>6} | {'Jac':>10} | {'nnz':>8} | {'Cold TC':>10} | {'Cold SLSQP':>11} | {'Warm TC':>10} | {'Warm SLSQP':>11}"
+    )
+    print("-" * 72)
+
+    for n in sizes:
+        jac_type, nnz, density = inspect_sparse_jacobian(n)
+        cold_tc = measure_cold_end_to_end("trust-constr", n)
+        cold_slsqp = measure_cold_end_to_end("SLSQP", n)
+        warm_tc = measure_warm_cached("trust-constr", n)
+        warm_slsqp = measure_warm_cached("SLSQP", n)
+
+        trust_cold.append(cold_tc.median_ms)
+        trust_warm.append(warm_tc.median_ms)
+        slsqp_cold.append(cold_slsqp.median_ms)
+        slsqp_warm.append(warm_slsqp.median_ms)
+
+        results.append(
+            {
+                "n": n,
+                "jacobian_type": jac_type,
+                "nnz": nnz,
+                "density": density,
+                "cold_trust_constr_median_ms": cold_tc.median_ms,
+                "cold_slsqp_median_ms": cold_slsqp.median_ms,
+                "warm_trust_constr_median_ms": warm_tc.median_ms,
+                "warm_slsqp_median_ms": warm_slsqp.median_ms,
+            }
+        )
+
+        print(
+            f"{n:6d} | {jac_type:>10} | {nnz:8d} | {cold_tc.median_ms:10.1f} | "
+            f"{cold_slsqp.median_ms:11.1f} | {warm_tc.median_ms:10.1f} | {warm_slsqp.median_ms:11.1f}"
+        )
+
+    print("-" * 72)
+
+    output_path = RESULTS_DIR / "sparse_solve_end_to_end_results.json"
+    output_path.write_text(json.dumps(results, indent=2) + "\n")
+
+    fig, axes = plt.subplots(1, 2, figsize=(12, 4.5))
+
+    axes[0].plot(sizes, trust_cold, marker="o", label="trust-constr (sparse)")
+    axes[0].plot(sizes, slsqp_cold, marker="o", label="SLSQP (scalar constraints)")
+    axes[0].set_title("Cold End-to-End Build + Solve")
+    axes[0].set_xlabel("Variables")
+    axes[0].set_ylabel("Median time (ms)")
+    axes[0].grid(True, alpha=0.3)
+    axes[0].legend()
+
+    axes[1].plot(sizes, trust_warm, marker="o", label="trust-constr (sparse)")
+    axes[1].plot(sizes, slsqp_warm, marker="o", label="SLSQP (scalar constraints)")
+    axes[1].set_title("Warm Cached Solve-Only")
+    axes[1].set_xlabel("Variables")
+    axes[1].set_ylabel("Median time (ms)")
+    axes[1].grid(True, alpha=0.3)
+    axes[1].legend()
+
+    fig.suptitle("Sparse Chain NLP: Solver-Path Reference Benchmark", fontsize=12)
+    plt.tight_layout()
+    plot_path = RESULTS_DIR / "sparse_solve_end_to_end.png"
+    plt.savefig(plot_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+
+    print(f"Results saved to: {output_path}")
+    print(f"Plot saved to: {plot_path}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/benchmarks/results/bench_vs_scipy_overhead_breakdown.png b/benchmarks/results/bench_vs_scipy_overhead_breakdown.png
index 5e39f30..79d72f7 100644
Binary files a/benchmarks/results/bench_vs_scipy_overhead_breakdown.png and b/benchmarks/results/bench_vs_scipy_overhead_breakdown.png differ
diff --git a/benchmarks/results/benchmark_metadata.json b/benchmarks/results/benchmark_metadata.json
new file mode 100644
index 0000000..bbc9d53
--- /dev/null
+++ b/benchmarks/results/benchmark_metadata.json
@@ -0,0 +1,13 @@
+{
+  "benchmark_suite": "run_benchmarks",
+  "cpu_count": 2,
+  "machine": "x86_64",
+  "numpy_version": "2.3.5",
+  "optyx_version": "1.3.0",
+  "platform": "Linux-6.8.0-1044-azure-x86_64-with-glibc2.39",
+  "processor": "x86_64",
+  "python_implementation": "CPython",
+  "python_version": "3.12.1",
+  "scipy_version": "1.16.3",
+  "timestamp_utc": "2026-04-21T10:21:56.933482+00:00"
+}
diff --git a/benchmarks/results/benchmark_output.txt b/benchmarks/results/benchmark_output.txt
index 857d75a..0393f39 100644
--- a/benchmarks/results/benchmark_output.txt
+++ b/benchmarks/results/benchmark_output.txt
@@ -13,6 +13,7 @@ Compared against SciPy (which has no build phase).
 
 Results will be saved to: /workspaces/optix/benchmarks/results
 Terminal output being saved to: /workspaces/optix/benchmarks/results/benchmark_output.txt
+Benchmark metadata saved to: /workspaces/optix/benchmarks/results/benchmark_metadata.json
 
 ================================================================================
 LP SCALING BENCHMARK (End-to-End)
@@ -21,100 +22,20 @@ LP SCALING BENCHMARK (End-to-End)
 Measures: Build (vars + problem + constraints) + Solve
 Compared against: SciPy linprog (no build phase)
 
---- Loop-based Variable (n ≤ 100, slow cold solve) ---
-  n=   10: Build=     0.4ms, Cold=     5.3ms, Warm=    1.7ms | SciPy=    1.1ms | Cold overhead=  5.2x, Warm overhead=  1.9x
-  n=   25: Build=     0.7ms, Cold=     8.1ms, Warm=    1.3ms | SciPy=    1.2ms | Cold overhead=  7.1x, Warm overhead=  1.6x
-  n=   50: Build=     3.0ms, Cold=    25.9ms, Warm=    1.8ms | SciPy=    1.9ms | Cold overhead= 14.9x, Warm overhead=  2.5x
-  n=  100: Build=    11.7ms, Cold=   135.9ms, Warm=    3.2ms | SciPy=    3.5ms | Cold overhead= 42.0x, Warm overhead=  4.2x
+--- Loop-based Variable (n ≤ 500, slow cold solve) ---
+  Loop n=   10: Build=     0.5ms, Cold=    18.2ms, Warm=    1.9ms | SciPy=    1.8ms | Cold overhead= 10.2x, Warm overhead=  1.1x
+  Loop n=   25: Build=     1.4ms, Cold=    15.4ms, Warm=    2.5ms | SciPy=    2.5ms | Cold overhead=  6.6x, Warm overhead=  1.0x
+  Loop n=   50: Build=     4.8ms, Cold=    56.2ms, Warm=    2.4ms | SciPy=    2.1ms | Cold overhead= 29.0x, Warm overhead=  1.1x
+  Loop n=  100: Build=    11.8ms, Cold=   110.7ms, Warm=    3.6ms | SciPy=    3.0ms | Cold overhead= 40.3x, Warm overhead=  1.2x
+  Loop n=  200: Build=    69.9ms, Cold=   424.6ms, Warm=   11.1ms | SciPy=    8.0ms | Cold overhead= 62.1x, Warm overhead=  1.4x
+  Loop n=  500: Build=   505.8ms, Cold=  4262.3ms, Warm=   58.2ms | SciPy=   53.8ms | Cold overhead= 88.7x, Warm overhead=  1.1x
 
 --- VectorVariable (n ≤ 5,000) ---
-  n=   10: Build=     0.2ms, Cold=     1.4ms, Warm=    1.2ms | SciPy=    1.3ms | Cold overhead=  1.2x, Warm overhead=  1.0x
-  n=   25: Build=     0.2ms, Cold=     1.6ms, Warm=    1.3ms | SciPy=    1.6ms | Cold overhead=  1.1x, Warm overhead=  0.9x
-  n=   50: Build=     0.5ms, Cold=     3.2ms, Warm=    2.2ms | SciPy=    1.7ms | Cold overhead=  2.2x, Warm overhead=  1.5x
-  n=  100: Build=     0.5ms, Cold=     4.3ms, Warm=    3.8ms | SciPy=    3.6ms | Cold overhead=  1.3x, Warm overhead=  1.2x
-  n=  200: Build=     0.9ms, Cold=    12.2ms, Warm=    8.8ms | SciPy=   11.9ms | Cold overhead=  1.1x, Warm overhead=  0.8x
-  n=  500: Build=     4.2ms, Cold=    80.9ms, Warm=   57.1ms | SciPy=   57.4ms | Cold overhead=  1.5x, Warm overhead=  1.1x
-  n= 1000: Build=     6.1ms, Cold=   267.1ms, Warm=  213.8ms | SciPy=  238.9ms | Cold overhead=  1.1x, Warm overhead=  0.9x
-  n= 2000: Build=     9.1ms, Cold=   948.6ms, Warm=  957.6ms | SciPy=  973.5ms | Cold overhead=  1.0x, Warm overhead=  1.0x
-  n= 5000: Build=    51.3ms, Cold=  9034.2ms, Warm= 8664.3ms | SciPy= 8518.6ms | Cold overhead=  1.1x, Warm overhead=  1.0x
-
-Saved: /workspaces/optix/benchmarks/results/lp_scaling_comparison.png
-
-================================================================================
-UNCONSTRAINED NLP SCALING BENCHMARK (End-to-End)
-================================================================================
-
-Objective: min Σx²ᵢ - Σxᵢ (optimal at x* = 0.5)
-Measures: Build + Solve (includes gradient compilation)
-
---- Loop-based Variable (n ≤ 100, slow cold solve) ---
-  n=   10: Build=     0.2ms, Cold=     5.4ms, Warm=    0.7ms | SciPy=    0.3ms | Cold overhead= 18.6x, Warm overhead=  3.0x
-  n=   25: Build=     0.2ms, Cold=    50.9ms, Warm=    0.5ms | SciPy=    0.3ms | Cold overhead=168.7x, Warm overhead=  2.3x
-  n=   50: Build=     0.3ms, Cold=    56.2ms, Warm=    0.6ms | SciPy=    0.5ms | Cold overhead=121.7x, Warm overhead=  2.0x
-  n=  100: Build=     0.5ms, Cold=   262.2ms, Warm=    0.9ms | SciPy=    1.0ms | Cold overhead=275.6x, Warm overhead=  1.6x
-
---- VectorVariable with x.dot(x) - x.sum() (n ≤ 5,000) ---
-  n=   10: Build=     0.1ms, Cold=     1.3ms, Warm=    0.5ms | SciPy=    0.3ms | Cold overhead=  3.9x, Warm overhead=  1.6x
-  n=   25: Build=     0.1ms, Cold=     2.4ms, Warm=    1.0ms | SciPy=    0.6ms | Cold overhead=  4.2x, Warm overhead=  1.8x
-  n=   50: Build=     0.2ms, Cold=     4.5ms, Warm=    1.1ms | SciPy=    0.8ms | Cold overhead=  5.9x, Warm overhead=  1.7x
-  n=  100: Build=     0.4ms, Cold=    12.8ms, Warm=    1.1ms | SciPy=    0.9ms | Cold overhead= 14.8x, Warm overhead=  1.6x
-  n=  200: Build=     0.7ms, Cold=    36.3ms, Warm=    2.9ms | SciPy=    2.9ms | Cold overhead= 13.0x, Warm overhead=  1.3x
-  n=  500: Build=     1.7ms, Cold=   138.2ms, Warm=    3.0ms | SciPy=   20.5ms | Cold overhead=  6.8x, Warm overhead=  0.2x
-  n= 1000: Build=     4.1ms, Cold=   469.3ms, Warm=   10.0ms | SciPy=  118.4ms | Cold overhead=  4.0x, Warm overhead=  0.1x
-  n= 2000: Build=     6.4ms, Cold=  1588.4ms, Warm=   15.5ms | SciPy= 1568.4ms | Cold overhead=  1.0x, Warm overhead=  0.0x
-  n= 5000: Build=    18.6ms, Cold=  9094.8ms, Warm=   37.5ms | SciPy=23116.6ms | Cold overhead=  0.4x, Warm overhead=  0.0x
-
-Saved: /workspaces/optix/benchmarks/results/nlp_scaling_comparison.png
-
-================================================================================
-CONSTRAINED QP SCALING BENCHMARK (End-to-End)
-================================================================================
-
-Objective: min Σx²ᵢ s.t. Σxᵢ ≥ 1, xᵢ ≥ 0
-Measures: Build + Solve (includes gradient/Jacobian compilation)
-
---- Loop-based Variable (n ≤ 100, slow cold solve) ---
-  n=   10: Build=     0.2ms, Cold=     3.7ms, Warm=    0.4ms | SciPy=    0.4ms | Cold overhead=  9.2x, Warm overhead=  1.4x
-  n=   25: Build=     0.3ms, Cold=    19.2ms, Warm=    0.7ms | SciPy=    0.5ms | Cold overhead= 42.2x, Warm overhead=  2.2x
-  n=   50: Build=     0.3ms, Cold=    90.2ms, Warm=    1.0ms | SciPy=    0.6ms | Cold overhead=154.4x, Warm overhead=  2.4x
-  n=  100: Build=     0.6ms, Cold=   315.1ms, Warm=    1.8ms | SciPy=    0.9ms | Cold overhead=356.7x, Warm overhead=  2.8x
-
---- VectorVariable with x.dot(x), x.sum() (n ≤ 5,000) ---
-  n=   10: Build=     0.1ms, Cold=     1.2ms, Warm=    0.4ms | SciPy=    0.3ms | Cold overhead=  4.2x, Warm overhead=  1.6x
-  n=   25: Build=     0.1ms, Cold=     1.6ms, Warm=    1.0ms | SciPy=    0.5ms | Cold overhead=  3.4x, Warm overhead=  2.3x
-  n=   50: Build=     0.2ms, Cold=     2.3ms, Warm=    0.7ms | SciPy=    1.1ms | Cold overhead=  2.2x, Warm overhead=  0.8x
-  n=  100: Build=     0.4ms, Cold=     2.0ms, Warm=    1.1ms | SciPy=    1.2ms | Cold overhead=  2.0x, Warm overhead=  1.2x
-  n=  200: Build=     0.6ms, Cold=     4.2ms, Warm=    2.7ms | SciPy=    2.4ms | Cold overhead=  2.1x, Warm overhead=  1.4x
-  n=  500: Build=     2.6ms, Cold=    26.2ms, Warm=   20.5ms | SciPy=   20.6ms | Cold overhead=  1.4x, Warm overhead=  1.1x
-  n= 1000: Build=     3.7ms, Cold=   136.3ms, Warm=   80.6ms | SciPy=   76.5ms | Cold overhead=  1.8x, Warm overhead=  1.1x
-  n= 2000: Build=     9.3ms, Cold=   493.2ms, Warm=  474.2ms | SciPy=  499.3ms | Cold overhead=  1.0x, Warm overhead=  1.0x
-  n= 5000: Build=    18.7ms, Cold=  6524.3ms, Warm= 6330.3ms | SciPy= 6274.8ms | Cold overhead=  1.0x, Warm overhead=  1.0x
-
-Saved: /workspaces/optix/benchmarks/results/cqp_scaling_comparison.png
-
-================================================================================
-OVERHEAD SUMMARY BY PROBLEM TYPE
-================================================================================
-LP (n=50): Cold=2.2x, Warm=1.8x
-LP (n=500): Cold=1.2x, Warm=1.1x
-NLP (n=50): Cold=27.7x, Warm=1.7x
-NLP (n=500): Cold=11.0x, Warm=0.4x
-CQP (n=50): Cold=1.7x, Warm=0.9x
-CQP (n=500): Cold=4.7x, Warm=3.6x
-
-Saved: /workspaces/optix/benchmarks/results/overhead_breakdown.png
-
-================================================================================
-BENCHMARK COMPLETE
-================================================================================
-
-Plots saved to: /workspaces/optix/benchmarks/results
-  - bench_vs_scipy_overhead_breakdown.png
-  - cqp_scaling_comparison.png
-  - lp_cache_benefit.png
-  - lp_scaling_comparison.png
-  - multi_problem_scaling.png
-  - nlp_quadratic_scaling.png
-  - nlp_scaling_comparison.png
-  - overhead_breakdown.png
-  - scipy_lp_scaling.png
+  Vec  n=   10: Build=     0.2ms, Cold=     1.7ms, Warm=    1.3ms | SciPy=    1.2ms | Cold overhead=  1.6x, Warm overhead=  1.2x
+  Vec  n=   25: Build=     0.1ms, Cold=     1.6ms, Warm=    1.6ms | SciPy=    1.3ms | Cold overhead=  1.4x, Warm overhead=  1.3x
+  Vec  n=   50: Build=     0.3ms, Cold=     2.4ms, Warm=    2.0ms | SciPy=    1.7ms | Cold overhead=  1.5x, Warm overhead=  1.2x
+  Vec  n=  100: Build=     0.5ms, Cold=     4.2ms, Warm=    3.3ms | SciPy=    3.2ms | Cold overhead=  1.5x, Warm overhead=  1.0x
+  Vec  n=  200: Build=     1.0ms, Cold=    11.3ms, Warm=    9.3ms | SciPy=   12.3ms | Cold overhead=  1.0x, Warm overhead=  0.8x
+  Vec  n=  500: Build=    10.3ms, Cold=    94.7ms, Warm=   55.8ms | SciPy=   52.8ms | Cold overhead=  2.0x, Warm overhead=  1.1x
+  Vec  n= 1000: Build=     7.2ms, Cold=   239.9ms, Warm=  274.6ms | SciPy=  286.8ms | Cold overhead=  0.9x, Warm overhead=  1.0x
+  Vec  n= 2000: Build=    10.0ms, Cold=   938.4ms, Warm= 1028.2ms | SciPy= 1014.3ms | Cold overhead=  0.9x, Warm overhead=  1.0x
diff --git a/benchmarks/results/benchmark_results.json b/benchmarks/results/benchmark_results.json
new file mode 100644
index 0000000..b962dea
--- /dev/null
+++ b/benchmarks/results/benchmark_results.json
@@ -0,0 +1,861 @@
+{
+  "artifacts": {
+    "metadata": "benchmark_metadata.json",
+    "output_log": "benchmark_output.txt",
+    "plots": {
+      "cqp_scaling": "cqp_scaling_comparison.png",
+      "lp_scaling": "lp_scaling_comparison.png",
+      "milp_scaling": "milp_scaling_comparison.png",
+      "nlp_scaling": "nlp_scaling_comparison.png",
+      "overhead_breakdown": "overhead_breakdown.png"
+    },
+    "results_json": "benchmark_results.json"
+  },
+  "benchmark_suite": "run_benchmarks",
+  "overhead_summary": [
+    {
+      "cold_overhead": 1.0501582337223818,
+      "problem_type": "LP",
+      "size": 50,
+      "warm_overhead": 0.812985045888142
+    },
+    {
+      "cold_overhead": 1.1275902207716624,
+      "problem_type": "LP",
+      "size": 5000,
+      "warm_overhead": 1.0140021159852615
+    },
+    {
+      "cold_overhead": 3.026941579482231,
+      "problem_type": "NLP",
+      "size": 50,
+      "warm_overhead": 2.0825227513121036
+    },
+    {
+      "cold_overhead": 81.94926695989462,
+      "problem_type": "NLP",
+      "size": 5000,
+      "warm_overhead": 42.13192875480498
+    },
+    {
+      "cold_overhead": 1.4299693678646468,
+      "problem_type": "CQP",
+      "size": 50,
+      "warm_overhead": 0.788050478137063
+    },
+    {
+      "cold_overhead": 1.0946971400391046,
+      "problem_type": "CQP",
+      "size": 5000,
+      "warm_overhead": 1.001488479208934
+    },
+    {
+      "cold_overhead": 1.4566705000975524,
+      "problem_type": "MILP",
+      "size": 50,
+      "warm_overhead": 1.2941061236838522
+    },
+    {
+      "cold_overhead": 1.0031123576531944,
+      "problem_type": "MILP",
+      "size": 5000,
+      "warm_overhead": 1.179959153413669
+    }
+  ],
+  "performance_summary": [
+    {
+      "cold_overhead": 1.0501582337223818,
+      "note": "Near-parity with SciPy linprog",
+      "problem_type": "LP",
+      "size": 50,
+      "warm_overhead": 0.812985045888142
+    },
+    {
+      "cold_overhead": 1.211487886529665,
+      "note": "Near-parity with SciPy linprog",
+      "problem_type": "LP",
+      "size": 500,
+      "warm_overhead": 1.0357210528392964
+    },
+    {
+      "cold_overhead": 1.1275902207716624,
+      "note": "Scales to large LPs while staying near parity",
+      "problem_type": "LP",
+      "size": 5000,
+      "warm_overhead": 1.0140021159852615
+    },
+    {
+      "cold_overhead": 3.026941579482231,
+      "note": "Autodiff overhead on a trivially simple objective",
+      "problem_type": "NLP",
+      "size": 50,
+      "warm_overhead": 2.0825227513121036
+    },
+    {
+      "cold_overhead": 53.78946185114727,
+      "note": "Autodiff overhead on a trivially simple objective",
+      "problem_type": "NLP",
+      "size": 500,
+      "warm_overhead": 8.802874053183821
+    },
+    {
+      "cold_overhead": 81.94926695989462,
+      "note": "Simple quadratic; SciPy converges almost instantly",
+      "problem_type": "NLP",
+      "size": 5000,
+      "warm_overhead": 42.13192875480498
+    },
+    {
+      "cold_overhead": 1.4299693678646468,
+      "note": "O(1) Jacobian compilation for vectorized constraints",
+      "problem_type": "CQP",
+      "size": 50,
+      "warm_overhead": 0.788050478137063
+    },
+    {
+      "cold_overhead": 1.6394185969433936,
+      "note": "O(1) Jacobian compilation for vectorized constraints",
+      "problem_type": "CQP",
+      "size": 500,
+      "warm_overhead": 0.9872978508888796
+    },
+    {
+      "cold_overhead": 1.0946971400391046,
+      "note": "Exact Jacobians keep constrained solves near parity",
+      "problem_type": "CQP",
+      "size": 5000,
+      "warm_overhead": 1.001488479208934
+    },
+    {
+      "cold_overhead": 1.4566705000975524,
+      "note": "Near-parity with SciPy milp",
+      "problem_type": "MILP",
+      "size": 50,
+      "warm_overhead": 1.2941061236838522
+    },
+    {
+      "cold_overhead": 1.9537429622573275,
+      "note": "Near-parity with SciPy milp",
+      "problem_type": "MILP",
+      "size": 500,
+      "warm_overhead": 1.2936619533279687
+    },
+    {
+      "cold_overhead": 1.0031123576531944,
+      "note": "Scales to large binary knapsack problems",
+      "problem_type": "MILP",
+      "size": 5000,
+      "warm_overhead": 1.179959153413669
+    }
+  ],
+  "scaling": {
+    "cqp": {
+      "loop": {
+        "label": "CQP (Loop)",
+        "results": [
+          {
+            "build_ms": 0.153315002535237,
+            "cold_overhead": 31.11061123509847,
+            "cold_solve_ms": 10.939440999209182,
+            "cold_total_ms": 11.09275600174442,
+            "n": 10,
+            "scipy_ms": 0.3565586004697252,
+            "warm_overhead": 1.7591885287050133,
+            "warm_solve_ms": 0.6272537997574545,
+            "warm_total_ms": 0.6272537997574545
+          },
+          {
+            "build_ms": 0.2530210003897082,
+            "cold_overhead": 18.974517042517437,
+            "cold_solve_ms": 15.85142200201517,
+            "cold_total_ms": 16.104443002404878,
+            "n": 25,
+            "scipy_ms": 0.8487406012136489,
+            "warm_overhead": 1.3679175940132715,
+            "warm_solve_ms": 1.1610072011535522,
+            "warm_total_ms": 1.1610072011535522
+          },
+          {
+            "build_ms": 1.158421000582166,
+            "cold_overhead": 61.60524408065892,
+            "cold_solve_ms": 71.6935749987897,
+            "cold_total_ms": 72.85199599937187,
+            "n": 50,
+            "scipy_ms": 1.1825615998532157,
+            "warm_overhead": 1.4221486635349372,
+            "warm_solve_ms": 1.681778398778988,
+            "warm_total_ms": 1.681778398778988
+          },
+          {
+            "build_ms": 1.2048469980072696,
+            "cold_overhead": 255.63438117091056,
+            "cold_solve_ms": 221.54135299933841,
+            "cold_total_ms": 222.74619999734568,
+            "n": 100,
+            "scipy_ms": 0.8713467999768909,
+            "warm_overhead": 2.100260194994894,
+            "warm_solve_ms": 1.8300550000276417,
+            "warm_total_ms": 1.8300550000276417
+          },
+          {
+            "build_ms": 1.9555170001694933,
+            "cold_overhead": 396.1053364293281,
+            "cold_solve_ms": 762.428201000148,
+            "cold_total_ms": 764.3837180003175,
+            "n": 200,
+            "scipy_ms": 1.9297485989227425,
+            "warm_overhead": 1.9573368272172225,
+            "warm_solve_ms": 3.7771679999423213,
+            "warm_total_ms": 3.7771679999423213
+          },
+          {
+            "build_ms": 5.547715998545755,
+            "cold_overhead": 461.5214241891787,
+            "cold_solve_ms": 5982.5169229989115,
+            "cold_total_ms": 5988.064638997457,
+            "n": 500,
+            "scipy_ms": 12.974618999578524,
+            "warm_overhead": 2.6842881013962274,
+            "warm_solve_ms": 34.82761540071806,
+            "warm_total_ms": 34.82761540071806
+          }
+        ]
+      },
+      "vector": {
+        "label": "CQP (VectorVariable)",
+        "results": [
+          {
+            "build_ms": 0.11850099690491334,
+            "cold_overhead": 3.027583458815483,
+            "cold_solve_ms": 0.8402160019613802,
+            "cold_total_ms": 0.9587169988662936,
+            "n": 10,
+            "scipy_ms": 0.316660799580859,
+            "warm_overhead": 1.3346085183142544,
+            "warm_solve_ms": 0.4226182005368173,
+            "warm_total_ms": 0.4226182005368173
+          },
+          {
+            "build_ms": 0.1562409997859504,
+            "cold_overhead": 2.391429352767669,
+            "cold_solve_ms": 0.9384200020576827,
+            "cold_total_ms": 1.0946610018436331,
+            "n": 25,
+            "scipy_ms": 0.45774339960189536,
+            "warm_overhead": 2.260624187010286,
+            "warm_solve_ms": 1.034785800584359,
+            "warm_total_ms": 1.034785800584359
+          },
+          {
+            "build_ms": 0.21687400294467807,
+            "cold_overhead": 1.4299693678646468,
+            "cold_solve_ms": 1.0550480001256801,
+            "cold_total_ms": 1.2719220030703582,
+            "n": 50,
+            "scipy_ms": 0.8894749997125473,
+            "warm_overhead": 0.788050478137063,
+            "warm_solve_ms": 0.7009511988144368,
+            "warm_total_ms": 0.7009511988144368
+          },
+          {
+            "build_ms": 0.3956479995395057,
+            "cold_overhead": 1.6844031244504607,
+            "cold_solve_ms": 1.463579999835929,
+            "cold_total_ms": 1.8592279993754346,
+            "n": 100,
+            "scipy_ms": 1.1037904005206656,
+            "warm_overhead": 1.1312225582223807,
+            "warm_solve_ms": 1.2486326006182935,
+            "warm_total_ms": 1.2486326006182935
+          },
+          {
+            "build_ms": 0.7324860016524326,
+            "cold_overhead": 1.907498936382662,
+            "cold_solve_ms": 2.9472659989551175,
+            "cold_total_ms": 3.67975200060755,
+            "n": 200,
+            "scipy_ms": 1.9290977994387504,
+            "warm_overhead": 1.237126703114857,
+            "warm_solve_ms": 2.3865384006057866,
+            "warm_total_ms": 2.3865384006057866
+          },
+          {
+            "build_ms": 2.5035090002347715,
+            "cold_overhead": 1.6394185969433936,
+            "cold_solve_ms": 18.565805999969598,
+            "cold_total_ms": 21.06931500020437,
+            "n": 500,
+            "scipy_ms": 12.851699400926009,
+            "warm_overhead": 0.9872978508888796,
+            "warm_solve_ms": 12.68845519880415,
+            "warm_total_ms": 12.68845519880415
+          },
+          {
+            "build_ms": 13.506178998795804,
+            "cold_overhead": 1.340633127996738,
+            "cold_solve_ms": 80.1798009997583,
+            "cold_total_ms": 93.6859799985541,
+            "n": 1000,
+            "scipy_ms": 69.88189240000793,
+            "warm_overhead": 1.3084826449294356,
+            "warm_solve_ms": 91.43924340023659,
+            "warm_total_ms": 91.43924340023659
+          },
+          {
+            "build_ms": 11.169469999003923,
+            "cold_overhead": 0.8354444607531919,
+            "cold_solve_ms": 471.47300299911876,
+            "cold_total_ms": 482.6424729981227,
+            "n": 2000,
+            "scipy_ms": 577.7074308003648,
+            "warm_overhead": 1.0372864849082362,
+            "warm_solve_ms": 599.2481102002785,
+            "warm_total_ms": 599.2481102002785
+          },
+          {
+            "build_ms": 49.87247100143577,
+            "cold_overhead": 1.0946971400391046,
+            "cold_solve_ms": 7601.275322998845,
+            "cold_total_ms": 7651.147794000281,
+            "n": 5000,
+            "scipy_ms": 6989.282710400585,
+            "warm_overhead": 1.001488479208934,
+            "warm_solve_ms": 6999.686112400377,
+            "warm_total_ms": 6999.686112400377
+          }
+        ]
+      }
+    },
+    "lp": {
+      "loop": {
+        "label": "LP (Loop)",
+        "results": [
+          {
+            "build_ms": 0.4565819981507957,
+            "cold_overhead": 11.482336147813978,
+            "cold_solve_ms": 20.522652001091046,
+            "cold_total_ms": 20.979233999241842,
+            "n": 10,
+            "scipy_ms": 1.8270876003953163,
+            "warm_overhead": 1.0815988235244256,
+            "warm_solve_ms": 1.9761757990636397,
+            "warm_total_ms": 1.9761757990636397
+          },
+          {
+            "build_ms": 1.4050399986444972,
+            "cold_overhead": 9.623407770861848,
+            "cold_solve_ms": 19.63746299952618,
+            "cold_total_ms": 21.042502998170676,
+            "n": 25,
+            "scipy_ms": 2.1865957984118722,
+            "warm_overhead": 1.1279439032452812,
+            "warm_solve_ms": 2.466357399680419,
+            "warm_total_ms": 2.466357399680419
+          },
+          {
+            "build_ms": 4.869180997047806,
+            "cold_overhead": 32.24808044538227,
+            "cold_solve_ms": 51.346608001040295,
+            "cold_total_ms": 56.2157889980881,
+            "n": 50,
+            "scipy_ms": 1.7432289991120342,
+            "warm_overhead": 2.138066428056541,
+            "warm_solve_ms": 3.727139399416046,
+            "warm_total_ms": 3.727139399416046
+          },
+          {
+            "build_ms": 10.630352997395676,
+            "cold_overhead": 34.299098632360746,
+            "cold_solve_ms": 108.15988299873425,
+            "cold_total_ms": 118.79023599612992,
+            "n": 100,
+            "scipy_ms": 3.4633631999895442,
+            "warm_overhead": 0.9625728540754156,
+            "warm_solve_ms": 3.3337394001137,
+            "warm_total_ms": 3.3337394001137
+          },
+          {
+            "build_ms": 63.9043990013306,
+            "cold_overhead": 60.31374442643511,
+            "cold_solve_ms": 477.2999010019703,
+            "cold_total_ms": 541.2043000033009,
+            "n": 200,
+            "scipy_ms": 8.973150401288876,
+            "warm_overhead": 0.9726232159191104,
+            "warm_solve_ms": 8.727494400227442,
+            "warm_total_ms": 8.727494400227442
+          },
+          {
+            "build_ms": 478.78952999963076,
+            "cold_overhead": 91.74939438260711,
+            "cold_solve_ms": 4352.143078998779,
+            "cold_total_ms": 4830.93260899841,
+            "n": 500,
+            "scipy_ms": 52.65356399904704,
+            "warm_overhead": 1.0590257100395577,
+            "warm_solve_ms": 55.76147800020408,
+            "warm_total_ms": 55.76147800020408
+          }
+        ]
+      },
+      "vector": {
+        "label": "LP (VectorVariable)",
+        "results": [
+          {
+            "build_ms": 0.19218799934606068,
+            "cold_overhead": 1.693216922730903,
+            "cold_solve_ms": 1.6525819992239121,
+            "cold_total_ms": 1.8447699985699728,
+            "n": 10,
+            "scipy_ms": 1.0895060011534952,
+            "warm_overhead": 1.2623675308353952,
+            "warm_solve_ms": 1.375357000506483,
+            "warm_total_ms": 1.375357000506483
+          },
+          {
+            "build_ms": 0.2016159996856004,
+            "cold_overhead": 1.4924938118363915,
+            "cold_solve_ms": 1.623988999199355,
+            "cold_total_ms": 1.8256049988849554,
+            "n": 25,
+            "scipy_ms": 1.2231910004629754,
+            "warm_overhead": 1.2657148376693776,
+            "warm_solve_ms": 1.5482109985896386,
+            "warm_total_ms": 1.5482109985896386
+          },
+          {
+            "build_ms": 0.29033099781372584,
+            "cold_overhead": 1.0501582337223818,
+            "cold_solve_ms": 2.3654819997318555,
+            "cold_total_ms": 2.6558129975455813,
+            "n": 50,
+            "scipy_ms": 2.528964600060135,
+            "warm_overhead": 0.812985045888142,
+            "warm_solve_ms": 2.0560104014293756,
+            "warm_total_ms": 2.0560104014293756
+          },
+          {
+            "build_ms": 0.9552609990350902,
+            "cold_overhead": 1.4109392686950275,
+            "cold_solve_ms": 6.260796002607094,
+            "cold_total_ms": 7.216057001642184,
+            "n": 100,
+            "scipy_ms": 5.114363999746274,
+            "warm_overhead": 1.7028074262404869,
+            "warm_solve_ms": 8.708776999264956,
+            "warm_total_ms": 8.708776999264956
+          },
+          {
+            "build_ms": 1.8441590000293218,
+            "cold_overhead": 3.6727232458672763,
+            "cold_solve_ms": 26.99932399991667,
+            "cold_total_ms": 28.84348299994599,
+            "n": 200,
+            "scipy_ms": 7.8534321997722145,
+            "warm_overhead": 1.2149146968198785,
+            "warm_solve_ms": 9.541250199981732,
+            "warm_total_ms": 9.541250199981732
+          },
+          {
+            "build_ms": 2.4393290004809387,
+            "cold_overhead": 1.211487886529665,
+            "cold_solve_ms": 63.093166001635836,
+            "cold_total_ms": 65.53249500211678,
+            "n": 500,
+            "scipy_ms": 54.092571399814915,
+            "warm_overhead": 1.0357210528392964,
+            "warm_solve_ms": 56.024815001001116,
+            "warm_total_ms": 56.024815001001116
+          },
+          {
+            "build_ms": 6.566907002707012,
+            "cold_overhead": 1.004822563939135,
+            "cold_solve_ms": 252.37838400062174,
+            "cold_total_ms": 258.94529100332875,
+            "n": 1000,
+            "scipy_ms": 257.7025041995512,
+            "warm_overhead": 1.0960677571869186,
+            "warm_solve_ms": 282.45940579945454,
+            "warm_total_ms": 282.45940579945454
+          },
+          {
+            "build_ms": 10.243332999380073,
+            "cold_overhead": 1.0615410333742983,
+            "cold_solve_ms": 1171.9294570029888,
+            "cold_total_ms": 1182.1727900023689,
+            "n": 2000,
+            "scipy_ms": 1113.6383359997126,
+            "warm_overhead": 1.0187540921722584,
+            "warm_solve_ms": 1134.5236119996116,
+            "warm_total_ms": 1134.5236119996116
+          },
+          {
+            "build_ms": 24.960611001006328,
+            "cold_overhead": 1.1275902207716624,
+            "cold_solve_ms": 10199.972689999413,
+            "cold_total_ms": 10224.93330100042,
+            "n": 5000,
+            "scipy_ms": 9067.951382198953,
+            "warm_overhead": 1.0140021159852615,
+            "warm_solve_ms": 9194.921889201214,
+            "warm_total_ms": 9194.921889201214
+          }
+        ]
+      }
+    },
+    "milp": {
+      "loop": {
+        "label": "MILP (Loop)",
+        "results": [
+          {
+            "build_ms": 0.172080999618629,
+            "cold_overhead": 17.811266453769836,
+            "cold_solve_ms": 14.173112998832949,
+            "cold_total_ms": 14.345193998451577,
+            "n": 10,
+            "scipy_ms": 0.8053999998082872,
+            "warm_overhead": 1.2008266692982976,
+            "warm_solve_ms": 0.9671457992226351,
+            "warm_total_ms": 0.9671457992226351
+          },
+          {
+            "build_ms": 0.2327029978914652,
+            "cold_overhead": 2.200366322114951,
+            "cold_solve_ms": 1.718735002214089,
+            "cold_total_ms": 1.9514380001055542,
+            "n": 25,
+            "scipy_ms": 0.8868696000718046,
+            "warm_overhead": 1.4006958858066936,
+            "warm_solve_ms": 1.2422346000676043,
+            "warm_total_ms": 1.2422346000676043
+          },
+          {
+            "build_ms": 0.34325999877182767,
+            "cold_overhead": 2.69034763531842,
+            "cold_solve_ms": 2.502537001419114,
+            "cold_total_ms": 2.8457970001909416,
+            "n": 50,
+            "scipy_ms": 1.0577804008789826,
+            "warm_overhead": 1.3059045146807384,
+            "warm_solve_ms": 1.3813602010486647,
+            "warm_total_ms": 1.3813602010486647
+          },
+          {
+            "build_ms": 2.207367000664817,
+            "cold_overhead": 4.825542619460967,
+            "cold_solve_ms": 4.877707000559894,
+            "cold_total_ms": 7.0850740012247115,
+            "n": 100,
+            "scipy_ms": 1.4682440007163677,
+            "warm_overhead": 1.215488841472715,
+            "warm_solve_ms": 1.784634199430002,
+            "warm_total_ms": 1.784634199430002
+          },
+          {
+            "build_ms": 0.9081530006369576,
+            "cold_overhead": 4.364352366893895,
+            "cold_solve_ms": 10.057105999294436,
+            "cold_total_ms": 10.965258999931393,
+            "n": 200,
+            "scipy_ms": 2.512459599529393,
+            "warm_overhead": 1.3177663034185723,
+            "warm_solve_ms": 3.310834598960355,
+            "warm_total_ms": 3.310834598960355
+          },
+          {
+            "build_ms": 3.3278769988100976,
+            "cold_overhead": 4.835364174134148,
+            "cold_solve_ms": 34.82242199970642,
+            "cold_total_ms": 38.15029899851652,
+            "n": 500,
+            "scipy_ms": 7.889850200444926,
+            "warm_overhead": 1.1001823581781829,
+            "warm_solve_ms": 8.680273999198107,
+            "warm_total_ms": 8.680273999198107
+          }
+        ]
+      },
+      "vector": {
+        "label": "MILP (VectorVariable)",
+        "results": [
+          {
+            "build_ms": 0.11342200014041737,
+            "cold_overhead": 1.1751891455861652,
+            "cold_solve_ms": 1.0656769991328474,
+            "cold_total_ms": 1.1790989992732648,
+            "n": 10,
+            "scipy_ms": 1.003326999489218,
+            "warm_overhead": 0.9674415220778275,
+            "warm_solve_ms": 0.9706601995276287,
+            "warm_total_ms": 0.9706601995276287
+          },
+          {
+            "build_ms": 0.16660999972373247,
+            "cold_overhead": 1.1871918475053154,
+            "cold_solve_ms": 1.0797040013130754,
+            "cold_total_ms": 1.246314001036808,
+            "n": 25,
+            "scipy_ms": 1.0497999996005092,
+            "warm_overhead": 1.0163364446826544,
+            "warm_solve_ms": 1.0669499992218334,
+            "warm_total_ms": 1.0669499992218334
+          },
+          {
+            "build_ms": 0.20800800120923668,
+            "cold_overhead": 1.4566705000975524,
+            "cold_solve_ms": 1.331152001512237,
+            "cold_total_ms": 1.5391600027214736,
+            "n": 50,
+            "scipy_ms": 1.0566288001427893,
+            "warm_overhead": 1.2941061236838522,
+            "warm_solve_ms": 1.3673898007255048,
+            "warm_total_ms": 1.3673898007255048
+          },
+          {
+            "build_ms": 0.32505700073670596,
+            "cold_overhead": 1.451575594142868,
+            "cold_solve_ms": 1.7858999999589287,
+            "cold_total_ms": 2.1109570006956346,
+            "n": 100,
+            "scipy_ms": 1.4542521996190771,
+            "warm_overhead": 1.2799012436930013,
+            "warm_solve_ms": 1.8612991989357397,
+            "warm_total_ms": 1.8612991989357397
+          },
+          {
+            "build_ms": 0.5490439980349038,
+            "cold_overhead": 1.3673208274083901,
+            "cold_solve_ms": 2.898244998505106,
+            "cold_total_ms": 3.44728899654001,
+            "n": 200,
+            "scipy_ms": 2.521199799957685,
+            "warm_overhead": 1.1874288581875057,
+            "warm_solve_ms": 2.993745399726322,
+            "warm_total_ms": 2.993745399726322
+          },
+          {
+            "build_ms": 1.1771960016631056,
+            "cold_overhead": 1.9537429622573275,
+            "cold_solve_ms": 14.222654997865902,
+            "cold_total_ms": 15.399850999529008,
+            "n": 500,
+            "scipy_ms": 7.882229800452478,
+            "warm_overhead": 1.2936619533279687,
+            "warm_solve_ms": 10.196940800233278,
+            "warm_total_ms": 10.196940800233278
+          },
+          {
+            "build_ms": 4.252782000548905,
+            "cold_overhead": 1.3152853856338191,
+            "cold_solve_ms": 28.930814998602727,
+            "cold_total_ms": 33.18359699915163,
+            "n": 1000,
+            "scipy_ms": 25.229199200111907,
+            "warm_overhead": 1.1026000539842433,
+            "warm_solve_ms": 27.81771640002262,
+            "warm_total_ms": 27.81771640002262
+          },
+          {
+            "build_ms": 4.538343997410266,
+            "cold_overhead": 1.0930986857200522,
+            "cold_solve_ms": 90.94023099896731,
+            "cold_total_ms": 95.47857499637757,
+            "n": 2000,
+            "scipy_ms": 87.34671100028208,
+            "warm_overhead": 1.0280106162114089,
+            "warm_solve_ms": 89.79334619943984,
+            "warm_total_ms": 89.79334619943984
+          },
+          {
+            "build_ms": 14.063347000046633,
+            "cold_overhead": 1.0031123576531944,
+            "cold_solve_ms": 556.2133999992511,
+            "cold_total_ms": 570.2767469992978,
+            "n": 5000,
+            "scipy_ms": 568.5073488013586,
+            "warm_overhead": 1.179959153413669,
+            "warm_solve_ms": 670.8154500011005,
+            "warm_total_ms": 670.8154500011005
+          }
+        ]
+      }
+    },
+    "nlp": {
+      "loop": {
+        "label": "NLP (Loop)",
+        "results": [
+          {
+            "build_ms": 0.23259400040842593,
+            "cold_overhead": 26.924193665611664,
+            "cold_solve_ms": 22.282316000200808,
+            "cold_total_ms": 22.514910000609234,
+            "n": 10,
+            "scipy_ms": 0.83623339960468,
+            "warm_overhead": 1.526948339291722,
+            "warm_solve_ms": 1.2768852007866371,
+            "warm_total_ms": 1.2768852007866371
+          },
+          {
+            "build_ms": 0.8333039986609947,
+            "cold_overhead": 140.23467756679662,
+            "cold_solve_ms": 23.261622001882643,
+            "cold_total_ms": 24.094926000543637,
+            "n": 25,
+            "scipy_ms": 0.17181860021082684,
+            "warm_overhead": 2.940754958360747,
+            "warm_solve_ms": 0.5052764005085919,
+            "warm_total_ms": 0.5052764005085919
+          },
+          {
+            "build_ms": 0.3780549996008631,
+            "cold_overhead": 256.11622214696143,
+            "cold_solve_ms": 42.20331599935889,
+            "cold_total_ms": 42.581370998959756,
+            "n": 50,
+            "scipy_ms": 0.16625800053589046,
+            "warm_overhead": 3.638935862690727,
+            "warm_solve_ms": 0.6050022006093059,
+            "warm_total_ms": 0.6050022006093059
+          },
+          {
+            "build_ms": 0.510792997374665,
+            "cold_overhead": 560.5602547995003,
+            "cold_solve_ms": 171.82303099980345,
+            "cold_total_ms": 172.33382399717811,
+            "n": 100,
+            "scipy_ms": 0.30743140014237724,
+            "warm_overhead": 5.524515057550911,
+            "warm_solve_ms": 1.6984093992505223,
+            "warm_total_ms": 1.6984093992505223
+          },
+          {
+            "build_ms": 1.5647879990865476,
+            "cold_overhead": 2373.6715815740263,
+            "cold_solve_ms": 788.4804659988731,
+            "cold_total_ms": 790.0452539979597,
+            "n": 200,
+            "scipy_ms": 0.33283680022577755,
+            "warm_overhead": 5.649991223581403,
+            "warm_solve_ms": 1.88052500016056,
+            "warm_total_ms": 1.88052500016056
+          },
+          {
+            "build_ms": 2.4829899994074367,
+            "cold_overhead": 5156.3964225459185,
+            "cold_solve_ms": 5282.304603999364,
+            "cold_total_ms": 5284.787593998772,
+            "n": 500,
+            "scipy_ms": 1.024899398908019,
+            "warm_overhead": 7.431381273147058,
+            "warm_solve_ms": 7.616418199904729,
+            "warm_total_ms": 7.616418199904729
+          }
+        ]
+      },
+      "vector": {
+        "label": "NLP (VectorVariable)",
+        "results": [
+          {
+            "build_ms": 0.1335380002274178,
+            "cold_overhead": 7.034893721008192,
+            "cold_solve_ms": 1.6221139994740952,
+            "cold_total_ms": 1.755651999701513,
+            "n": 10,
+            "scipy_ms": 0.24956340057542548,
+            "warm_overhead": 2.187587599443851,
+            "warm_solve_ms": 0.5459418003738392,
+            "warm_total_ms": 0.5459418003738392
+          },
+          {
+            "build_ms": 0.18729899966274388,
+            "cold_overhead": 8.070642423746817,
+            "cold_solve_ms": 3.2761719994596206,
+            "cold_total_ms": 3.4634709991223644,
+            "n": 25,
+            "scipy_ms": 0.4291443998226896,
+            "warm_overhead": 5.572431566330814,
+            "warm_solve_ms": 2.3913778000860475,
+            "warm_total_ms": 2.3913778000860475
+          },
+          {
+            "build_ms": 0.2650540009199176,
+            "cold_overhead": 3.026941579482231,
+            "cold_solve_ms": 1.2355649996607099,
+            "cold_total_ms": 1.5006190005806275,
+            "n": 50,
+            "scipy_ms": 0.4957541998010129,
+            "warm_overhead": 2.0825227513121036,
+            "warm_solve_ms": 1.0324194001441356,
+            "warm_total_ms": 1.0324194001441356
+          },
+          {
+            "build_ms": 0.4631140000128653,
+            "cold_overhead": 4.760779426991482,
+            "cold_solve_ms": 1.846163002483081,
+            "cold_total_ms": 2.3092770024959464,
+            "n": 100,
+            "scipy_ms": 0.4850628007261548,
+            "warm_overhead": 4.305729478136866,
+            "warm_solve_ms": 2.088549199834233,
+            "warm_total_ms": 2.088549199834233
+          },
+          {
+            "build_ms": 0.943560000450816,
+            "cold_overhead": 5.758374810789764,
+            "cold_solve_ms": 5.066017001809087,
+            "cold_total_ms": 6.009577002259903,
+            "n": 200,
+            "scipy_ms": 1.0436238000693265,
+            "warm_overhead": 2.2984234359876172,
+            "warm_solve_ms": 2.3986894004337955,
+            "warm_total_ms": 2.3986894004337955
+          },
+          {
+            "build_ms": 4.8641109970049,
+            "cold_overhead": 53.78946185114727,
+            "cold_solve_ms": 6.9507119987974875,
+            "cold_total_ms": 11.814822995802388,
+            "n": 500,
+            "scipy_ms": 0.21964939951431006,
+            "warm_overhead": 8.802874053183821,
+            "warm_solve_ms": 1.933545999781927,
+            "warm_total_ms": 1.933545999781927
+          },
+          {
+            "build_ms": 2.3693789989920333,
+            "cold_overhead": 36.298616780646455,
+            "cold_solve_ms": 6.737806001183344,
+            "cold_total_ms": 9.107185000175377,
+            "n": 1000,
+            "scipy_ms": 0.2508961995772552,
+            "warm_overhead": 17.360370574977356,
+            "warm_solve_ms": 4.3556510005146265,
+            "warm_total_ms": 4.3556510005146265
+          },
+          {
+            "build_ms": 4.656695000448963,
+            "cold_overhead": 63.99828017713911,
+            "cold_solve_ms": 15.803311998752179,
+            "cold_total_ms": 20.46000699920114,
+            "n": 2000,
+            "scipy_ms": 0.3196962003130466,
+            "warm_overhead": 22.64619971147447,
+            "warm_solve_ms": 7.239903999288799,
+            "warm_total_ms": 7.239903999288799
+          },
+          {
+            "build_ms": 19.125397000607336,
+            "cold_overhead": 81.94926695989462,
+            "cold_solve_ms": 47.659322000981774,
+            "cold_total_ms": 66.78471900158911,
+            "n": 5000,
+            "scipy_ms": 0.8149519999278709,
+            "warm_overhead": 42.13192875480498,
+            "warm_solve_ms": 34.33549959954689,
+            "warm_total_ms": 34.33549959954689
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/benchmarks/results/cqp_scaling_comparison.png b/benchmarks/results/cqp_scaling_comparison.png
index 34ff333..40a0908 100644
Binary files a/benchmarks/results/cqp_scaling_comparison.png and b/benchmarks/results/cqp_scaling_comparison.png differ
diff --git a/benchmarks/results/lp_cache_benefit.png b/benchmarks/results/lp_cache_benefit.png
index a8aebfc..4119340 100644
Binary files a/benchmarks/results/lp_cache_benefit.png and b/benchmarks/results/lp_cache_benefit.png differ
diff --git a/benchmarks/results/lp_scaling_comparison.png b/benchmarks/results/lp_scaling_comparison.png
index dee96b2..fb7b5c7 100644
Binary files a/benchmarks/results/lp_scaling_comparison.png and b/benchmarks/results/lp_scaling_comparison.png differ
diff --git a/benchmarks/results/milp_scaling_comparison.png b/benchmarks/results/milp_scaling_comparison.png
new file mode 100644
index 0000000..3ee030f
Binary files /dev/null and b/benchmarks/results/milp_scaling_comparison.png differ
diff --git a/benchmarks/results/multi_problem_scaling.png b/benchmarks/results/multi_problem_scaling.png
index 4a979e6..b7f0c95 100644
Binary files a/benchmarks/results/multi_problem_scaling.png and b/benchmarks/results/multi_problem_scaling.png differ
diff --git a/benchmarks/results/nlp_quadratic_scaling.png b/benchmarks/results/nlp_quadratic_scaling.png
index c15e9e9..03fb244 100644
Binary files a/benchmarks/results/nlp_quadratic_scaling.png and b/benchmarks/results/nlp_quadratic_scaling.png differ
diff --git a/benchmarks/results/nlp_scaling_comparison.png b/benchmarks/results/nlp_scaling_comparison.png
index 5c898a5..ce91e22 100644
Binary files a/benchmarks/results/nlp_scaling_comparison.png and b/benchmarks/results/nlp_scaling_comparison.png differ
diff --git a/benchmarks/results/overhead_breakdown.png b/benchmarks/results/overhead_breakdown.png
index cf22443..75dbecc 100644
Binary files a/benchmarks/results/overhead_breakdown.png and b/benchmarks/results/overhead_breakdown.png differ
diff --git a/benchmarks/results/scipy_lp_scaling.png b/benchmarks/results/scipy_lp_scaling.png
index c1140cb..eac448e 100644
Binary files a/benchmarks/results/scipy_lp_scaling.png and b/benchmarks/results/scipy_lp_scaling.png differ
diff --git a/benchmarks/results/sparse_benchmark_results.txt b/benchmarks/results/sparse_benchmark_results.txt
new file mode 100644
index 0000000..8e51ed2
--- /dev/null
+++ b/benchmarks/results/sparse_benchmark_results.txt
@@ -0,0 +1,37 @@
+Sparse vs Dense Jacobian Compilation Benchmark
+======================================================================
+
+======================================================================
+CHAIN CONSTRAINTS: x_i + x_{i+1} (2 nnz per row, density=2/n)
+======================================================================
+     n |  Dense Compile |  Sparse Compile |  Dense Eval |  Sparse Eval |  Compile Speedup |  Eval Speedup |  Density
+------------------------------------------------------------------------------------------------------------------------
+    10 |         5.48ms |          6.53ms |     0.000ms |      0.000ms |            0.8x |         1.4x |   20.0%
+    25 |         5.07ms |          1.56ms |     0.000ms |      0.000ms |            3.2x |         0.7x |    8.0%
+    50 |        12.20ms |          7.59ms |     0.000ms |      0.000ms |            1.6x |         0.8x |    4.0%
+   100 |        16.11ms |         13.08ms |     0.000ms |      0.000ms |            1.2x |         0.7x |    2.0%
+   200 |        71.44ms |         34.71ms |     0.004ms |      0.000ms |            2.1x |        15.5x |    1.0%
+   500 |       146.92ms |        159.77ms |     0.009ms |      0.000ms |            0.9x |        24.2x |    0.4%
+
+======================================================================
+PAIRWISE CONSTRAINTS: x_i - x_j (2 nnz per row, m=n)
+======================================================================
+     n |  Dense Eval |  Sparse Eval |  Eval Speedup |  Dense Memory |  Sparse Memory
+------------------------------------------------------------------------------------------
+    10 |     0.000ms |      0.000ms |         1.4x |        800 B |         284 B
+    25 |     0.000ms |      0.000ms |         0.9x |      5,000 B |         704 B
+    50 |     0.000ms |      0.000ms |         0.9x |     20,000 B |       1,404 B
+   100 |     0.000ms |      0.001ms |         0.2x |     79,200 B |       2,776 B
+   200 |     0.004ms |      0.000ms |        14.5x |    316,800 B |       5,548 B
+   500 |     0.009ms |      0.000ms |        20.1x |  2,000,000 B |      14,004 B
+
+======================================================================
+NONLINEAR SPARSE: x_i² + x_{i+1}² (2 nnz per row)
+======================================================================
+     n |  Dense Eval |  Sparse Eval |  Eval Speedup
+------------------------------------------------------------
+    10 |     0.056ms |      0.355ms |         0.2x
+    25 |     0.139ms |      0.437ms |         0.3x
+    50 |     0.477ms |      0.231ms |         2.1x
+   100 |     1.445ms |      0.483ms |         3.0x
+   200 |     1.546ms |      0.659ms |         2.3x
diff --git a/benchmarks/results/sparse_memory_reduction.png b/benchmarks/results/sparse_memory_reduction.png
new file mode 100644
index 0000000..5b39bb2
Binary files /dev/null and b/benchmarks/results/sparse_memory_reduction.png differ
diff --git a/benchmarks/results/sparse_solve_end_to_end.png b/benchmarks/results/sparse_solve_end_to_end.png
new file mode 100644
index 0000000..8e08269
Binary files /dev/null and b/benchmarks/results/sparse_solve_end_to_end.png differ
diff --git a/benchmarks/results/sparse_solve_end_to_end_metadata.json b/benchmarks/results/sparse_solve_end_to_end_metadata.json
new file mode 100644
index 0000000..118d380
--- /dev/null
+++ b/benchmarks/results/sparse_solve_end_to_end_metadata.json
@@ -0,0 +1,13 @@
+{
+  "benchmark_suite": "sparse_solve_end_to_end",
+  "cpu_count": 2,
+  "machine": "x86_64",
+  "numpy_version": "2.3.5",
+  "optyx_version": "1.3.0",
+  "platform": "Linux-6.8.0-1044-azure-x86_64-with-glibc2.39",
+  "processor": "x86_64",
+  "python_implementation": "CPython",
+  "python_version": "3.12.1",
+  "scipy_version": "1.16.3",
+  "timestamp_utc": "2026-04-18T21:05:46.137793+00:00"
+}
diff --git a/benchmarks/results/sparse_solve_end_to_end_results.json b/benchmarks/results/sparse_solve_end_to_end_results.json
new file mode 100644
index 0000000..1983da5
--- /dev/null
+++ b/benchmarks/results/sparse_solve_end_to_end_results.json
@@ -0,0 +1,42 @@
+[
+  {
+    "n": 20,
+    "jacobian_type": "csr_matrix",
+    "nnz": 40,
+    "density": 0.09523809523809523,
+    "cold_trust_constr_median_ms": 216.23572600037733,
+    "cold_slsqp_median_ms": 16.729955001210328,
+    "warm_trust_constr_median_ms": 202.07499099888082,
+    "warm_slsqp_median_ms": 19.78887599943846
+  },
+  {
+    "n": 40,
+    "jacobian_type": "csr_matrix",
+    "nnz": 80,
+    "density": 0.04878048780487805,
+    "cold_trust_constr_median_ms": 528.6076329994103,
+    "cold_slsqp_median_ms": 55.64899599994533,
+    "warm_trust_constr_median_ms": 99.23417800018797,
+    "warm_slsqp_median_ms": 2.7929649986617733
+  },
+  {
+    "n": 80,
+    "jacobian_type": "csr_matrix",
+    "nnz": 160,
+    "density": 0.024691358024691357,
+    "cold_trust_constr_median_ms": 3570.338139999876,
+    "cold_slsqp_median_ms": 187.50832499972603,
+    "warm_trust_constr_median_ms": 136.33992400173156,
+    "warm_slsqp_median_ms": 8.31679700058885
+  },
+  {
+    "n": 120,
+    "jacobian_type": "csr_matrix",
+    "nnz": 240,
+    "density": 0.01652892561983471,
+    "cold_trust_constr_median_ms": 11636.690797999108,
+    "cold_slsqp_median_ms": 455.27698600017175,
+    "warm_trust_constr_median_ms": 154.7880569996778,
+    "warm_slsqp_median_ms": 18.819584998709615
+  }
+]
diff --git a/benchmarks/results/sparse_vs_dense_comparison.png b/benchmarks/results/sparse_vs_dense_comparison.png
new file mode 100644
index 0000000..fca5249
Binary files /dev/null and b/benchmarks/results/sparse_vs_dense_comparison.png differ
diff --git a/benchmarks/run_benchmarks.py b/benchmarks/run_benchmarks.py
index e37e386..e5b5a43 100644
--- a/benchmarks/run_benchmarks.py
+++ b/benchmarks/run_benchmarks.py
@@ -16,14 +16,18 @@
     - lp_scaling_comparison.png: LP scaling with cold/warm breakdown
     - nlp_scaling_comparison.png: NLP scaling with cold/warm breakdown
     - overhead_breakdown.png: Overhead by problem type
+    - benchmark_metadata.json: machine and dependency metadata for the run
 """
 
 from __future__ import annotations
 
+import json
+import shutil
 import sys
 import time
 from dataclasses import dataclass, field
 from pathlib import Path
+from typing import Any, cast
 
 # Add benchmarks to path
 sys.path.insert(0, str(Path(__file__).parent))
@@ -31,12 +35,32 @@
 import numpy as np
 from scipy.optimize import linprog, minimize
 
-from optyx import Variable, VectorVariable, Problem
-from utils import RESULTS_DIR
+from optyx import Variable, VectorVariable, BinaryVariable, Problem
+from utils import RESULTS_DIR, write_benchmark_metadata
 
 import matplotlib.pyplot as plt
 
 
+DOCS_BENCHMARKS_DIR = (
+    Path(__file__).resolve().parents[1] / "docs" / "assets" / "benchmarks"
+)
+
+PLOT_FILE_NAMES = {
+    "lp_scaling": "lp_scaling_comparison.png",
+    "nlp_scaling": "nlp_scaling_comparison.png",
+    "cqp_scaling": "cqp_scaling_comparison.png",
+    "milp_scaling": "milp_scaling_comparison.png",
+    "overhead_breakdown": "overhead_breakdown.png",
+}
+
+SUMMARY_TARGET_SIZES = {
+    "LP": [50, 500, 5000],
+    "NLP": [50, 500, 5000],
+    "CQP": [50, 500, 5000],
+    "MILP": [50, 500, 5000],
+}
+
+
 class Tee:
     """Helper to write to both stdout and a file."""
 
@@ -70,8 +94,8 @@ def cold_total_ms(self) -> float:
 
     @property
     def warm_total_ms(self) -> float:
-        """Total time for warm solve (build + cached solve)."""
-        return self.build_ms + self.warm_solve_ms
+        """Total time for warm solve (solve-only, excludes build)."""
+        return self.warm_solve_ms
 
     @property
     def cold_overhead(self) -> float:
@@ -80,8 +104,8 @@ def cold_overhead(self) -> float:
 
     @property
     def warm_overhead(self) -> float:
-        """Warm overhead vs SciPy."""
-        return self.warm_total_ms / self.scipy_ms if self.scipy_ms > 0 else float("inf")
+        """Warm overhead vs SciPy (solve-only, excludes build)."""
+        return self.warm_solve_ms / self.scipy_ms if self.scipy_ms > 0 else float("inf")
 
 
 @dataclass
@@ -111,6 +135,175 @@ def scipy_times(self) -> list[float]:
         return [r.scipy_ms for r in self.results]
 
 
+def benchmark_result_to_dict(result: BenchmarkResult) -> dict[str, float | int]:
+    """Serialize a benchmark result to JSON-compatible primitives."""
+    return {
+        "n": int(result.n),
+        "build_ms": float(result.build_ms),
+        "cold_solve_ms": float(result.cold_solve_ms),
+        "warm_solve_ms": float(result.warm_solve_ms),
+        "scipy_ms": float(result.scipy_ms),
+        "cold_total_ms": float(result.cold_total_ms),
+        "warm_total_ms": float(result.warm_total_ms),
+        "cold_overhead": float(result.cold_overhead),
+        "warm_overhead": float(result.warm_overhead),
+    }
+
+
+def scaling_results_to_dict(results: ScalingResults) -> dict[str, object]:
+    """Serialize a scaling result series for documentation consumption."""
+    return {
+        "label": results.label,
+        "results": [benchmark_result_to_dict(result) for result in results.results],
+    }
+
+
+def find_benchmark_result(
+    results: ScalingResults,
+    n: int,
+) -> BenchmarkResult:
+    """Look up a benchmark result by size."""
+    for result in results.results:
+        if result.n == n:
+            return result
+    raise ValueError(f"No benchmark result for n={n} in {results.label}")
+
+
+def summary_note(problem_type: str, result: BenchmarkResult, *, max_size: int) -> str:
+    """Generate a brief note for the performance summary table."""
+    if problem_type == "NLP":
+        if result.n >= max_size:
+            return "Simple quadratic; SciPy converges almost instantly"
+        return "Autodiff overhead on a trivially simple objective"
+    if problem_type == "LP":
+        if result.n >= max_size:
+            return "Scales to large LPs while staying near parity"
+        return "Near-parity with SciPy linprog"
+    if problem_type == "CQP":
+        if result.n >= max_size:
+            return "Exact Jacobians keep constrained solves near parity"
+        return "O(1) Jacobian compilation for vectorized constraints"
+    if problem_type == "MILP":
+        if result.n >= max_size:
+            return "Scales to large binary knapsack problems"
+        return "Near-parity with SciPy milp"
+    return "Derived from the latest benchmark run"
+
+
+def build_benchmark_payload(
+    *,
+    lp_loop_results: ScalingResults,
+    lp_vec_results: ScalingResults,
+    nlp_loop_results: ScalingResults,
+    nlp_vec_results: ScalingResults,
+    cqp_loop_results: ScalingResults,
+    cqp_vec_results: ScalingResults,
+    milp_loop_results: ScalingResults,
+    milp_vec_results: ScalingResults,
+) -> dict[str, object]:
+    """Build structured benchmark data for the documentation page."""
+    vector_series = {
+        "LP": lp_vec_results,
+        "NLP": nlp_vec_results,
+        "CQP": cqp_vec_results,
+        "MILP": milp_vec_results,
+    }
+
+    performance_summary = []
+    for problem_type, sizes in SUMMARY_TARGET_SIZES.items():
+        series = vector_series[problem_type]
+        max_size = max(result.n for result in series.results)
+        for size in sizes:
+            result = find_benchmark_result(series, size)
+            performance_summary.append(
+                {
+                    "problem_type": problem_type,
+                    "size": int(size),
+                    "cold_overhead": float(result.cold_overhead),
+                    "warm_overhead": float(result.warm_overhead),
+                    "note": summary_note(problem_type, result, max_size=max_size),
+                }
+            )
+
+    overhead_summary = []
+    for problem_type, series in vector_series.items():
+        for size in (50, max(result.n for result in series.results)):
+            result = find_benchmark_result(series, size)
+            overhead_summary.append(
+                {
+                    "problem_type": problem_type,
+                    "size": int(size),
+                    "cold_overhead": float(result.cold_overhead),
+                    "warm_overhead": float(result.warm_overhead),
+                }
+            )
+
+    return {
+        "benchmark_suite": "run_benchmarks",
+        "artifacts": {
+            "plots": PLOT_FILE_NAMES,
+            "metadata": "benchmark_metadata.json",
+            "output_log": "benchmark_output.txt",
+            "results_json": "benchmark_results.json",
+        },
+        "performance_summary": performance_summary,
+        "overhead_summary": overhead_summary,
+        "scaling": {
+            "lp": {
+                "loop": scaling_results_to_dict(lp_loop_results),
+                "vector": scaling_results_to_dict(lp_vec_results),
+            },
+            "nlp": {
+                "loop": scaling_results_to_dict(nlp_loop_results),
+                "vector": scaling_results_to_dict(nlp_vec_results),
+            },
+            "cqp": {
+                "loop": scaling_results_to_dict(cqp_loop_results),
+                "vector": scaling_results_to_dict(cqp_vec_results),
+            },
+            "milp": {
+                "loop": scaling_results_to_dict(milp_loop_results),
+                "vector": scaling_results_to_dict(milp_vec_results),
+            },
+        },
+    }
+
+
+def write_benchmark_results_json(
+    payload: dict[str, object],
+    file_name: str = "benchmark_results.json",
+) -> Path:
+    """Persist structured benchmark results for documentation rendering."""
+    output_path = RESULTS_DIR / file_name
+    output_path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n")
+    return output_path
+
+
+def sync_results_to_docs_assets(files: list[Path]) -> list[Path]:
+    """Copy benchmark artifacts into docs/assets/benchmarks."""
+    DOCS_BENCHMARKS_DIR.mkdir(parents=True, exist_ok=True)
+
+    copied: list[Path] = []
+    seen: set[str] = set()
+    for file_path in files:
+        if not file_path.exists() or file_path.name in seen:
+            continue
+        destination = DOCS_BENCHMARKS_DIR / file_path.name
+        shutil.copy2(file_path, destination)
+        copied.append(destination)
+        seen.add(file_path.name)
+
+    return copied
+
+
+def collect_results_artifacts() -> list[Path]:
+    """Collect result artifacts that should be mirrored into docs assets."""
+    artifacts: list[Path] = []
+    for pattern in ("*.json", "*.txt", "*.png"):
+        artifacts.extend(sorted(RESULTS_DIR.glob(pattern)))
+    return artifacts
+
+
 def time_scipy_lp(
     c: np.ndarray, A: np.ndarray, b: np.ndarray, n_runs: int = 5
 ) -> float:
@@ -119,9 +312,10 @@ def time_scipy_lp(
     times = []
     for _ in range(n_runs):
         start = time.perf_counter()
-        linprog(-c, A_ub=A, b_ub=b, bounds=bounds, method="highs")
+        res = linprog(-c, A_ub=A, b_ub=b, bounds=bounds, method="highs")
         times.append((time.perf_counter() - start) * 1000)
-    return np.mean(times)
+        assert res.success, f"SciPy LP failed: {res.message}"
+    return float(np.mean(times))
 
 
 def time_scipy_nlp(n: int, n_runs: int = 5) -> float:
@@ -137,9 +331,11 @@ def grad(v):
     times = []
     for _ in range(n_runs):
         start = time.perf_counter()
-        minimize(obj, x0, jac=grad, method="BFGS")
+        # Use L-BFGS-B to match optyx's auto-selected method for unconstrained NLP
+        res = minimize(obj, x0, jac=grad, method="L-BFGS-B")
         times.append((time.perf_counter() - start) * 1000)
-    return np.mean(times)
+        assert res.success, f"SciPy NLP failed: {res.message}"
+    return float(np.mean(times))
 
 
 def time_scipy_constrained_nlp(n: int, n_runs: int = 5) -> float:
@@ -164,11 +360,36 @@ def grad(v):
     times = []
     for _ in range(n_runs):
         start = time.perf_counter()
-        minimize(
+        res = minimize(
             obj, x0, jac=grad, method="SLSQP", constraints=constraints, bounds=bounds
         )
         times.append((time.perf_counter() - start) * 1000)
-    return np.mean(times)
+        assert res.success, f"SciPy CQP failed: {res.message}"
+    return float(np.mean(times))
+
+
+def time_scipy_milp(
+    c: np.ndarray,
+    capacity: int,
+    n_runs: int = 5,
+) -> float:
+    """Time SciPy MILP solve (average of n_runs).
+
+    Single-constraint binary knapsack: max c'x s.t. sum(x) <= capacity, x in {0,1}.
+    """
+    from scipy.optimize import milp, LinearConstraint, Bounds
+
+    n = len(c)
+    bounds = Bounds(lb=cast(Any, np.zeros(n)), ub=cast(Any, np.ones(n)))
+    constraints = LinearConstraint(np.ones((1, n)), -np.inf, capacity)
+    integrality = np.ones(n, dtype=int)
+    times = []
+    for _ in range(n_runs):
+        start = time.perf_counter()
+        res = milp(-c, constraints=constraints, integrality=integrality, bounds=bounds)
+        times.append((time.perf_counter() - start) * 1000)
+        assert res.success, f"SciPy MILP failed: {res.message}"
+    return float(np.mean(times))
 
 
 def benchmark_lp_loop(
@@ -181,7 +402,7 @@ def benchmark_lp_loop(
     start = time.perf_counter()
     x = np.array([Variable(f"x{i}", lb=0, ub=1) for i in range(n)])
     prob = Problem(name=f"lp_loop_{n}")
-    prob.maximize(c @ x)
+    prob.maximize(sum(float(c[i]) * x[i] for i in range(n)))
     for i in range(m):
         prob.subject_to(A[i] @ x <= b[i])
     build_ms = (time.perf_counter() - start) * 1000
@@ -191,13 +412,13 @@ def benchmark_lp_loop(
     prob.solve()
     cold_solve_ms = (time.perf_counter() - start) * 1000
 
-    # Time warm solves (3 runs)
+    # Time warm solves (5 runs)
     warm_times = []
-    for _ in range(3):
+    for _ in range(5):
         start = time.perf_counter()
         prob.solve()
         warm_times.append((time.perf_counter() - start) * 1000)
-    warm_solve_ms = np.mean(warm_times)
+    warm_solve_ms = float(np.mean(warm_times))
 
     # SciPy baseline
     scipy_ms = time_scipy_lp(c, A, b)
@@ -215,7 +436,7 @@ def benchmark_lp_vector(
     start = time.perf_counter()
     x = VectorVariable("x", n, lb=0, ub=1)
     prob = Problem(name=f"lp_vec_{n}")
-    prob.maximize(c @ x)
+    prob.maximize(x @ c)
     for i in range(m):
         prob.subject_to(A[i] @ x <= b[i])
     build_ms = (time.perf_counter() - start) * 1000
@@ -225,13 +446,13 @@ def benchmark_lp_vector(
     prob.solve()
     cold_solve_ms = (time.perf_counter() - start) * 1000
 
-    # Time warm solves (3 runs)
+    # Time warm solves (5 runs)
     warm_times = []
-    for _ in range(3):
+    for _ in range(5):
         start = time.perf_counter()
         prob.solve()
         warm_times.append((time.perf_counter() - start) * 1000)
-    warm_solve_ms = np.mean(warm_times)
+    warm_solve_ms = float(np.mean(warm_times))
 
     # SciPy baseline
     scipy_ms = time_scipy_lp(c, A, b)
@@ -255,13 +476,13 @@ def benchmark_nlp_loop(n: int) -> BenchmarkResult:
     prob.solve(x0=x0)
     cold_solve_ms = (time.perf_counter() - start) * 1000
 
-    # Time warm solves (3 runs)
+    # Time warm solves (5 runs)
     warm_times = []
-    for _ in range(3):
+    for _ in range(5):
         start = time.perf_counter()
         prob.solve(x0=x0)
         warm_times.append((time.perf_counter() - start) * 1000)
-    warm_solve_ms = np.mean(warm_times)
+    warm_solve_ms = float(np.mean(warm_times))
 
     # SciPy baseline
     scipy_ms = time_scipy_nlp(n)
@@ -286,13 +507,13 @@ def benchmark_nlp_vector(n: int) -> BenchmarkResult:
     prob.solve(x0=x0)
     cold_solve_ms = (time.perf_counter() - start) * 1000
 
-    # Time warm solves (3 runs)
+    # Time warm solves (5 runs)
     warm_times = []
-    for _ in range(3):
+    for _ in range(5):
         start = time.perf_counter()
         prob.solve(x0=x0)
         warm_times.append((time.perf_counter() - start) * 1000)
-    warm_solve_ms = np.mean(warm_times)
+    warm_solve_ms = float(np.mean(warm_times))
 
     # SciPy baseline
     scipy_ms = time_scipy_nlp(n)
@@ -317,13 +538,13 @@ def benchmark_cqp_loop(n: int) -> BenchmarkResult:
     prob.solve(x0=x0)
     cold_solve_ms = (time.perf_counter() - start) * 1000
 
-    # Time warm solves (3 runs)
+    # Time warm solves (5 runs)
     warm_times = []
-    for _ in range(3):
+    for _ in range(5):
         start = time.perf_counter()
         prob.solve(x0=x0)
         warm_times.append((time.perf_counter() - start) * 1000)
-    warm_solve_ms = np.mean(warm_times)
+    warm_solve_ms = float(np.mean(warm_times))
 
     # SciPy baseline
     scipy_ms = time_scipy_constrained_nlp(n)
@@ -349,13 +570,13 @@ def benchmark_cqp_vector(n: int) -> BenchmarkResult:
     prob.solve(x0=x0)
     cold_solve_ms = (time.perf_counter() - start) * 1000
 
-    # Time warm solves (3 runs)
+    # Time warm solves (5 runs)
     warm_times = []
-    for _ in range(3):
+    for _ in range(5):
         start = time.perf_counter()
         prob.solve(x0=x0)
         warm_times.append((time.perf_counter() - start) * 1000)
-    warm_solve_ms = np.mean(warm_times)
+    warm_solve_ms = float(np.mean(warm_times))
 
     # SciPy baseline
     scipy_ms = time_scipy_constrained_nlp(n)
@@ -363,10 +584,75 @@ def benchmark_cqp_vector(n: int) -> BenchmarkResult:
     return BenchmarkResult(n, build_ms, cold_solve_ms, warm_solve_ms, scipy_ms)
 
 
+def benchmark_milp_loop(n: int, c: np.ndarray, capacity: int) -> BenchmarkResult:
+    """Benchmark MILP with loop-based variables (full end-to-end).
+
+    Single-constraint binary knapsack: max c'x s.t. sum(x) <= capacity, x in {0,1}.
+    """
+    # Time build phase
+    start = time.perf_counter()
+    x = np.array([BinaryVariable(f"x{i}") for i in range(n)])
+    prob = Problem(name=f"milp_loop_{n}")
+    prob.maximize(sum(float(c[i]) * x[i] for i in range(n)))
+    prob.subject_to(np.sum(x) <= capacity)
+    build_ms = (time.perf_counter() - start) * 1000
+
+    # Time cold solve
+    start = time.perf_counter()
+    prob.solve()
+    cold_solve_ms = (time.perf_counter() - start) * 1000
+
+    # Time warm solves (5 runs)
+    warm_times = []
+    for _ in range(5):
+        start = time.perf_counter()
+        prob.solve()
+        warm_times.append((time.perf_counter() - start) * 1000)
+    warm_solve_ms = float(np.mean(warm_times))
+
+    # SciPy baseline
+    scipy_ms = time_scipy_milp(c, capacity)
+
+    return BenchmarkResult(n, build_ms, cold_solve_ms, warm_solve_ms, scipy_ms)
+
+
+def benchmark_milp_vector(n: int, c: np.ndarray, capacity: int) -> BenchmarkResult:
+    """Benchmark MILP with VectorVariable (full end-to-end).
+
+    Single-constraint binary knapsack: max c'x s.t. sum(x) <= capacity, x in {0,1}.
+    Uses a single binary VectorVariable to leverage efficient vectorized ops.
+    """
+    # Time build phase
+    start = time.perf_counter()
+    x = VectorVariable("x", n, domain="binary")
+    prob = Problem(name=f"milp_vec_{n}")
+    prob.maximize(x @ c)
+    prob.subject_to(x.sum() <= capacity)
+    build_ms = (time.perf_counter() - start) * 1000
+
+    # Time cold solve
+    start = time.perf_counter()
+    prob.solve()
+    cold_solve_ms = (time.perf_counter() - start) * 1000
+
+    # Time warm solves (5 runs)
+    warm_times = []
+    for _ in range(5):
+        start = time.perf_counter()
+        prob.solve()
+        warm_times.append((time.perf_counter() - start) * 1000)
+    warm_solve_ms = float(np.mean(warm_times))
+
+    # SciPy baseline
+    scipy_ms = time_scipy_milp(c, capacity)
+
+    return BenchmarkResult(n, build_ms, cold_solve_ms, warm_solve_ms, scipy_ms)
+
+
 def print_result(label: str, r: BenchmarkResult) -> None:
     """Print a benchmark result with full breakdown."""
     print(
-        f"  n={r.n:5d}: Build={r.build_ms:8.1f}ms, "
+        f"  {label:4s} n={r.n:5d}: Build={r.build_ms:8.1f}ms, "
         f"Cold={r.cold_solve_ms:8.1f}ms, Warm={r.warm_solve_ms:7.1f}ms | "
         f"SciPy={r.scipy_ms:7.1f}ms | "
         f"Cold overhead={r.cold_overhead:5.1f}x, Warm overhead={r.warm_overhead:5.1f}x"
@@ -381,15 +667,15 @@ def run_lp_scaling():
     print("\nMeasures: Build (vars + problem + constraints) + Solve")
     print("Compared against: SciPy linprog (no build phase)")
 
-    # Loop-based: limited to n=100 due to exponential cold solve time
-    loop_sizes = [10, 25, 50, 100]
-    # VectorVariable: scale to n=5000 to test large problems
+    # Loop-based: limited due to superlinear cold solve time
+    loop_sizes = [10, 25, 50, 100, 200, 500]
+    # VectorVariable: scale to n=5000 (LP solver dominates at larger sizes)
     vec_sizes = [10, 25, 50, 100, 200, 500, 1000, 2000, 5000]
 
     loop_results = ScalingResults(label="LP (Loop)")
     vec_results = ScalingResults(label="LP (VectorVariable)")
 
-    print("\n--- Loop-based Variable (n ≤ 100, slow cold solve) ---")
+    print(f"\n--- Loop-based Variable (n ≤ {max(loop_sizes)}, slow cold solve) ---")
     for n in loop_sizes:
         m = n // 2
         np.random.seed(42)
@@ -401,7 +687,7 @@ def run_lp_scaling():
         loop_results.add(r)
         print_result("Loop", r)
 
-    print("\n--- VectorVariable (n ≤ 5,000) ---")
+    print(f"\n--- VectorVariable (n ≤ {max(vec_sizes):,}) ---")
     for n in vec_sizes:
         m = n // 2
         np.random.seed(42)
@@ -432,21 +718,21 @@ def run_nlp_scaling():
     print("\nObjective: min Σx²ᵢ - Σxᵢ (optimal at x* = 0.5)")
     print("Measures: Build + Solve (includes gradient compilation)")
 
-    # Loop-based: limited to n=100 due to exponential cold solve time
-    loop_sizes = [10, 25, 50, 100]
-    # VectorVariable with vectorized ops: scale to n=10000 to test large problems
+    # Loop-based: limited to n=500 due to superlinear cold solve time
+    loop_sizes = [10, 25, 50, 100, 200, 500]
+    # VectorVariable with vectorized ops: scale to n=10,000
     vec_sizes = [10, 25, 50, 100, 200, 500, 1000, 2000, 5000]
 
     loop_results = ScalingResults(label="NLP (Loop)")
     vec_results = ScalingResults(label="NLP (VectorVariable)")
 
-    print("\n--- Loop-based Variable (n ≤ 100, slow cold solve) ---")
+    print(f"\n--- Loop-based Variable (n ≤ {max(loop_sizes)}, slow cold solve) ---")
     for n in loop_sizes:
         r = benchmark_nlp_loop(n)
         loop_results.add(r)
         print_result("Loop", r)
 
-    print("\n--- VectorVariable with x.dot(x) - x.sum() (n ≤ 5,000) ---")
+    print(f"\n--- VectorVariable with x.dot(x) - x.sum() (n ≤ {max(vec_sizes):,}) ---")
     for n in vec_sizes:
         r = benchmark_nlp_vector(n)
         vec_results.add(r)
@@ -471,21 +757,21 @@ def run_cqp_scaling():
     print("\nObjective: min Σx²ᵢ s.t. Σxᵢ ≥ 1, xᵢ ≥ 0")
     print("Measures: Build + Solve (includes gradient/Jacobian compilation)")
 
-    # Loop-based: limited to n=100 due to exponential cold solve time
-    loop_sizes = [10, 25, 50, 100]
-    # VectorVariable: scale to n=5000 to test large problems
+    # Loop-based: limited due to superlinear cold solve time
+    loop_sizes = [10, 25, 50, 100, 200, 500]
+    # VectorVariable: scale to n=5000 (SLSQP solver is O(n²), dominates at larger sizes)
     vec_sizes = [10, 25, 50, 100, 200, 500, 1000, 2000, 5000]
 
     loop_results = ScalingResults(label="CQP (Loop)")
     vec_results = ScalingResults(label="CQP (VectorVariable)")
 
-    print("\n--- Loop-based Variable (n ≤ 100, slow cold solve) ---")
+    print(f"\n--- Loop-based Variable (n ≤ {max(loop_sizes)}, slow cold solve) ---")
     for n in loop_sizes:
         r = benchmark_cqp_loop(n)
         loop_results.add(r)
         print_result("Loop", r)
 
-    print("\n--- VectorVariable with x.dot(x), x.sum() (n ≤ 5,000) ---")
+    print(f"\n--- VectorVariable with x.dot(x), x.sum() (n ≤ {max(vec_sizes)}) ---")
     for n in vec_sizes:
         r = benchmark_cqp_vector(n)
         vec_results.add(r)
@@ -502,6 +788,54 @@ def run_cqp_scaling():
     return loop_results, vec_results
 
 
+def run_milp_scaling():
+    """Run MILP scaling benchmarks."""
+    print("\n" + "=" * 80)
+    print("MILP SCALING BENCHMARK (End-to-End)")
+    print("=" * 80)
+    print("\nMeasures: Build (vars + problem + constraints) + Solve")
+    print("Compared against: SciPy milp (no build phase)")
+    print("Problem: Single-constraint binary knapsack (sum(x) <= n//2)")
+
+    # Loop-based: push to n=500 to measure build overhead at scale
+    loop_sizes = [10, 25, 50, 100, 200, 500]
+    # VectorVariable: push to n=5000 to measure solve scaling
+    vec_sizes = [10, 25, 50, 100, 200, 500, 1000, 2000, 5000]
+
+    loop_results = ScalingResults(label="MILP (Loop)")
+    vec_results = ScalingResults(label="MILP (VectorVariable)")
+
+    print(f"\n--- Loop-based Variable (n ≤ {max(loop_sizes)}, slow cold solve) ---")
+    for n in loop_sizes:
+        np.random.seed(42)
+        c = np.random.rand(n)
+        capacity = n // 2  # Pick at most half the items
+
+        r = benchmark_milp_loop(n, c, capacity)
+        loop_results.add(r)
+        print_result("Loop", r)
+
+    print(f"\n--- VectorVariable (n ≤ {max(vec_sizes)}) ---")
+    for n in vec_sizes:
+        np.random.seed(42)
+        c = np.random.rand(n)
+        capacity = n // 2
+
+        r = benchmark_milp_vector(n, c, capacity)
+        vec_results.add(r)
+        print_result("Vec", r)
+
+    # Plot
+    plot_scaling_comparison(
+        loop_results,
+        vec_results,
+        title="MILP Scaling: End-to-End Time vs SciPy",
+        save_path=RESULTS_DIR / "milp_scaling_comparison.png",
+    )
+
+    return loop_results, vec_results
+
+
 def plot_scaling_comparison(
     loop_results: ScalingResults,
     vec_results: ScalingResults,
@@ -633,7 +967,10 @@ def plot_scaling_comparison(
 
     ax2.set_xlabel("Problem Size (n)", fontsize=11)
     ax2.set_ylabel("Overhead vs SciPy (×)", fontsize=11)
-    ax2.set_title("Overhead Ratio (log scale, lower is better)", fontsize=12)
+    ax2.set_title(
+        "Overhead Ratio (log scale, lower is better)\nWarm = solve-only (excludes build)",
+        fontsize=11,
+    )
     ax2.set_xscale("log")
     ax2.set_yscale("log")
     ax2.legend(loc="upper right", fontsize=9)
@@ -646,8 +983,18 @@ def plot_scaling_comparison(
     plt.close()
 
 
-def run_overhead_summary():
-    """Generate overhead summary for common problem types."""
+def run_overhead_summary(
+    lp_results: ScalingResults | None = None,
+    nlp_results: ScalingResults | None = None,
+    cqp_results: ScalingResults | None = None,
+    milp_results: ScalingResults | None = None,
+):
+    """Generate overhead summary from previously recorded scaling results.
+
+    When pre-recorded results are provided the summary is derived directly
+    from them so that the numbers are consistent with the detailed tables.
+    Falls back to a fresh measurement only when a result set is missing.
+    """
     print("\n" + "=" * 80)
     print("OVERHEAD SUMMARY BY PROBLEM TYPE")
     print("=" * 80)
@@ -656,58 +1003,58 @@ def run_overhead_summary():
     cold_overheads = []
     warm_overheads = []
 
-    # Small LP (n=50)
-    n, m = 50, 25
-    np.random.seed(42)
-    c = np.random.rand(n)
-    A = np.random.rand(m, n)
-    b = np.sum(A, axis=1) * 0.5
-
-    r = benchmark_lp_vector(n, c, A, b)
-    categories.append(f"LP\nn={n}")
-    cold_overheads.append(r.cold_overhead)
-    warm_overheads.append(r.warm_overhead)
-    print(f"LP (n={n}): Cold={r.cold_overhead:.1f}x, Warm={r.warm_overhead:.1f}x")
-
-    # Medium LP (n=500)
-    n, m = 500, 250
-    c = np.random.rand(n)
-    A = np.random.rand(m, n)
-    b = np.sum(A, axis=1) * 0.5
-
-    r = benchmark_lp_vector(n, c, A, b)
-    categories.append(f"LP\nn={n}")
-    cold_overheads.append(r.cold_overhead)
-    warm_overheads.append(r.warm_overhead)
-    print(f"LP (n={n}): Cold={r.cold_overhead:.1f}x, Warm={r.warm_overhead:.1f}x")
-
-    # Small NLP (n=50)
-    r = benchmark_nlp_vector(50)
-    categories.append("NLP\nn=50")
-    cold_overheads.append(r.cold_overhead)
-    warm_overheads.append(r.warm_overhead)
-    print(f"NLP (n=50): Cold={r.cold_overhead:.1f}x, Warm={r.warm_overhead:.1f}x")
-
-    # Medium NLP (n=500)
-    r = benchmark_nlp_vector(500)
-    categories.append("NLP\nn=500")
-    cold_overheads.append(r.cold_overhead)
-    warm_overheads.append(r.warm_overhead)
-    print(f"NLP (n=500): Cold={r.cold_overhead:.1f}x, Warm={r.warm_overhead:.1f}x")
-
-    # Small CQP (n=50)
-    r = benchmark_cqp_vector(50)
-    categories.append("CQP\nn=50")
-    cold_overheads.append(r.cold_overhead)
-    warm_overheads.append(r.warm_overhead)
-    print(f"CQP (n=50): Cold={r.cold_overhead:.1f}x, Warm={r.warm_overhead:.1f}x")
-
-    # Medium CQP (n=500)
-    r = benchmark_cqp_vector(500)
-    categories.append("CQP\nn=500")
-    cold_overheads.append(r.cold_overhead)
-    warm_overheads.append(r.warm_overhead)
-    print(f"CQP (n=500): Cold={r.cold_overhead:.1f}x, Warm={r.warm_overhead:.1f}x")
+    def _add(label: str, result: BenchmarkResult):
+        categories.append(label)
+        cold_overheads.append(result.cold_overhead)
+        warm_overheads.append(result.warm_overhead)
+        print(
+            f"{label.replace(chr(10), ' ')}: "
+            f"Cold={result.cold_overhead:.1f}x, Warm={result.warm_overhead:.1f}x"
+        )
+
+    def _find(results: ScalingResults | None, n: int) -> BenchmarkResult | None:
+        if results is None:
+            return None
+        for r in results.results:
+            if r.n == n:
+                return r
+        return None
+
+    # --- LP ---
+    for n in (50, 5000):
+        r = _find(lp_results, n)
+        if r is None:
+            m = n // 2
+            np.random.seed(42)
+            c = np.random.rand(n)
+            A = np.random.rand(m, n)
+            b = np.sum(A, axis=1) * 0.5
+            r = benchmark_lp_vector(n, c, A, b)
+        _add(f"LP\nn={n}", r)
+
+    # --- NLP ---
+    for n in (50, 5000):
+        r = _find(nlp_results, n)
+        if r is None:
+            r = benchmark_nlp_vector(n)
+        _add(f"NLP\nn={n}", r)
+
+    # --- CQP ---
+    for n in (50, 5000):
+        r = _find(cqp_results, n)
+        if r is None:
+            r = benchmark_cqp_vector(n)
+        _add(f"CQP\nn={n}", r)
+
+    # --- MILP ---
+    for n in (50, 5000):
+        r = _find(milp_results, n)
+        if r is None:
+            np.random.seed(42)
+            c = np.random.rand(n)
+            capacity = n // 2
+            r = benchmark_milp_vector(n, c, capacity)
+        _add(f"MILP\nn={n}", r)
 
     # Plot
     fig, ax = plt.subplots(figsize=(10, 6))
@@ -779,11 +1126,17 @@ def run_overhead_summary():
 def main():
     """Run all benchmarks."""
     RESULTS_DIR.mkdir(parents=True, exist_ok=True)
+    metadata_path = write_benchmark_metadata(
+        RESULTS_DIR,
+        extra={"benchmark_suite": "run_benchmarks"},
+    )
 
     # Capture output to file
     output_path = RESULTS_DIR / "benchmark_output.txt"
     original_stdout = sys.stdout
 
+    results_payload: dict[str, object] | None = None
+
     with open(output_path, "w") as log_file:
         sys.stdout = Tee(sys.stdout, log_file)  # type: ignore
 
@@ -800,14 +1153,34 @@ def main():
             print("\nCompared against SciPy (which has no build phase).")
             print(f"\nResults will be saved to: {RESULTS_DIR}")
             print(f"Terminal output being saved to: {output_path}")
-
-            # Run scaling benchmarks
-            run_lp_scaling()
-            run_nlp_scaling()
-            run_cqp_scaling()
-
-            # Run overhead summary
-            run_overhead_summary()
+            print(f"Benchmark metadata saved to: {metadata_path}")
+
+            # Run scaling benchmarks (capture results for summary)
+            lp_loop_results, lp_vec_results = run_lp_scaling()
+            nlp_loop_results, nlp_vec_results = run_nlp_scaling()
+            cqp_loop_results, cqp_vec_results = run_cqp_scaling()
+            milp_loop_results, milp_vec_results = run_milp_scaling()
+
+            results_payload = build_benchmark_payload(
+                lp_loop_results=lp_loop_results,
+                lp_vec_results=lp_vec_results,
+                nlp_loop_results=nlp_loop_results,
+                nlp_vec_results=nlp_vec_results,
+                cqp_loop_results=cqp_loop_results,
+                cqp_vec_results=cqp_vec_results,
+                milp_loop_results=milp_loop_results,
+                milp_vec_results=milp_vec_results,
+            )
+            benchmark_results_path = write_benchmark_results_json(results_payload)
+            print(f"Structured benchmark results saved to: {benchmark_results_path}")
+
+            # Run overhead summary from recorded data (no fresh recompute)
+            run_overhead_summary(
+                lp_results=lp_vec_results,
+                nlp_results=nlp_vec_results,
+                cqp_results=cqp_vec_results,
+                milp_results=milp_vec_results,
+            )
 
             print("\n" + "=" * 80)
             print("BENCHMARK COMPLETE")
@@ -819,6 +1192,14 @@ def main():
         finally:
             sys.stdout = original_stdout
 
+    if results_payload is not None:
+        artifacts_to_sync = collect_results_artifacts()
+        copied_files = sync_results_to_docs_assets(artifacts_to_sync)
+
+        print(f"Synced benchmark artifacts to: {DOCS_BENCHMARKS_DIR}")
+        for file_path in copied_files:
+            print(f"  - {file_path.name}")
+
 
 if __name__ == "__main__":
     main()
diff --git a/benchmarks/sparse_benchmark.py b/benchmarks/sparse_benchmark.py
new file mode 100644
index 0000000..ef47d3d
--- /dev/null
+++ b/benchmarks/sparse_benchmark.py
@@ -0,0 +1,402 @@
+"""Sparse vs Dense Jacobian compilation benchmark.
+
+Demonstrates the memory and performance benefit of compile_sparse_jacobian
+vs compile_jacobian for problems with sparse constraint structure.
+
+Generates comparison plots saved to benchmarks/results/.
+"""
+
+import time
+import numpy as np
+from optyx import Variable
+from optyx.core.autodiff import compile_jacobian, compile_sparse_jacobian
+from scipy import sparse
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+RESULTS_DIR = Path(__file__).parent / "results"
+RESULTS_DIR.mkdir(exist_ok=True)
+
+
+def benchmark_chain_constraints(n_values: list[int]) -> dict:
+    """Benchmark chain constraints: x_i + x_{i+1} <= 1.
+
+    Each row of the Jacobian has exactly 2 non-zeros → density = 2/n.
+    This is the classic pattern for sparse benefit.
+    """
+    print("=" * 70)
+    print("CHAIN CONSTRAINTS: x_i + x_{i+1} (2 nnz per row, density=2/n)")
+    print("=" * 70)
+    print(
+        f"{'n':>6} | {'Dense Compile':>14} | {'Sparse Compile':>15} | {'Dense Eval':>11} | {'Sparse Eval':>12} | {'Compile Speedup':>16} | {'Eval Speedup':>13} | {'Density':>8}"
+    )
+    print("-" * 120)
+
+    data = {
+        "n": [],
+        "dense_compile": [],
+        "sparse_compile": [],
+        "dense_eval": [],
+        "sparse_eval": [],
+        "compile_speedup": [],
+        "eval_speedup": [],
+    }
+
+    for n in n_values:
+        variables = [Variable(f"x{i}") for i in range(n)]
+        exprs = [variables[i] + variables[i + 1] for i in range(n - 1)]
+        x = np.ones(n)
+
+        # Dense compilation
+        t0 = time.perf_counter()
+        dense_fn = compile_jacobian(exprs, variables)
+        t_dense_compile = time.perf_counter() - t0
+
+        # Sparse compilation
+        t0 = time.perf_counter()
+        sparse_fn = compile_sparse_jacobian(exprs, variables)
+        t_sparse_compile = time.perf_counter() - t0
+
+        # Dense evaluation (average of 10 runs)
+        for _ in range(3):
+            dense_fn(x)
+        t0 = time.perf_counter()
+        for _ in range(10):
+            dense_result = dense_fn(x)
+        t_dense_eval = (time.perf_counter() - t0) / 10
+
+        # Sparse evaluation (average of 10 runs)
+        for _ in range(3):
+            sparse_fn(x)
+        t0 = time.perf_counter()
+        for _ in range(10):
+            sparse_result = sparse_fn(x)
+        t_sparse_eval = (time.perf_counter() - t0) / 10
+
+        # Verify correctness
+        if sparse.issparse(sparse_result):
+            np.testing.assert_array_almost_equal(sparse_result.toarray(), dense_result)
+
+        density = 2.0 / n
+        compile_speedup = (
+            t_dense_compile / t_sparse_compile if t_sparse_compile > 0 else float("inf")
+        )
+        eval_speedup = (
+            t_dense_eval / t_sparse_eval if t_sparse_eval > 0 else float("inf")
+        )
+
+        data["n"].append(n)
+        data["dense_compile"].append(t_dense_compile * 1000)
+        data["sparse_compile"].append(t_sparse_compile * 1000)
+        data["dense_eval"].append(t_dense_eval * 1000)
+        data["sparse_eval"].append(t_sparse_eval * 1000)
+        data["compile_speedup"].append(compile_speedup)
+        data["eval_speedup"].append(eval_speedup)
+
+        print(
+            f"  {n:>4} | {t_dense_compile * 1000:>12.2f}ms | {t_sparse_compile * 1000:>13.2f}ms | "
+            f"{t_dense_eval * 1000:>9.3f}ms | {t_sparse_eval * 1000:>10.3f}ms | "
+            f"{compile_speedup:>14.1f}x | {eval_speedup:>11.1f}x | {density:>7.1%}"
+        )
+
+    return data
+
+
+def benchmark_pairwise_constraints(n_values: list[int]) -> dict:
+    """Benchmark pairwise constraints on random pairs.
+
+    Each constraint involves exactly 2 of n variables.
+    Number of constraints = n (so Jacobian is n × n with ~2n non-zeros).
+    """
+    print()
+    print("=" * 70)
+    print("PAIRWISE CONSTRAINTS: x_i - x_j (2 nnz per row, m=n)")
+    print("=" * 70)
+    print(
+        f"{'n':>6} | {'Dense Eval':>11} | {'Sparse Eval':>12} | {'Eval Speedup':>13} | {'Dense Memory':>13} | {'Sparse Memory':>14}"
+    )
+    print("-" * 90)
+
+    data = {
+        "n": [],
+        "dense_eval": [],
+        "sparse_eval": [],
+        "eval_speedup": [],
+        "dense_mem": [],
+        "sparse_mem": [],
+    }
+
+    for n in n_values:
+        variables = [Variable(f"x{i}") for i in range(n)]
+        rng = np.random.RandomState(42)
+        pairs = [(rng.randint(0, n), rng.randint(0, n)) for _ in range(n)]
+        exprs = [variables[i] - variables[j] for i, j in pairs if i != j]
+        x = np.ones(n)
+
+        dense_fn = compile_jacobian(exprs, variables)
+        sparse_fn = compile_sparse_jacobian(exprs, variables)
+
+        # Warmup
+        for _ in range(3):
+            dense_fn(x)
+            sparse_fn(x)
+
+        # Eval
+        t0 = time.perf_counter()
+        for _ in range(10):
+            dense_result = dense_fn(x)
+        t_dense = (time.perf_counter() - t0) / 10
+
+        t0 = time.perf_counter()
+        for _ in range(10):
+            sparse_result = sparse_fn(x)
+        t_sparse = (time.perf_counter() - t0) / 10
+
+        dense_mem = dense_result.nbytes
+        if sparse.issparse(sparse_result):
+            sparse_mem = (
+                sparse_result.data.nbytes
+                + sparse_result.indices.nbytes
+                + sparse_result.indptr.nbytes
+            )
+        else:
+            sparse_mem = sparse_result.nbytes
+
+        speedup = t_dense / t_sparse if t_sparse > 0 else float("inf")
+
+        data["n"].append(n)
+        data["dense_eval"].append(t_dense * 1000)
+        data["sparse_eval"].append(t_sparse * 1000)
+        data["eval_speedup"].append(speedup)
+        data["dense_mem"].append(dense_mem)
+        data["sparse_mem"].append(sparse_mem)
+
+        print(
+            f"  {n:>4} | {t_dense * 1000:>9.3f}ms | {t_sparse * 1000:>10.3f}ms | "
+            f"{speedup:>11.1f}x | {dense_mem:>10,} B | {sparse_mem:>11,} B"
+        )
+
+    return data
+
+
+def benchmark_nonlinear_sparse(n_values: list[int]) -> dict:
+    """Benchmark non-linear sparse constraints: x_i^2 + x_{i+1}^2.
+
+    Each row has 2 non-zeros but gradient computation is non-trivial.
+    """
+    print()
+    print("=" * 70)
+    print("NONLINEAR SPARSE: x_i² + x_{i+1}² (2 nnz per row)")
+    print("=" * 70)
+    print(f"{'n':>6} | {'Dense Eval':>11} | {'Sparse Eval':>12} | {'Eval Speedup':>13}")
+    print("-" * 60)
+
+    data = {
+        "n": [],
+        "dense_eval": [],
+        "sparse_eval": [],
+        "eval_speedup": [],
+    }
+
+    for n in n_values:
+        variables = [Variable(f"x{i}") for i in range(n)]
+        exprs = [variables[i] ** 2 + variables[i + 1] ** 2 for i in range(n - 1)]
+        x = np.ones(n)
+
+        dense_fn = compile_jacobian(exprs, variables)
+        sparse_fn = compile_sparse_jacobian(exprs, variables)
+
+        # Warmup
+        for _ in range(3):
+            dense_fn(x)
+            sparse_fn(x)
+
+        # Eval
+        t0 = time.perf_counter()
+        for _ in range(10):
+            dense_fn(x)
+        t_dense = (time.perf_counter() - t0) / 10
+
+        t0 = time.perf_counter()
+        for _ in range(10):
+            sparse_fn(x)
+        t_sparse = (time.perf_counter() - t0) / 10
+
+        speedup = t_dense / t_sparse if t_sparse > 0 else float("inf")
+
+        data["n"].append(n)
+        data["dense_eval"].append(t_dense * 1000)
+        data["sparse_eval"].append(t_sparse * 1000)
+        data["eval_speedup"].append(speedup)
+
+        print(
+            f"  {n:>4} | {t_dense * 1000:>9.3f}ms | {t_sparse * 1000:>10.3f}ms | "
+            f"{speedup:>11.1f}x"
+        )
+
+    return data
+
+
+def plot_results(chain: dict, pairwise: dict, nonlinear: dict) -> None:
+    """Generate comparison plots and save to benchmarks/results/."""
+    fig, axes = plt.subplots(2, 3, figsize=(18, 10))
+    fig.suptitle("Sparse vs Dense Jacobian: Performance Comparison", fontsize=16, y=0.98)
+
+    # --- Row 1: Absolute timings ---
+
+    # 1a. Chain — Compile times
+    ax = axes[0, 0]
+    ax.plot(chain["n"], chain["dense_compile"], "o-", color="#d62728", label="Dense", linewidth=2)
+    ax.plot(chain["n"], chain["sparse_compile"], "s-", color="#2ca02c", label="Sparse", linewidth=2)
+    ax.set_xlabel("Problem size (n variables)")
+    ax.set_ylabel("Compile time (ms)")
+    ax.set_title("Chain: Compilation Time")
+    ax.legend()
+    ax.set_xscale("log")
+    ax.set_yscale("log")
+    ax.grid(True, alpha=0.3)
+
+    # 1b. Chain — Eval times
+    ax = axes[0, 1]
+    ax.plot(chain["n"], chain["dense_eval"], "o-", color="#d62728", label="Dense", linewidth=2)
+    ax.plot(chain["n"], chain["sparse_eval"], "s-", color="#2ca02c", label="Sparse", linewidth=2)
+    ax.set_xlabel("Problem size (n variables)")
+    ax.set_ylabel("Evaluation time (ms)")
+    ax.set_title("Chain: Evaluation Time")
+    ax.legend()
+    ax.set_xscale("log")
+    ax.set_yscale("log")
+    ax.grid(True, alpha=0.3)
+
+    # 1c. Pairwise — Memory
+    ax = axes[0, 2]
+    dense_kb = [m / 1024 for m in pairwise["dense_mem"]]
+    sparse_kb = [m / 1024 for m in pairwise["sparse_mem"]]
+    ax.plot(pairwise["n"], dense_kb, "o-", color="#d62728", label="Dense", linewidth=2)
+    ax.plot(pairwise["n"], sparse_kb, "s-", color="#2ca02c", label="Sparse", linewidth=2)
+    ax.set_xlabel("Problem size (n variables)")
+    ax.set_ylabel("Jacobian memory (KB)")
+    ax.set_title("Pairwise: Memory Usage")
+    ax.legend()
+    ax.set_xscale("log")
+    ax.set_yscale("log")
+    ax.grid(True, alpha=0.3)
+
+    # --- Row 2: Speedups ---
+
+    # 2a. Chain — Speedups
+    ax = axes[1, 0]
+    ax.bar(
+        [x - 0.15 for x in range(len(chain["n"]))],
+        chain["compile_speedup"],
+        width=0.3,
+        color="#1f77b4",
+        label="Compile speedup",
+    )
+    ax.bar(
+        [x + 0.15 for x in range(len(chain["n"]))],
+        chain["eval_speedup"],
+        width=0.3,
+        color="#ff7f0e",
+        label="Eval speedup",
+    )
+    ax.set_xticks(range(len(chain["n"])))
+    ax.set_xticklabels([str(n) for n in chain["n"]])
+    ax.set_xlabel("Problem size (n)")
+    ax.set_ylabel("Speedup (×)")
+    ax.set_title("Chain: Sparse Speedup Factor")
+    ax.legend()
+    ax.axhline(y=1, color="gray", linestyle="--", alpha=0.5)
+    ax.grid(True, alpha=0.3, axis="y")
+
+    # 2b. Pairwise — Eval speedup
+    ax = axes[1, 1]
+    ax.bar(
+        range(len(pairwise["n"])),
+        pairwise["eval_speedup"],
+        color="#9467bd",
+        label="Eval speedup",
+    )
+    ax.set_xticks(range(len(pairwise["n"])))
+    ax.set_xticklabels([str(n) for n in pairwise["n"]])
+    ax.set_xlabel("Problem size (n)")
+    ax.set_ylabel("Speedup (×)")
+    ax.set_title("Pairwise: Sparse Eval Speedup")
+    ax.axhline(y=1, color="gray", linestyle="--", alpha=0.5)
+    ax.grid(True, alpha=0.3, axis="y")
+
+    # 2c. Nonlinear — Eval speedup
+    ax = axes[1, 2]
+    ax.plot(nonlinear["n"], nonlinear["dense_eval"], "o-", color="#d62728", label="Dense", linewidth=2)
+    ax.plot(nonlinear["n"], nonlinear["sparse_eval"], "s-", color="#2ca02c", label="Sparse", linewidth=2)
+    ax.set_xlabel("Problem size (n variables)")
+    ax.set_ylabel("Evaluation time (ms)")
+    ax.set_title("Nonlinear: x²+x² Evaluation Time")
+    ax.legend()
+    ax.set_xscale("log")
+    ax.set_yscale("log")
+    ax.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    plot_path = RESULTS_DIR / "sparse_vs_dense_comparison.png"
+    fig.savefig(plot_path, dpi=150, bbox_inches="tight")
+    plt.close(fig)
+    print(f"\nPlot saved to: {plot_path}")
+
+    # --- Memory & speedup plot (2 subplots) ---
+    fig2, (ax_mem, ax_spd) = plt.subplots(1, 2, figsize=(14, 5))
+    fig2.suptitle("Pairwise Constraints: Sparse vs Dense", fontsize=14, y=1.02)
+
+    # Left: actual memory usage
+    x_pos = np.arange(len(pairwise["n"]))
+    bar_w = 0.35
+    dense_kb = [m / 1024 for m in pairwise["dense_mem"]]
+    sparse_kb = [m / 1024 for m in pairwise["sparse_mem"]]
+    ax_mem.bar(x_pos - bar_w / 2, dense_kb, bar_w, color="#d62728", label="Dense")
+    ax_mem.bar(x_pos + bar_w / 2, sparse_kb, bar_w, color="#2ca02c", label="Sparse")
+    ax_mem.set_xticks(x_pos)
+    ax_mem.set_xticklabels([str(n) for n in pairwise["n"]])
+    ax_mem.set_xlabel("Problem size (n variables)")
+    ax_mem.set_ylabel("Jacobian memory (KB)")
+    ax_mem.set_title("Memory Usage")
+    ax_mem.set_yscale("log")
+    ax_mem.legend()
+    ax_mem.grid(True, alpha=0.3, axis="y")
+
+    # Right: memory reduction factor
+    mem_reduction = [d / s if s > 0 else 1 for d, s in zip(pairwise["dense_mem"], pairwise["sparse_mem"])]
+    ax_spd.bar(x_pos, mem_reduction, color="#2ca02c", edgecolor="#1a7a1a")
+    ax_spd.set_xticks(x_pos)
+    ax_spd.set_xticklabels([str(n) for n in pairwise["n"]])
+    ax_spd.set_xlabel("Problem size (n variables)")
+    ax_spd.set_ylabel("Memory reduction (×)")
+    ax_spd.set_title("Sparse Memory Savings (Dense / Sparse)")
+    ax_spd.axhline(y=1, color="gray", linestyle="--", alpha=0.5)
+    ax_spd.grid(True, alpha=0.3, axis="y")
+    for i, v in enumerate(mem_reduction):
+        ax_spd.text(i, v + 0.3, f"{v:.0f}×", ha="center", fontweight="bold", fontsize=10)
+
+    plt.tight_layout()
+    mem_path = RESULTS_DIR / "sparse_memory_reduction.png"
+    fig2.savefig(mem_path, dpi=150, bbox_inches="tight")
+    plt.close(fig2)
+    print(f"Plot saved to: {mem_path}")
+
+
+if __name__ == "__main__":
+    print("Sparse vs Dense Jacobian Compilation Benchmark")
+    print("=" * 70)
+    print()
+
+    chain_sizes = [10, 25, 50, 100, 200, 500]
+    pairwise_sizes = [10, 25, 50, 100, 200, 500]
+    nonlinear_sizes = [10, 25, 50, 100, 200]
+
+    chain_data = benchmark_chain_constraints(chain_sizes)
+    pairwise_data = benchmark_pairwise_constraints(pairwise_sizes)
+    nonlinear_data = benchmark_nonlinear_sparse(nonlinear_sizes)
+
+    print()
+    print("=" * 70)
+    print("Generating comparison plots...")
+    plot_results(chain_data, pairwise_data, nonlinear_data)
diff --git a/benchmarks/utils.py b/benchmarks/utils.py
index b4b5286..e3956b3 100644
--- a/benchmarks/utils.py
+++ b/benchmarks/utils.py
@@ -2,12 +2,19 @@
 
 from __future__ import annotations
 
+import json
+import os
+import platform
 import time
+from datetime import datetime, timezone
 from dataclasses import dataclass, field
+from importlib import metadata as importlib_metadata
 from pathlib import Path
 from statistics import mean, stdev
 from typing import TYPE_CHECKING, Callable
 
+import numpy as np
+
 
 if TYPE_CHECKING:
     from optyx.problem import Problem
@@ -24,12 +31,19 @@ class TimingResult:
 
     mean_ms: float
     std_ms: float
+    median_ms: float
+    p05_ms: float
+    p95_ms: float
     min_ms: float
     max_ms: float
     n_runs: int
 
     def __str__(self) -> str:
-        return f"{self.mean_ms:.3f} ± {self.std_ms:.3f} ms (n={self.n_runs})"
+        return (
+            f"median={self.median_ms:.3f} ms "
+            f"(p05-p95: {self.p05_ms:.3f}-{self.p95_ms:.3f}, "
+            f"mean={self.mean_ms:.3f} ± {self.std_ms:.3f}, n={self.n_runs})"
+        )
 
 
 @dataclass
@@ -93,9 +107,14 @@ def time_function(
         elapsed = (time.perf_counter() - start) * 1000
         times_ms.append(elapsed)
 
+    times_arr = np.array(times_ms, dtype=float)
+
     return TimingResult(
         mean_ms=mean(times_ms),
         std_ms=stdev(times_ms) if len(times_ms) > 1 else 0.0,
+        median_ms=float(np.median(times_arr)),
+        p05_ms=float(np.percentile(times_arr, 5)),
+        p95_ms=float(np.percentile(times_arr, 95)),
         min_ms=min(times_ms),
         max_ms=max(times_ms),
         n_runs=n_runs,
@@ -144,7 +163,7 @@ def __str__(self) -> str:
         return (
             f"Optyx: {self.optyx_timing}\n"
             f"Baseline: {self.baseline_timing}\n"
-            f"Overhead: {self.overhead_ratio:.2f}x"
+            f"Median overhead: {self.overhead_ratio:.2f}x"
         )
 
 
@@ -169,8 +188,8 @@ def compare_timing(
     baseline_timing = time_function(baseline_func, n_warmup=n_warmup, n_runs=n_runs)
 
     overhead = (
-        optyx_timing.mean_ms / baseline_timing.mean_ms
-        if baseline_timing.mean_ms > 0
+        optyx_timing.median_ms / baseline_timing.median_ms
+        if baseline_timing.median_ms > 0
         else float("inf")
     )
 
@@ -181,6 +200,52 @@ def compare_timing(
     )
 
 
+def collect_benchmark_metadata(
+    extra: dict[str, object] | None = None,
+) -> dict[str, object]:
+    """Collect machine and dependency metadata for benchmark output."""
+    metadata: dict[str, object] = {
+        "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+        "platform": platform.platform(),
+        "machine": platform.machine(),
+        "processor": platform.processor() or "unknown",
+        "cpu_count": os.cpu_count(),
+        "python_version": platform.python_version(),
+        "python_implementation": platform.python_implementation(),
+        "numpy_version": np.__version__,
+    }
+
+    try:
+        import scipy
+
+        metadata["scipy_version"] = scipy.__version__
+    except Exception:
+        metadata["scipy_version"] = "unknown"
+
+    try:
+        metadata["optyx_version"] = importlib_metadata.version("optyx")
+    except Exception:
+        metadata["optyx_version"] = "local-worktree"
+
+    if extra:
+        metadata.update(extra)
+
+    return metadata
+
+
+def write_benchmark_metadata(
+    results_dir: Path,
+    file_name: str = "benchmark_metadata.json",
+    extra: dict[str, object] | None = None,
+) -> Path:
+    """Write benchmark metadata alongside generated outputs."""
+    results_dir.mkdir(parents=True, exist_ok=True)
+    metadata = collect_benchmark_metadata(extra=extra)
+    output_path = results_dir / file_name
+    output_path.write_text(json.dumps(metadata, indent=2, sort_keys=True) + "\n")
+    return output_path
+
+
 def check_solution_accuracy(
     solution: Solution,
     expected_values: dict[str, float],
diff --git a/docs/_quarto.yml b/docs/_quarto.yml
index c7cc3fc..b1ad88b 100644
--- a/docs/_quarto.yml
+++ b/docs/_quarto.yml
@@ -17,6 +17,8 @@ quartodoc:
       desc: "Fundamental building blocks for optimization models"
       contents:
         - core.expressions.Variable
+        - BinaryVariable
+        - IntegerVariable
         - core.expressions.Constant
         - core.expressions.Expression
     
@@ -24,6 +26,7 @@ quartodoc:
       desc: "High-dimensional decision variables for scalable optimization"
       contents:
         - core.vectors.VectorVariable
+        - core.variable_dict.VariableDict
         - core.vectors.VectorExpression
         - core.vectors.DotProduct
         - core.vectors.L2Norm
@@ -50,6 +53,7 @@ quartodoc:
         - problem.Problem
         - solution.Solution
         - solution.SolverStatus
+        - solution.SolverProgress
     
     - title: Mathematical Functions
       desc: "Transcendental and special functions for expressions"
@@ -81,8 +85,8 @@ quartodoc:
 website:
   title: "Optyx"
   description: "Symbolic optimization for people who hate writing gradients"
-  site-url: https://daggbt.github.io/optyx/
-  repo-url: https://github.com/daggbt/optyx
+  site-url: https://optyx-dev.github.io/optyx/
+  repo-url: https://github.com/optyx-dev/optyx
   repo-actions: [issue, source]
   
   navbar:
@@ -101,28 +105,50 @@ website:
             href: getting-started/how-it-works.qmd
       - text: "Tutorials"
         menu:
+          - text: "Modeling Fundamentals"
           - text: "Basic Optimization"
             href: tutorials/basic-optimization.qmd
           - text: "Working with Constraints"
             href: tutorials/constraints.qmd
           - text: "Automatic Differentiation"
             href: tutorials/autodiff.qmd
+          - text: "---"
+          - text: "Variables"
           - text: "Vector Variables"
             href: tutorials/vectors.qmd
           - text: "Matrix Variables"
             href: tutorials/matrices.qmd
-          - text: "Performance Guide"
+          - text: "Named Variables (VariableDict)"
+            href: tutorials/variable-dict.qmd
+          - text: "Integer Programming (MILP)"
+            href: tutorials/integer-programming.qmd
+          - text: "---"
+          - text: "Advanced"
+          - text: "Performance & Scaling"
             href: tutorials/performance.qmd
       - text: "Examples"
         menu:
+          - text: "Industry Applications"
           - text: "Portfolio Optimization"
             href: examples/portfolio.qmd
           - text: "Fleet Dispatch"
             href: examples/fleet-dispatch.qmd
           - text: "Mine Scheduling"
             href: examples/mine-scheduling.qmd
+          - text: "Mine Production Planning"
+            href: examples/mine-production-planning.qmd
+          - text: "Mine Equipment (MILP)"
+            href: examples/mine-equipment-milp.qmd
           - text: "Road Maintenance"
             href: examples/road-maintenance.qmd
+          - text: "---"
+          - text: "Techniques"
+          - text: "Modify and Re-solve"
+            href: examples/modify-and-resolve.qmd
+          - text: "Solver Callbacks"
+            href: examples/solver-callbacks.qmd
+          - text: "LP Export"
+            href: examples/lp-export.qmd
           - text: "Rosenbrock Function"
             href: examples/rosenbrock.qmd
           - text: "---"
@@ -136,7 +162,7 @@ website:
           - text: "Overview"
             href: api/index.qmd
           - text: "---"
-          - text: "Guides"
+          - text: "Topic Guides"
           - text: "Expressions"
             href: api/expressions.qmd
           - text: "Vector Variables"
@@ -157,13 +183,15 @@ website:
           - text: "Auto-Generated"
           - text: "Full API Reference"
             href: api/reference/index.qmd
+      - text: "What's New"
+        href: whats-new.qmd
       - text: "Benchmarks"
         href: benchmarks.qmd
       - text: "Contributing"
         href: contributing.qmd
     right:
       - icon: github
-        href: https://github.com/daggbt/optyx
+        href: https://github.com/optyx-dev/optyx
       - text: "PyPI"
         href: https://pypi.org/project/optyx/
   
@@ -171,7 +199,7 @@ website:
     left: "© 2025 Optyx Contributors"
     right:
       - icon: github
-        href: https://github.com/daggbt/optyx
+        href: https://github.com/optyx-dev/optyx
 
 format:
   html:
diff --git a/docs/api/expressions.qmd b/docs/api/expressions.qmd
index 791f873..978a0f7 100644
--- a/docs/api/expressions.qmd
+++ b/docs/api/expressions.qmd
@@ -28,9 +28,9 @@ x = Variable(name, lb=None, ub=None, domain="continuous")
 | `ub` | `float | None` | Upper bound | `None` (unbounded) |
 | `domain` | `str` | One of `"continuous"`, `"integer"`, `"binary"` | `"continuous"` |
 
-::: {.callout-warning}
-## Integer/Binary Domains Relaxed
-The `"integer"` and `"binary"` domains are accepted but **relaxed to continuous values** when using the SciPy solver backend. A runtime warning is emitted when this occurs. For true mixed-integer programming, consider using PuLP or Pyomo.
+::: {.callout-tip}
+## Integer/Binary Domains Supported
+The `"integer"` and `"binary"` domains are fully supported for **linear** problems via `scipy.optimize.milp()` (HiGHS backend). Problems with integer/binary variables and a linear objective are automatically routed to the MILP solver. For nonlinear objectives with discrete variables (MIQP/MINLP), a clear error is raised. See the [Integer Programming tutorial](../tutorials/integer-programming.qmd).
 :::
 
 ### Properties
diff --git a/docs/api/problem.qmd b/docs/api/problem.qmd
index 42bd2a0..4e11532 100644
--- a/docs/api/problem.qmd
+++ b/docs/api/problem.qmd
@@ -102,44 +102,118 @@ Internally, maximization is converted to minimization by negating the objective.
 
 ### `.subject_to(constraint)`
 
-Add a constraint to the problem.
+Add one or more constraints to the problem. Accepts scalar constraints, matrix-style constraints like `A @ x <= b`, a list of constraints, or a generator expression.
 
 ```python
 prob.subject_to(constraint)
+prob.subject_to([c1, c2, c3])
+prob.subject_to(x[i] >= 0 for i in range(n))  # generator
+prob.subject_to(A @ x <= b)
+prob.subject_to((A @ x).eq(b))
 ```
 
 | Parameter | Type | Description |
 |-----------|------|-------------|
-| `constraint` | `Constraint` | An inequality or equality constraint |
+| `constraint` | `Constraint \| Iterable[Constraint]` | Constraint(s) to add, including matrix blocks produced by `A @ x <= b` |
 
 **Returns:** `self` (for chaining)
 
+::: {.callout-note}
+For dense matrices, `prob.subject_to(A @ x <= b)` works directly. For raw `scipy.sparse` matrices, wrap the matrix first with `as_matrix(...)`. SciPy owns the left-hand `@` operator for sparse matrices and tries to do a numeric multiplication before Optyx can build a symbolic `MatrixVectorProduct`.
+
+`as_matrix()` also accepts `storage="auto" | "dense" | "sparse"` when you want to force or auto-select the internal storage format for large matrix blocks.
+:::
+
+### `.remove_constraint(index_or_name)`
+
+Remove a constraint by index or name.
+
+```python
+prob.remove_constraint(0)       # remove first constraint
+prob.remove_constraint("cap")   # remove by name
+```
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `index_or_name` | `int \| str` | Index position or constraint name |
+
+**Returns:** `self` (for chaining)
+
+**Raises:** `IndexError` if index is out of range; `KeyError` if name not found.
+
+### `.reset()`
+
+Clear solver caches and warm-start state, forcing cold re-analysis on the next `solve()`.
+
+```python
+prob.reset()
+```
+
+### `.write(filename)`
+
+Export the problem to LP file format. Supports linear and quadratic objectives, constraints, variable bounds, and integer/binary sections.
+
+```python
+prob.write("model.lp")
+```
+
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `filename` | `str` | Output `.lp` file path |
+
+**Raises:** `InvalidOperationError` for nonlinear expressions.
+
+### `.to_lp()`
+
+Return the LP format string (same as `write()` but returns the string instead of writing to a file).
+
+```python
+lp_string = prob.to_lp()
+```
+
+**Returns:** `str` — the LP format representation.
+
+### Context Manager
+
+`Problem` supports `with` statements:
+
+```python
+with Problem() as p:
+    p.minimize(x**2 + y**2)
+    p.subject_to(x + y >= 1)
+    solution = p.solve()
+```
+
 ### `.solve(**kwargs)`
 
 Solve the optimization problem.
 
 ```python
-solution = prob.solve(method="auto", strict=False, x0=None, tol=None, maxiter=None)
+solution = prob.solve(method="auto", strict=False, warm_start=True,
+                      callback=None, time_limit=None, x0=None,
+                      tol=None, maxiter=None)
 ```
 
 | Parameter | Type | Description | Default |
 |-----------|------|-------------|---------|
-| `method` | `str` | Solver method | `"auto"` |
+| `method` | `str` | Solver method (see below) | `"auto"` |
 | `strict` | `bool` | Raise error for unsupported features | `False` |
-| `x0` | `np.ndarray | None` | Initial point | Auto-generated |
-| `tol` | `float | None` | Solver tolerance | Solver default |
-| `maxiter` | `int | None` | Maximum iterations | Solver default |
+| `warm_start` | `bool` | Reuse previous solution as initial point | `True` |
+| `callback` | `Callable[[SolverProgress], bool \| None] \| None` | Called each iteration; return `True` to stop | `None` |
+| `time_limit` | `float \| None` | Wall-clock time budget in seconds | `None` |
+| `x0` | `np.ndarray \| None` | Initial point | Auto-generated |
+| `tol` | `float \| None` | Solver tolerance | Solver default |
+| `maxiter` | `int \| None` | Maximum iterations | Solver default |
 
 **Returns:** [`Solution`](solution.qmd)
 
-**Raises:** `ValueError` if `strict=True` and the problem contains features the solver cannot handle (e.g., integer/binary variables with SciPy).
-
 **Automatic method selection (`method="auto"`):**
 
 When `method="auto"` (default), Optyx automatically selects the best solver based on problem structure:
 
 | Problem Type | Selected Method |
 |--------------|-----------------|
+| Linear with integer/binary variables | `milp` (HiGHS MILP solver) |
 | Linear objective and constraints | `linprog` (HiGHS LP solver) |
 | Unconstrained, n ≤ 3 | `Nelder-Mead` |
 | Unconstrained, n > 1000 | `L-BFGS-B` |
@@ -153,6 +227,7 @@ When `method="auto"` (default), Optyx automatically selects the best solver base
 | Method | Bounds | Constraints | Gradient | Hessian | Description |
 |--------|--------|-------------|----------|---------|-------------|
 | `"auto"` | ✅ | ✅ | ✅ | ✅ | Automatic selection (default) |
+| `"milp"` | ✅ | ✅ (linear) | N/A | N/A | HiGHS MILP solver (integer/binary) |
 | `"linprog"` | ✅ | ✅ (linear) | N/A | N/A | HiGHS LP solver (for linear problems) |
 | `"SLSQP"` | ✅ | ✅ | ✅ | ❌ | Sequential Least Squares Programming |
 | `"trust-constr"` | ✅ | ✅ | ✅ | ✅ | Trust-region constrained optimization |
@@ -179,8 +254,8 @@ When `method="auto"` (default), Optyx automatically selects the best solver base
 
 ::: {.callout-note}
 ## Performance
-- **LP problems**: ~1x overhead vs raw SciPy (near parity)
-- **NLP problems**: ~1.4-2.2x overhead (autodiff cost, but exact gradients)
+- **LP problems**: ~1.1x overhead vs raw SciPy (near parity)
+- **CQP problems**: ~1.2-2.2x overhead (with exact Jacobians)
 - **Repeated solves**: 2x-900x speedup due to caching
 
 See the [Benchmarks](../benchmarks.qmd) page for detailed performance analysis.
@@ -193,17 +268,11 @@ See the [Benchmarks](../benchmarks.qmd) page for detailed performance analysis.
 Use `strict=True` to enforce that the solver can handle all problem features exactly:
 
 ```python
-# Default: warn and relax integer/binary to continuous
-solution = prob.solve()  # Works, but may produce fractional values
-
-# Strict: fail if problem can't be solved exactly
-solution = prob.solve(strict=True)  # Raises ValueError for integer/binary
+# Strict: fail early if problem can't be solved exactly
+solution = prob.solve(strict=True)  # Raises ValueError for unsupported configurations
 ```
 
-This is useful for production code where you want to ensure correctness:
-
-- **Prototyping:** Use `strict=False` (default) to quickly test ideas
-- **Production:** Use `strict=True` to catch unsupported configurations early
+This is useful for production code where you want to catch configurations that the solver cannot handle (e.g., nonlinear objectives with integer variables / MIQP).
 
 ---
 
diff --git a/docs/api/solution.qmd b/docs/api/solution.qmd
index d902ade..b5906ba 100644
--- a/docs/api/solution.qmd
+++ b/docs/api/solution.qmd
@@ -58,6 +58,10 @@ print(solution.values)
 | `.solve_time` | `float` | Time to solve (seconds) |
 | `.iterations` | `int` | Number of solver iterations |
 | `.message` | `str` | Solver message |
+| `.mip_gap` | `float \| None` | Relative optimality gap (MILP only) |
+| `.best_bound` | `float \| None` | Best dual bound (MILP only) |
+| `.is_optimal` | `bool` | `True` if status is `OPTIMAL` |
+| `.is_feasible` | `bool` | `True` if status is `OPTIMAL`, `MAX_ITERATIONS`, or `TERMINATED` |
 
 ### Examples
 
@@ -97,6 +101,7 @@ from optyx import SolverStatus
 | `SolverStatus.INFEASIBLE` | No feasible solution exists |
 | `SolverStatus.UNBOUNDED` | Objective can be improved indefinitely |
 | `SolverStatus.MAX_ITERATIONS` | Reached iteration limit |
+| `SolverStatus.TERMINATED` | Stopped early by callback or time limit |
 | `SolverStatus.FAILED` | Solver encountered an error |
 | `SolverStatus.NOT_SOLVED` | Problem has not been solved yet |
 
@@ -205,3 +210,71 @@ print(f"  Product Z: {solution['z']:.2f} units")
 print()
 print(f"Maximum Profit: ${solution.objective_value:.2f}")
 ```
+
+---
+
+## Serialization Methods
+
+### `.to_dict()`
+
+Convert the solution to a plain dictionary.
+
+```python
+data = solution.to_dict()
+```
+
+### `.to_json(path=None)`
+
+Serialize to JSON. Returns a string, or writes to `path` if provided.
+
+```python
+json_str = solution.to_json()          # returns string
+solution.to_json("solution.json")      # writes to file
+```
+
+### `Solution.from_json(json_str_or_path)`
+
+Reconstruct a Solution from a JSON string or file.
+
+```python
+restored = Solution.from_json("solution.json")
+restored = Solution.from_json('{"status": "optimal", ...}')
+```
+
+### `.print_vars()`
+
+Pretty-print status, objective, and all variable values.
+
+```python
+solution.print_vars()
+```
+
+---
+
+## SolverProgress
+
+The `SolverProgress` dataclass is passed to your callback function at each solver iteration.
+
+```python
+from optyx import SolverProgress
+```
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `.iteration` | `int` | Current iteration number |
+| `.objective_value` | `float` | Current objective function value |
+| `.constraint_violation` | `float` | Max constraint violation (0.0 if feasible) |
+| `.elapsed_time` | `float` | Wall-clock seconds since solve started |
+| `.x` | `np.ndarray` | Current variable values |
+
+```python
+def my_callback(progress: SolverProgress) -> bool | None:
+    print(f"Iter {progress.iteration}: obj={progress.objective_value:.4f}")
+    if progress.elapsed_time > 10:
+        return True  # stop early
+    return None  # continue
+
+solution = prob.solve(callback=my_callback)
+```
+
+See the [Solver Callbacks example](../examples/solver-callbacks.qmd) for a full walkthrough.
diff --git a/docs/assets/benchmarks/bench_vs_scipy_overhead_breakdown.png b/docs/assets/benchmarks/bench_vs_scipy_overhead_breakdown.png
index 2bb3644..79d72f7 100644
Binary files a/docs/assets/benchmarks/bench_vs_scipy_overhead_breakdown.png and b/docs/assets/benchmarks/bench_vs_scipy_overhead_breakdown.png differ
diff --git a/docs/assets/benchmarks/benchmark_metadata.json b/docs/assets/benchmarks/benchmark_metadata.json
new file mode 100644
index 0000000..d69b4a7
--- /dev/null
+++ b/docs/assets/benchmarks/benchmark_metadata.json
@@ -0,0 +1,13 @@
+{
+  "benchmark_suite": "run_benchmarks",
+  "cpu_count": 2,
+  "machine": "x86_64",
+  "numpy_version": "2.3.5",
+  "optyx_version": "1.3.0",
+  "platform": "Linux-6.8.0-1044-azure-x86_64-with-glibc2.39",
+  "processor": "x86_64",
+  "python_implementation": "CPython",
+  "python_version": "3.12.1",
+  "scipy_version": "1.16.3",
+  "timestamp_utc": "2026-04-21T10:17:46.022288+00:00"
+}
diff --git a/docs/assets/benchmarks/benchmark_output.txt b/docs/assets/benchmarks/benchmark_output.txt
new file mode 100644
index 0000000..fe8eea3
--- /dev/null
+++ b/docs/assets/benchmarks/benchmark_output.txt
@@ -0,0 +1,163 @@
+================================================================================
+OPTYX BENCHMARK SUITE - END-TO-END COMPARISON
+================================================================================
+
+This benchmark measures TOTAL time including:
+  • Variable creation
+  • Problem setup
+  • Constraint construction
+  • Cold solve (first solve, includes compilation)
+  • Warm solve (cached subsequent solves)
+
+Compared against SciPy (which has no build phase).
+
+Results will be saved to: /workspaces/optix/benchmarks/results
+Terminal output being saved to: /workspaces/optix/benchmarks/results/benchmark_output.txt
+Benchmark metadata saved to: /workspaces/optix/benchmarks/results/benchmark_metadata.json
+
+================================================================================
+LP SCALING BENCHMARK (End-to-End)
+================================================================================
+
+Measures: Build (vars + problem + constraints) + Solve
+Compared against: SciPy linprog (no build phase)
+
+--- Loop-based Variable (n ≤ 500, slow cold solve) ---
+  Loop n=   10: Build=     0.5ms, Cold=    20.5ms, Warm=    2.0ms | SciPy=    1.8ms | Cold overhead= 11.5x, Warm overhead=  1.1x
+  Loop n=   25: Build=     1.4ms, Cold=    19.6ms, Warm=    2.5ms | SciPy=    2.2ms | Cold overhead=  9.6x, Warm overhead=  1.1x
+  Loop n=   50: Build=     4.9ms, Cold=    51.3ms, Warm=    3.7ms | SciPy=    1.7ms | Cold overhead= 32.2x, Warm overhead=  2.1x
+  Loop n=  100: Build=    10.6ms, Cold=   108.2ms, Warm=    3.3ms | SciPy=    3.5ms | Cold overhead= 34.3x, Warm overhead=  1.0x
+  Loop n=  200: Build=    63.9ms, Cold=   477.3ms, Warm=    8.7ms | SciPy=    9.0ms | Cold overhead= 60.3x, Warm overhead=  1.0x
+  Loop n=  500: Build=   478.8ms, Cold=  4352.1ms, Warm=   55.8ms | SciPy=   52.7ms | Cold overhead= 91.7x, Warm overhead=  1.1x
+
+--- VectorVariable (n ≤ 5,000) ---
+  Vec  n=   10: Build=     0.2ms, Cold=     1.7ms, Warm=    1.4ms | SciPy=    1.1ms | Cold overhead=  1.7x, Warm overhead=  1.3x
+  Vec  n=   25: Build=     0.2ms, Cold=     1.6ms, Warm=    1.5ms | SciPy=    1.2ms | Cold overhead=  1.5x, Warm overhead=  1.3x
+  Vec  n=   50: Build=     0.3ms, Cold=     2.4ms, Warm=    2.1ms | SciPy=    2.5ms | Cold overhead=  1.1x, Warm overhead=  0.8x
+  Vec  n=  100: Build=     1.0ms, Cold=     6.3ms, Warm=    8.7ms | SciPy=    5.1ms | Cold overhead=  1.4x, Warm overhead=  1.7x
+  Vec  n=  200: Build=     1.8ms, Cold=    27.0ms, Warm=    9.5ms | SciPy=    7.9ms | Cold overhead=  3.7x, Warm overhead=  1.2x
+  Vec  n=  500: Build=     2.4ms, Cold=    63.1ms, Warm=   56.0ms | SciPy=   54.1ms | Cold overhead=  1.2x, Warm overhead=  1.0x
+  Vec  n= 1000: Build=     6.6ms, Cold=   252.4ms, Warm=  282.5ms | SciPy=  257.7ms | Cold overhead=  1.0x, Warm overhead=  1.1x
+  Vec  n= 2000: Build=    10.2ms, Cold=  1171.9ms, Warm= 1134.5ms | SciPy= 1113.6ms | Cold overhead=  1.1x, Warm overhead=  1.0x
+  Vec  n= 5000: Build=    25.0ms, Cold= 10200.0ms, Warm= 9194.9ms | SciPy= 9068.0ms | Cold overhead=  1.1x, Warm overhead=  1.0x
+
+Saved: /workspaces/optix/benchmarks/results/lp_scaling_comparison.png
+
+================================================================================
+UNCONSTRAINED NLP SCALING BENCHMARK (End-to-End)
+================================================================================
+
+Objective: min Σx²ᵢ - Σxᵢ (optimal at x* = 0.5)
+Measures: Build + Solve (includes gradient compilation)
+
+--- Loop-based Variable (n ≤ 500, slow cold solve) ---
+  Loop n=   10: Build=     0.2ms, Cold=    22.3ms, Warm=    1.3ms | SciPy=    0.8ms | Cold overhead= 26.9x, Warm overhead=  1.5x
+  Loop n=   25: Build=     0.8ms, Cold=    23.3ms, Warm=    0.5ms | SciPy=    0.2ms | Cold overhead=140.2x, Warm overhead=  2.9x
+  Loop n=   50: Build=     0.4ms, Cold=    42.2ms, Warm=    0.6ms | SciPy=    0.2ms | Cold overhead=256.1x, Warm overhead=  3.6x
+  Loop n=  100: Build=     0.5ms, Cold=   171.8ms, Warm=    1.7ms | SciPy=    0.3ms | Cold overhead=560.6x, Warm overhead=  5.5x
+  Loop n=  200: Build=     1.6ms, Cold=   788.5ms, Warm=    1.9ms | SciPy=    0.3ms | Cold overhead=2373.7x, Warm overhead=  5.6x
+  Loop n=  500: Build=     2.5ms, Cold=  5282.3ms, Warm=    7.6ms | SciPy=    1.0ms | Cold overhead=5156.4x, Warm overhead=  7.4x
+
+--- VectorVariable with x.dot(x) - x.sum() (n ≤ 5,000) ---
+  Vec  n=   10: Build=     0.1ms, Cold=     1.6ms, Warm=    0.5ms | SciPy=    0.2ms | Cold overhead=  7.0x, Warm overhead=  2.2x
+  Vec  n=   25: Build=     0.2ms, Cold=     3.3ms, Warm=    2.4ms | SciPy=    0.4ms | Cold overhead=  8.1x, Warm overhead=  5.6x
+  Vec  n=   50: Build=     0.3ms, Cold=     1.2ms, Warm=    1.0ms | SciPy=    0.5ms | Cold overhead=  3.0x, Warm overhead=  2.1x
+  Vec  n=  100: Build=     0.5ms, Cold=     1.8ms, Warm=    2.1ms | SciPy=    0.5ms | Cold overhead=  4.8x, Warm overhead=  4.3x
+  Vec  n=  200: Build=     0.9ms, Cold=     5.1ms, Warm=    2.4ms | SciPy=    1.0ms | Cold overhead=  5.8x, Warm overhead=  2.3x
+  Vec  n=  500: Build=     4.9ms, Cold=     7.0ms, Warm=    1.9ms | SciPy=    0.2ms | Cold overhead= 53.8x, Warm overhead=  8.8x
+  Vec  n= 1000: Build=     2.4ms, Cold=     6.7ms, Warm=    4.4ms | SciPy=    0.3ms | Cold overhead= 36.3x, Warm overhead= 17.4x
+  Vec  n= 2000: Build=     4.7ms, Cold=    15.8ms, Warm=    7.2ms | SciPy=    0.3ms | Cold overhead= 64.0x, Warm overhead= 22.6x
+  Vec  n= 5000: Build=    19.1ms, Cold=    47.7ms, Warm=   34.3ms | SciPy=    0.8ms | Cold overhead= 81.9x, Warm overhead= 42.1x
+
+Saved: /workspaces/optix/benchmarks/results/nlp_scaling_comparison.png
+
+================================================================================
+CONSTRAINED QP SCALING BENCHMARK (End-to-End)
+================================================================================
+
+Objective: min Σx²ᵢ s.t. Σxᵢ ≥ 1, xᵢ ≥ 0
+Measures: Build + Solve (includes gradient/Jacobian compilation)
+
+--- Loop-based Variable (n ≤ 500, slow cold solve) ---
+  Loop n=   10: Build=     0.2ms, Cold=    10.9ms, Warm=    0.6ms | SciPy=    0.4ms | Cold overhead= 31.1x, Warm overhead=  1.8x
+  Loop n=   25: Build=     0.3ms, Cold=    15.9ms, Warm=    1.2ms | SciPy=    0.8ms | Cold overhead= 19.0x, Warm overhead=  1.4x
+  Loop n=   50: Build=     1.2ms, Cold=    71.7ms, Warm=    1.7ms | SciPy=    1.2ms | Cold overhead= 61.6x, Warm overhead=  1.4x
+  Loop n=  100: Build=     1.2ms, Cold=   221.5ms, Warm=    1.8ms | SciPy=    0.9ms | Cold overhead=255.6x, Warm overhead=  2.1x
+  Loop n=  200: Build=     2.0ms, Cold=   762.4ms, Warm=    3.8ms | SciPy=    1.9ms | Cold overhead=396.1x, Warm overhead=  2.0x
+  Loop n=  500: Build=     5.5ms, Cold=  5982.5ms, Warm=   34.8ms | SciPy=   13.0ms | Cold overhead=461.5x, Warm overhead=  2.7x
+
+--- VectorVariable with x.dot(x), x.sum() (n ≤ 5000) ---
+  Vec  n=   10: Build=     0.1ms, Cold=     0.8ms, Warm=    0.4ms | SciPy=    0.3ms | Cold overhead=  3.0x, Warm overhead=  1.3x
+  Vec  n=   25: Build=     0.2ms, Cold=     0.9ms, Warm=    1.0ms | SciPy=    0.5ms | Cold overhead=  2.4x, Warm overhead=  2.3x
+  Vec  n=   50: Build=     0.2ms, Cold=     1.1ms, Warm=    0.7ms | SciPy=    0.9ms | Cold overhead=  1.4x, Warm overhead=  0.8x
+  Vec  n=  100: Build=     0.4ms, Cold=     1.5ms, Warm=    1.2ms | SciPy=    1.1ms | Cold overhead=  1.7x, Warm overhead=  1.1x
+  Vec  n=  200: Build=     0.7ms, Cold=     2.9ms, Warm=    2.4ms | SciPy=    1.9ms | Cold overhead=  1.9x, Warm overhead=  1.2x
+  Vec  n=  500: Build=     2.5ms, Cold=    18.6ms, Warm=   12.7ms | SciPy=   12.9ms | Cold overhead=  1.6x, Warm overhead=  1.0x
+  Vec  n= 1000: Build=    13.5ms, Cold=    80.2ms, Warm=   91.4ms | SciPy=   69.9ms | Cold overhead=  1.3x, Warm overhead=  1.3x
+  Vec  n= 2000: Build=    11.2ms, Cold=   471.5ms, Warm=  599.2ms | SciPy=  577.7ms | Cold overhead=  0.8x, Warm overhead=  1.0x
+  Vec  n= 5000: Build=    49.9ms, Cold=  7601.3ms, Warm= 6999.7ms | SciPy= 6989.3ms | Cold overhead=  1.1x, Warm overhead=  1.0x
+
+Saved: /workspaces/optix/benchmarks/results/cqp_scaling_comparison.png
+
+================================================================================
+MILP SCALING BENCHMARK (End-to-End)
+================================================================================
+
+Measures: Build (vars + problem + constraints) + Solve
+Compared against: SciPy milp (no build phase)
+Problem: Single-constraint binary knapsack (sum(x) <= n//2)
+
+--- Loop-based Variable (n ≤ 500, slow cold solve) ---
+  Loop n=   10: Build=     0.2ms, Cold=    14.2ms, Warm=    1.0ms | SciPy=    0.8ms | Cold overhead= 17.8x, Warm overhead=  1.2x
+  Loop n=   25: Build=     0.2ms, Cold=     1.7ms, Warm=    1.2ms | SciPy=    0.9ms | Cold overhead=  2.2x, Warm overhead=  1.4x
+  Loop n=   50: Build=     0.3ms, Cold=     2.5ms, Warm=    1.4ms | SciPy=    1.1ms | Cold overhead=  2.7x, Warm overhead=  1.3x
+  Loop n=  100: Build=     2.2ms, Cold=     4.9ms, Warm=    1.8ms | SciPy=    1.5ms | Cold overhead=  4.8x, Warm overhead=  1.2x
+  Loop n=  200: Build=     0.9ms, Cold=    10.1ms, Warm=    3.3ms | SciPy=    2.5ms | Cold overhead=  4.4x, Warm overhead=  1.3x
+  Loop n=  500: Build=     3.3ms, Cold=    34.8ms, Warm=    8.7ms | SciPy=    7.9ms | Cold overhead=  4.8x, Warm overhead=  1.1x
+
+--- VectorVariable (n ≤ 5000) ---
+  Vec  n=   10: Build=     0.1ms, Cold=     1.1ms, Warm=    1.0ms | SciPy=    1.0ms | Cold overhead=  1.2x, Warm overhead=  1.0x
+  Vec  n=   25: Build=     0.2ms, Cold=     1.1ms, Warm=    1.1ms | SciPy=    1.0ms | Cold overhead=  1.2x, Warm overhead=  1.0x
+  Vec  n=   50: Build=     0.2ms, Cold=     1.3ms, Warm=    1.4ms | SciPy=    1.1ms | Cold overhead=  1.5x, Warm overhead=  1.3x
+  Vec  n=  100: Build=     0.3ms, Cold=     1.8ms, Warm=    1.9ms | SciPy=    1.5ms | Cold overhead=  1.5x, Warm overhead=  1.3x
+  Vec  n=  200: Build=     0.5ms, Cold=     2.9ms, Warm=    3.0ms | SciPy=    2.5ms | Cold overhead=  1.4x, Warm overhead=  1.2x
+  Vec  n=  500: Build=     1.2ms, Cold=    14.2ms, Warm=   10.2ms | SciPy=    7.9ms | Cold overhead=  2.0x, Warm overhead=  1.3x
+  Vec  n= 1000: Build=     4.3ms, Cold=    28.9ms, Warm=   27.8ms | SciPy=   25.2ms | Cold overhead=  1.3x, Warm overhead=  1.1x
+  Vec  n= 2000: Build=     4.5ms, Cold=    90.9ms, Warm=   89.8ms | SciPy=   87.3ms | Cold overhead=  1.1x, Warm overhead=  1.0x
+  Vec  n= 5000: Build=    14.1ms, Cold=   556.2ms, Warm=  670.8ms | SciPy=  568.5ms | Cold overhead=  1.0x, Warm overhead=  1.2x
+
+Saved: /workspaces/optix/benchmarks/results/milp_scaling_comparison.png
+Structured benchmark results saved to: /workspaces/optix/benchmarks/results/benchmark_results.json
+
+================================================================================
+OVERHEAD SUMMARY BY PROBLEM TYPE
+================================================================================
+LP n=50: Cold=1.1x, Warm=0.8x
+LP n=5000: Cold=1.1x, Warm=1.0x
+NLP n=50: Cold=3.0x, Warm=2.1x
+NLP n=5000: Cold=81.9x, Warm=42.1x
+CQP n=50: Cold=1.4x, Warm=0.8x
+CQP n=5000: Cold=1.1x, Warm=1.0x
+MILP n=50: Cold=1.5x, Warm=1.3x
+MILP n=5000: Cold=1.0x, Warm=1.2x
+
+Saved: /workspaces/optix/benchmarks/results/overhead_breakdown.png
+
+================================================================================
+BENCHMARK COMPLETE
+================================================================================
+
+Plots saved to: /workspaces/optix/benchmarks/results
+  - bench_vs_scipy_overhead_breakdown.png
+  - cqp_scaling_comparison.png
+  - lp_cache_benefit.png
+  - lp_scaling_comparison.png
+  - milp_scaling_comparison.png
+  - multi_problem_scaling.png
+  - nlp_quadratic_scaling.png
+  - nlp_scaling_comparison.png
+  - overhead_breakdown.png
+  - scipy_lp_scaling.png
+  - sparse_memory_reduction.png
+  - sparse_solve_end_to_end.png
+  - sparse_vs_dense_comparison.png
diff --git a/docs/assets/benchmarks/benchmark_results.json b/docs/assets/benchmarks/benchmark_results.json
new file mode 100644
index 0000000..b962dea
--- /dev/null
+++ b/docs/assets/benchmarks/benchmark_results.json
@@ -0,0 +1,861 @@
+{
+  "artifacts": {
+    "metadata": "benchmark_metadata.json",
+    "output_log": "benchmark_output.txt",
+    "plots": {
+      "cqp_scaling": "cqp_scaling_comparison.png",
+      "lp_scaling": "lp_scaling_comparison.png",
+      "milp_scaling": "milp_scaling_comparison.png",
+      "nlp_scaling": "nlp_scaling_comparison.png",
+      "overhead_breakdown": "overhead_breakdown.png"
+    },
+    "results_json": "benchmark_results.json"
+  },
+  "benchmark_suite": "run_benchmarks",
+  "overhead_summary": [
+    {
+      "cold_overhead": 1.0501582337223818,
+      "problem_type": "LP",
+      "size": 50,
+      "warm_overhead": 0.812985045888142
+    },
+    {
+      "cold_overhead": 1.1275902207716624,
+      "problem_type": "LP",
+      "size": 5000,
+      "warm_overhead": 1.0140021159852615
+    },
+    {
+      "cold_overhead": 3.026941579482231,
+      "problem_type": "NLP",
+      "size": 50,
+      "warm_overhead": 2.0825227513121036
+    },
+    {
+      "cold_overhead": 81.94926695989462,
+      "problem_type": "NLP",
+      "size": 5000,
+      "warm_overhead": 42.13192875480498
+    },
+    {
+      "cold_overhead": 1.4299693678646468,
+      "problem_type": "CQP",
+      "size": 50,
+      "warm_overhead": 0.788050478137063
+    },
+    {
+      "cold_overhead": 1.0946971400391046,
+      "problem_type": "CQP",
+      "size": 5000,
+      "warm_overhead": 1.001488479208934
+    },
+    {
+      "cold_overhead": 1.4566705000975524,
+      "problem_type": "MILP",
+      "size": 50,
+      "warm_overhead": 1.2941061236838522
+    },
+    {
+      "cold_overhead": 1.0031123576531944,
+      "problem_type": "MILP",
+      "size": 5000,
+      "warm_overhead": 1.179959153413669
+    }
+  ],
+  "performance_summary": [
+    {
+      "cold_overhead": 1.0501582337223818,
+      "note": "Near-parity with SciPy linprog",
+      "problem_type": "LP",
+      "size": 50,
+      "warm_overhead": 0.812985045888142
+    },
+    {
+      "cold_overhead": 1.211487886529665,
+      "note": "Near-parity with SciPy linprog",
+      "problem_type": "LP",
+      "size": 500,
+      "warm_overhead": 1.0357210528392964
+    },
+    {
+      "cold_overhead": 1.1275902207716624,
+      "note": "Scales to large LPs while staying near parity",
+      "problem_type": "LP",
+      "size": 5000,
+      "warm_overhead": 1.0140021159852615
+    },
+    {
+      "cold_overhead": 3.026941579482231,
+      "note": "Autodiff overhead on a trivially simple objective",
+      "problem_type": "NLP",
+      "size": 50,
+      "warm_overhead": 2.0825227513121036
+    },
+    {
+      "cold_overhead": 53.78946185114727,
+      "note": "Autodiff overhead on a trivially simple objective",
+      "problem_type": "NLP",
+      "size": 500,
+      "warm_overhead": 8.802874053183821
+    },
+    {
+      "cold_overhead": 81.94926695989462,
+      "note": "Simple quadratic; SciPy converges almost instantly",
+      "problem_type": "NLP",
+      "size": 5000,
+      "warm_overhead": 42.13192875480498
+    },
+    {
+      "cold_overhead": 1.4299693678646468,
+      "note": "O(1) Jacobian compilation for vectorized constraints",
+      "problem_type": "CQP",
+      "size": 50,
+      "warm_overhead": 0.788050478137063
+    },
+    {
+      "cold_overhead": 1.6394185969433936,
+      "note": "O(1) Jacobian compilation for vectorized constraints",
+      "problem_type": "CQP",
+      "size": 500,
+      "warm_overhead": 0.9872978508888796
+    },
+    {
+      "cold_overhead": 1.0946971400391046,
+      "note": "Exact Jacobians keep constrained solves near parity",
+      "problem_type": "CQP",
+      "size": 5000,
+      "warm_overhead": 1.001488479208934
+    },
+    {
+      "cold_overhead": 1.4566705000975524,
+      "note": "Near-parity with SciPy milp",
+      "problem_type": "MILP",
+      "size": 50,
+      "warm_overhead": 1.2941061236838522
+    },
+    {
+      "cold_overhead": 1.9537429622573275,
+      "note": "Near-parity with SciPy milp",
+      "problem_type": "MILP",
+      "size": 500,
+      "warm_overhead": 1.2936619533279687
+    },
+    {
+      "cold_overhead": 1.0031123576531944,
+      "note": "Scales to large binary knapsack problems",
+      "problem_type": "MILP",
+      "size": 5000,
+      "warm_overhead": 1.179959153413669
+    }
+  ],
+  "scaling": {
+    "cqp": {
+      "loop": {
+        "label": "CQP (Loop)",
+        "results": [
+          {
+            "build_ms": 0.153315002535237,
+            "cold_overhead": 31.11061123509847,
+            "cold_solve_ms": 10.939440999209182,
+            "cold_total_ms": 11.09275600174442,
+            "n": 10,
+            "scipy_ms": 0.3565586004697252,
+            "warm_overhead": 1.7591885287050133,
+            "warm_solve_ms": 0.6272537997574545,
+            "warm_total_ms": 0.6272537997574545
+          },
+          {
+            "build_ms": 0.2530210003897082,
+            "cold_overhead": 18.974517042517437,
+            "cold_solve_ms": 15.85142200201517,
+            "cold_total_ms": 16.104443002404878,
+            "n": 25,
+            "scipy_ms": 0.8487406012136489,
+            "warm_overhead": 1.3679175940132715,
+            "warm_solve_ms": 1.1610072011535522,
+            "warm_total_ms": 1.1610072011535522
+          },
+          {
+            "build_ms": 1.158421000582166,
+            "cold_overhead": 61.60524408065892,
+            "cold_solve_ms": 71.6935749987897,
+            "cold_total_ms": 72.85199599937187,
+            "n": 50,
+            "scipy_ms": 1.1825615998532157,
+            "warm_overhead": 1.4221486635349372,
+            "warm_solve_ms": 1.681778398778988,
+            "warm_total_ms": 1.681778398778988
+          },
+          {
+            "build_ms": 1.2048469980072696,
+            "cold_overhead": 255.63438117091056,
+            "cold_solve_ms": 221.54135299933841,
+            "cold_total_ms": 222.74619999734568,
+            "n": 100,
+            "scipy_ms": 0.8713467999768909,
+            "warm_overhead": 2.100260194994894,
+            "warm_solve_ms": 1.8300550000276417,
+            "warm_total_ms": 1.8300550000276417
+          },
+          {
+            "build_ms": 1.9555170001694933,
+            "cold_overhead": 396.1053364293281,
+            "cold_solve_ms": 762.428201000148,
+            "cold_total_ms": 764.3837180003175,
+            "n": 200,
+            "scipy_ms": 1.9297485989227425,
+            "warm_overhead": 1.9573368272172225,
+            "warm_solve_ms": 3.7771679999423213,
+            "warm_total_ms": 3.7771679999423213
+          },
+          {
+            "build_ms": 5.547715998545755,
+            "cold_overhead": 461.5214241891787,
+            "cold_solve_ms": 5982.5169229989115,
+            "cold_total_ms": 5988.064638997457,
+            "n": 500,
+            "scipy_ms": 12.974618999578524,
+            "warm_overhead": 2.6842881013962274,
+            "warm_solve_ms": 34.82761540071806,
+            "warm_total_ms": 34.82761540071806
+          }
+        ]
+      },
+      "vector": {
+        "label": "CQP (VectorVariable)",
+        "results": [
+          {
+            "build_ms": 0.11850099690491334,
+            "cold_overhead": 3.027583458815483,
+            "cold_solve_ms": 0.8402160019613802,
+            "cold_total_ms": 0.9587169988662936,
+            "n": 10,
+            "scipy_ms": 0.316660799580859,
+            "warm_overhead": 1.3346085183142544,
+            "warm_solve_ms": 0.4226182005368173,
+            "warm_total_ms": 0.4226182005368173
+          },
+          {
+            "build_ms": 0.1562409997859504,
+            "cold_overhead": 2.391429352767669,
+            "cold_solve_ms": 0.9384200020576827,
+            "cold_total_ms": 1.0946610018436331,
+            "n": 25,
+            "scipy_ms": 0.45774339960189536,
+            "warm_overhead": 2.260624187010286,
+            "warm_solve_ms": 1.034785800584359,
+            "warm_total_ms": 1.034785800584359
+          },
+          {
+            "build_ms": 0.21687400294467807,
+            "cold_overhead": 1.4299693678646468,
+            "cold_solve_ms": 1.0550480001256801,
+            "cold_total_ms": 1.2719220030703582,
+            "n": 50,
+            "scipy_ms": 0.8894749997125473,
+            "warm_overhead": 0.788050478137063,
+            "warm_solve_ms": 0.7009511988144368,
+            "warm_total_ms": 0.7009511988144368
+          },
+          {
+            "build_ms": 0.3956479995395057,
+            "cold_overhead": 1.6844031244504607,
+            "cold_solve_ms": 1.463579999835929,
+            "cold_total_ms": 1.8592279993754346,
+            "n": 100,
+            "scipy_ms": 1.1037904005206656,
+            "warm_overhead": 1.1312225582223807,
+            "warm_solve_ms": 1.2486326006182935,
+            "warm_total_ms": 1.2486326006182935
+          },
+          {
+            "build_ms": 0.7324860016524326,
+            "cold_overhead": 1.907498936382662,
+            "cold_solve_ms": 2.9472659989551175,
+            "cold_total_ms": 3.67975200060755,
+            "n": 200,
+            "scipy_ms": 1.9290977994387504,
+            "warm_overhead": 1.237126703114857,
+            "warm_solve_ms": 2.3865384006057866,
+            "warm_total_ms": 2.3865384006057866
+          },
+          {
+            "build_ms": 2.5035090002347715,
+            "cold_overhead": 1.6394185969433936,
+            "cold_solve_ms": 18.565805999969598,
+            "cold_total_ms": 21.06931500020437,
+            "n": 500,
+            "scipy_ms": 12.851699400926009,
+            "warm_overhead": 0.9872978508888796,
+            "warm_solve_ms": 12.68845519880415,
+            "warm_total_ms": 12.68845519880415
+          },
+          {
+            "build_ms": 13.506178998795804,
+            "cold_overhead": 1.340633127996738,
+            "cold_solve_ms": 80.1798009997583,
+            "cold_total_ms": 93.6859799985541,
+            "n": 1000,
+            "scipy_ms": 69.88189240000793,
+            "warm_overhead": 1.3084826449294356,
+            "warm_solve_ms": 91.43924340023659,
+            "warm_total_ms": 91.43924340023659
+          },
+          {
+            "build_ms": 11.169469999003923,
+            "cold_overhead": 0.8354444607531919,
+            "cold_solve_ms": 471.47300299911876,
+            "cold_total_ms": 482.6424729981227,
+            "n": 2000,
+            "scipy_ms": 577.7074308003648,
+            "warm_overhead": 1.0372864849082362,
+            "warm_solve_ms": 599.2481102002785,
+            "warm_total_ms": 599.2481102002785
+          },
+          {
+            "build_ms": 49.87247100143577,
+            "cold_overhead": 1.0946971400391046,
+            "cold_solve_ms": 7601.275322998845,
+            "cold_total_ms": 7651.147794000281,
+            "n": 5000,
+            "scipy_ms": 6989.282710400585,
+            "warm_overhead": 1.001488479208934,
+            "warm_solve_ms": 6999.686112400377,
+            "warm_total_ms": 6999.686112400377
+          }
+        ]
+      }
+    },
+    "lp": {
+      "loop": {
+        "label": "LP (Loop)",
+        "results": [
+          {
+            "build_ms": 0.4565819981507957,
+            "cold_overhead": 11.482336147813978,
+            "cold_solve_ms": 20.522652001091046,
+            "cold_total_ms": 20.979233999241842,
+            "n": 10,
+            "scipy_ms": 1.8270876003953163,
+            "warm_overhead": 1.0815988235244256,
+            "warm_solve_ms": 1.9761757990636397,
+            "warm_total_ms": 1.9761757990636397
+          },
+          {
+            "build_ms": 1.4050399986444972,
+            "cold_overhead": 9.623407770861848,
+            "cold_solve_ms": 19.63746299952618,
+            "cold_total_ms": 21.042502998170676,
+            "n": 25,
+            "scipy_ms": 2.1865957984118722,
+            "warm_overhead": 1.1279439032452812,
+            "warm_solve_ms": 2.466357399680419,
+            "warm_total_ms": 2.466357399680419
+          },
+          {
+            "build_ms": 4.869180997047806,
+            "cold_overhead": 32.24808044538227,
+            "cold_solve_ms": 51.346608001040295,
+            "cold_total_ms": 56.2157889980881,
+            "n": 50,
+            "scipy_ms": 1.7432289991120342,
+            "warm_overhead": 2.138066428056541,
+            "warm_solve_ms": 3.727139399416046,
+            "warm_total_ms": 3.727139399416046
+          },
+          {
+            "build_ms": 10.630352997395676,
+            "cold_overhead": 34.299098632360746,
+            "cold_solve_ms": 108.15988299873425,
+            "cold_total_ms": 118.79023599612992,
+            "n": 100,
+            "scipy_ms": 3.4633631999895442,
+            "warm_overhead": 0.9625728540754156,
+            "warm_solve_ms": 3.3337394001137,
+            "warm_total_ms": 3.3337394001137
+          },
+          {
+            "build_ms": 63.9043990013306,
+            "cold_overhead": 60.31374442643511,
+            "cold_solve_ms": 477.2999010019703,
+            "cold_total_ms": 541.2043000033009,
+            "n": 200,
+            "scipy_ms": 8.973150401288876,
+            "warm_overhead": 0.9726232159191104,
+            "warm_solve_ms": 8.727494400227442,
+            "warm_total_ms": 8.727494400227442
+          },
+          {
+            "build_ms": 478.78952999963076,
+            "cold_overhead": 91.74939438260711,
+            "cold_solve_ms": 4352.143078998779,
+            "cold_total_ms": 4830.93260899841,
+            "n": 500,
+            "scipy_ms": 52.65356399904704,
+            "warm_overhead": 1.0590257100395577,
+            "warm_solve_ms": 55.76147800020408,
+            "warm_total_ms": 55.76147800020408
+          }
+        ]
+      },
+      "vector": {
+        "label": "LP (VectorVariable)",
+        "results": [
+          {
+            "build_ms": 0.19218799934606068,
+            "cold_overhead": 1.693216922730903,
+            "cold_solve_ms": 1.6525819992239121,
+            "cold_total_ms": 1.8447699985699728,
+            "n": 10,
+            "scipy_ms": 1.0895060011534952,
+            "warm_overhead": 1.2623675308353952,
+            "warm_solve_ms": 1.375357000506483,
+            "warm_total_ms": 1.375357000506483
+          },
+          {
+            "build_ms": 0.2016159996856004,
+            "cold_overhead": 1.4924938118363915,
+            "cold_solve_ms": 1.623988999199355,
+            "cold_total_ms": 1.8256049988849554,
+            "n": 25,
+            "scipy_ms": 1.2231910004629754,
+            "warm_overhead": 1.2657148376693776,
+            "warm_solve_ms": 1.5482109985896386,
+            "warm_total_ms": 1.5482109985896386
+          },
+          {
+            "build_ms": 0.29033099781372584,
+            "cold_overhead": 1.0501582337223818,
+            "cold_solve_ms": 2.3654819997318555,
+            "cold_total_ms": 2.6558129975455813,
+            "n": 50,
+            "scipy_ms": 2.528964600060135,
+            "warm_overhead": 0.812985045888142,
+            "warm_solve_ms": 2.0560104014293756,
+            "warm_total_ms": 2.0560104014293756
+          },
+          {
+            "build_ms": 0.9552609990350902,
+            "cold_overhead": 1.4109392686950275,
+            "cold_solve_ms": 6.260796002607094,
+            "cold_total_ms": 7.216057001642184,
+            "n": 100,
+            "scipy_ms": 5.114363999746274,
+            "warm_overhead": 1.7028074262404869,
+            "warm_solve_ms": 8.708776999264956,
+            "warm_total_ms": 8.708776999264956
+          },
+          {
+            "build_ms": 1.8441590000293218,
+            "cold_overhead": 3.6727232458672763,
+            "cold_solve_ms": 26.99932399991667,
+            "cold_total_ms": 28.84348299994599,
+            "n": 200,
+            "scipy_ms": 7.8534321997722145,
+            "warm_overhead": 1.2149146968198785,
+            "warm_solve_ms": 9.541250199981732,
+            "warm_total_ms": 9.541250199981732
+          },
+          {
+            "build_ms": 2.4393290004809387,
+            "cold_overhead": 1.211487886529665,
+            "cold_solve_ms": 63.093166001635836,
+            "cold_total_ms": 65.53249500211678,
+            "n": 500,
+            "scipy_ms": 54.092571399814915,
+            "warm_overhead": 1.0357210528392964,
+            "warm_solve_ms": 56.024815001001116,
+            "warm_total_ms": 56.024815001001116
+          },
+          {
+            "build_ms": 6.566907002707012,
+            "cold_overhead": 1.004822563939135,
+            "cold_solve_ms": 252.37838400062174,
+            "cold_total_ms": 258.94529100332875,
+            "n": 1000,
+            "scipy_ms": 257.7025041995512,
+            "warm_overhead": 1.0960677571869186,
+            "warm_solve_ms": 282.45940579945454,
+            "warm_total_ms": 282.45940579945454
+          },
+          {
+            "build_ms": 10.243332999380073,
+            "cold_overhead": 1.0615410333742983,
+            "cold_solve_ms": 1171.9294570029888,
+            "cold_total_ms": 1182.1727900023689,
+            "n": 2000,
+            "scipy_ms": 1113.6383359997126,
+            "warm_overhead": 1.0187540921722584,
+            "warm_solve_ms": 1134.5236119996116,
+            "warm_total_ms": 1134.5236119996116
+          },
+          {
+            "build_ms": 24.960611001006328,
+            "cold_overhead": 1.1275902207716624,
+            "cold_solve_ms": 10199.972689999413,
+            "cold_total_ms": 10224.93330100042,
+            "n": 5000,
+            "scipy_ms": 9067.951382198953,
+            "warm_overhead": 1.0140021159852615,
+            "warm_solve_ms": 9194.921889201214,
+            "warm_total_ms": 9194.921889201214
+          }
+        ]
+      }
+    },
+    "milp": {
+      "loop": {
+        "label": "MILP (Loop)",
+        "results": [
+          {
+            "build_ms": 0.172080999618629,
+            "cold_overhead": 17.811266453769836,
+            "cold_solve_ms": 14.173112998832949,
+            "cold_total_ms": 14.345193998451577,
+            "n": 10,
+            "scipy_ms": 0.8053999998082872,
+            "warm_overhead": 1.2008266692982976,
+            "warm_solve_ms": 0.9671457992226351,
+            "warm_total_ms": 0.9671457992226351
+          },
+          {
+            "build_ms": 0.2327029978914652,
+            "cold_overhead": 2.200366322114951,
+            "cold_solve_ms": 1.718735002214089,
+            "cold_total_ms": 1.9514380001055542,
+            "n": 25,
+            "scipy_ms": 0.8868696000718046,
+            "warm_overhead": 1.4006958858066936,
+            "warm_solve_ms": 1.2422346000676043,
+            "warm_total_ms": 1.2422346000676043
+          },
+          {
+            "build_ms": 0.34325999877182767,
+            "cold_overhead": 2.69034763531842,
+            "cold_solve_ms": 2.502537001419114,
+            "cold_total_ms": 2.8457970001909416,
+            "n": 50,
+            "scipy_ms": 1.0577804008789826,
+            "warm_overhead": 1.3059045146807384,
+            "warm_solve_ms": 1.3813602010486647,
+            "warm_total_ms": 1.3813602010486647
+          },
+          {
+            "build_ms": 2.207367000664817,
+            "cold_overhead": 4.825542619460967,
+            "cold_solve_ms": 4.877707000559894,
+            "cold_total_ms": 7.0850740012247115,
+            "n": 100,
+            "scipy_ms": 1.4682440007163677,
+            "warm_overhead": 1.215488841472715,
+            "warm_solve_ms": 1.784634199430002,
+            "warm_total_ms": 1.784634199430002
+          },
+          {
+            "build_ms": 0.9081530006369576,
+            "cold_overhead": 4.364352366893895,
+            "cold_solve_ms": 10.057105999294436,
+            "cold_total_ms": 10.965258999931393,
+            "n": 200,
+            "scipy_ms": 2.512459599529393,
+            "warm_overhead": 1.3177663034185723,
+            "warm_solve_ms": 3.310834598960355,
+            "warm_total_ms": 3.310834598960355
+          },
+          {
+            "build_ms": 3.3278769988100976,
+            "cold_overhead": 4.835364174134148,
+            "cold_solve_ms": 34.82242199970642,
+            "cold_total_ms": 38.15029899851652,
+            "n": 500,
+            "scipy_ms": 7.889850200444926,
+            "warm_overhead": 1.1001823581781829,
+            "warm_solve_ms": 8.680273999198107,
+            "warm_total_ms": 8.680273999198107
+          }
+        ]
+      },
+      "vector": {
+        "label": "MILP (VectorVariable)",
+        "results": [
+          {
+            "build_ms": 0.11342200014041737,
+            "cold_overhead": 1.1751891455861652,
+            "cold_solve_ms": 1.0656769991328474,
+            "cold_total_ms": 1.1790989992732648,
+            "n": 10,
+            "scipy_ms": 1.003326999489218,
+            "warm_overhead": 0.9674415220778275,
+            "warm_solve_ms": 0.9706601995276287,
+            "warm_total_ms": 0.9706601995276287
+          },
+          {
+            "build_ms": 0.16660999972373247,
+            "cold_overhead": 1.1871918475053154,
+            "cold_solve_ms": 1.0797040013130754,
+            "cold_total_ms": 1.246314001036808,
+            "n": 25,
+            "scipy_ms": 1.0497999996005092,
+            "warm_overhead": 1.0163364446826544,
+            "warm_solve_ms": 1.0669499992218334,
+            "warm_total_ms": 1.0669499992218334
+          },
+          {
+            "build_ms": 0.20800800120923668,
+            "cold_overhead": 1.4566705000975524,
+            "cold_solve_ms": 1.331152001512237,
+            "cold_total_ms": 1.5391600027214736,
+            "n": 50,
+            "scipy_ms": 1.0566288001427893,
+            "warm_overhead": 1.2941061236838522,
+            "warm_solve_ms": 1.3673898007255048,
+            "warm_total_ms": 1.3673898007255048
+          },
+          {
+            "build_ms": 0.32505700073670596,
+            "cold_overhead": 1.451575594142868,
+            "cold_solve_ms": 1.7858999999589287,
+            "cold_total_ms": 2.1109570006956346,
+            "n": 100,
+            "scipy_ms": 1.4542521996190771,
+            "warm_overhead": 1.2799012436930013,
+            "warm_solve_ms": 1.8612991989357397,
+            "warm_total_ms": 1.8612991989357397
+          },
+          {
+            "build_ms": 0.5490439980349038,
+            "cold_overhead": 1.3673208274083901,
+            "cold_solve_ms": 2.898244998505106,
+            "cold_total_ms": 3.44728899654001,
+            "n": 200,
+            "scipy_ms": 2.521199799957685,
+            "warm_overhead": 1.1874288581875057,
+            "warm_solve_ms": 2.993745399726322,
+            "warm_total_ms": 2.993745399726322
+          },
+          {
+            "build_ms": 1.1771960016631056,
+            "cold_overhead": 1.9537429622573275,
+            "cold_solve_ms": 14.222654997865902,
+            "cold_total_ms": 15.399850999529008,
+            "n": 500,
+            "scipy_ms": 7.882229800452478,
+            "warm_overhead": 1.2936619533279687,
+            "warm_solve_ms": 10.196940800233278,
+            "warm_total_ms": 10.196940800233278
+          },
+          {
+            "build_ms": 4.252782000548905,
+            "cold_overhead": 1.3152853856338191,
+            "cold_solve_ms": 28.930814998602727,
+            "cold_total_ms": 33.18359699915163,
+            "n": 1000,
+            "scipy_ms": 25.229199200111907,
+            "warm_overhead": 1.1026000539842433,
+            "warm_solve_ms": 27.81771640002262,
+            "warm_total_ms": 27.81771640002262
+          },
+          {
+            "build_ms": 4.538343997410266,
+            "cold_overhead": 1.0930986857200522,
+            "cold_solve_ms": 90.94023099896731,
+            "cold_total_ms": 95.47857499637757,
+            "n": 2000,
+            "scipy_ms": 87.34671100028208,
+            "warm_overhead": 1.0280106162114089,
+            "warm_solve_ms": 89.79334619943984,
+            "warm_total_ms": 89.79334619943984
+          },
+          {
+            "build_ms": 14.063347000046633,
+            "cold_overhead": 1.0031123576531944,
+            "cold_solve_ms": 556.2133999992511,
+            "cold_total_ms": 570.2767469992978,
+            "n": 5000,
+            "scipy_ms": 568.5073488013586,
+            "warm_overhead": 1.179959153413669,
+            "warm_solve_ms": 670.8154500011005,
+            "warm_total_ms": 670.8154500011005
+          }
+        ]
+      }
+    },
+    "nlp": {
+      "loop": {
+        "label": "NLP (Loop)",
+        "results": [
+          {
+            "build_ms": 0.23259400040842593,
+            "cold_overhead": 26.924193665611664,
+            "cold_solve_ms": 22.282316000200808,
+            "cold_total_ms": 22.514910000609234,
+            "n": 10,
+            "scipy_ms": 0.83623339960468,
+            "warm_overhead": 1.526948339291722,
+            "warm_solve_ms": 1.2768852007866371,
+            "warm_total_ms": 1.2768852007866371
+          },
+          {
+            "build_ms": 0.8333039986609947,
+            "cold_overhead": 140.23467756679662,
+            "cold_solve_ms": 23.261622001882643,
+            "cold_total_ms": 24.094926000543637,
+            "n": 25,
+            "scipy_ms": 0.17181860021082684,
+            "warm_overhead": 2.940754958360747,
+            "warm_solve_ms": 0.5052764005085919,
+            "warm_total_ms": 0.5052764005085919
+          },
+          {
+            "build_ms": 0.3780549996008631,
+            "cold_overhead": 256.11622214696143,
+            "cold_solve_ms": 42.20331599935889,
+            "cold_total_ms": 42.581370998959756,
+            "n": 50,
+            "scipy_ms": 0.16625800053589046,
+            "warm_overhead": 3.638935862690727,
+            "warm_solve_ms": 0.6050022006093059,
+            "warm_total_ms": 0.6050022006093059
+          },
+          {
+            "build_ms": 0.510792997374665,
+            "cold_overhead": 560.5602547995003,
+            "cold_solve_ms": 171.82303099980345,
+            "cold_total_ms": 172.33382399717811,
+            "n": 100,
+            "scipy_ms": 0.30743140014237724,
+            "warm_overhead": 5.524515057550911,
+            "warm_solve_ms": 1.6984093992505223,
+            "warm_total_ms": 1.6984093992505223
+          },
+          {
+            "build_ms": 1.5647879990865476,
+            "cold_overhead": 2373.6715815740263,
+            "cold_solve_ms": 788.4804659988731,
+            "cold_total_ms": 790.0452539979597,
+            "n": 200,
+            "scipy_ms": 0.33283680022577755,
+            "warm_overhead": 5.649991223581403,
+            "warm_solve_ms": 1.88052500016056,
+            "warm_total_ms": 1.88052500016056
+          },
+          {
+            "build_ms": 2.4829899994074367,
+            "cold_overhead": 5156.3964225459185,
+            "cold_solve_ms": 5282.304603999364,
+            "cold_total_ms": 5284.787593998772,
+            "n": 500,
+            "scipy_ms": 1.024899398908019,
+            "warm_overhead": 7.431381273147058,
+            "warm_solve_ms": 7.616418199904729,
+            "warm_total_ms": 7.616418199904729
+          }
+        ]
+      },
+      "vector": {
+        "label": "NLP (VectorVariable)",
+        "results": [
+          {
+            "build_ms": 0.1335380002274178,
+            "cold_overhead": 7.034893721008192,
+            "cold_solve_ms": 1.6221139994740952,
+            "cold_total_ms": 1.755651999701513,
+            "n": 10,
+            "scipy_ms": 0.24956340057542548,
+            "warm_overhead": 2.187587599443851,
+            "warm_solve_ms": 0.5459418003738392,
+            "warm_total_ms": 0.5459418003738392
+          },
+          {
+            "build_ms": 0.18729899966274388,
+            "cold_overhead": 8.070642423746817,
+            "cold_solve_ms": 3.2761719994596206,
+            "cold_total_ms": 3.4634709991223644,
+            "n": 25,
+            "scipy_ms": 0.4291443998226896,
+            "warm_overhead": 5.572431566330814,
+            "warm_solve_ms": 2.3913778000860475,
+            "warm_total_ms": 2.3913778000860475
+          },
+          {
+            "build_ms": 0.2650540009199176,
+            "cold_overhead": 3.026941579482231,
+            "cold_solve_ms": 1.2355649996607099,
+            "cold_total_ms": 1.5006190005806275,
+            "n": 50,
+            "scipy_ms": 0.4957541998010129,
+            "warm_overhead": 2.0825227513121036,
+            "warm_solve_ms": 1.0324194001441356,
+            "warm_total_ms": 1.0324194001441356
+          },
+          {
+            "build_ms": 0.4631140000128653,
+            "cold_overhead": 4.760779426991482,
+            "cold_solve_ms": 1.846163002483081,
+            "cold_total_ms": 2.3092770024959464,
+            "n": 100,
+            "scipy_ms": 0.4850628007261548,
+            "warm_overhead": 4.305729478136866,
+            "warm_solve_ms": 2.088549199834233,
+            "warm_total_ms": 2.088549199834233
+          },
+          {
+            "build_ms": 0.943560000450816,
+            "cold_overhead": 5.758374810789764,
+            "cold_solve_ms": 5.066017001809087,
+            "cold_total_ms": 6.009577002259903,
+            "n": 200,
+            "scipy_ms": 1.0436238000693265,
+            "warm_overhead": 2.2984234359876172,
+            "warm_solve_ms": 2.3986894004337955,
+            "warm_total_ms": 2.3986894004337955
+          },
+          {
+            "build_ms": 4.8641109970049,
+            "cold_overhead": 53.78946185114727,
+            "cold_solve_ms": 6.9507119987974875,
+            "cold_total_ms": 11.814822995802388,
+            "n": 500,
+            "scipy_ms": 0.21964939951431006,
+            "warm_overhead": 8.802874053183821,
+            "warm_solve_ms": 1.933545999781927,
+            "warm_total_ms": 1.933545999781927
+          },
+          {
+            "build_ms": 2.3693789989920333,
+            "cold_overhead": 36.298616780646455,
+            "cold_solve_ms": 6.737806001183344,
+            "cold_total_ms": 9.107185000175377,
+            "n": 1000,
+            "scipy_ms": 0.2508961995772552,
+            "warm_overhead": 17.360370574977356,
+            "warm_solve_ms": 4.3556510005146265,
+            "warm_total_ms": 4.3556510005146265
+          },
+          {
+            "build_ms": 4.656695000448963,
+            "cold_overhead": 63.99828017713911,
+            "cold_solve_ms": 15.803311998752179,
+            "cold_total_ms": 20.46000699920114,
+            "n": 2000,
+            "scipy_ms": 0.3196962003130466,
+            "warm_overhead": 22.64619971147447,
+            "warm_solve_ms": 7.239903999288799,
+            "warm_total_ms": 7.239903999288799
+          },
+          {
+            "build_ms": 19.125397000607336,
+            "cold_overhead": 81.94926695989462,
+            "cold_solve_ms": 47.659322000981774,
+            "cold_total_ms": 66.78471900158911,
+            "n": 5000,
+            "scipy_ms": 0.8149519999278709,
+            "warm_overhead": 42.13192875480498,
+            "warm_solve_ms": 34.33549959954689,
+            "warm_total_ms": 34.33549959954689
+          }
+        ]
+      }
+    }
+  }
+}
diff --git a/docs/assets/benchmarks/cqp_scaling_comparison.png b/docs/assets/benchmarks/cqp_scaling_comparison.png
index 7aca848..40a0908 100644
Binary files a/docs/assets/benchmarks/cqp_scaling_comparison.png and b/docs/assets/benchmarks/cqp_scaling_comparison.png differ
diff --git a/docs/assets/benchmarks/lp_cache_benefit.png b/docs/assets/benchmarks/lp_cache_benefit.png
index 06e6a84..4119340 100644
Binary files a/docs/assets/benchmarks/lp_cache_benefit.png and b/docs/assets/benchmarks/lp_cache_benefit.png differ
diff --git a/docs/assets/benchmarks/lp_scaling_comparison.png b/docs/assets/benchmarks/lp_scaling_comparison.png
index d3f6094..fb7b5c7 100644
Binary files a/docs/assets/benchmarks/lp_scaling_comparison.png and b/docs/assets/benchmarks/lp_scaling_comparison.png differ
diff --git a/docs/assets/benchmarks/milp_scaling_comparison.png b/docs/assets/benchmarks/milp_scaling_comparison.png
new file mode 100644
index 0000000..3ee030f
Binary files /dev/null and b/docs/assets/benchmarks/milp_scaling_comparison.png differ
diff --git a/docs/assets/benchmarks/multi_problem_scaling.png b/docs/assets/benchmarks/multi_problem_scaling.png
index 5990b80..b7f0c95 100644
Binary files a/docs/assets/benchmarks/multi_problem_scaling.png and b/docs/assets/benchmarks/multi_problem_scaling.png differ
diff --git a/docs/assets/benchmarks/nlp_quadratic_scaling.png b/docs/assets/benchmarks/nlp_quadratic_scaling.png
index e873109..03fb244 100644
Binary files a/docs/assets/benchmarks/nlp_quadratic_scaling.png and b/docs/assets/benchmarks/nlp_quadratic_scaling.png differ
diff --git a/docs/assets/benchmarks/nlp_scaling_comparison.png b/docs/assets/benchmarks/nlp_scaling_comparison.png
index 81e5162..ce91e22 100644
Binary files a/docs/assets/benchmarks/nlp_scaling_comparison.png and b/docs/assets/benchmarks/nlp_scaling_comparison.png differ
diff --git a/docs/assets/benchmarks/overhead_breakdown.png b/docs/assets/benchmarks/overhead_breakdown.png
index a108771..75dbecc 100644
Binary files a/docs/assets/benchmarks/overhead_breakdown.png and b/docs/assets/benchmarks/overhead_breakdown.png differ
diff --git a/docs/assets/benchmarks/scipy_lp_scaling.png b/docs/assets/benchmarks/scipy_lp_scaling.png
index 6d798fb..eac448e 100644
Binary files a/docs/assets/benchmarks/scipy_lp_scaling.png and b/docs/assets/benchmarks/scipy_lp_scaling.png differ
diff --git a/docs/assets/benchmarks/sparse_benchmark_results.txt b/docs/assets/benchmarks/sparse_benchmark_results.txt
new file mode 100644
index 0000000..8e51ed2
--- /dev/null
+++ b/docs/assets/benchmarks/sparse_benchmark_results.txt
@@ -0,0 +1,37 @@
+Sparse vs Dense Jacobian Compilation Benchmark
+======================================================================
+
+======================================================================
+CHAIN CONSTRAINTS: x_i + x_{i+1} (2 nnz per row, density=2/n)
+======================================================================
+     n |  Dense Compile |  Sparse Compile |  Dense Eval |  Sparse Eval |  Compile Speedup |  Eval Speedup |  Density
+------------------------------------------------------------------------------------------------------------------------
+    10 |         5.48ms |          6.53ms |     0.000ms |      0.000ms |            0.8x |         1.4x |   20.0%
+    25 |         5.07ms |          1.56ms |     0.000ms |      0.000ms |            3.2x |         0.7x |    8.0%
+    50 |        12.20ms |          7.59ms |     0.000ms |      0.000ms |            1.6x |         0.8x |    4.0%
+   100 |        16.11ms |         13.08ms |     0.000ms |      0.000ms |            1.2x |         0.7x |    2.0%
+   200 |        71.44ms |         34.71ms |     0.004ms |      0.000ms |            2.1x |        15.5x |    1.0%
+   500 |       146.92ms |        159.77ms |     0.009ms |      0.000ms |            0.9x |        24.2x |    0.4%
+
+======================================================================
+PAIRWISE CONSTRAINTS: x_i - x_j (2 nnz per row, m=n)
+======================================================================
+     n |  Dense Eval |  Sparse Eval |  Eval Speedup |  Dense Memory |  Sparse Memory
+------------------------------------------------------------------------------------------
+    10 |     0.000ms |      0.000ms |         1.4x |        800 B |         284 B
+    25 |     0.000ms |      0.000ms |         0.9x |      5,000 B |         704 B
+    50 |     0.000ms |      0.000ms |         0.9x |     20,000 B |       1,404 B
+   100 |     0.000ms |      0.001ms |         0.2x |     79,200 B |       2,776 B
+   200 |     0.004ms |      0.000ms |        14.5x |    316,800 B |       5,548 B
+   500 |     0.009ms |      0.000ms |        20.1x |  2,000,000 B |      14,004 B
+
+======================================================================
+NONLINEAR SPARSE: x_i² + x_{i+1}² (2 nnz per row)
+======================================================================
+     n |  Dense Eval |  Sparse Eval |  Eval Speedup
+------------------------------------------------------------
+    10 |     0.056ms |      0.355ms |         0.2x
+    25 |     0.139ms |      0.437ms |         0.3x
+    50 |     0.477ms |      0.231ms |         2.1x
+   100 |     1.445ms |      0.483ms |         3.0x
+   200 |     1.546ms |      0.659ms |         2.3x
diff --git a/docs/assets/benchmarks/sparse_memory_reduction.png b/docs/assets/benchmarks/sparse_memory_reduction.png
new file mode 100644
index 0000000..5b39bb2
Binary files /dev/null and b/docs/assets/benchmarks/sparse_memory_reduction.png differ
diff --git a/docs/assets/benchmarks/sparse_solve_end_to_end.png b/docs/assets/benchmarks/sparse_solve_end_to_end.png
new file mode 100644
index 0000000..8e08269
Binary files /dev/null and b/docs/assets/benchmarks/sparse_solve_end_to_end.png differ
diff --git a/docs/assets/benchmarks/sparse_solve_end_to_end_metadata.json b/docs/assets/benchmarks/sparse_solve_end_to_end_metadata.json
new file mode 100644
index 0000000..118d380
--- /dev/null
+++ b/docs/assets/benchmarks/sparse_solve_end_to_end_metadata.json
@@ -0,0 +1,13 @@
+{
+  "benchmark_suite": "sparse_solve_end_to_end",
+  "cpu_count": 2,
+  "machine": "x86_64",
+  "numpy_version": "2.3.5",
+  "optyx_version": "1.3.0",
+  "platform": "Linux-6.8.0-1044-azure-x86_64-with-glibc2.39",
+  "processor": "x86_64",
+  "python_implementation": "CPython",
+  "python_version": "3.12.1",
+  "scipy_version": "1.16.3",
+  "timestamp_utc": "2026-04-18T21:05:46.137793+00:00"
+}
diff --git a/docs/assets/benchmarks/sparse_solve_end_to_end_results.json b/docs/assets/benchmarks/sparse_solve_end_to_end_results.json
new file mode 100644
index 0000000..1983da5
--- /dev/null
+++ b/docs/assets/benchmarks/sparse_solve_end_to_end_results.json
@@ -0,0 +1,42 @@
+[
+  {
+    "n": 20,
+    "jacobian_type": "csr_matrix",
+    "nnz": 40,
+    "density": 0.09523809523809523,
+    "cold_trust_constr_median_ms": 216.23572600037733,
+    "cold_slsqp_median_ms": 16.729955001210328,
+    "warm_trust_constr_median_ms": 202.07499099888082,
+    "warm_slsqp_median_ms": 19.78887599943846
+  },
+  {
+    "n": 40,
+    "jacobian_type": "csr_matrix",
+    "nnz": 80,
+    "density": 0.04878048780487805,
+    "cold_trust_constr_median_ms": 528.6076329994103,
+    "cold_slsqp_median_ms": 55.64899599994533,
+    "warm_trust_constr_median_ms": 99.23417800018797,
+    "warm_slsqp_median_ms": 2.7929649986617733
+  },
+  {
+    "n": 80,
+    "jacobian_type": "csr_matrix",
+    "nnz": 160,
+    "density": 0.024691358024691357,
+    "cold_trust_constr_median_ms": 3570.338139999876,
+    "cold_slsqp_median_ms": 187.50832499972603,
+    "warm_trust_constr_median_ms": 136.33992400173156,
+    "warm_slsqp_median_ms": 8.31679700058885
+  },
+  {
+    "n": 120,
+    "jacobian_type": "csr_matrix",
+    "nnz": 240,
+    "density": 0.01652892561983471,
+    "cold_trust_constr_median_ms": 11636.690797999108,
+    "cold_slsqp_median_ms": 455.27698600017175,
+    "warm_trust_constr_median_ms": 154.7880569996778,
+    "warm_slsqp_median_ms": 18.819584998709615
+  }
+]
diff --git a/docs/assets/benchmarks/sparse_vs_dense_comparison.png b/docs/assets/benchmarks/sparse_vs_dense_comparison.png
new file mode 100644
index 0000000..fca5249
Binary files /dev/null and b/docs/assets/benchmarks/sparse_vs_dense_comparison.png differ
diff --git a/docs/benchmarks.qmd b/docs/benchmarks.qmd
index abfb7a6..09e3460 100644
--- a/docs/benchmarks.qmd
+++ b/docs/benchmarks.qmd
@@ -3,21 +3,169 @@ title: "Benchmarks"
 description: "Performance analysis and comparison with SciPy"
 ---
 
+```{python}
+#| echo: false
+#| output: asis
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+
+ASSET_DIR_CANDIDATES = [
+	Path("assets/benchmarks"),
+	Path("docs/assets/benchmarks"),
+]
+ASSETS_DIR = next((path for path in ASSET_DIR_CANDIDATES if path.exists()), ASSET_DIR_CANDIDATES[0])
+RESULTS_PATH = ASSETS_DIR / "benchmark_results.json"
+METADATA_PATH = ASSETS_DIR / "benchmark_metadata.json"
+OUTPUT_PATH = ASSETS_DIR / "benchmark_output.txt"
+
+required_paths = [RESULTS_PATH, METADATA_PATH, OUTPUT_PATH]
+missing_paths = [path for path in required_paths if not path.exists()]
+if missing_paths:
+	raise FileNotFoundError(
+		"Missing benchmark artifacts: "
+		+ ", ".join(path.as_posix() for path in missing_paths)
+		+ ". Run `uv run python benchmarks/run_benchmarks.py` to regenerate and sync docs assets."
+	)
+
+benchmark_data = json.loads(RESULTS_PATH.read_text())
+benchmark_metadata = json.loads(METADATA_PATH.read_text())
+benchmark_output = OUTPUT_PATH.read_text()
+
+
+def fmt_ms(value: float) -> str:
+	if value >= 1000:
+		return f"{value:,.1f}ms"
+	return f"{value:.1f}ms"
+
+
+def fmt_x(value: float) -> str:
+	return f"{value:.1f}x"
+
+
+def render_table(headers: list[str], rows: list[list[str]]) -> None:
+	print("| " + " | ".join(headers) + " |")
+	print("|" + "|".join("---" for _ in headers) + "|")
+	for row in rows:
+		print("| " + " | ".join(row) + " |")
+	print()
+
+
+def render_plot(plot_key: str, alt_text: str) -> None:
+	plot_name = benchmark_data["artifacts"]["plots"][plot_key]
+	print(f"![{alt_text}]({(ASSETS_DIR / plot_name).as_posix()}){{width=100%}}")
+	print()
+
+
+def render_scaling_table(problem_key: str, variant_key: str) -> None:
+	series = benchmark_data["scaling"][problem_key][variant_key]["results"]
+	rows = []
+	for result in series:
+		rows.append(
+			[
+				str(result["n"]),
+				fmt_ms(result["build_ms"]),
+				fmt_ms(result["cold_solve_ms"]),
+				fmt_ms(result["warm_solve_ms"]),
+				fmt_ms(result["scipy_ms"]),
+				fmt_x(result["cold_overhead"]),
+				fmt_x(result["warm_overhead"]),
+			]
+		)
+	render_table(
+		["n", "Build", "Cold Solve", "Warm Solve", "SciPy", "Cold Overhead", "Warm Overhead"],
+		rows,
+	)
+
+
+def render_metadata_callout() -> None:
+	timestamp = benchmark_metadata.get("timestamp_utc", "unknown")
+	processor = benchmark_metadata.get("processor") or benchmark_metadata.get("machine", "unknown")
+	cpu_count = benchmark_metadata.get("cpu_count", "unknown")
+	platform = benchmark_metadata.get("platform", "unknown")
+	python_version = benchmark_metadata.get("python_version", "unknown")
+	numpy_version = benchmark_metadata.get("numpy_version", "unknown")
+	scipy_version = benchmark_metadata.get("scipy_version", "unknown")
+	optyx_version = benchmark_metadata.get("optyx_version", "unknown")
+
+	print("::: {.callout-note}")
+	print("## Reference Hardware")
+	print(
+		"\n".join(
+			[
+				f"Last synced benchmark assets: **{timestamp}**  ",
+				f"CPU: **{processor}** with **{cpu_count}** logical cores  ",
+				f"Platform: **{platform}**  ",
+				f"Python: **{python_version}**, NumPy: **{numpy_version}**, SciPy: **{scipy_version}**, Optyx: **{optyx_version}**",
+			]
+		)
+	)
+	print(":::")
+	print()
+
+
+def render_performance_summary() -> None:
+	rows = []
+	for item in benchmark_data["performance_summary"]:
+		rows.append(
+			[
+				f"**{item['problem_type']}**",
+				f"n={item['size']}",
+				fmt_x(item["cold_overhead"]),
+				fmt_x(item["warm_overhead"]),
+				item["note"],
+			]
+		)
+	render_table(["Problem Type", "Size", "Cold Overhead", "Warm Overhead", "Notes"], rows)
+
+
+def render_overhead_summary() -> None:
+	rows = []
+	for item in benchmark_data["overhead_summary"]:
+		rows.append(
+			[
+				f"{item['problem_type']} (n={item['size']})",
+				fmt_x(item["cold_overhead"]),
+				fmt_x(item["warm_overhead"]),
+			]
+		)
+	render_table(["Problem Type", "Cold Overhead", "Warm Overhead"], rows)
+
+
+def extract_output_section(start_marker: str, end_marker: str) -> str:
+	start = benchmark_output.find(start_marker)
+	if start == -1:
+		return benchmark_output[-1200:]
+	end = benchmark_output.find(end_marker, start)
+	if end == -1:
+		end = len(benchmark_output)
+	return benchmark_output[start:end].strip()
+
+
+render_metadata_callout()
+```
+
 # Benchmarks
 
 Optyx includes a comprehensive benchmark suite measuring **end-to-end performance** including variable creation, problem setup, constraint construction, and solving. All benchmarks compare against raw SciPy (which has no build phase).
 
+This page renders directly from synced artifacts in `docs/assets/benchmarks/`:
+
+- `benchmark_results.json` for structured tables and summary values
+- `benchmark_metadata.json` for machine and dependency metadata
+- `benchmark_output.txt` for the raw console transcript
+- `.png` plots copied from the latest benchmark run
+
 ## Quick Start
 
 ```bash
 # Run all benchmark tests
 uv run pytest benchmarks/ -v
 
-# Generate performance analysis plots
+# Generate performance analysis plots and sync docs assets automatically
 uv run python benchmarks/run_benchmarks.py
-
-# Copy plots to docs (for documentation updates)
-cp benchmarks/results/*.png docs/assets/benchmarks/
 ```
 
 ::: {.callout-note}
@@ -33,34 +181,31 @@ All benchmarks measure **total time** including:
 
 ## Performance Summary
 
-| Problem Type | Size | Cold Overhead | Warm Overhead | Notes |
-|--------------|------|---------------|---------------|-------|
-| **LP** | n=50 | 1.5x | 1.2x | Near-parity with SciPy linprog |
-| **LP** | n=500 | 1.3x | 1.0x | Warm solves at parity |
-| **LP** | n=5000 | 1.0x | 1.0x | Scales to large problems |
-| **NLP** | n=50 | 8.8x | 1.7x | Fast warm solves |
-| **NLP** | n=500 | 9.0x | **0.2x** | Warm solves 5x faster than SciPy |
-| **NLP** | n=5000 | 0.4x | **0.0x** | **800x faster** than SciPy at scale |
-| **CQP** | n=50 | 2.9x | 1.5x | O(1) Jacobian compilation |
-| **CQP** | n=500 | 1.5x | 1.2x | Near-parity with SciPy |
-| **CQP** | n=5000 | 1.0x | 1.0x | Perfect scaling |
+```{python}
+#| echo: false
+#| output: asis
+render_performance_summary()
+```
 
-**Key Insight**: Cold solves include one-time compilation. Warm solves (repeated optimization with cached structure) achieve near-parity or better than raw SciPy.
+**Key Insight**: Cold solves include one-time compilation. Warm solves (repeated optimization with cached structure) achieve near-parity with raw SciPy for LP, CQP, and MILP. NLP overhead reflects autodiff costs on trivially simple benchmarks — for complex nonlinear problems, automatic differentiation provides significant modeling advantages.
 
 ---
 
 ## LP Scaling: VectorVariable vs Loop-Based
 
-![LP Scaling Comparison](assets/benchmarks/lp_scaling_comparison.png){width=100%}
+```{python}
+#| echo: false
+#| output: asis
+render_plot("lp_scaling", "LP Scaling Comparison")
+```
 
-### Loop-Based Variables (n ≤ 100)
+### Loop-Based Variables (n ≤ 500)
 
-| n | Build | Cold Solve | Warm Solve | SciPy | Cold Overhead | Warm Overhead |
-|---|-------|------------|------------|-------|---------------|---------------|
-| 10 | 0.4ms | 5.1ms | 1.2ms | 1.1ms | 5.0x | 1.4x |
-| 25 | 1.1ms | 12.7ms | 2.1ms | 4.0ms | 3.5x | 0.8x |
-| 50 | 5.3ms | 45.1ms | 4.8ms | 3.3ms | 15.4x | 3.1x |
-| 100 | 20.5ms | 203.1ms | 5.6ms | 3.2ms | 70.6x | 8.3x |
+```{python}
+#| echo: false
+#| output: asis
+render_scaling_table("lp", "loop")
+```
 
 ::: {.callout-warning}
 ## Loop-Based Variables Don't Scale
@@ -69,97 +214,100 @@ Loop-based variable construction creates O(n²) expression tree nodes, causing e
 
 ### VectorVariable (n ≤ 5,000)
 
-| n | Build | Cold Solve | Warm Solve | SciPy | Cold Overhead | Warm Overhead |
-|---|-------|------------|------------|-------|---------------|---------------|
-| 10 | 0.2ms | 1.3ms | 1.1ms | 1.1ms | 1.4x | 1.2x |
-| 25 | 0.2ms | 1.6ms | 1.3ms | 1.2ms | 1.4x | 1.2x |
-| 50 | 0.3ms | 2.3ms | 1.8ms | 1.7ms | 1.5x | 1.2x |
-| 100 | 0.5ms | 4.2ms | 3.2ms | 3.0ms | 1.6x | 1.2x |
-| 200 | 1.2ms | 12.1ms | 8.8ms | 8.7ms | 1.5x | 1.1x |
-| 500 | 2.3ms | 71.5ms | 56.0ms | 58.5ms | 1.3x | 1.0x |
-| 1000 | 7.4ms | 270.8ms | 224.5ms | 283.3ms | 1.0x | 0.8x |
-| 2000 | 9.7ms | 988.9ms | 957.0ms | 959.5ms | 1.0x | 1.0x |
-| 5000 | 44.9ms | 8,491ms | 8,374ms | 8,396ms | 1.0x | 1.0x |
+```{python}
+#| echo: false
+#| output: asis
+render_scaling_table("lp", "vector")
+```
 
-**VectorVariable achieves parity or better than raw SciPy** for warm solves at all scales. Cold solve overhead is ~2x due to one-time compilation.
+**VectorVariable achieves parity or better than raw SciPy** for warm solves at all scales. Cold solve overhead is minimal due to one-time compilation.
 
 ---
 
 ## NLP Scaling: Unconstrained Optimization
 
-![NLP Scaling Comparison](assets/benchmarks/nlp_scaling_comparison.png){width=100%}
+```{python}
+#| echo: false
+#| output: asis
+render_plot("nlp_scaling", "NLP Scaling Comparison")
+```
 
 Objective: `min Σx²ᵢ - Σxᵢ` (optimal at x* = 0.5)
 
 ### VectorVariable with `x.dot(x) - x.sum()`
 
-| n | Build | Cold Solve | Warm Solve | SciPy | Cold Overhead | Warm Overhead |
-|---|-------|------------|------------|-------|---------------|---------------|
-| 10 | 0.1ms | 1.2ms | 0.5ms | 0.3ms | 3.9x | 1.6x |
-| 25 | 0.1ms | 2.3ms | 0.6ms | 0.3ms | 6.9x | 1.9x |
-| 50 | 0.2ms | 4.8ms | 0.7ms | 0.6ms | 8.8x | 1.7x |
-| 100 | 0.3ms | 10.8ms | 1.1ms | 0.9ms | 12.0x | 1.5x |
-| 200 | 0.7ms | 35.7ms | 1.8ms | 2.9ms | 12.8x | 0.9x |
-| 500 | 1.6ms | 170.7ms | 3.0ms | 19.2ms | 9.0x | 0.2x |
-| 1000 | 3.6ms | 418.7ms | 6.0ms | 109.6ms | 3.9x | 0.1x |
-| 2000 | 6.8ms | 1,554ms | 15.5ms | 1,577ms | 1.0x | 0.0x |
-| 5000 | 16.6ms | 8,830ms | 27.9ms | 23,004ms | 0.4x | 0.0x |
-
-::: {.callout-tip}
-## At Large Scale, Optyx Can Be Faster
-At n=5000, Optyx warm solves are **800x faster** than SciPy due to cached gradient computation and efficient vectorized evaluation.
+```{python}
+#| echo: false
+#| output: asis
+render_scaling_table("nlp", "vector")
+```
+
+::: {.callout-note}
+## Interpreting NLP Overhead
+This benchmark uses a trivially simple quadratic (`Σx² - Σx`) where SciPy’s L-BFGS-B converges in a single iteration (~0.2–0.4ms regardless of size). The overhead reflects Optyx’s automatic differentiation machinery, not solver performance. For complex nonlinear objectives where manual gradients are impractical, Optyx’s autodiff provides significant modeling advantages.
 :::
 
 ---
 
 ## Constrained QP Scaling
 
-![CQP Scaling Comparison](assets/benchmarks/cqp_scaling_comparison.png){width=100%}
+```{python}
+#| echo: false
+#| output: asis
+render_plot("cqp_scaling", "CQP Scaling Comparison")
+```
 
 Objective: `min Σx²ᵢ` subject to `Σxᵢ ≥ 1, xᵢ ≥ 0`
 
 ### VectorVariable with `x.dot(x)`, `x.sum()`
 
-| n | Build | Cold Solve | Warm Solve | SciPy | Cold Overhead | Warm Overhead |
-|---|-------|------------|------------|-------|---------------|---------------|
-| 10 | 0.1ms | 1.2ms | 0.4ms | 0.3ms | 3.9x | 1.6x |
-| 25 | 0.1ms | 1.3ms | 0.5ms | 0.5ms | 3.1x | 1.4x |
-| 50 | 0.2ms | 1.5ms | 0.7ms | 0.6ms | 2.9x | 1.5x |
-| 100 | 0.3ms | 2.0ms | 1.0ms | 0.9ms | 2.7x | 1.5x |
-| 200 | 0.6ms | 4.2ms | 2.3ms | 1.9ms | 2.5x | 1.5x |
-| 500 | 2.5ms | 15.3ms | 12.3ms | 12.0ms | 1.5x | 1.2x |
-| 1000 | 6.1ms | 75.4ms | 72.3ms | 84.8ms | 1.0x | 0.9x |
-| 2000 | 6.2ms | 471.8ms | 519.7ms | 480.3ms | 1.0x | 1.1x |
-| 5000 | 15.7ms | 6,423ms | 6,338ms | 6,297ms | 1.0x | 1.0x |
+```{python}
+#| echo: false
+#| output: asis
+render_scaling_table("cqp", "vector")
+```
 
-With O(1) Jacobian computation, constrained problems now achieve parity with SciPy at all scales up to n=5,000.
+With O(1) Jacobian computation, constrained problems achieve near-parity with SciPy at scale (≤1.2x warm overhead for n ≥ 500).
 
 ---
 
-## Overhead Summary by Problem Type
+## MILP Scaling: Binary Knapsack
 
-![Overhead Breakdown](assets/benchmarks/overhead_breakdown.png){width=100%}
+```{python}
+#| echo: false
+#| output: asis
+render_plot("milp_scaling", "MILP Scaling Comparison")
+```
+
+Problem: Single-constraint binary knapsack (`sum(x) <= n//2`)
 
-| Problem Type | Cold Overhead | Warm Overhead |
-|--------------|---------------|---------------|
-| LP (n=50) | 2.2x | 1.5x |
-| LP (n=500) | 1.2x | 1.2x |
-| NLP (n=50) | 24.3x | 1.7x |
-| NLP (n=500) | 10.7x | 0.3x |
-| CQP (n=50) | 2.3x | 2.4x |
-| CQP (n=500) | 3.7x | 2.4x |
+### VectorVariable (n ≤ 5,000)
+
+```{python}
+#| echo: false
+#| output: asis
+render_scaling_table("milp", "vector")
+```
 
-**Pattern**: Cold overhead includes one-time compilation. Warm overhead is at or below 1.5x for all problem types - Optyx matches or beats raw SciPy on repeated solves.
+MILP warm solves achieve near-parity with SciPy at all scales. The integer programming solver adds minimal overhead beyond the SciPy `milp` baseline.
 
 ---
 
-## The Value of Caching
+## Overhead Summary by Problem Type
 
-One of Optyx's core value propositions is **"compile once, solve many."** This is particularly valuable for parameter sweeps, scenario analysis, and control loops.
+```{python}
+#| echo: false
+#| output: asis
+render_plot("overhead_breakdown", "Overhead Breakdown")
+```
 
-![Cache Benefit](assets/benchmarks/lp_cache_benefit.png){width=100%}
+```{python}
+#| echo: false
+#| output: asis
+render_overhead_summary()
+```
 
-As demonstrated in the chart, the **first solve** pays a compilation cost. Subsequent solves (using the same problem structure but different data/parameters) bypass this phase, achieving performance comparable to or better than raw SciPy. This benefit grows with problem complexity, where Optyx's cache enables resolving complex NLPs instantly.
+**Pattern**: LP, CQP, and MILP achieve near-parity with SciPy on warm solves at all scales. NLP overhead reflects autodiff costs on a trivially simple quadratic — for complex nonlinear problems, automatic differentiation eliminates the need for manual gradient derivation.
 
 ---
 
@@ -172,7 +320,7 @@ As demonstrated in the chart, the **first solve** pays a compilation cost. Subse
 ✅ **Prototyping**: Clean Python API, no manual gradients  
 ✅ **Large LP**: VectorVariable achieves parity with SciPy up to n=5,000  
 ✅ **Non-convex NLP**: Automatic differentiation with exact gradients  
-✅ **Large NLP**: 800x faster than SciPy at n=5,000 for warm solves
+✅ **Mixed-integer programming**: MILP at near-parity with SciPy milp
 
 ### Consider Alternatives For
 
@@ -182,38 +330,6 @@ As demonstrated in the chart, the **first solve** pays a compilation cost. Subse
 
 ---
 
-
-## SciPy Baseline Scaling
-
-To understand the comparison, here is how the raw SciPy `linprog` solver scales with problem size.
-
-![SciPy Scaling](assets/benchmarks/scipy_lp_scaling.png){width=100%}
-
-Optyx aims to match this curve in "warm solve" mode, while adding only a small constant factor overhead in "cold solve" mode for compilation.
-
----
-
-## Comparison with CVXPY
-
-For convex problems, Optyx can be compared against CVXPY. Install with `uv sync --extra benchmarks`.
-
-| Problem | Optyx | CVXPY | Overhead | Notes |
-|---------|-------|-------|----------|-------|
-| Small LP (2 vars) | 1.1ms | 1.0ms | 1.08x | Near parity |
-| Medium LP (20 vars) | 1.3ms | 1.5ms | **0.85x** | Optyx faster |
-| Simple QP | 0.4ms | 1.2ms | **0.33x** | Optyx 3x faster |
-| Portfolio QP (n=10) | 3.6ms | 2.5ms | 1.47x | CVXPY's specialized QP solver |
-| Portfolio QP (n=50) | 17.6ms | 1.7ms | 10.1x | CVXPY scales better for large QP |
-
-::: {.callout-note}
-## Optyx vs CVXPY: Different Strengths
-- **LP/Simple QP**: Optyx matches or beats CVXPY
-- **Dense Quadratic Programs**: CVXPY's specialized `quad_form` with interior-point solvers scales better for large portfolio optimization
-- **Non-convex NLP**: Optyx supports non-convex objectives with autodiff; CVXPY requires convexity
-:::
-
----
-
 ## Running Benchmarks
 
 ```bash
@@ -230,13 +346,16 @@ uv run pytest benchmarks/comparison/ -v
 uv run python benchmarks/run_benchmarks.py
 ```
 
-## Success Criteria
-
-| Criterion | Target | Status |
-|-----------|--------|--------|
-| LP warm overhead | < 1.5x vs SciPy | ✅ ~1.0x |
-| NLP warm overhead | < 3x vs SciPy | ✅ **0.001x** (800x faster at n=5000) |
-| CQP warm overhead | < 2x vs SciPy | ✅ **0.9x** (faster than SciPy at n=1000) |
-| VectorVariable scales | n > 1000 | ✅ n=5,000 tested |
-| Gradient accuracy | < 1e-5 error | ✅ < 1e-10 |
-| All validations pass | 100% | ✅ 100% |
+## Latest Console Summary
+
+```{python}
+#| echo: false
+#| output: asis
+console_summary = extract_output_section(
+	"OVERHEAD SUMMARY BY PROBLEM TYPE",
+	"BENCHMARK COMPLETE",
+)
+print("```text")
+print(console_summary)
+print("```")
+```
diff --git a/docs/contributing.qmd b/docs/contributing.qmd
index 65a9724..24b27f2 100644
--- a/docs/contributing.qmd
+++ b/docs/contributing.qmd
@@ -20,7 +20,7 @@ Thank you for your interest in contributing to Optyx! This guide will help you g
 
 ```bash
 # Clone the repository
-git clone https://github.com/daggbt/optyx.git
+git clone https://github.com/optyx-dev/optyx.git
 cd optyx
 
 # Create virtual environment and install dependencies
@@ -196,7 +196,7 @@ git push origin feature/your-feature-name
 
 ### 5. Open Pull Request
 
-- Go to [GitHub](https://github.com/daggbt/optyx/pulls)
+- Go to [GitHub](https://github.com/optyx-dev/optyx/pulls)
 - Click "New Pull Request"
 - Select your branch
 - Fill in the PR template
diff --git a/docs/examples/lp-export.qmd b/docs/examples/lp-export.qmd
new file mode 100644
index 0000000..593bce5
--- /dev/null
+++ b/docs/examples/lp-export.qmd
@@ -0,0 +1,91 @@
+---
+title: "LP Format Export"
+description: "Export optimization models to the standard LP file format"
+---
+
+Export models to `.lp` files for use with external solvers like CPLEX, Gurobi,
+GLPK, and HiGHS.
+
+## Linear Program
+
+```{python}
+from optyx import Problem, Variable
+
+x = Variable("x", lb=0)
+y = Variable("y", lb=0)
+
+prob = Problem("simple_lp")
+prob.minimize(2 * x + 3 * y)
+prob.subject_to(x + y >= 1)
+prob.subject_to(x - y <= 5)
+
+print(prob.to_lp())
+```
+
+Use `prob.write("model.lp")` to save directly to a file.
+
+## Quadratic Program
+
+Quadratic objectives use the standard `[ ... ] / 2` notation.
+
+```{python}
+from optyx import VectorVariable, quadratic_form
+import numpy as np
+
+w = VectorVariable("w", 3, lb=0, ub=1)
+Q = np.array([[2, 1, 0], [1, 3, 1], [0, 1, 2]], dtype=float)
+c = np.array([1.0, 2.0, 3.0])
+
+prob = Problem("portfolio")
+prob.minimize(quadratic_form(w, Q) + c @ w)
+prob.subject_to(w.sum().eq(1))
+
+print(prob.to_lp())
+```
+
+## Mixed-Integer Program
+
+Integer and binary variables are listed in `Generals` and `Binaries` sections.
+
+```{python}
+from optyx import BinaryVariable, IntegerVariable
+
+x = IntegerVariable("x", lb=0, ub=10)
+y = BinaryVariable("y")
+z = Variable("z", lb=0)
+
+prob = Problem("mip")
+prob.maximize(3 * x + 5 * y + z)
+prob.subject_to(x + 2 * y + z <= 15)
+prob.subject_to(x + y >= 2)
+
+print(prob.to_lp())
+```
+
+## Supported Features
+
+| Feature | Support |
+|---------|---------|
+| Linear objectives | ✓ |
+| Quadratic objectives | ✓ |
+| `<=`, `>=`, `==` constraints | ✓ |
+| Variable bounds | ✓ |
+| Free variables | ✓ |
+| Integer variables (Generals) | ✓ |
+| Binary variables (Binaries) | ✓ |
+| Matrix constraints | ✓ |
+| Sparse matrix constraints | ✓ |
+| Nonlinear objectives | ✗ (raises error) |
+
+## Export Methods
+
+The `Problem.to_lp()` method returns the LP string, while `Problem.write(path)`
+writes it to a file.
+
+```python
+# String representation
+lp_string = prob.to_lp()
+
+# Write to file
+prob.write("model.lp")
+```
diff --git a/docs/examples/mine-equipment-milp.qmd b/docs/examples/mine-equipment-milp.qmd
new file mode 100644
index 0000000..a360a70
--- /dev/null
+++ b/docs/examples/mine-equipment-milp.qmd
@@ -0,0 +1,373 @@
+---
+title: "Mixed-Integer Programming (MILP)"
+description: "Equipment selection and scheduling with binary and integer variables"
+date: last-modified
+execute:
+  warning: false
+---
+
+## Overview
+
+This example demonstrates **Mixed-Integer Linear Programming (MILP)** in Optyx — optimization problems where some variables must take discrete (integer or binary) values. MILP is essential for engineering decisions like equipment selection, shift scheduling, and facility location.
+
+Optyx automatically detects integer/binary variables and routes to the MILP solver (SciPy's HiGHS backend).
+
+### MILP Variable Types
+
+| Type | Creation | Values | Use Case |
+|---|---|---|---|
+| `BinaryVariable` | `BinaryVariable("x")` | 0 or 1 | Yes/no decisions |
+| `IntegerVariable` | `IntegerVariable("x", lb, ub)` | Integers in range | Discrete quantities |
+| `VectorVariable` (binary) | `VectorVariable("x", n, domain="binary")` | Vector of 0/1 | Selection problems |
+| `VectorVariable` (integer) | `VectorVariable("x", n, domain="integer")` | Vector of integers | Batch scheduling |
+
+---
+
+## Problem Setup
+
+A mining operation needs to select equipment, schedule shifts, and decide which depots to open.
+
+```{python}
+import numpy as np
+from optyx import (
+    BinaryVariable,
+    IntegerVariable,
+    Variable,
+    VectorVariable,
+    Problem,
+)
+
+equipment = ["Excavator A", "Excavator B", "Loader C", "Drill Rig D"]
+n_equip = len(equipment)
+
+# Fixed cost to acquire/lease ($k/month)
+fixed_cost = [120, 180, 85, 95]
+
+# Capacity per shift (tonnes/shift)
+capacity_per_shift = [500, 800, 350, 200]
+
+# Operating cost per shift ($k/shift)
+op_cost_per_shift = [8, 12, 5, 6]
+
+# Maximum shifts per week
+max_shifts = [14, 14, 21, 21]
+
+min_production = 8000   # tonnes/week minimum
+target_production = 12000  # tonnes/week ideal
+
+print(f"{'Machine':<16} {'Fixed ($k)':>10} {'Cap/Shift':>10} {'Op ($k)':>8} {'Max Shifts':>11}")
+print("-" * 58)
+for i in range(n_equip):
+    print(f"{equipment[i]:<16} {fixed_cost[i]:>10} {capacity_per_shift[i]:>8} t {op_cost_per_shift[i]:>7} {max_shifts[i]:>9}/wk")
+```
+
+---
+
+## Part 1: Binary Equipment Selection
+
+The simplest MILP involves **binary decisions** — should we acquire each piece of equipment?
+
+### BinaryVariable
+
+`BinaryVariable("name")` creates a variable constrained to $\{0, 1\}$:
+
+```{python}
+# Binary: acquire this equipment?
+acquire = [BinaryVariable(f"acquire_{equipment[i]}") for i in range(n_equip)]
+
+print("Created binary variables:")
+for a in acquire:
+    print(f"  {a}")
+```
+
+### Model
+
+Minimize fixed costs while ensuring enough capacity to meet minimum production:
+
+$$
+\min \sum_{i} c_i^{\text{fixed}} \cdot y_i \quad \text{s.t.} \quad \sum_{i} \text{cap}_i \cdot S_i^{\max} \cdot y_i \geq D^{\min}, \quad \sum_i y_i \geq 2
+$$
+
+```{python}
+prob1 = Problem(name="equipment_selection")
+
+# Objective: minimize fixed costs
+total_fixed = sum(fixed_cost[i] * acquire[i] for i in range(n_equip))
+prob1.minimize(total_fixed)
+
+# Capacity constraint (at max shifts)
+total_capacity = sum(
+    capacity_per_shift[i] * max_shifts[i] * acquire[i] 
+    for i in range(n_equip)
+)
+prob1.subject_to(total_capacity >= min_production)
+
+# Redundancy: need at least 2 machines
+prob1.subject_to(sum(acquire) >= 2)
+
+sol1 = prob1.solve()
+
+print(f"Status: {sol1.status.name}")
+print(f"Optimal fixed cost: ${sol1.objective_value:.0f}k/month")
+print(f"MIP gap: {sol1.mip_gap}")
+print(f"Best bound: {sol1.best_bound}")
+
+print("\nEquipment acquired:")
+for i in range(n_equip):
+    selected = sol1[acquire[i].name]
+    marker = "YES" if selected > 0.5 else "no"
+    print(f"  {equipment[i]:<16} → {marker}")
+```
+
+::: {.callout-note}
+`sol.mip_gap` and `sol.best_bound` are MIP-specific solution fields. The gap indicates how close the solution is to proven optimality — a gap of 0 means the solution is provably optimal.
+:::
+
+---
+
+## Part 2: Integer Shift Scheduling
+
+**`IntegerVariable`** handles discrete quantities — here, the number of shifts per week for each machine.
+
+```{python}
+shifts = [
+    IntegerVariable(f"shifts_{equipment[i]}", lb=0, ub=max_shifts[i])
+    for i in range(n_equip)
+]
+
+print("Created integer variables:")
+for s in shifts:
+    print(f"  {s}")
+```
+
+### Model
+
+Minimize operating cost while meeting the production target:
+
+```{python}
+prob2 = Problem(name="shift_scheduling")
+
+total_op_cost = sum(op_cost_per_shift[i] * shifts[i] for i in range(n_equip))
+prob2.minimize(total_op_cost)
+
+# Meet production target
+production = sum(capacity_per_shift[i] * shifts[i] for i in range(n_equip))
+prob2.subject_to(production >= target_production)
+
+# Minimum 2 shifts each (maintenance window)
+for i in range(n_equip):
+    prob2.subject_to(shifts[i] >= 2)
+
+sol2 = prob2.solve()
+
+print(f"Status: {sol2.status.name}")
+print(f"Optimal operating cost: ${sol2.objective_value:.0f}k/week")
+
+print(f"\n{'Machine':<16} {'Shifts/wk':>10} {'Production':>12} {'Cost':>10}")
+print("-" * 52)
+total_prod = 0
+for i in range(n_equip):
+    s = sol2[shifts[i].name]
+    prod = s * capacity_per_shift[i]
+    cost = s * op_cost_per_shift[i]
+    total_prod += prod
+    print(f"{equipment[i]:<16} {s:>10.0f} {prod:>10.0f} t ${cost:>7.0f}k")
+print("-" * 52)
+print(f"{'TOTAL':<16} {'':>10} {total_prod:>10.0f} t ${sol2.objective_value:>7.0f}k")
+```
+
+---
+
+## Part 3: Binary Vectors
+
+**`VectorVariable`** with `domain="binary"` creates a vector of binary variables — ideal for selection/knapsack problems with many items.
+
+### Spare Parts Selection
+
+Select which spare parts to stock, maximizing equipment coverage within a budget:
+
+```{python}
+n_parts = 8
+part_names = [f"Part-{chr(65+i)}" for i in range(n_parts)]
+part_coverage = np.array([15, 22, 8, 30, 12, 18, 25, 10])  # coverage score
+part_cost = np.array([5, 8, 3, 12, 4, 7, 10, 4])  # cost ($k)
+budget = 30  # $k
+
+# Binary vector: stock this part?
+stock = VectorVariable("stock", n_parts, domain="binary")
+
+prob3 = Problem(name="parts_selection")
+prob3.maximize(part_coverage @ stock)       # maximize coverage
+prob3.subject_to(part_cost @ stock <= budget)  # budget constraint
+prob3.subject_to(stock.sum() >= 3)           # minimum 3 parts
+```
+
+The `@` operator computes the dot product with numpy arrays — combining vectorized operations with binary constraints:
+
+```{python}
+sol3 = prob3.solve()
+
+print(f"Status: {sol3.status.name}")
+print(f"Max coverage: {sol3.objective_value:.0f}")
+
+print(f"\n{'Part':<10} {'Coverage':>10} {'Cost ($k)':>10} {'Selected':>10}")
+print("-" * 43)
+total_cost_parts = 0
+for i in range(n_parts):
+    selected = sol3[f"stock[{i}]"]
+    sel_str = "YES" if selected > 0.5 else "-"
+    if selected > 0.5:
+        total_cost_parts += part_cost[i]
+    print(f"{part_names[i]:<10} {part_coverage[i]:>10} {part_cost[i]:>10} {sel_str:>10}")
+print(f"\nTotal cost: ${total_cost_parts}k / ${budget}k budget")
+```
+
+---
+
+## Part 4: Mixed-Integer — Depot Location
+
+The most powerful MILP pattern combines **binary** (open/close) and **continuous** (allocation) variables linked by **Big-M constraints**.
+
+### Problem
+
+Decide which supply depots to open and how to allocate material to mining sites:
+
+- Binary: whether to open each depot
+- Continuous: tonnes/day shipped from each depot to each site
+- Big-M: can only ship from open depots
+
+```{python}
+depots = ["Central", "North", "South"]
+sites = ["Pit A", "Pit B", "Pit C", "Pit D"]
+n_depots = len(depots)
+n_sites = len(sites)
+
+depot_fixed_cost = [50, 35, 40]   # $k/month
+depot_capacity = [200, 150, 180]  # tonnes/day
+
+# Transport cost per tonne ($)
+transport_cost = np.array([
+    [3, 8, 5, 7],   # Central → each site
+    [6, 2, 9, 4],   # North
+    [7, 5, 3, 2],   # South
+])
+
+site_demand = [60, 45, 55, 40]  # tonnes/day
+
+print(f"{'Depot':<10} {'Fixed ($k)':>10} {'Capacity':>10}")
+print("-" * 33)
+for j in range(n_depots):
+    print(f"{depots[j]:<10} {depot_fixed_cost[j]:>10} {depot_capacity[j]:>8} t/d")
+
+print(f"\nTransport cost matrix ($/t):")
+print(f"{'':>10}", end="")
+for k in range(n_sites):
+    print(f"{sites[k]:>10}", end="")
+print()
+for j in range(n_depots):
+    print(f"{depots[j]:>10}", end="")
+    for k in range(n_sites):
+        print(f"{transport_cost[j,k]:>10}", end="")
+    print()
+```
+
+### Formulation
+
+$$
+\min \sum_j c_j^{\text{fixed}} \cdot y_j + \sum_{j,k} t_{jk} \cdot x_{jk}
+$$
+
+Subject to:
+
+$$
+\begin{aligned}
+\sum_j x_{jk} &\geq d_k \quad &\forall k \quad &\text{(demand)} \\
+\sum_k x_{jk} &\leq C_j \cdot y_j \quad &\forall j \quad &\text{(Big-M capacity)}
+\end{aligned}
+$$
+
+```{python}
+prob4 = Problem(name="depot_location")
+
+# Binary: open depot j?
+open_depot = [BinaryVariable(f"open_{depots[j]}") for j in range(n_depots)]
+
+# Continuous: tonnes from depot j to site k
+alloc = {}
+for j in range(n_depots):
+    for k in range(n_sites):
+        alloc[j, k] = Variable(f"alloc_{depots[j]}_{sites[k]}", lb=0)
+
+# Objective: fixed + transport costs
+obj = sum(depot_fixed_cost[j] * open_depot[j] for j in range(n_depots))
+for j in range(n_depots):
+    for k in range(n_sites):
+        obj = obj + transport_cost[j, k] * alloc[j, k]
+prob4.minimize(obj)
+
+# Demand satisfaction
+for k in range(n_sites):
+    prob4.subject_to(
+        sum(alloc[j, k] for j in range(n_depots)) >= site_demand[k]
+    )
+
+# Big-M capacity linking: can only allocate from open depots
+for j in range(n_depots):
+    prob4.subject_to(
+        sum(alloc[j, k] for k in range(n_sites)) <= depot_capacity[j] * open_depot[j]
+    )
+```
+
+### Solution
+
+```{python}
+sol4 = prob4.solve()
+
+print(f"Status: {sol4.status.name}")
+print(f"Total cost: ${sol4.objective_value:.1f}k")
+print(f"MIP gap: {sol4.mip_gap}")
+
+print("\nDepot decisions:")
+for j in range(n_depots):
+    opened = sol4[open_depot[j].name]
+    status = "OPEN" if opened > 0.5 else "closed"
+    fc = f"${depot_fixed_cost[j]}k" if opened > 0.5 else "-"
+    print(f"  {depots[j]:<10} → {status:<8} (fixed: {fc})")
+
+print(f"\n{'From → To':<25} {'Tonnes/day':>12}")
+print("-" * 40)
+for j in range(n_depots):
+    if sol4[open_depot[j].name] > 0.5:
+        for k in range(n_sites):
+            val = sol4[alloc[j, k].name]
+            if val > 0.1:
+                print(f"  {depots[j]} → {sites[k]:<12} {val:>10.1f}")
+```
+
+---
+
+## Automatic Solver Routing
+
+Optyx detects variable domains and routes automatically:
+
+| Variables | Solver |
+|---|---|
+| All continuous | LP (linprog) |
+| Any integer/binary | MILP (HiGHS via milp) |
+| Nonlinear objective/constraints | NLP (minimize) |
+
+No configuration needed — just declare your variable types and call `prob.solve()`.
+
+---
+
+## Summary
+
+| Feature | Example |
+|---|---|
+| **Binary decisions** | `BinaryVariable("open")` — yes/no |
+| **Integer quantities** | `IntegerVariable("shifts", lb=0, ub=14)` |
+| **Binary vectors** | `VectorVariable("x", n, domain="binary")` |
+| **Mixed formulations** | Binary + continuous with Big-M |
+| **Dot products** | `coefficients @ binary_vector` |
+| **MIP quality** | `sol.mip_gap`, `sol.best_bound` |
+| **Auto-routing** | Detected from variable domains |
diff --git a/docs/examples/mine-production-planning.qmd b/docs/examples/mine-production-planning.qmd
new file mode 100644
index 0000000..de2837b
--- /dev/null
+++ b/docs/examples/mine-production-planning.qmd
@@ -0,0 +1,329 @@
+---
+title: "Mine Production Planning"
+description: "Ore zone extraction optimization using VariableDict for named decision variables"
+date: last-modified
+execute:
+  warning: false
+---
+
+## Overview
+
+This example demonstrates **`VariableDict`** — a dict-indexed variable collection where decision variables are keyed by descriptive string names rather than integer indices. This is a natural fit for mining problems where ore zones, pits, and stockpiles have names.
+
+We'll solve a **mine production planning** problem: choosing how much ore to extract from each zone to maximize profit while meeting mill blend grade targets and throughput constraints.
+
+### What is VariableDict?
+
+`VariableDict` creates a set of decision variables indexed by string keys, much like a Python dictionary. It's ideal when your variables correspond to **named entities** — ore zones, equipment, products — rather than numeric indices.
+
+Key methods demonstrated:
+
+| Method | Purpose |
+|---|---|
+| `VariableDict(name, keys, lb, ub)` | Create with per-key bounds |
+| `vd['key']` | Access individual variable |
+| `vd.sum()` | Sum all variables |
+| `vd.sum(subset)` | Sum a subset of variables |
+| `vd.prod(coefficients)` | Weighted sum (grade blending, costs) |
+| `vd.keys()`, `values()`, `items()` | Dict-like iteration |
+| `len(vd)`, `'key' in vd` | Length and membership |
+| `solution[vd]` | Extract all results as a dict |
+
+---
+
+## Problem Data
+
+An open-pit mining operation has five ore zones, each with different copper grades, extraction costs, and tonnage limits.
+
+```{python}
+from optyx import VariableDict, Problem
+
+# Ore zones
+zones = ["North Pit", "South Pit", "East Bench", "West Cutback", "Stockpile"]
+
+# Ore grade (% copper) per zone
+grade = {
+    "North Pit": 0.85,
+    "South Pit": 0.62,
+    "East Bench": 1.20,
+    "West Cutback": 0.45,
+    "Stockpile": 0.55,
+}
+
+# Extraction cost ($/tonne) per zone
+cost = {
+    "North Pit": 12.50,
+    "South Pit": 9.80,
+    "East Bench": 18.00,
+    "West Cutback": 8.50,
+    "Stockpile": 5.00,
+}
+
+# Revenue per unit of contained metal
+cu_price = 85.0  # $/unit grade-tonne
+
+# Maximum extractable tonnage per zone (kt)
+max_tonnes = {
+    "North Pit": 500,
+    "South Pit": 800,
+    "East Bench": 300,
+    "West Cutback": 600,
+    "Stockpile": 200,
+}
+
+# Mill constraints
+mill_capacity = 1500     # kt total throughput
+min_feed_grade = 0.60    # minimum blend grade (% Cu)
+max_feed_grade = 1.00    # maximum blend grade (% Cu)
+
+# Zone groups
+high_grade_zones = ["North Pit", "East Bench"]
+low_grade_zones = ["South Pit", "West Cutback", "Stockpile"]
+
+print(f"{'Zone':<18} {'Grade (%Cu)':>12} {'Cost ($/t)':>12} {'Max (kt)':>10}")
+print("-" * 55)
+for z in zones:
+    print(f"{z:<18} {grade[z]:>12.2f} {cost[z]:>12.2f} {max_tonnes[z]:>10}")
+print(f"\nMill capacity: {mill_capacity} kt")
+print(f"Feed grade window: {min_feed_grade}% – {max_feed_grade}% Cu")
+```
+
+---
+
+## Creating a VariableDict
+
+Unlike `VectorVariable` (indexed by integers), `VariableDict` uses **string keys**. Each zone becomes a named decision variable with its own bounds.
+
+```{python}
+# Create extraction variables with per-key upper bounds
+extract = VariableDict("extract", zones, lb=0, ub=max_tonnes)
+
+print(f"VariableDict: {extract}")
+print(f"Keys:         {extract.keys()}")
+print(f"Count:        {len(extract)} variables")
+```
+
+### Accessing Individual Variables
+
+Use `vd['key']` to access a specific zone's variable — just like a dictionary:
+
+```{python}
+print(f"extract['North Pit']  → {extract['North Pit']}")
+print(f"extract['East Bench'] → {extract['East Bench']}")
+```
+
+### Membership Testing
+
+```{python}
+print(f"'East Bench' in extract  → {'East Bench' in extract}")
+print(f"'Underground' in extract → {'Underground' in extract}")
+```
+
+---
+
+## Building the Model
+
+### Objective: Maximize Profit
+
+The profit for each zone is:
+
+$$
+\text{net}_z = (\text{cu\_price} \times \text{grade}_z - \text{cost}_z) \times \text{extract}_z
+$$
+
+We use **`prod()`** to compute weighted sums — the grade-weighted revenue and cost-weighted total:
+
+```{python}
+prob = Problem(name="mine_plan")
+
+# Revenue coefficients: cu_price × grade per zone
+revenue_coeffs = {z: cu_price * grade[z] for z in zones}
+
+# prod() computes the weighted sum: Σ coefficient[z] × extract[z]
+revenue = extract.prod(revenue_coeffs)
+total_cost = extract.prod(cost)
+
+prob.maximize(revenue - total_cost)
+
+print("Net profit per tonne by zone:")
+for z in zones:
+    net = revenue_coeffs[z] - cost[z]
+    print(f"  {z:<18} ${net:.2f}/t")
+```
+
+### Constraint 1: Mill Throughput
+
+**`sum()`** returns the sum over all keys — total extraction must fit the mill:
+
+```{python}
+prob.subject_to(extract.sum() <= mill_capacity)
+print(f"Total extraction ≤ {mill_capacity} kt")
+```
+
+### Constraint 2–3: Blend Grade Window
+
+The mill feed must meet grade specifications. We use **`prod(grade)`** for the grade-weighted tonnage:
+
+$$
+\text{grade}_{\min} \cdot \sum_z x_z \leq \sum_z g_z \cdot x_z \leq \text{grade}_{\max} \cdot \sum_z x_z
+$$
+
+```{python}
+prob.subject_to(extract.prod(grade) >= min_feed_grade * extract.sum())
+prob.subject_to(extract.prod(grade) <= max_feed_grade * extract.sum())
+print(f"Blend grade: {min_feed_grade}% ≤ avg ≤ {max_feed_grade}%")
+```
+
+### Constraint 4–5: Zone Group Requirements
+
+**`sum(subset)`** sums only selected keys — useful for grouping zones:
+
+```{python}
+# High-grade zones must contribute at least 300 kt
+prob.subject_to(extract.sum(high_grade_zones) >= 300)
+
+# Low-grade zones capped at 60% of total feed
+prob.subject_to(extract.sum(low_grade_zones) <= 0.6 * extract.sum())
+
+print(f"High-grade zones ({', '.join(high_grade_zones)}): ≥ 300 kt")
+print(f"Low-grade zones ({', '.join(low_grade_zones)}): ≤ 60% of feed")
+```
+
+### Constraint 6: Minimum Extraction
+
+Use **`items()`** to iterate over `(key, variable)` pairs and add per-zone constraints:
+
+```{python}
+min_extract = 50  # kt minimum per zone
+
+for key, var in extract.items():
+    prob.subject_to(var >= min_extract)
+
+print(f"Minimum {min_extract} kt per zone (equipment utilization)")
+```
+
+---
+
+## Solving
+
+```{python}
+import time
+
+start = time.time()
+sol = prob.solve()
+solve_time = (time.time() - start) * 1000
+
+print(f"Status: {sol.status.name}")
+print(f"Solve time: {solve_time:.1f}ms")
+```
+
+---
+
+## Results
+
+### Extracting All Values at Once
+
+**`solution[vd]`** returns a dictionary mapping each key to its optimal value:
+
+```{python}
+# Extract all results as a dict
+result = sol[extract]
+print(f"Type: {type(result).__name__}")
+print(f"Keys: {list(result.keys())}")
+```
+
+### Production Plan Summary
+
+```{python}
+print(f"\n{'Zone':<18} {'Extract (kt)':>14} {'Grade':>8} {'Revenue ($k)':>14} {'Cost ($k)':>12}")
+print("-" * 70)
+
+total_tonnes = 0
+total_metal = 0
+total_revenue = 0
+total_cost_val = 0
+
+for zone in zones:
+    t = result[zone]
+    metal = t * grade[zone]
+    rev = t * revenue_coeffs[zone]
+    cst = t * cost[zone]
+    total_tonnes += t
+    total_metal += metal
+    total_revenue += rev
+    total_cost_val += cst
+    print(f"{zone:<18} {t:>14.1f} {grade[zone]:>7.2f}% {rev:>14.1f} {cst:>12.1f}")
+
+print("-" * 70)
+blend_grade = total_metal / total_tonnes if total_tonnes > 0 else 0
+profit = total_revenue - total_cost_val
+print(f"{'TOTAL':<18} {total_tonnes:>14.1f} {blend_grade:>7.2f}% {total_revenue:>14.1f} {total_cost_val:>12.1f}")
+print(f"\nProfit: ${profit:,.0f}k")
+```
+
+### Key Metrics
+
+```{python}
+print(f"Blend grade:      {blend_grade:.3f}% Cu (target: {min_feed_grade}–{max_feed_grade}%)")
+print(f"Mill utilization: {total_tonnes / mill_capacity * 100:.1f}%")
+
+hg_total = sum(result[z] for z in high_grade_zones)
+lg_total = sum(result[z] for z in low_grade_zones)
+print(f"High-grade zones: {hg_total:.0f} kt ({hg_total / total_tonnes * 100:.0f}%)")
+print(f"Low-grade zones:  {lg_total:.0f} kt ({lg_total / total_tonnes * 100:.0f}%)")
+```
+
+### Individual Variable Access from Solution
+
+You can also extract a single zone's result by indexing the `VariableDict` first:
+
+```{python}
+# Access individual variable from solution
+east_bench_tonnes = sol[extract["East Bench"]]
+print(f"East Bench extraction: {east_bench_tonnes:.1f} kt")
+```
+
+---
+
+## Inspecting the VariableDict
+
+`VariableDict` provides several introspection methods:
+
+```{python}
+# get_variables() — list of underlying Variable objects
+all_vars = extract.get_variables()
+print(f"get_variables(): {len(all_vars)} Variable objects")
+
+# values() — variables in key order (like dict.values())
+print(f"values():        {[v.name for v in extract.values()]}")
+
+# keys() — list of keys
+print(f"keys():          {extract.keys()}")
+```
+
+---
+
+## Comparison: VariableDict vs VectorVariable
+
+| Feature | `VectorVariable` | `VariableDict` |
+|---|---|---|
+| **Index type** | Integer (0, 1, 2, ...) | String keys |
+| **Creation** | `VectorVariable("x", n)` | `VariableDict("x", keys)` |
+| **Access** | `x[0]`, `x[3]` | `x["North Pit"]` |
+| **Per-element bounds** | Array/scalar | Dict/scalar |
+| **Sum** | `x.sum()` | `vd.sum()`, `vd.sum(subset)` |
+| **Weighted sum** | `coeff @ x` (dot product) | `vd.prod(coeff_dict)` |
+| **Best for** | Homogeneous arrays, matrix ops | Named entities, readable models |
+
+Use `VectorVariable` when you have **large, uniform arrays** (1000+ variables). Use `VariableDict` when your variables represent **named entities** and readability matters.
+
+---
+
+## Summary
+
+`VariableDict` makes optimization models more readable by using descriptive string keys:
+
+- **`prod(coefficients)`** handles weighted sums for grade blending and cost calculations
+- **`sum(subset)`** enables constraints on zone groups without manual bookkeeping
+- **`items()`** provides natural iteration for per-entity constraints
+- **`solution[vd]`** extracts all results as a ready-to-use dictionary
diff --git a/docs/examples/modify-and-resolve.qmd b/docs/examples/modify-and-resolve.qmd
new file mode 100644
index 0000000..181cd23
--- /dev/null
+++ b/docs/examples/modify-and-resolve.qmd
@@ -0,0 +1,206 @@
+---
+title: "Modify and Re-solve"
+description: "Adapting an optimization model to changing conditions without rebuilding"
+date: last-modified
+---
+
+## Overview
+
+Real-world optimization rarely involves a single solve. Conditions change — new regulations appear, equipment breaks down, capacity shifts — and the model must adapt. Optyx lets you **modify a problem in place** and re-solve without rebuilding from scratch.
+
+This example demonstrates:
+
+- **Adding and removing constraints** between solves
+- **Updating variable bounds** (tightening, relaxing, fixing)
+- **Warm starting** nonlinear solves from the previous solution
+- **Resetting** the solver state for a clean start
+
+---
+
+## Part 1: Linear Production Planning
+
+A factory produces two products with limited machine hours and raw materials. We solve the base plan, then adjust it as conditions change.
+
+### Setup
+
+```{python}
+from optyx import Variable, Problem
+from optyx.constraints import Constraint
+
+a = Variable("a", lb=0, ub=100)  # Units of product A
+b = Variable("b", lb=0, ub=100)  # Units of product B
+
+prob = Problem(name="factory_production")
+prob.maximize(5 * a + 8 * b)  # $5/unit A, $8/unit B
+
+# We use Constraint() with a name so we can remove them by name later.
+# For constraints you never need to remove, simple subject_to(expr) works fine.
+mh = Constraint(expr=(a + 2 * b - 120), sense="<=", name="machine_hours")
+prob.subject_to(mh)
+
+rm = Constraint(expr=(3 * a + 2 * b - 150), sense="<=", name="raw_material")
+prob.subject_to(rm)
+
+print(prob.summary())
+```
+
+### Base Case
+
+```{python}
+sol = prob.solve()
+print(f"Profit: ${sol.objective_value:.2f}")
+print(f"Product A: {sol.values['a']:.1f} units")
+print(f"Product B: {sol.values['b']:.1f} units")
+```
+
+### Add a Regulation
+
+A new regulation caps product B at 40 units. We add a **named** constraint so we can remove it later by name.
+
+```{python}
+reg = Constraint(expr=(b - 40), sense="<=", name="regulation_b")
+prob.subject_to(reg)
+
+sol = prob.solve()
+print(f"Profit: ${sol.objective_value:.2f}")
+print(f"Product A: {sol.values['a']:.1f} units")
+print(f"Product B: {sol.values['b']:.1f} units")
+```
+
+Profit drops because the high-margin product B is now capped.
+
+### Lift the Regulation
+
+The regulation is removed. We call `remove_constraint()` by name and re-solve.
+
+```{python}
+prob.remove_constraint("regulation_b")
+
+sol = prob.solve()
+print(f"Profit: ${sol.objective_value:.2f}")
+print(f"Product A: {sol.values['a']:.1f} units")
+print(f"Product B: {sol.values['b']:.1f} units")
+```
+
+Profit returns to the original optimum.
+
+### Increase Capacity
+
+The factory adds a second shift, increasing machine hours from 120 to 200. We remove the old constraint by name and add the updated one.
+
+```{python}
+prob.remove_constraint("machine_hours")  # Remove by name
+mh2 = Constraint(expr=(a + 2 * b - 200), sense="<=", name="machine_hours")
+prob.subject_to(mh2)
+
+sol = prob.solve()
+print(f"Profit: ${sol.objective_value:.2f}")
+print(f"Product A: {sol.values['a']:.1f} units")
+print(f"Product B: {sol.values['b']:.1f} units")
+```
+
+### Fix and Unfix Variables
+
+Product A's line goes down for maintenance. We fix `a = 0` by setting its bounds, then restore it.
+
+```{python}
+# Maintenance: shut down line A
+a.lb = 0
+a.ub = 0
+sol = prob.solve()
+print(f"During maintenance — Profit: ${sol.objective_value:.2f}")
+print(f"Product A: {sol.values['a']:.1f}, Product B: {sol.values['b']:.1f}")
+
+# Maintenance complete: restore line A
+a.lb = 0
+a.ub = 100
+sol = prob.solve()
+print(f"After maintenance  — Profit: ${sol.objective_value:.2f}")
+print(f"Product A: {sol.values['a']:.1f}, Product B: {sol.values['b']:.1f}")
+```
+
+::: {.callout-tip}
+## Bounds Are Always Fresh
+Variable bounds are re-read on every solve. Changing `v.lb` or `v.ub` between solves is always safe — no need to invalidate caches manually.
+:::
+
+---
+
+## Part 2: Warm Starting (Nonlinear)
+
+For nonlinear problems, Optyx automatically stores the previous solution and uses it as the starting point for the next solve. This can dramatically reduce iterations when the problem changes only slightly.
+
+### Setup
+
+```{python}
+x = Variable("x", lb=0, ub=10)
+y = Variable("y", lb=0, ub=10)
+
+nlp = Problem(name="warm_start_demo")
+nlp.minimize((x - 3) ** 2 + (y - 4) ** 2)
+nlp.subject_to(x + y >= 5)
+```
+
+### Initial Solve
+
+```{python}
+sol1 = nlp.solve(method="SLSQP")
+print(f"x = {sol1.values['x']:.4f}, y = {sol1.values['y']:.4f}")
+print(f"Objective: {sol1.objective_value:.6f}")
+print(f"Iterations: {sol1.iterations}")
+```
+
+### Re-solve with Warm Start
+
+Solving the same problem again starts from the previous solution, converging immediately.
+
+```{python}
+sol2 = nlp.solve(method="SLSQP")
+print(f"x = {sol2.values['x']:.4f}, y = {sol2.values['y']:.4f}")
+print(f"Iterations: {sol2.iterations}")
+```
+
+### Modify and Re-solve
+
+Add a tighter constraint. The warm start provides a nearby initial point.
+
+```{python}
+nlp.subject_to(x >= 4)
+sol3 = nlp.solve(method="SLSQP")
+print(f"x = {sol3.values['x']:.4f}, y = {sol3.values['y']:.4f}")
+print(f"Objective: {sol3.objective_value:.6f}")
+```
+
+Remove it and recover the original solution.
+
+```{python}
+nlp.remove_constraint(1)  # Remove x >= 4 (index 1)
+sol4 = nlp.solve(method="SLSQP")
+print(f"x = {sol4.values['x']:.4f}, y = {sol4.values['y']:.4f}")
+print(f"Objective: {sol4.objective_value:.6f}")
+```
+
+### Reset for a Cold Start
+
+Call `reset()` to clear the warm start state and all caches, forcing a fresh start.
+
+```{python}
+nlp.reset()
+sol5 = nlp.solve(method="SLSQP")
+print(f"x = {sol5.values['x']:.4f}, y = {sol5.values['y']:.4f}")
+print(f"Iterations: {sol5.iterations}")
+```
+
+---
+
+## Key Methods
+
+| Method | Description |
+|--------|-------------|
+| `prob.subject_to(c)` | Add a constraint |
+| `prob.remove_constraint(i)` | Remove constraint by index |
+| `prob.remove_constraint("name")` | Remove constraint by name |
+| `prob.solve(warm_start=True)` | Re-solve using previous solution (default) |
+| `prob.solve(warm_start=False)` | Re-solve with a fresh initial point |
+| `prob.reset()` | Clear caches and warm start state |
+| `v.lb = ...` / `v.ub = ...` | Update bounds (always respected) |
diff --git a/docs/examples/solver-callbacks.qmd b/docs/examples/solver-callbacks.qmd
new file mode 100644
index 0000000..8768429
--- /dev/null
+++ b/docs/examples/solver-callbacks.qmd
@@ -0,0 +1,132 @@
+---
+title: "Solver Callbacks"
+description: "Monitor solver progress and enforce time limits during optimization"
+date: last-modified
+---
+
+## Overview
+
+Long-running optimizations benefit from **real-time visibility** into solver
+progress.  Optyx exposes a simple callback interface that delivers a
+`SolverProgress` snapshot at every iteration.  You can use it to:
+
+- **Log** objective value, constraint violation, and elapsed time
+- **Terminate early** when a solution is "good enough"
+- **Enforce a time budget** so the solver never runs longer than allowed
+- **Combine** a callback with a time limit
+
+All three NLP methods (`SLSQP`, `trust-constr`, `L-BFGS-B`) support
+callbacks and time limits.
+
+---
+
+## Part 1: Logging Solver Progress
+
+We minimize a 10-dimension Rosenbrock function and print a status line at
+every iteration.
+
+```{python}
+from optyx import Problem, SolverProgress, VectorVariable
+
+n = 10
+v = VectorVariable("v", n, lb=-5, ub=5)
+prob = Problem("rosenbrock")
+
+# Vectorized Rosenbrock — VectorVariable supports slicing
+v_head = v[:-1]  # first n-1 elements
+v_tail = v[1:]   # last  n-1 elements
+obj = ((1 - v_head) ** 2 + 100 * (v_tail - v_head ** 2) ** 2).sum()
+prob.minimize(obj)
+
+
+def log_progress(p: SolverProgress) -> None:
+    print(
+        f"  iter {p.iteration:3d}  |  obj {p.objective_value:12.4f}"
+        f"  |  violation {p.constraint_violation:.2e}"
+        f"  |  time {p.elapsed_time:.3f}s"
+    )
+
+
+sol = prob.solve(method="SLSQP", callback=log_progress)
+print(f"\nStatus: {sol.status.value}  |  Objective: {sol.objective_value:.6f}")
+```
+
+The `SolverProgress` object contains five fields:
+
+| Field                  | Type           | Description                                |
+|------------------------|----------------|--------------------------------------------|
+| `iteration`            | `int`          | Current iteration number (1-based)         |
+| `objective_value`      | `float`        | Objective in the **original** sense        |
+| `constraint_violation` | `float`        | Max constraint violation (0 if feasible)   |
+| `elapsed_time`         | `float`        | Wall-clock seconds since solve started     |
+| `x`                    | `np.ndarray`   | Current variable values                    |
+
+---
+
+## Part 2: Early Termination
+
+Return `True` from the callback to stop the solver.  The solution will have
+status `SolverStatus.TERMINATED`.
+
+```{python}
+prob.reset()  # clear warm start so we see more iterations
+
+THRESHOLD = 1.0
+
+def stop_when_good_enough(p: SolverProgress) -> bool:
+    if p.objective_value < THRESHOLD:
+        print(f"  Objective {p.objective_value:.4f} < {THRESHOLD} — stopping early")
+        return True
+    return False
+
+sol = prob.solve(method="SLSQP", callback=stop_when_good_enough)
+print(f"Status: {sol.status.value}  |  Objective: {sol.objective_value:.6f}")
+```
+
+Returning `None` or `False` lets the solver continue normally.
+
+---
+
+## Part 3: Time Limits
+
+Pass `time_limit=` (in seconds) to cap the wall-clock duration.  This is
+useful for production systems that must respond within a deadline.
+
+```{python}
+prob.reset()
+
+sol = prob.solve(method="SLSQP", time_limit=0.005)
+print(f"Status: {sol.status.value}")
+print(f"Objective: {sol.objective_value:.6f}")
+print(f"Solve time: {sol.solve_time:.4f}s  |  Iterations: {sol.iterations}")
+```
+
+---
+
+## Part 4: Combining Callback and Time Limit
+
+Both mechanisms work together — whichever fires first terminates the solve.
+
+```{python}
+prob.reset()
+
+history: list[float] = []
+
+def record_objective(p: SolverProgress) -> None:
+    history.append(p.objective_value)
+
+sol = prob.solve(method="SLSQP", callback=record_objective, time_limit=0.05)
+print(f"Status: {sol.status.value}  |  Objective: {sol.objective_value:.6f}")
+print(f"Recorded {len(history)} objective snapshots")
+```
+
+---
+
+## Key Points
+
+- **`callback`** receives a `SolverProgress` each iteration; return `True` to stop.
+- **`time_limit`** is a wall-clock budget in seconds.
+- Early-terminated solutions still contain variable values, objective, and
+  solve time — they just carry `SolverStatus.TERMINATED` instead of `OPTIMAL`.
+- Both parameters are supported by all NLP methods (`SLSQP`, `trust-constr`,
+  `L-BFGS-B`).
diff --git a/docs/getting-started/concepts.qmd b/docs/getting-started/concepts.qmd
index 24bbc51..e33503d 100644
--- a/docs/getting-started/concepts.qmd
+++ b/docs/getting-started/concepts.qmd
@@ -39,8 +39,8 @@ print(f"Binary bounds: [{binary.lb}, {binary.ub}]")
 | `ub` | Upper bound | `None` (unbounded) |
 | `domain` | Variable type: `"continuous"`, `"integer"`, `"binary"` | `"continuous"` |
 
-::: {.callout-warning}
-Integer and binary domains are currently relaxed to continuous values. True mixed-integer programming is planned for v2.0.
+::: {.callout-tip}
+Integer and binary domains are fully supported via `scipy.optimize.milp()` (HiGHS backend). See the [Integer Programming tutorial](../tutorials/integer-programming.qmd) for details.
 :::
 
 ## Expressions
diff --git a/docs/getting-started/installation.qmd b/docs/getting-started/installation.qmd
index 813007f..5454692 100644
--- a/docs/getting-started/installation.qmd
+++ b/docs/getting-started/installation.qmd
@@ -37,7 +37,7 @@ For contributing or development:
 
 ```bash
 # Clone the repository
-git clone https://github.com/daggbt/optyx.git
+git clone https://github.com/optyx-dev/optyx.git
 cd optyx
 
 # Install with uv (recommended)
diff --git a/docs/index.qmd b/docs/index.qmd
index d926b1a..54647e2 100644
--- a/docs/index.qmd
+++ b/docs/index.qmd
@@ -77,11 +77,11 @@ We believe most optimization code is harder to write than it needs to be. Optyx
 
 Optyx is young and opinionated. It's **not** a replacement for specialized tools:
 
-- Need MILP at scale? → Use Pyomo or Gurobi
+- Need large-scale MILP with cutting planes? → Use Pyomo or Gurobi
 - Need convex guarantees? → Use CVXPY  
 - Need maximum performance? → Use raw solver APIs
 
-But if you want readable optimization code that just works for most problems, keep reading.
+Optyx does support [MILP](tutorials/integer-programming.qmd) via HiGHS, [sparse LPs](tutorials/performance.qmd) with 100,000+ variables, and [solver callbacks](examples/solver-callbacks.qmd). But if you need industrial-grade MIP with custom branching strategies, a dedicated solver is the right choice.
 
 ---
 
@@ -680,10 +680,13 @@ Instant feedback for real-time applications.
 
 - **VectorVariable** — Create vectors of variables with `VectorVariable("x", 100)`
 - **MatrixVariable** — 2D variable arrays with row/column slicing
+- **VariableDict** — Dict-indexed variables keyed by strings, with `.prod()` and `.sum(subset)` aggregation. [Tutorial →](tutorials/variable-dict.qmd)
 - **Native gradient rules** — L2Norm, L1Norm, DotProduct compute gradients without loops
 - **Math-like quadratic forms** — `w.dot(Σ @ w)` for portfolio variance
 - **Parameter class** — Updatable constants for fast scenario analysis
 - **VectorParameter** — Array-valued parameters for bulk updates
+- **LP export** — `Problem.write("model.lp")` for model sharing and debugging. [Example →](examples/lp-export.qmd)
+- **Solution serialization** — `Solution.to_dict()` and `Solution.to_json()` for logging and auditing
 
 [Learn more about Vectors →](tutorials/vectors.qmd)
 
diff --git a/docs/tutorials/constraints.qmd b/docs/tutorials/constraints.qmd
index 1b58ba6..06c9063 100644
--- a/docs/tutorials/constraints.qmd
+++ b/docs/tutorials/constraints.qmd
@@ -166,6 +166,16 @@ print(f"Distance from origin: {dist_from_origin:.3f}")
 
 ---
 
+
+### Range Constraints (Between)
+
+If a variable or expression must be strictly bounded between two values, you can use `.between(lb, ub)`. This saves you from writing (and evaluating) two separate constraints.
+
+```python
+# Instead of: prob.subject_to(x + y >= 5).subject_to(x + y <= 10)
+prob.subject_to((x + y).between(5, 10))
+```
+
 ## Handling Infeasibility
 
 ### Detecting Infeasible Problems
@@ -217,6 +227,40 @@ print(f"Constraint violation: {sol['slack']:.2f}")
 
 ## Multiple Constraints
 
+### Legacy Loops (Loops vs Generators)
+
+For large problems, you can pass Python generator expressions directly into `subject_to()`. Optyx will unpack and add them efficiently.
+
+```python
+from optyx import Problem, VectorVariable
+
+x = VectorVariable("x", 100)
+prob = Problem()
+
+# Add 100 constraints in one clean line
+prob.subject_to(x[i] >= i for i in range(100))
+```
+
+### Direct Matrix Constraints
+
+When dealing with massive constraint sets (10,000+), looping over components is slow. Use direct matrix constraints through `subject_to(...)`:
+
+```python
+from optyx import as_matrix
+
+# Wrap scipy.sparse so A @ x stays symbolic
+A_sparse = as_matrix(A_sparse, storage="sparse")
+prob.subject_to(A_sparse @ x <= b_vector)
+```
+
+::: {.callout-note}
+Raw `scipy.sparse` matrices cannot be used directly on the left side of `@` here. SciPy intercepts `A @ x` first and attempts a numeric sparse multiplication, which fails before Optyx can turn it into a symbolic matrix constraint. `as_matrix(...)` wraps the sparse matrix in an Optyx matrix object so the symbolic path is used instead.
+
+If you already have a dense array but want explicit storage control, `as_matrix()` accepts `storage="auto"`, `storage="dense"`, and `storage="sparse"`. `storage="auto"` keeps sparse inputs sparse and can convert large, low-density dense arrays into CSR storage automatically.
+:::
+
+See the [Performance Guide](performance.qmd) for more details.
+
 ### Building Constraint Lists
 
 ```{python}
@@ -246,7 +290,7 @@ for i in range(n):
 Optyx variables work seamlessly with NumPy arrays. Use `np.array([...])` to wrap your variables, then use `@` for matrix multiplication and `np.sum()` for summations.
 :::
 
-### Constraint Generators
+### Legacy Loops (Loops vs Generators)
 
 For large problems, generate constraints programmatically:
 
diff --git a/docs/tutorials/integer-programming.qmd b/docs/tutorials/integer-programming.qmd
new file mode 100644
index 0000000..1571fcd
--- /dev/null
+++ b/docs/tutorials/integer-programming.qmd
@@ -0,0 +1,127 @@
+---
+title: "Mixed-Integer Linear Programming (MILP)"
+description: "Solve problems requiring discrete answers with binary and integer variables"
+date: last-modified
+---
+
+## Overview
+
+Sometimes variables can't take fractional values. You can't drill half a shaft, dispatch 3.2 trucks, or open 0.7 of a warehouse. Optyx automatically detects integer and binary variables and routes them to the **MILP solver** (via `scipy.optimize.milp()` using the HiGHS backend).
+
+::: {.callout-note}
+## Support Boundary
+Optyx v1.3.0 supports **Mixed-Integer Linear Programming (MILP)**. This means your objective and constraints must be purely *linear*. Mixed-Integer Quadratic Programming (MIQP) or general MINLP are not currently supported and will raise an `UnsupportedOperationError`.
+:::
+
+## Creating Integer & Binary Variables
+
+Optyx provides explicit constructor functions for convenience.
+
+```{python}
+from optyx import Problem, IntegerVariable, BinaryVariable, VectorVariable
+
+# Single variables
+x = IntegerVariable("x", lb=0, ub=10)
+y = BinaryVariable("y")  # Equivalent to domain='binary', bounds [0, 1]
+
+# Vectors of discrete variables
+allocations = VectorVariable("qty", 5, domain="integer", lb=0, ub=100)
+open_facilities = VectorVariable("open", 10, domain="binary")
+```
+
+## Example: The Knapsack Problem
+
+The classic binary problem: maximize total value while respecting a weight capacity.
+
+```{python}
+import numpy as np
+from optyx import Problem, VectorVariable
+
+np.random.seed(42)
+n = 10
+values = np.random.randint(10, 100, size=n).astype(float)
+weights = np.random.randint(5, 50, size=n).astype(float)
+capacity = 120.0
+
+# Define a binary variable for each item
+take = VectorVariable("take", n, domain="binary")
+
+sol = (
+    Problem("knapsack")
+    .maximize(values @ take)
+    .subject_to(weights @ take <= capacity)
+    .solve()
+)
+
+print(f"Status: {sol.status.name}")
+print(f"Total Value: {sol.objective_value:.1f}")
+
+# Find which items we took (value > 0.5 avoids precise float matching)
+taken_items = [i for i in range(n) if sol[f"take[{i}]"] > 0.5]
+print(f"Items packed: {taken_items}")
+```
+
+## Example: Facility Location (Mixed Types)
+
+This problem mixes binary variables (opening a facility) with continuous variables (transporting goods).
+
+```{python}
+from optyx import Problem, VectorVariable, BinaryVariable, Variable
+
+# 3 potential warehouses, 4 customers
+fixed_costs = np.array([1000, 1200, 1500])
+capacities = np.array([500, 600, 800])
+demand = np.array([200, 300, 150, 250])
+
+# Transport cost matrix (warehouse i to customer j)
+transport_costs = np.array([
+    [2.5, 3.1, 4.0, 1.2],
+    [3.2, 1.5, 2.8, 3.4],
+    [1.8, 2.4, 2.0, 2.2]
+])
+
+prob = Problem("facility_location")
+
+# Binary decisions: open warehouse i?
+y = [BinaryVariable(f"open_{i}") for i in range(3)]
+
+# Continuous decisions: amount shipped from warehouse i to customer j
+x = [[Variable(f"ship_{i}_{j}", lb=0) for j in range(4)] for i in range(3)]
+
+# Objective: minimize fixed costs + transport costs
+obj = sum(fixed_costs[i] * y[i] for i in range(3))
+for i in range(3):
+    for j in range(4):
+        obj = obj + transport_costs[i, j] * x[i][j]
+prob.minimize(obj)
+
+# Demand satisfaction (each customer gets what they need)
+for j in range(4):
+    prob.subject_to(sum(x[i][j] for i in range(3)) >= demand[j])
+
+# Capacity constraint: can only ship if facility is open!
+for i in range(3):
+    prob.subject_to(sum(x[i][j] for j in range(4)) <= capacities[i] * y[i])
+
+sol = prob.solve()
+
+# MILP solves provide gap reporting
+print(f"Optimal cost: ${sol.objective_value:.2f}")
+print(f"MIP Gap: {sol.mip_gap}")
+print(f"Best Bound: {sol.best_bound}")
+
+for i in range(3):
+    if sol[f"open_{i}"] > 0.5:
+        print(f"Warehouse {i} is OPEN")
+```
+
+## Solution Metadata
+
+When running an MILP, Optyx populates additional metadata fields on the `Solution` object (originating from the underlying HiGHS solver):
+
+- `sol.mip_gap`: The relative mip gap at termination. A gap of `0.0` signifies proven optimality.
+- `sol.best_bound`: The best discovered dual bound.
+
+## Sparse Constraints in MILP
+
+Large combinatorial formulations can use sparse constraints as well. The internal translation correctly delegates sparse equality and inequality matrices added through `subject_to(...)` to the solver. See the [Performance guide](performance.qmd) for more details.
diff --git a/docs/tutorials/performance.qmd b/docs/tutorials/performance.qmd
index 3c420d0..cf65583 100644
--- a/docs/tutorials/performance.qmd
+++ b/docs/tutorials/performance.qmd
@@ -6,174 +6,103 @@ date: last-modified
 
 ## Introduction
 
-Optyx is designed to handle large optimization problems efficiently. However, the way you build expressions can dramatically impact performance. This guide explains the common pitfalls and recommended patterns.
+Optyx is designed to handle large optimization problems efficiently. With v1.3.0, Optyx has made massive strides in automatic acceleration for typical high-dimensional optimization problems.
 
 By the end of this tutorial, you'll understand:
-
-- Why loops create performance problems
-- How to use vectorized operations
-- When the iterative autodiff engine kicks in
+- How vectorized gradients achieve near-parity CQP cold starts (≤2x overhead vs SciPy)
+- The new scale of Sparse LP (100,000+ variables)
+- Native structure flattening for deep trees
 - Power-user utilities for edge cases
 
 ---
 
-## The Problem with Loops
-
-When you build an objective function using a Python loop, you create a **deep expression tree**:
-
-```{python}
-from optyx import VectorVariable
-from optyx.core.autodiff import gradient, _estimate_tree_depth
-
-# Building an expression in a loop
-x = VectorVariable("x", 100)
-obj = x[0] ** 2
-for i in range(1, 100):
-    obj = obj + x[i] ** 2
+## The Vectorized Fast Paths
 
-# Check the tree depth
-depth = _estimate_tree_depth(obj)
-print(f"Expression tree depth: {depth}")
-```
+In older versions of Optyx (or when writing models with raw `for` loops), expressions are built piece-by-piece, resulting in large in-memory tree structures. While Optyx has an iterative engine capable of evaluating arbitrarily deep trees, **vectorizing your model** remains the most important step for getting massive speedups.
 
-This creates a **left-skewed binary tree** where each `+` operation nests inside the previous one:
+Optyx looks for common expressions and triggers **Vectorized Gradients**: O(1) mathematical formulation of gradients that compile perfectly to fast `numpy` code.
 
-```
-                    (+)              ← depth 99
-                   /   \
-                (+)    x[99]²
-               /   \
-            (+)    x[98]²
-           /   \
-         ...   ...
-        /
-    x[0]²                           ← depth 0
-```
+### Equivalence Table & Benchmarks
 
-### Why This Matters
+| Loop Pattern | Vectorized Equivalent | Cold Overhead vs SciPy (n=1000) |
+|--------------|----------------------|---------------------------------|
+| `sum(c[i]*x[i] for i ...)` | `c @ x` | **~1.1x** (LP at parity) |
+| `sum(x[i]**2 for i ...)` | `x.dot(x)` | **~1.8x** (CQP near-parity) |
+| double loop with `Q` | `x.dot(Q @ x)` | **~2x** (quadratic form) |
 
-1. **Gradient computation** must traverse the entire tree
-2. **Python's recursion limit** (~1000) can be hit for large n
-3. **Memory usage** grows with tree depth
+When Optyx encounters objects like `DotProduct` or `QuadraticForm`, the Jacobian compilation bypasses Python iteration entirely and applies pre-compiled numerical patterns like `nabla: 2x` or `nabla: Q+Q.T`.
 
-For n=500, the tree depth is ~500. For n=5000, it's ~5000.
+To take advantage:
+1. Always declare grouped variables as `VectorVariable` or `VariableDict`
+2. Apply operations over the **entire vector** at once (`x.sum()`, `c @ x`)
 
 ---
 
-## Automatic Iterative Fallback
-
-Optyx automatically switches to an **iterative gradient algorithm** when it detects deep expression trees:
-
-```{python}
-# This works fine despite deep tree - automatic switching!
-x = VectorVariable("x", 1000)
-obj = x[0] ** 2
-for i in range(1, 1000):
-    obj = obj + x[i] ** 2
-
-# gradient() auto-detects depth >= 400 and uses iterative algorithm
-grad = gradient(obj, x[0])
-print(f"Gradient computed: {grad}")
-```
-
-The threshold is ~400 levels. Below this, the faster recursive algorithm is used. Above it, the iterative algorithm handles arbitrarily deep trees.
-
----
+## Scale Out: Sparse Constraints
 
-## Recommended: Vectorized Operations
+If you scale your linear programming models up to 100,000+ continuous variables, constructing `10_000` separate `subject_to()` constraint expressions incurs memory and CPU overhead.
 
-While the iterative fallback works, **vectorized operations are always faster**:
+For industrial-scale modeling, use direct matrix constraints with `subject_to(...)` and push `scipy.sparse` representations straight into the solver backend.
 
 ```{python}
-import time
-
-x = VectorVariable("x", 1000)
-
-# ❌ Loop-built expression (works but slower)
-start = time.perf_counter()
-obj_loop = x[0] ** 2
-for i in range(1, 1000):
-    obj_loop = obj_loop + x[i] ** 2
-loop_time = time.perf_counter() - start
-
-# ✅ Vectorized expression (fast, flat tree)
-start = time.perf_counter()
-obj_vec = x.dot(x)  # Same result: sum of squares
-vec_time = time.perf_counter() - start
-
-print(f"Loop construction: {loop_time*1000:.2f} ms")
-print(f"Vector construction: {vec_time*1000:.2f} ms")
-print(f"Speedup: {loop_time/vec_time:.1f}x")
-```
-
-### Equivalence Table
-
-| Loop Pattern | Vectorized Equivalent |
-|--------------|----------------------|
-| `sum(x[i] for i in range(n))` | `x.sum()` |
-| `sum(x[i]**2 for i in range(n))` | `x.dot(x)` |
-| `sum(c[i]*x[i] for i in range(n))` | `c @ x` (where c is ndarray) |
-| `sum((x[i] - y[i])**2 ...)` | `(x - y).dot(x - y)` |
+import numpy as np
+from scipy import sparse as sp
+from optyx import Problem, VectorVariable, as_matrix
 
-### Matrix Operations
+n = 10_000
+m = 1_000
+density = 0.01
 
-```{python}
-import numpy as np
-from optyx import VectorVariable
+# A large, sparse constraint matrix
+A_sparse = as_matrix(
+    sp.random(m, n, density=density, format='csr', random_state=42),
+    storage='sparse',
+)
+b = np.random.rand(m)
+c = np.random.rand(n)
 
-n = 50
-Q = np.eye(n)  # Example matrix
+x = VectorVariable('x', n, lb=0, ub=1)
 
-x = VectorVariable("x", n)
+prob = Problem(name='sparse_lp')
+prob.maximize(c @ x)
 
-# ❌ SLOW: Double loop creates O(n²) depth tree
-# obj = 0
-# for i in range(n):
-#     for j in range(n):
-#         obj = obj + Q[i,j] * x[i] * x[j]
+# Passes directly to HiGHS
+prob.subject_to(A_sparse @ x <= b)
 
-# ✅ FAST: Math-like quadratic form with O(1) gradient
-obj = x.dot(Q @ x)  # Automatically creates QuadraticForm
-print(f"Quadratic form type: {type(obj).__name__}")  # QuadraticForm
+print(f"Variables: {n:,}, Constraints: {m:,}, Non-zeros: {A_sparse.data.nnz:,}")
+# For 100,000+ variables, the same pattern applies — just scale up n and m
 ```
 
-::: {.callout-tip}
-## Automatic Optimization
-`x.dot(Q @ x)` is automatically recognized as a quadratic form pattern and creates a `QuadraticForm` expression with an O(1) gradient rule: `∇(xᵀQx) = (Q + Qᵀ)x`.
-:::
+`as_matrix()` also accepts `storage='auto'` and `storage='dense'`. The default `storage='auto'` keeps sparse inputs sparse and can convert large, mostly-zero dense arrays into CSR storage when you want the matrix-block path without manually building a SciPy sparse matrix first.
 
 ---
 
-## Depth Estimation
+## Automatic Flattening for Loops
 
-You can check expression depth before computing gradients:
+If you absolutely must write `for` loops to construct expressions, Optyx v1.3.0 handles the structural overhead smoothly.
+
+Previously, `obj = x[0] + x[1] + ... + x[100]` created 100 nested operations. The compiler now detects sequence operations and collapses them into O(1) structures (`NarySum` and `NaryProduct`), keeping memory layout entirely flat.
 
 ```{python}
+from optyx import VectorVariable
 from optyx.core.autodiff import _estimate_tree_depth
 
-x = VectorVariable("x", 500)
-
-# Left-skewed tree (common from loops)
-left_tree = x[0]
-for i in range(1, 500):
-    left_tree = left_tree + x[i]
-
-# Check depth with default left-spine heuristic (fast)
-depth_fast = _estimate_tree_depth(left_tree)
-print(f"Left-spine estimate: {depth_fast}")
+# Building an expression in a loop
+x = VectorVariable("x", 100)
+obj = x[0] ** 2
+for i in range(1, 100):
+    obj = obj + x[i] ** 2
 
-# Full traversal for exact depth (slower but accurate for any tree shape)
-depth_exact = _estimate_tree_depth(left_tree, full_traversal=True)
-print(f"Full traversal: {depth_exact}")
+# Flattening keeps depth bounded regardless of sequential assignment length
+depth = _estimate_tree_depth(obj)
+print(f"Expression tree depth: {depth}") # Extremely small now!
 ```
 
-The left-spine heuristic is O(depth) and accurate for left-skewed trees (the common case). Use `full_traversal=True` when you need exact depth for right-skewed or balanced trees.
-
 ---
 
 ## Power User: Recursion Limit Override
 
-In rare cases, you might want to temporarily increase Python's recursion limit:
+In rare cases where you construct complex, asymmetric deep trees, the framework automatically uses an iterative fallback. If needed, you might want to temporarily increase Python's recursion limit:
 
 ```{python}
 from optyx import increased_recursion_limit
@@ -182,34 +111,15 @@ from optyx import increased_recursion_limit
 with increased_recursion_limit(5000):
     # Code that might need deep recursion
     pass
-
-# Back to normal limit
 ```
 
 ::: {.callout-warning}
 ## Use with Caution
-Very high limits can cause stack overflow crashes. The automatic iterative algorithm is the preferred solution for deep trees.
+Very high limits can cause stack overflow crashes. The automatic iterative flatten logic usually prevents this issue. 
 :::
 
 ---
 
-## Performance Summary
-
-| Approach | Tree Depth | Gradient Time | Recommendation |
-|----------|------------|---------------|----------------|
-| Loop-built | O(n) | O(n) per variable | Avoid for large n |
-| Vectorized | O(1) | O(1) via native rules | ✅ Preferred |
-| Iterative fallback | Any | O(n) total nodes | Automatic for deep trees |
-
-### Key Takeaways
-
-1. **Use vectorized operations** (`x.sum()`, `x.dot(x)`, `c @ x`) whenever possible
-2. **Loops are fine for small n** (< 100) but don't scale
-3. **Optyx handles deep trees** automatically via iterative gradient computation
-4. **Check depth** with `_estimate_tree_depth()` if you're unsure
-
----
-
 ## Next Steps
 
 - [Vectors Tutorial](vectors.qmd): Learn all VectorVariable operations
diff --git a/docs/tutorials/variable-dict.qmd b/docs/tutorials/variable-dict.qmd
new file mode 100644
index 0000000..2b0c7c6
--- /dev/null
+++ b/docs/tutorials/variable-dict.qmd
@@ -0,0 +1,92 @@
+---
+title: "Dict-Indexed Variables"
+description: "Model named entities like products, locations or time-slots directly using VariableDict"
+date: last-modified
+---
+
+## Introduction
+
+In many real-world problems (diet optimization, logistics, shifts), decisions are naturally indexed by strings or categorical data rather than flat integers. `VariableDict` allows you to manage arrays of decision variables using robust dictionary-like indexing.
+
+## Creating a VariableDict
+
+Supply a base name and a list of keys:
+
+```{python}
+from optyx import VariableDict
+
+foods = ["Apple", "Banana", "Carrot", "Donut"]
+buy = VariableDict("buy", keys=foods, lb=0)
+
+# Access individual variables by key
+print(buy["Apple"])   # Equivalent to Variable("buy[Apple]", lb=0)
+```
+
+You can also pass a dictionary of bounds to set per-key limits. When using a dict, you must provide an entry for every key:
+
+```{python}
+# Per-key bounds: every key must be listed
+lower_bounds = {"Apple": 2, "Banana": 0, "Carrot": 0, "Donut": 0}
+upper_bounds = {"Apple": 10, "Banana": 10, "Carrot": 10, "Donut": 5}
+
+buy2 = VariableDict(
+    "buy", 
+    keys=foods, 
+    lb=lower_bounds,
+    ub=upper_bounds,
+)
+```
+
+## Vectorized Aggregations
+
+Just like `VectorVariable`, `VariableDict` exposes native aggregation methods that avoid constructing deep loop-based expression trees.
+
+### Weighted Sums (`.prod()`)
+
+If you have a dictionary of coefficients (like costs or weights), `.prod()` operates exactly like a dot-product. Unlisted keys are assumed to have a 0 coefficient.
+
+```{python}
+from optyx import Problem
+
+costs = {"Apple": 0.50, "Banana": 0.30, "Carrot": 0.20, "Donut": 1.50}
+
+prob = Problem("diet")
+# Effectively: 0.5*buy[Apple] + 0.3*buy[Banana] + ...
+prob.minimize(buy.prod(costs))
+```
+
+### Subsetting (`.sum()`)
+
+You can sum all elements, or sum over a specific subset of keys using `.sum(keys=...)`. 
+
+```{python}
+calories = {"Apple": 95, "Banana": 105, "Carrot": 25, "Donut": 400}
+
+# Total calories must be >= 1000
+prob.subject_to(buy.prod(calories) >= 1000)
+
+# Limit sugary foods to at most 1 item
+sugary_items = ["Donut"]
+prob.subject_to(buy.sum(sugary_items) <= 1)
+```
+
+## Extracting Solutions
+
+When you solve the problem, you can extract solution values by iterating over the `VariableDict` keys:
+
+```{python}
+sol = prob.solve()
+
+# Extract values using standard key iteration
+results = {key: sol[f"buy[{key}]"] for key in buy.keys()}
+
+print("Optimal Diet:")
+for food, quantity in results.items():
+    if quantity > 1e-4:
+        print(f"{food}: {quantity:.2f}")
+```
+
+## Use Cases
+
+`VariableDict` pairs powerfully with the new `domain="binary"` and `domain="integer"` parameters. Use them to cleanly implement job-shop schedules (`keys=[f"{job}_{machine}" for job in jobs for machine in machines]`), stock picking assignments, or supply chain routes.
+
diff --git a/docs/tutorials/vectors.qmd b/docs/tutorials/vectors.qmd
index c374516..69de0df 100644
--- a/docs/tutorials/vectors.qmd
+++ b/docs/tutorials/vectors.qmd
@@ -51,6 +51,24 @@ print(f"Bounds: [{w.lb}, {w.ub}]")
 print(f"Domain: {w.domain}")
 ```
 
+
+You can also pass arrays for per-element bounds:
+```python
+import numpy as np
+# x[0] in [0,1], x[1] in [0.5, 2.0], etc.
+w = VectorVariable("w", 3, lb=np.array([0.0, 0.5, 0.2]), ub=np.array([1.0, 2.0, 1.5]))
+```
+
+
+
+You can also pass arrays for per-element bounds:
+```python
+import numpy as np
+# x[0] in [0,1], x[1] in [0.5, 2.0], etc.
+w = VectorVariable("w", 3, lb=np.array([0.0, 0.5, 0.2]), ub=np.array([1.0, 2.0, 1.5]))
+```
+
+
 All 10 variables are created with consistent names (`w[0]`, `w[1]`, ..., `w[9]`) and bounds.
 
 ::: {.callout-tip}
@@ -208,6 +226,26 @@ print(f"Addition result: {type(added).__name__}")
 
 ---
 
+
+### Fancy Indexing
+
+You can slice a `VectorVariable` with lists or arrays of indices, returning a new `VectorExpression` subset:
+
+```python
+x = VectorVariable("x", 10)
+subset = x[[0, 2, 5]]  # Returns a 3-element vector expression
+```
+
+
+### Fancy Indexing
+
+You can slice a `VectorVariable` with lists or arrays of indices, returning a new `VectorExpression` subset:
+
+```python
+x = VectorVariable("x", 10)
+subset = x[[0, 2, 5]]  # Returns a 3-element vector expression
+```
+
 ## Vector Constraints
 
 Create constraints on all elements at once:
diff --git a/docs/whats-new.qmd b/docs/whats-new.qmd
new file mode 100644
index 0000000..c213a0b
--- /dev/null
+++ b/docs/whats-new.qmd
@@ -0,0 +1,97 @@
+---
+title: "What's New in v1.3.0"
+description: "Scalable expressions, MILP support, vectorized gradients, and modeling convenience"
+date: last-modified
+---
+
+## Optyx v1.3.0
+
+**Theme:** Scalable Expressions, Vectorized Gradients, Sparse Computation, Basic MIP, Modeling Convenience
+
+This release addresses critical scalability limitations discovered in v1.2.x benchmarks and adds major new capabilities.
+
+---
+
+### Mixed-Integer Linear Programming (MILP)
+
+Optyx now supports integer and binary decision variables, automatically routing problems with discrete variables to the MILP solver (SciPy's HiGHS backend via `scipy.optimize.milp()`).
+
+- **`BinaryVariable()`** and **`IntegerVariable()`** constructor aliases
+- **`VectorVariable(domain="binary")`** and **`VectorVariable(domain="integer")`** for vectorized discrete variables
+- **`Solution.mip_gap`** and **`Solution.best_bound`** for optimality reporting
+- Domain validation enforces correct bounds for binary variables
+- Clear error when attempting unsupported MIQP (quadratic + integer)
+
+See the [Integer Programming tutorial](tutorials/integer-programming.qmd) and the [Mine Equipment MILP example](examples/mine-equipment-milp.qmd).
+
+---
+
+### Vectorized Gradients & Scalability
+
+Cold-start performance for quadratic programs has been dramatically improved through automatic vectorized gradient detection.
+
+| Problem | Cold Overhead vs SciPy | Warm Overhead vs SciPy |
+|---------|------------------------|------------------------|
+| CQP n=500 | 2.2x | 1.2x |
+| CQP n=1,000 | 1.8x | 1.2x |
+| CQP n=5,000 | 1.1x | 1.0x |
+
+- **`VectorGradientPattern`** detects expressions with vectorizable gradient structure (∇f = Ax + b)
+- **`NarySum` / `NaryProduct`** flatten deep loop-built trees to O(1) depth
+- **`VectorBinaryOp`** preserves vector structure for element-wise operations
+
+See the [Benchmarks](benchmarks.qmd) and the [Performance & Scaling guide](tutorials/performance.qmd).
+
+---
+
+### Sparse Computation
+
+Large-scale LPs with 100,000+ variables are now practical.
+
+- **`Problem.subject_to(A @ x <= b)`** supports matrix blocks directly, with `as_matrix(...)` for sparse coefficient matrices
+- **`as_matrix(storage="auto" | "dense" | "sparse")`** gives explicit control over matrix-block storage, with automatic CSR conversion for large low-density dense arrays
+- Sparse Jacobian compilation reduces memory from O(m×n) to O(nnz)
+- Sparse constrained NLPs now bias toward `trust-constr` sooner, lazily compiling the batched sparse Jacobian only when that solver path is actually used
+- n=100,000 LP with 1% density constraint matrix solves end-to-end
+
+---
+
+### Modeling Convenience
+
+- **`VariableDict`** — dict-indexed variables keyed by strings, with `.prod()` and `.sum(subset)` aggregation. See the [VariableDict tutorial](tutorials/variable-dict.qmd).
+- **`Expression.between(lb, ub)`** — range constraints in one call
+- **`subject_to()` accepts generators** — `prob.subject_to(x[i] >= 0 for i in range(n))`
+- **`Problem` context manager** — `with Problem() as p: ...`
+- **`Problem.reset()`** — clear solver cache and warm-start state
+- **`Problem.remove_constraint()`** — incremental model modification
+- **Warm starts** — re-solves automatically use the previous solution
+- **Bounds correctness fix** — variable bounds are never cached, enabling fix-and-dive patterns
+
+---
+
+### Solver Callbacks & Termination
+
+- **`SolverProgress`** dataclass with iteration, objective, violation, elapsed time, and current x
+- **`callback=`** parameter on `solve()` — return `True` to stop early
+- **`time_limit=`** parameter on `solve()` — wall-clock budget
+- **`SolverStatus.TERMINATED`** for callback-initiated stops
+
+See the [Solver Callbacks example](examples/solver-callbacks.qmd).
+
+---
+
+### Serialization & I/O
+
+- **`Problem.write("model.lp")`** — export to LP format (linear and quadratic objectives, constraints, bounds, integer/binary sections)
+- **`Solution.to_dict()`** and **`Solution.to_json()`** — solution serialization for logging and auditing
+
+See the [LP Export example](examples/lp-export.qmd).
+
+---
+
+### Per-Element Array Bounds & Fancy Indexing
+
+- **Array bounds on `VectorVariable`**: `VectorVariable("x", 3, lb=np.array([0, 0.5, 0.2]))`
+- **Fancy indexing**: `x[[0, 2, 5]]` returns a subset vector expression
+
+See the [Vector Variables tutorial](tutorials/vectors.qmd).
diff --git a/examples/lp_export.py b/examples/lp_export.py
new file mode 100644
index 0000000..82bbca0
--- /dev/null
+++ b/examples/lp_export.py
@@ -0,0 +1,104 @@
+"""LP format export.
+
+Demonstrates how to export optimization models to the standard LP file
+format using Problem.write() and Problem.to_lp().
+"""
+
+from optyx import (
+    BinaryVariable,
+    IntegerVariable,
+    Problem,
+    Variable,
+    VectorVariable,
+    quadratic_form,
+)
+import numpy as np
+import os
+
+# --- Example 1: Simple LP ---
+print("=== Example 1: Simple linear program ===\n")
+
+x = Variable("x", lb=0)
+y = Variable("y", lb=0)
+
+prob = Problem("simple_lp")
+prob.minimize(2 * x + 3 * y)
+prob.subject_to(x + y >= 1)
+prob.subject_to(x - y <= 5)
+
+print(prob.to_lp())
+
+
+# --- Example 2: Quadratic objective ---
+print("=== Example 2: Quadratic program ===\n")
+
+x0 = Variable("x0", lb=0)
+x1 = Variable("x1", lb=0)
+x2 = Variable("x2", lb=0)
+
+prob2 = Problem("dense_qp")
+prob2.minimize(x0 + x1 + x0**2 + x0 * x1 + x1**2 + x1 * x2 + x2**2)
+prob2.subject_to(x0 + 2 * x1 + 3 * x2 >= 4)
+prob2.subject_to(x0 + x1 >= 1)
+
+print(prob2.to_lp())
+
+
+# --- Example 3: Portfolio optimization (QuadraticForm) ---
+print("=== Example 3: Portfolio optimization ===\n")
+
+n_assets = 4
+w = VectorVariable("w", n_assets, lb=0, ub=1)
+
+# Covariance matrix
+cov = np.array([
+    [0.04, 0.006, 0.002, 0.001],
+    [0.006, 0.09, 0.004, 0.003],
+    [0.002, 0.004, 0.01, 0.002],
+    [0.001, 0.003, 0.002, 0.06],
+])
+expected_return = np.array([0.10, 0.15, 0.08, 0.12])
+
+prob3 = Problem("portfolio")
+prob3.minimize(quadratic_form(w, cov))
+prob3.subject_to(w.sum().eq(1))
+prob3.subject_to(expected_return @ w >= 0.10)
+
+print(prob3.to_lp())
+
+
+# --- Example 4: Mixed-integer program ---
+print("=== Example 4: Mixed-integer program ===\n")
+
+# Knapsack-like problem
+items = ["A", "B", "C", "D"]
+from optyx import VariableDict
+
+select = VariableDict("select", items, domain="binary")
+quantity = VariableDict("qty", items, lb=0, ub=10, domain="integer")
+
+weights = {"A": 3, "B": 5, "C": 2, "D": 7}
+values = {"A": 4, "B": 7, "C": 3, "D": 9}
+
+prob4 = Problem("knapsack_mip")
+prob4.maximize(sum(values[i] * select[i] for i in items))
+prob4.subject_to(sum(weights[i] * select[i] for i in items) <= 12)
+
+print(prob4.to_lp())
+
+
+# --- Example 5: Write to file ---
+print("=== Example 5: Writing to file ===\n")
+
+_dir = os.path.dirname(os.path.abspath(__file__))
+
+prob.write(os.path.join(_dir, "simple_lp.lp"))
+print("Wrote simple LP to examples/simple_lp.lp")
+
+prob3.write(os.path.join(_dir, "portfolio.lp"))
+print("Wrote portfolio QP to examples/portfolio.lp")
+
+prob4.write(os.path.join(_dir, "knapsack.lp"))
+print("Wrote knapsack MIP to examples/knapsack.lp")
+
+print("\nDone!")
diff --git a/examples/mine_equipment_milp.py b/examples/mine_equipment_milp.py
new file mode 100644
index 0000000..132fa02
--- /dev/null
+++ b/examples/mine_equipment_milp.py
@@ -0,0 +1,277 @@
+"""Example: Mine Equipment Selection (Mixed-Integer Linear Programming)
+
+Demonstrates MILP capabilities in Optyx using BinaryVariable, IntegerVariable,
+and VectorVariable with domain="binary"/"integer".
+
+Problem:
+- A mining company must select which equipment to purchase/lease and decide
+  how many shifts to operate each machine to meet production targets.
+- Binary decisions: whether to acquire each piece of equipment
+- Integer decisions: number of shifts per week for each machine
+- Continuous decisions: tonnes allocated from each machine to each ore type
+
+This showcases:
+  - BinaryVariable for yes/no decisions
+  - IntegerVariable for discrete quantities
+  - VectorVariable with domain="binary" and domain="integer"
+  - Mixed continuous + integer formulations
+  - Big-M constraints linking binary and continuous variables
+  - Solution MIP-specific fields: mip_gap, best_bound
+"""
+
+import numpy as np
+from optyx import (
+    BinaryVariable,
+    IntegerVariable,
+    Variable,
+    VectorVariable,
+    Problem,
+)
+
+print("=" * 70)
+print("OPTYX - Mine Equipment Selection (MILP)")
+print("=" * 70)
+
+# =============================================================================
+# Problem Data
+# =============================================================================
+equipment = ["Excavator A", "Excavator B", "Loader C", "Drill Rig D"]
+n_equip = len(equipment)
+
+# Fixed cost to acquire/lease each machine ($k/month)
+fixed_cost = [120, 180, 85, 95]
+
+# Capacity per shift (tonnes/shift)
+capacity_per_shift = [500, 800, 350, 200]
+
+# Operating cost per shift ($k/shift)
+op_cost_per_shift = [8, 12, 5, 6]
+
+# Maximum shifts per week
+max_shifts = [14, 14, 21, 21]  # Some machines can run 3 shifts/day
+
+# Production targets
+min_production = 8000  # tonnes/week minimum
+target_production = 12000  # tonnes/week ideal
+
+print("\n--- Equipment Options ---")
+print(f"{'Machine':<16} {'Fixed Cost':>12} {'Cap/Shift':>12} {'Op Cost':>10} {'Max Shifts':>12}")
+print("-" * 65)
+for i in range(n_equip):
+    print(f"{equipment[i]:<16} ${fixed_cost[i]:>10}k {capacity_per_shift[i]:>10} t "
+          f"${op_cost_per_shift[i]:>7}k {max_shifts[i]:>10}/wk")
+
+print(f"\nMin production: {min_production} t/week")
+print(f"Target production: {target_production} t/week")
+
+# =============================================================================
+# Part 1: Basic MILP — Binary Equipment Selection
+# =============================================================================
+print("\n" + "=" * 70)
+print("Part 1: Binary Equipment Selection (BinaryVariable)")
+print("=" * 70)
+
+# Binary: acquire this equipment? (0 or 1)
+acquire = [BinaryVariable(f"acquire_{equipment[i]}") for i in range(n_equip)]
+
+prob1 = Problem(name="equipment_selection")
+
+# Minimize fixed costs of acquired equipment
+total_fixed = sum(fixed_cost[i] * acquire[i] for i in range(n_equip))
+prob1.minimize(total_fixed)
+
+# Must acquire enough capacity to meet minimum production
+# (assuming max shifts for feasibility check)
+total_capacity = sum(
+    capacity_per_shift[i] * max_shifts[i] * acquire[i] for i in range(n_equip)
+)
+prob1.subject_to(total_capacity >= min_production)
+
+# Need at least 2 machines for redundancy
+prob1.subject_to(sum(acquire) >= 2)
+
+sol1 = prob1.solve()
+
+print(f"\nStatus: {sol1.status.name}")
+print(f"MIP gap:    {sol1.mip_gap}")
+print(f"Best bound: {sol1.best_bound}")
+
+print(f"\nOptimal fixed cost: ${sol1.objective_value:.0f}k/month")
+print("\nEquipment acquired:")
+for i in range(n_equip):
+    selected = sol1[acquire[i].name]
+    marker = "YES" if selected > 0.5 else "no"
+    print(f"  {equipment[i]:<16} → {marker}")
+
+# =============================================================================
+# Part 2: Integer Shift Scheduling
+# =============================================================================
+print("\n" + "=" * 70)
+print("Part 2: Integer Shift Scheduling (IntegerVariable)")
+print("=" * 70)
+
+# Integer: how many shifts per week for each machine?
+shifts = [
+    IntegerVariable(f"shifts_{equipment[i]}", lb=0, ub=max_shifts[i])
+    for i in range(n_equip)
+]
+
+prob2 = Problem(name="shift_scheduling")
+
+# Minimize total operating cost
+total_op_cost = sum(op_cost_per_shift[i] * shifts[i] for i in range(n_equip))
+prob2.minimize(total_op_cost)
+
+# Meet production target
+production = sum(capacity_per_shift[i] * shifts[i] for i in range(n_equip))
+prob2.subject_to(production >= target_production)
+
+# Each machine needs at least 2 shifts if used at all (maintenance window)
+# (simplified: just set minimum 2 shifts for all)
+for i in range(n_equip):
+    prob2.subject_to(shifts[i] >= 2)
+
+sol2 = prob2.solve()
+
+print(f"\nStatus: {sol2.status.name}")
+print(f"Optimal operating cost: ${sol2.objective_value:.0f}k/week")
+
+print(f"\n{'Machine':<16} {'Shifts/wk':>10} {'Production':>12} {'Cost':>10}")
+print("-" * 52)
+total_prod = 0
+for i in range(n_equip):
+    s = sol2[shifts[i].name]
+    prod = s * capacity_per_shift[i]
+    cost = s * op_cost_per_shift[i]
+    total_prod += prod
+    print(f"{equipment[i]:<16} {s:>10.0f} {prod:>10.0f} t ${cost:>7.0f}k")
+print("-" * 52)
+print(f"{'TOTAL':<16} {'':>10} {total_prod:>10.0f} t ${sol2.objective_value:>7.0f}k")
+
+# =============================================================================
+# Part 3: VectorVariable with domain="binary"
+# =============================================================================
+print("\n" + "=" * 70)
+print("Part 3: Binary Knapsack (VectorVariable domain='binary')")
+print("=" * 70)
+
+# Spare parts selection: pick which parts to stock, maximize coverage
+n_parts = 8
+part_names = [f"Part-{chr(65+i)}" for i in range(n_parts)]
+part_coverage = np.array([15, 22, 8, 30, 12, 18, 25, 10])  # coverage score
+part_cost = np.array([5, 8, 3, 12, 4, 7, 10, 4])  # cost ($k)
+budget = 30  # $k
+
+# Binary vector: stock this part?
+stock = VectorVariable("stock", n_parts, domain="binary")
+
+prob3 = Problem(name="parts_selection")
+prob3.maximize(part_coverage @ stock)  # maximize coverage
+prob3.subject_to(part_cost @ stock <= budget)  # budget constraint
+prob3.subject_to(stock.sum() >= 3)  # minimum 3 different parts
+
+sol3 = prob3.solve()
+
+print(f"\nStatus: {sol3.status.name}")
+print(f"Maximum coverage score: {sol3.objective_value:.0f}")
+
+print(f"\n{'Part':<10} {'Coverage':>10} {'Cost ($k)':>10} {'Selected':>10}")
+print("-" * 43)
+total_cost_parts = 0
+for i in range(n_parts):
+    selected = sol3[f"stock[{i}]"]
+    sel_str = "YES" if selected > 0.5 else "-"
+    if selected > 0.5:
+        total_cost_parts += part_cost[i]
+    print(f"{part_names[i]:<10} {part_coverage[i]:>10} {part_cost[i]:>10} {sel_str:>10}")
+print(f"\nTotal cost: ${total_cost_parts}k / ${budget}k budget")
+
+# =============================================================================
+# Part 4: Mixed-Integer — Facility Location
+# =============================================================================
+print("\n" + "=" * 70)
+print("Part 4: Mixed-Integer — Depot Location")
+print("=" * 70)
+
+# Mining depots: binary open/close + continuous allocation
+depots = ["Central", "North", "South"]
+sites = ["Pit A", "Pit B", "Pit C", "Pit D"]
+n_depots = len(depots)
+n_sites = len(sites)
+
+depot_fixed_cost = [50, 35, 40]  # $k/month to operate
+depot_capacity = [200, 150, 180]  # tonnes/day
+
+# Transport cost per tonne from depot j to site k ($)
+transport_cost = np.array([
+    [3, 8, 5, 7],   # Central
+    [6, 2, 9, 4],   # North
+    [7, 5, 3, 2],   # South
+])
+
+site_demand = [60, 45, 55, 40]  # tonnes/day
+
+prob4 = Problem(name="depot_location")
+
+# Binary: open depot j?
+open_depot = [BinaryVariable(f"open_{depots[j]}") for j in range(n_depots)]
+
+# Continuous: tonnes from depot j to site k
+alloc = {}
+for j in range(n_depots):
+    for k in range(n_sites):
+        alloc[j, k] = Variable(f"alloc_{depots[j]}_{sites[k]}", lb=0)
+
+# Minimize: fixed costs + transport costs
+obj = sum(depot_fixed_cost[j] * open_depot[j] for j in range(n_depots))
+for j in range(n_depots):
+    for k in range(n_sites):
+        obj = obj + transport_cost[j, k] * alloc[j, k]
+prob4.minimize(obj)
+
+# Demand satisfaction
+for k in range(n_sites):
+    prob4.subject_to(
+        sum(alloc[j, k] for j in range(n_depots)) >= site_demand[k]
+    )
+
+# Capacity & linking (Big-M: can only allocate from open depots)
+for j in range(n_depots):
+    prob4.subject_to(
+        sum(alloc[j, k] for k in range(n_sites)) <= depot_capacity[j] * open_depot[j]
+    )
+
+sol4 = prob4.solve()
+
+print(f"\nStatus: {sol4.status.name}")
+print(f"Total cost: ${sol4.objective_value:.1f}k")
+print(f"MIP gap: {sol4.mip_gap}")
+
+print("\nDepot decisions:")
+for j in range(n_depots):
+    opened = sol4[open_depot[j].name]
+    status = "OPEN" if opened > 0.5 else "closed"
+    print(f"  {depots[j]:<10} → {status}")
+
+print(f"\n{'From → To':<25} {'Tonnes/day':>12}")
+print("-" * 40)
+for j in range(n_depots):
+    if sol4[open_depot[j].name] > 0.5:
+        for k in range(n_sites):
+            val = sol4[alloc[j, k].name]
+            if val > 0.1:
+                print(f"  {depots[j]} → {sites[k]:<12} {val:>10.1f}")
+
+# =============================================================================
+# Summary
+# =============================================================================
+print("\n" + "=" * 70)
+print("MILP features demonstrated:")
+print("  BinaryVariable('name')              — 0/1 decisions")
+print("  IntegerVariable('name', lb, ub)     — discrete quantities")
+print("  VectorVariable('x', n, domain='binary')  — binary vectors")
+print("  VectorVariable('x', n, domain='integer') — integer vectors")
+print("  Big-M linking constraints            — binary × continuous")
+print("  sol.mip_gap, sol.best_bound          — MIP solution quality")
+print("  Automatic MILP routing               — detected from domains")
+print("=" * 70)
diff --git a/examples/mine_production_planning.py b/examples/mine_production_planning.py
new file mode 100644
index 0000000..06a9eab
--- /dev/null
+++ b/examples/mine_production_planning.py
@@ -0,0 +1,235 @@
+"""Example: Mine Production Planning with VariableDict
+
+Demonstrates VariableDict for a mine production planning problem where
+decision variables are naturally indexed by pit/zone names rather than
+integer indices.
+
+Problem:
+- A mining operation has multiple ore zones, each with different grades,
+  extraction costs, and tonnage limits.
+- Plan extraction quantities to maximize profit while meeting:
+  - Mill blend grade targets (min/max acceptable feed grade)
+  - Mill throughput capacity
+  - Zone-specific extraction limits
+  - Minimum extraction commitments (keep equipment utilized)
+  - Stockpile balance: high-grade and low-grade zones tracked separately
+
+This showcases VariableDict's key methods:
+  - Creation with per-key bounds
+  - __getitem__ for individual variable access
+  - sum() and sum(subset) for total and partial sums
+  - prod(dict) for weighted sums (grade blending, cost calculation)
+  - keys(), values(), items() for iteration
+  - Solution[VariableDict] for result extraction
+"""
+
+from optyx import VariableDict, Problem
+
+print("=" * 70)
+print("OPTYX - Mine Production Planning with VariableDict")
+print("=" * 70)
+
+# =============================================================================
+# Problem Data — Ore Zones
+# =============================================================================
+zones = ["North Pit", "South Pit", "East Bench", "West Cutback", "Stockpile"]
+
+# Ore grade (% copper) per zone
+grade = {
+    "North Pit": 0.85,
+    "South Pit": 0.62,
+    "East Bench": 1.20,
+    "West Cutback": 0.45,
+    "Stockpile": 0.55,
+}
+
+# Extraction cost ($/tonne) per zone
+cost = {
+    "North Pit": 12.50,
+    "South Pit": 9.80,
+    "East Bench": 18.00,
+    "West Cutback": 8.50,
+    "Stockpile": 5.00,
+}
+
+# Revenue per unit of contained metal ($/tonne of ore × grade)
+cu_price = 85.0  # $/unit grade-tonne
+
+# Maximum extractable tonnage per zone (kt)
+max_tonnes = {
+    "North Pit": 500,
+    "South Pit": 800,
+    "East Bench": 300,
+    "West Cutback": 600,
+    "Stockpile": 200,
+}
+
+# Mill capacity
+mill_capacity = 1500  # kt total throughput
+min_feed_grade = 0.60  # minimum blend grade (% Cu)
+max_feed_grade = 1.00  # maximum blend grade (% Cu)
+
+# Define high-grade and low-grade zone groups
+high_grade_zones = ["North Pit", "East Bench"]
+low_grade_zones = ["South Pit", "West Cutback", "Stockpile"]
+
+print("\n--- Ore Zone Data ---")
+print(f"{'Zone':<18} {'Grade (%Cu)':>12} {'Cost ($/t)':>12} {'Max (kt)':>10}")
+print("-" * 55)
+for z in zones:
+    print(f"{z:<18} {grade[z]:>12.2f} {cost[z]:>12.2f} {max_tonnes[z]:>10}")
+
+print(f"\nMill capacity: {mill_capacity} kt")
+print(f"Feed grade window: {min_feed_grade}% - {max_feed_grade}% Cu")
+
+# =============================================================================
+# Model Setup — VariableDict creation with per-key bounds
+# =============================================================================
+print("\n--- Building Model ---")
+
+# Extraction tonnes per zone (per-key upper bounds from max_tonnes)
+extract = VariableDict("extract", zones, lb=0, ub=max_tonnes)
+
+print(f"Created VariableDict: {extract}")
+print(f"  Keys: {extract.keys()}")
+print(f"  Variable count: {len(extract)}")
+
+# Show individual variable access via __getitem__
+print(f"\n  extract['North Pit'] → {extract['North Pit']}")
+print(f"  extract['Stockpile'] → {extract['Stockpile']}")
+
+# Check membership via __contains__
+print(f"\n  'East Bench' in extract → {'East Bench' in extract}")
+print(f"  'Underground' in extract → {'Underground' in extract}")
+
+# =============================================================================
+# Objective — Maximize profit using prod()
+# =============================================================================
+prob = Problem(name="mine_plan")
+
+# Revenue = cu_price × (grade-weighted sum of extraction)
+revenue_coeffs = {z: cu_price * grade[z] for z in zones}
+revenue = extract.prod(revenue_coeffs)
+
+# Cost = cost-weighted sum of extraction
+total_cost = extract.prod(cost)
+
+# Profit = revenue - cost
+prob.maximize(revenue - total_cost)
+
+print("\nObjective: maximize Σ(price × grade - cost) × extract[zone]")
+print("  Revenue coefficients ($/t):")
+for z in zones:
+    net = revenue_coeffs[z] - cost[z]
+    print(f"    {z:<18} revenue={revenue_coeffs[z]:6.2f}  cost={cost[z]:5.2f}  net={net:6.2f}")
+
+# =============================================================================
+# Constraints — Using sum(), sum(subset), and prod()
+# =============================================================================
+
+# 1. Mill throughput: total extraction <= mill capacity
+#    Showcases: sum() — full sum over all keys
+prob.subject_to(extract.sum() <= mill_capacity)
+print(f"\nConstraint 1: Total extraction ≤ {mill_capacity} kt  [sum()]")
+
+# 2. Minimum feed grade (blend constraint)
+#    grade-weighted sum >= min_grade × total sum
+#    Showcases: prod(dict) for weighted sum
+prob.subject_to(extract.prod(grade) >= min_feed_grade * extract.sum())
+print(f"Constraint 2: Blend grade ≥ {min_feed_grade}%  [prod()]")
+
+# 3. Maximum feed grade
+prob.subject_to(extract.prod(grade) <= max_feed_grade * extract.sum())
+print(f"Constraint 3: Blend grade ≤ {max_feed_grade}%  [prod()]")
+
+# 4. High-grade zones must supply at least 300 kt
+#    Showcases: sum(subset) — partial sum over selected keys
+prob.subject_to(extract.sum(high_grade_zones) >= 300)
+print(f"Constraint 4: High-grade zones ≥ 300 kt  [sum(subset)]")
+
+# 5. Low-grade zones capped at 60% of total feed
+prob.subject_to(extract.sum(low_grade_zones) <= 0.6 * extract.sum())
+print(f"Constraint 5: Low-grade zones ≤ 60% of feed  [sum(subset)]")
+
+# 6. Minimum extraction per zone (keep equipment busy)
+#    Showcases: items() for iteration over (key, variable) pairs
+min_extract = 50  # kt minimum per zone
+for key, var in extract.items():
+    prob.subject_to(var >= min_extract)
+print(f"Constraint 6: Each zone ≥ {min_extract} kt  [items() iteration]")
+
+# =============================================================================
+# Solve
+# =============================================================================
+print("\n--- Solving ---")
+sol = prob.solve()
+
+if not sol.is_optimal:
+    print(f"Solver status: {sol.status}")
+    exit(1)
+
+# =============================================================================
+# Results — Solution extraction via Solution[VariableDict]
+# =============================================================================
+print("\n--- Optimal Production Plan ---")
+
+# Extract all results at once: Solution[VariableDict] → dict
+result = sol[extract]
+print(f"\nSolution type: {type(result).__name__}")  # dict
+
+print(f"\n{'Zone':<18} {'Extract (kt)':>14} {'Grade (%Cu)':>12} {'Revenue ($k)':>14} {'Cost ($k)':>12}")
+print("-" * 73)
+
+total_tonnes = 0
+total_metal = 0
+total_revenue = 0
+total_cost_val = 0
+
+for zone in zones:
+    t = result[zone]
+    metal = t * grade[zone]
+    rev = t * revenue_coeffs[zone]
+    cst = t * cost[zone]
+    total_tonnes += t
+    total_metal += metal
+    total_revenue += rev
+    total_cost_val += cst
+    print(f"{zone:<18} {t:>14.1f} {grade[zone]:>12.2f} {rev:>14.1f} {cst:>12.1f}")
+
+print("-" * 73)
+blend_grade = total_metal / total_tonnes if total_tonnes > 0 else 0
+print(f"{'TOTAL':<18} {total_tonnes:>14.1f} {blend_grade:>12.2f} {total_revenue:>14.1f} {total_cost_val:>12.1f}")
+
+profit = total_revenue - total_cost_val
+print(f"\nProfit: ${profit:,.0f}k")
+print(f"Blend grade: {blend_grade:.3f}% Cu (target: {min_feed_grade}-{max_feed_grade}%)")
+print(f"Mill utilization: {total_tonnes/mill_capacity*100:.1f}%")
+
+# Show subset sums from results
+hg_total = sum(result[z] for z in high_grade_zones)
+lg_total = sum(result[z] for z in low_grade_zones)
+print(f"\nHigh-grade zones: {hg_total:.1f} kt ({hg_total/total_tonnes*100:.0f}%)")
+print(f"Low-grade zones:  {lg_total:.1f} kt ({lg_total/total_tonnes*100:.0f}%)")
+
+# Also show individual variable access from solution
+print(f"\nIndividual access: extract['East Bench'] = {sol[extract['East Bench']]:.1f} kt")
+
+# Show get_variables() — returns list of Variable objects
+all_vars = extract.get_variables()
+print(f"\nget_variables() returned {len(all_vars)} Variable objects")
+
+# Show values() — returns list of Variable objects in key order
+print(f"values() returns: {[v.name for v in extract.values()]}")
+
+print("\n" + "=" * 70)
+print("Demo complete — VariableDict methods showcased:")
+print("  VariableDict(name, keys, lb, ub)  — creation with per-key bounds")
+print("  vd['key']                         — individual variable access")
+print("  vd.sum()                          — full sum")
+print("  vd.sum(subset)                    — partial sum")
+print("  vd.prod(coefficients)             — weighted sum")
+print("  vd.keys(), values(), items()      — dict-like iteration")
+print("  vd.get_variables()                — list of Variable objects")
+print("  len(vd), 'key' in vd             — length and membership")
+print("  solution[vd]                      — extract all results as dict")
+print("=" * 70)
diff --git a/examples/modify_and_resolve.py b/examples/modify_and_resolve.py
new file mode 100644
index 0000000..9ce160d
--- /dev/null
+++ b/examples/modify_and_resolve.py
@@ -0,0 +1,118 @@
+"""Modify and Re-solve: Adapting a Model to Changing Conditions.
+
+Shows how to modify an optimization problem between solves without
+rebuilding from scratch — add/remove constraints, update variable bounds,
+and leverage warm starting for faster re-solves.
+
+Scenario: A factory production plan is adjusted as operating conditions
+change (new regulations, capacity upgrades, equipment maintenance).
+"""
+
+from optyx import Variable, Problem
+from optyx.constraints import Constraint
+
+a = Variable("a", lb=0, ub=100)
+b = Variable("b", lb=0, ub=100)
+
+prob = Problem(name="factory_production")
+prob.maximize(5 * a + 8 * b)  # $5/unit A, $8/unit B
+
+# Named constraints via Constraint() so we can remove them by name later
+mh = Constraint(expr=(a + 2 * b - 120), sense="<=", name="machine_hours")
+prob.subject_to(mh)
+
+rm = Constraint(expr=(3 * a + 2 * b - 150), sense="<=", name="raw_material")
+prob.subject_to(rm)
+
+print("=" * 60)
+print("MODIFY AND RE-SOLVE DEMO")
+print("=" * 60)
+
+print("\n--- Solve 1: Base case ---")
+sol = prob.solve()
+print(f"Status: {sol.status}")
+print(f"Profit: ${sol.objective_value:.2f}")
+print(f"Production: A={sol.values['a']:.1f}, B={sol.values['b']:.1f}")
+
+print("\n--- Solve 2: New regulation limits product B to 40 units ---")
+reg = Constraint(expr=(b - 40), sense="<=", name="regulation_b")  # Named for later removal
+prob.subject_to(reg)
+sol = prob.solve()
+print(f"Status: {sol.status}")
+print(f"Profit: ${sol.objective_value:.2f}")
+print(f"Production: A={sol.values['a']:.1f}, B={sol.values['b']:.1f}")
+
+print("\n--- Solve 3: Regulation lifted ---")
+prob.remove_constraint("regulation_b")
+sol = prob.solve()
+print(f"Status: {sol.status}")
+print(f"Profit: ${sol.objective_value:.2f}")
+print(f"Production: A={sol.values['a']:.1f}, B={sol.values['b']:.1f}")
+
+print("\n--- Solve 4: Extra machine hours — capacity from 120h to 200h ---")
+prob.remove_constraint("machine_hours")  # Remove old constraint by name
+mh2 = Constraint(expr=(a + 2 * b - 200), sense="<=", name="machine_hours")
+prob.subject_to(mh2)
+sol = prob.solve()
+print(f"Status: {sol.status}")
+print(f"Profit: ${sol.objective_value:.2f}")
+print(f"Production: A={sol.values['a']:.1f}, B={sol.values['b']:.1f}")
+
+print("\n--- Solve 5: Maintenance — product A line shut down ---")
+a.lb = 0
+a.ub = 0
+sol = prob.solve()
+print(f"Status: {sol.status}")
+print(f"Profit: ${sol.objective_value:.2f}")
+print(f"Production: A={sol.values['a']:.1f}, B={sol.values['b']:.1f}")
+
+print("\n--- Solve 6: Maintenance complete — line A restored ---")
+a.lb = 0
+a.ub = 100
+sol = prob.solve()
+print(f"Status: {sol.status}")
+print(f"Profit: ${sol.objective_value:.2f}")
+print(f"Production: A={sol.values['a']:.1f}, B={sol.values['b']:.1f}")
+
+# --- Warm start with a nonlinear problem ---
+print("\n" + "=" * 60)
+print("WARM START DEMO (NLP)")
+print("=" * 60)
+
+x = Variable("x", lb=0, ub=10)
+y = Variable("y", lb=0, ub=10)
+
+nlp = Problem(name="warm_start_demo")
+nlp.minimize((x - 3) ** 2 + (y - 4) ** 2)
+nlp.subject_to(x + y >= 5)
+
+print("\n--- NLP Solve 1: Initial solve ---")
+sol1 = nlp.solve(method="SLSQP")
+print(f"Solution: x={sol1.values['x']:.4f}, y={sol1.values['y']:.4f}")
+print(f"Objective: {sol1.objective_value:.6f}")
+
+print("\n--- NLP Solve 2: Re-solve (warm start reuses previous solution) ---")
+sol2 = nlp.solve(method="SLSQP")
+print(f"Solution: x={sol2.values['x']:.4f}, y={sol2.values['y']:.4f}")
+print(f"Iterations: {sol2.iterations}")
+
+print("\n--- NLP Solve 3: Add constraint and re-solve ---")
+nlp.subject_to(x >= 4)
+sol3 = nlp.solve(method="SLSQP")
+print(f"Solution: x={sol3.values['x']:.4f}, y={sol3.values['y']:.4f}")
+print(f"Objective: {sol3.objective_value:.6f}")
+
+print("\n--- NLP Solve 4: Remove constraint and re-solve ---")
+nlp.remove_constraint(1)
+sol4 = nlp.solve(method="SLSQP")
+print(f"Solution: x={sol4.values['x']:.4f}, y={sol4.values['y']:.4f}")
+print(f"Objective: {sol4.objective_value:.6f}")
+
+print("\n--- Reset (forces cold start on next solve) ---")
+nlp.reset()
+sol5 = nlp.solve(method="SLSQP")
+print(f"Solution: x={sol5.values['x']:.4f}, y={sol5.values['y']:.4f}")
+
+print("\n" + "=" * 60)
+print("All demos completed successfully!")
+print("=" * 60)
diff --git a/examples/solver_callbacks.py b/examples/solver_callbacks.py
new file mode 100644
index 0000000..4c9040a
--- /dev/null
+++ b/examples/solver_callbacks.py
@@ -0,0 +1,74 @@
+"""Solver progress callbacks and time limits.
+
+Demonstrates how to monitor solver progress during optimization and
+apply time limits for long-running solves.
+"""
+
+from optyx import Problem, SolverProgress, VectorVariable
+
+# --- Problem setup: Rosenbrock in 10 dimensions ---
+n = 10
+v = VectorVariable("v", n, lb=-5, ub=5)
+prob = Problem("rosenbrock")
+
+# Vectorized Rosenbrock using VectorVariable slicing
+v_head = v[:-1]  # first n-1 elements
+v_tail = v[1:]   # last  n-1 elements
+obj = ((1 - v_head) ** 2 + 100 * (v_tail - v_head ** 2) ** 2).sum()
+prob.minimize(obj)
+
+
+# --- Example 1: Logging progress ---
+print("=== Example 1: Logging solver progress ===\n")
+
+
+def log_progress(p: SolverProgress) -> None:
+    print(
+        f"  iter {p.iteration:3d}  |  obj {p.objective_value:12.4f}"
+        f"  |  violation {p.constraint_violation:.2e}"
+        f"  |  time {p.elapsed_time:.3f}s"
+    )
+
+
+sol = prob.solve(method="SLSQP", callback=log_progress)
+print(f"\nStatus: {sol.status.value}  |  Objective: {sol.objective_value:.6f}\n")
+
+
+# --- Example 2: Early termination via callback ---
+print("=== Example 2: Stop when objective < threshold ===\n")
+
+THRESHOLD = 1.0
+
+
+def stop_when_good_enough(p: SolverProgress) -> bool:
+    if p.objective_value < THRESHOLD:
+        print(f"  Objective {p.objective_value:.4f} < {THRESHOLD} — stopping early")
+        return True  # signal termination
+    return False
+
+
+sol = prob.solve(method="SLSQP", callback=stop_when_good_enough)
+print(f"Status: {sol.status.value}  |  Objective: {sol.objective_value:.6f}\n")
+
+
+# --- Example 3: Time limit ---
+print("=== Example 3: Solve with a 0.01 s time limit ===\n")
+
+sol = prob.solve(method="SLSQP", time_limit=0.01)
+print(f"Status: {sol.status.value}  |  Objective: {sol.objective_value:.6f}")
+print(f"Solve time: {sol.solve_time:.4f}s  |  Iterations: {sol.iterations}\n")
+
+
+# --- Example 4: Combining callback and time limit ---
+print("=== Example 4: Callback + time limit together ===\n")
+
+history: list[float] = []
+
+
+def record_objective(p: SolverProgress) -> None:
+    history.append(p.objective_value)
+
+
+sol = prob.solve(method="SLSQP", callback=record_objective, time_limit=0.05)
+print(f"Status: {sol.status.value}  |  Objective: {sol.objective_value:.6f}")
+print(f"Recorded {len(history)} objective snapshots")
diff --git a/pyproject.toml b/pyproject.toml
index a669572..abeec4a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "optyx"
-version = "1.2.4"
+version = "1.3.0"
 description = "Intuitive symbolic interface for constrained optimization problems"
 readme = "README.md"
 license = "MIT"
@@ -37,11 +37,11 @@ dependencies = [
 ]
 
 [project.urls]
-Homepage = "https://daggbt.github.io/optyx/"
-Documentation = "https://daggbt.github.io/optyx/"
-Repository = "https://github.com/daggbt/optyx"
-Changelog = "https://github.com/daggbt/optyx/blob/main/CHANGELOG.md"
-Issues = "https://github.com/daggbt/optyx/issues"
+Homepage = "https://optyx-dev.github.io/optyx/"
+Documentation = "https://optyx-dev.github.io/optyx/"
+Repository = "https://github.com/optyx-dev/optyx"
+Changelog = "https://github.com/optyx-dev/optyx/blob/main/CHANGELOG.md"
+Issues = "https://github.com/optyx-dev/optyx/issues"
 
 [project.optional-dependencies]
 benchmarks = [
@@ -66,7 +66,7 @@ dev = [
     "ipykernel",
     "jupyter",
     "pyyaml",
-    "pyright>=1.1.407",
+    "pyright>=1.1.408",
     "quartodoc>=0.11.1",
 ]
 
diff --git a/pyrightconfig.json b/pyrightconfig.json
index d13de88..2cc9841 100644
--- a/pyrightconfig.json
+++ b/pyrightconfig.json
@@ -11,18 +11,20 @@
   "reportPossiblyUnboundVariable": "warning",
   "reportOperatorIssue": "warning",
   "include": [
-    "src"
+    "src",
+    "examples",
+    "benchmarks"
   ],
   "exclude": [
     "**/__pycache__",
     ".venv",
     "docs/_site",
     "docs/_freeze",
+    "./*.py",
     ".pytest_cache",
     "*.egg-info",
     "examples",
     "tests",
-    "benchmarks",
-    "compare_optyx_scipy.py"
+    "benchmarks"
   ]
 }
diff --git a/src/optyx/__init__.py b/src/optyx/__init__.py
index 34ff2c2..c7e1823 100644
--- a/src/optyx/__init__.py
+++ b/src/optyx/__init__.py
@@ -8,11 +8,14 @@
     Constant,
 )
 from optyx.core.vectors import VectorVariable
+from optyx.core.variable_dict import VariableDict
 from optyx.core.matrices import (
+    ConstantMatrix,
     MatrixVariable,
     MatrixVectorProduct,
     QuadraticForm,
     FrobeniusNorm,
+    as_matrix,
     matmul,
     quadratic_form,
     trace,
@@ -44,17 +47,38 @@
 )
 from optyx.constraints import Constraint
 from optyx.problem import Problem
-from optyx.solution import Solution, SolverStatus
+from optyx.solution import Solution, SolverStatus, SolverProgress
 
 __version__ = version("optyx")
 
+
+def BinaryVariable(name: str, **kwargs) -> Variable:
+    """Create a binary (0/1) variable.
+
+    Shorthand for ``Variable(name, domain='binary', lb=0, ub=1)``.
+    """
+    return Variable(name, domain="binary", **kwargs)
+
+
+def IntegerVariable(name: str, lb=None, ub=None, **kwargs) -> Variable:
+    """Create an integer variable.
+
+    Shorthand for ``Variable(name, domain='integer', lb=lb, ub=ub)``.
+    """
+    return Variable(name, domain="integer", lb=lb, ub=ub, **kwargs)
+
+
 __all__ = [
     # Core
     "Expression",
     "Variable",
     "Constant",
+    "BinaryVariable",
+    "IntegerVariable",
     "VectorVariable",
+    "VariableDict",
     "MatrixVariable",
+    "ConstantMatrix",
     # Parameters
     "Parameter",
     "VectorParameter",
@@ -63,6 +87,7 @@
     "MatrixVectorProduct",
     "QuadraticForm",
     "FrobeniusNorm",
+    "as_matrix",
     "matmul",
     "quadratic_form",
     "trace",
@@ -93,6 +118,7 @@
     "Problem",
     "Solution",
     "SolverStatus",
+    "SolverProgress",
     # Utilities
     "increased_recursion_limit",
 ]
diff --git a/src/optyx/analysis.py b/src/optyx/analysis.py
index 42eabf3..0714b50 100644
--- a/src/optyx/analysis.py
+++ b/src/optyx/analysis.py
@@ -15,7 +15,7 @@
 
 from dataclasses import dataclass
 from functools import lru_cache
-from typing import TYPE_CHECKING, Optional, Sequence
+from typing import TYPE_CHECKING, Any, Optional, Sequence
 import numbers
 
 import numpy as np
@@ -65,7 +65,6 @@ def _estimate_tree_depth(expr: Expression, max_depth: int = 500) -> int:
         Estimated maximum depth of the tree.
     """
     from optyx.core.vectors import LinearCombination, VectorSum, DotProduct
-    from typing import Any
 
     # Use explicit stack to avoid recursion
     stack: list[tuple[Any, int]] = [(expr, 0)]  # (node, current_depth)
@@ -710,9 +709,11 @@ class LPData:
     Attributes:
         c: Objective function coefficients (n,)
         sense: 'min' or 'max'
-        A_ub: Inequality constraint matrix (m_ub, n) or None
+        A_ub: Inequality constraint matrix (m_ub, n) or None.
+            Can be dense ndarray or scipy.sparse matrix.
         b_ub: Inequality RHS vector (m_ub,) or None
-        A_eq: Equality constraint matrix (m_eq, n) or None
+        A_eq: Equality constraint matrix (m_eq, n) or None.
+            Can be dense ndarray or scipy.sparse matrix.
         b_eq: Equality RHS vector (m_eq,) or None
         bounds: List of (lb, ub) tuples for each variable
         variables: List of variable names in order
@@ -720,9 +721,9 @@ class LPData:
 
     c: NDArray[np.floating]
     sense: str
-    A_ub: NDArray[np.floating] | None
+    A_ub: Any  # NDArray or scipy.sparse matrix or None
     b_ub: NDArray[np.floating] | None
-    A_eq: NDArray[np.floating] | None
+    A_eq: Any  # NDArray or scipy.sparse matrix or None
     b_eq: NDArray[np.floating] | None
     bounds: list[tuple[float | None, float | None]]
     variables: list[str]
@@ -959,6 +960,20 @@ def _extract_all_coefficients_impl(
         return
 
 
+def _vstack(a: Any, b: Any) -> Any:
+    """Vertically stack two matrices, preserving sparsity when possible."""
+    from scipy import sparse as sp
+
+    if sp.issparse(a) or sp.issparse(b):
+        # Convert dense to sparse if needed for concatenation
+        if not sp.issparse(a):
+            a = sp.csr_matrix(a)
+        if not sp.issparse(b):
+            b = sp.csr_matrix(b)
+        return sp.vstack([a, b], format="csr")
+    return np.vstack([a, b])
+
+
 class LinearProgramExtractor:
     """Extracts LP coefficients from a Problem for use with scipy.optimize.linprog.
 
@@ -1009,6 +1024,11 @@ def extract_objective(
         # Use batch extraction - O(n) instead of O(n²)
         c = extract_all_linear_coefficients(problem.objective, var_index, n)
 
+        # Add Variable.obj contributions (linear objective coefficients set at creation)
+        for i, var in enumerate(variables):
+            if var.obj != 0.0:
+                c[i] += var.obj
+
         sense = "min" if problem.sense == "minimize" else "max"
         return c, sense, variables
 
@@ -1078,6 +1098,82 @@ def extract_constraints(
         A_eq = np.array(eq_rows, dtype=np.float64) if eq_rows else None
         b_eq = np.array(eq_rhs, dtype=np.float64) if eq_rhs else None
 
+        # Merge structured matrix constraints collected via subject_to(A @ x <= b)
+        A_ub, b_ub, A_eq, b_eq = self._merge_matrix_constraints(
+            problem, variables, A_ub, b_ub, A_eq, b_eq
+        )
+
+        return A_ub, b_ub, A_eq, b_eq
+
+    @staticmethod
+    def _merge_matrix_constraints(
+        problem: Problem,
+        variables: Sequence[Variable],
+        A_ub: Any,
+        b_ub: NDArray[np.floating] | None,
+        A_eq: Any,
+        b_eq: NDArray[np.floating] | None,
+    ) -> tuple[Any, NDArray[np.floating] | None, Any, NDArray[np.floating] | None]:
+        """Merge matrix constraints into the extracted constraint matrices."""
+        from scipy import sparse as sp
+
+        if not problem._matrix_constraints:
+            return A_ub, b_ub, A_eq, b_eq
+
+        n = len(variables)
+        var_index = {var.name: i for i, var in enumerate(variables)}
+
+        for mc in problem._matrix_constraints:
+            # Build column permutation: mc.variables may be a subset or
+            # reordered relative to the full variable list
+            mc_n = len(mc.variables)
+            col_indices = np.array(
+                [var_index[v.name] for v in mc.variables], dtype=np.intp
+            )
+
+            # Build the full-width matrix for this constraint block
+            if sp.issparse(mc.A):
+                if mc_n == n and np.array_equal(col_indices, np.arange(n)):
+                    A_full = mc.A  # noqa: N806
+                else:
+                    # Permutation matrix P (mc_n x n): P[j, col_indices[j]] = 1
+                    # A_full = mc.A @ P  ->  (m, mc_n) @ (mc_n, n) = (m, n)
+                    P = sp.csr_matrix(  # noqa: N806
+                        (np.ones(mc_n), (np.arange(mc_n), col_indices)),
+                        shape=(mc_n, n),
+                    )
+                    A_full = (mc.A @ P).tocsr()  # noqa: N806
+            else:
+                # Dense path
+                if mc_n == n and np.array_equal(col_indices, np.arange(n)):
+                    # Variables already aligned — zero-copy
+                    A_full = mc.A  # noqa: N806
+                else:
+                    A_full = np.zeros((mc.A.shape[0], n), dtype=np.float64)  # noqa: N806
+                    A_full[:, col_indices] = mc.A
+
+            b_block = mc.b
+
+            if mc.sense == ">=":
+                A_full = -A_full  # noqa: N806
+                b_block = -b_block
+
+            if mc.sense == "==":
+                if A_eq is None:
+                    A_eq = A_full
+                    b_eq = b_block
+                else:
+                    A_eq = _vstack(A_eq, A_full)
+                    b_eq = np.concatenate([b_eq, b_block])  # type: ignore[arg-type]
+            else:
+                # <= (including >= converted to <=)
+                if A_ub is None:
+                    A_ub = A_full
+                    b_ub = b_block
+                else:
+                    A_ub = _vstack(A_ub, A_full)
+                    b_ub = np.concatenate([b_ub, b_block])  # type: ignore[arg-type]
+
         return A_ub, b_ub, A_eq, b_eq
 
     def extract_bounds(
@@ -1127,6 +1223,49 @@ def extract(self, problem: Problem) -> LPData:
         )
 
 
+# =============================================================================
+# Issue #106: Quadratic Coefficient Extraction
+# =============================================================================
+
+
+def extract_quadratic_coefficients(
+    expr: Expression,
+    variables: list[Variable],
+) -> NDArray[np.floating]:
+    """Extract the quadratic coefficient matrix from a quadratic expression.
+
+    For an expression of the form x'Qx + c'x + d, returns the matrix Q
+    such that the quadratic part is sum_{i,j} Q[i,j] * x_i * x_j.
+
+    Args:
+        expr: A quadratic expression.
+        variables: List of variables in the desired ordering.
+
+    Returns:
+        Symmetric (n, n) matrix of quadratic coefficients.
+
+    Raises:
+        NonLinearError: If the expression is not quadratic.
+    """
+    from optyx.io import _is_at_most_quadratic, _collect_quadratic_coefficients
+
+    if not _is_at_most_quadratic(expr):
+        raise NonLinearError(
+            expression=repr(expr)[:100],
+            context="quadratic coefficient extraction",
+            suggestion="Ensure the expression is at most quadratic.",
+        )
+
+    n = len(variables)
+    var_index = {v.name: i for i, v in enumerate(variables)}
+    Q = np.zeros((n, n), dtype=np.float64)
+    _collect_quadratic_coefficients(expr, var_index, Q, 1.0)
+
+    # Symmetrize: Q_sym = (Q + Q.T) / 2
+    Q_sym = (Q + Q.T) / 2.0
+    return Q_sym
+
+
 # =============================================================================
 # Issue #32: Constraint Helpers and Classification
 # =============================================================================
diff --git a/src/optyx/constraints.py b/src/optyx/constraints.py
index 5560d30..92532e6 100644
--- a/src/optyx/constraints.py
+++ b/src/optyx/constraints.py
@@ -10,11 +10,12 @@
 
 import numpy as np
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Mapping
+from typing import TYPE_CHECKING, Any, Mapping
 
 from optyx.core.errors import ConstraintError
 
 if TYPE_CHECKING:
+    from numpy.typing import NDArray
     from optyx.core.expressions import Expression, Variable
 
 
@@ -105,6 +106,70 @@ def __repr__(self) -> str:
         return f"Constraint({name_str}{self.expr} {self.sense} 0)"
 
 
+@dataclass(frozen=True)
+class MatrixConstraintBlock:
+    """Structured matrix constraint block: A @ x {<=, >=, ==} b.
+
+    This preserves the original matrix representation so LP/MILP extraction
+    can keep dense or sparse structure instead of expanding into many scalar
+    constraints.
+    """
+
+    A: Any
+    variables: tuple[Variable, ...]
+    sense: str
+    b: NDArray[np.floating]
+
+    def __post_init__(self):
+        if self.sense not in ("<=", ">=", "=="):
+            raise ConstraintError(
+                message=f"Invalid matrix constraint sense: {self.sense}. Use <=, >=, or ==.",
+                constraint_type=self.sense,
+            )
+
+
+def make_matrix_constraint_block(
+    A: Any,
+    x: Any,
+    sense: str,
+    b: Any,
+) -> MatrixConstraintBlock:
+    """Create a validated MatrixConstraintBlock from raw matrix data."""
+    from scipy import sparse as sp
+
+    from optyx.core.vectors import VectorVariable
+
+    if not isinstance(x, VectorVariable):
+        raise TypeError(
+            "Matrix constraints require a VectorVariable on the right-hand side."
+        )
+
+    b_arr = np.asarray(b, dtype=np.float64).ravel()
+
+    if sp.issparse(A):
+        m, n = A.shape
+        matrix = A
+    else:
+        matrix = np.asarray(A, dtype=np.float64)
+        if matrix.ndim != 2:
+            raise ValueError(f"A must be 2D, got array with ndim={matrix.ndim}")
+        m, n = matrix.shape
+
+    if n != x.size:
+        raise ValueError(f"A has {n} columns but x has {x.size} variables")
+    if m != len(b_arr):
+        raise ValueError(f"A has {m} rows but b has {len(b_arr)} elements")
+    if sense not in ("<=", ">=", "=="):
+        raise ValueError(f"sense must be '<=', '>=', or '==', got '{sense}'")
+
+    return MatrixConstraintBlock(
+        A=matrix,
+        variables=tuple(x._variables),
+        sense=sense,
+        b=b_arr,
+    )
+
+
 def _make_constraint(lhs: Expression, sense: str, rhs) -> Constraint:
     """Helper to create a constraint from lhs sense rhs.
 
diff --git a/src/optyx/core/__init__.py b/src/optyx/core/__init__.py
index ad81c09..bd89282 100644
--- a/src/optyx/core/__init__.py
+++ b/src/optyx/core/__init__.py
@@ -45,6 +45,7 @@
     BoundsError,
     EmptyContainerError,
     SolverError,
+    UnsupportedOperationError,
     InfeasibleError,
     UnboundedError,
     NotSolvedError,
@@ -92,6 +93,7 @@
     "BoundsError",
     "EmptyContainerError",
     "SolverError",
+    "UnsupportedOperationError",
     "InfeasibleError",
     "UnboundedError",
     "NotSolvedError",
diff --git a/src/optyx/core/autodiff.py b/src/optyx/core/autodiff.py
index 74eaac8..fd027d8 100644
--- a/src/optyx/core/autodiff.py
+++ b/src/optyx/core/autodiff.py
@@ -11,9 +11,11 @@
 from __future__ import annotations
 
 import sys
+from enum import Enum, auto
 from contextlib import contextmanager
+from dataclasses import dataclass
 from functools import lru_cache
-from typing import TYPE_CHECKING, Any, Callable, Iterator, cast
+from typing import TYPE_CHECKING, Any, Callable, Iterator, Protocol, cast
 
 import numpy as np
 from numpy.typing import NDArray
@@ -24,6 +26,10 @@
     from optyx.core.expressions import Expression, Variable
 
 
+class _VariableContainer(Protocol):
+    def get_variables(self) -> list[Variable]: ...
+
+
 # =============================================================================
 # Utilities
 # =============================================================================
@@ -132,6 +138,111 @@ def apply_gradient_rule(expr: "Expression", wrt: "Variable") -> "Expression":
     return func(expr, wrt)
 
 
+# =============================================================================
+# Pattern Matching System
+# =============================================================================
+
+
+class VectorExpressionPattern(Enum):
+    """Classification of patterns in gradient expressions for optimization.
+
+    These patterns allow the compiler to generate specialized, high-performance
+    kernels for common vector operations instead of using generic element-wise logic.
+    """
+
+    ZERO = auto()  # Constant(0)
+    CONSTANT = auto()  # c (non-zero)
+    COMPONENT = auto()  # x[i]
+    SCALED_COMPONENT = auto()  # c * x[i]
+    SUM = auto()  # sum(x)
+    SCALED_SUM = auto()  # c * sum(x)
+    L1_NORM = auto()  # ||x||_1
+    L2_NORM = auto()  # ||x||_2
+    DOT_PRODUCT = auto()  # c @ x (linear form)
+    QUADRATIC_FORM = auto()  # x @ Q @ x (quadratic form)
+    UNKNOWN = auto()  # General expression
+
+
+def detect_vector_gradient_pattern(
+    expr: Expression,
+    wrt: Variable | None = None,
+) -> VectorExpressionPattern:
+    """Detect the structural pattern of an expression.
+
+    Identifies standard forms like sums, dot products, and norms that can be
+    optimized by the compiler.
+    """
+    from optyx.core.expressions import BinaryOp, Constant, Variable as Var
+    from optyx.core.matrices import QuadraticForm
+    from optyx.core.vectors import (
+        DotProduct,
+        L1Norm,
+        L2Norm,
+        LinearCombination,
+        VectorSum,
+    )
+
+    # Base cases
+    if isinstance(expr, Constant):
+        return (
+            VectorExpressionPattern.ZERO
+            if expr.value == 0
+            else VectorExpressionPattern.CONSTANT
+        )
+
+    if isinstance(expr, Var):
+        if wrt is not None and expr.name == wrt.name:
+            return VectorExpressionPattern.COMPONENT
+        if wrt is None:
+            # If no variable specified, just treat as component/variable
+            return VectorExpressionPattern.COMPONENT
+        return VectorExpressionPattern.UNKNOWN
+
+    # Vector expressions
+    if isinstance(expr, VectorSum):
+        return VectorExpressionPattern.SUM
+
+    if isinstance(expr, LinearCombination):
+        # Could be DOT_PRODUCT if it represents c @ x
+        # TODO: Refine this check based on coefficients
+        return VectorExpressionPattern.DOT_PRODUCT
+
+    if isinstance(expr, DotProduct):
+        # We classify this as DOT_PRODUCT (linear) unless it's x @ x
+        # If both sides involve variables, it might be quadratic but usually
+        # QuadraticForm is explicitly used for that.
+        return VectorExpressionPattern.DOT_PRODUCT
+
+    if isinstance(expr, L1Norm):
+        return VectorExpressionPattern.L1_NORM
+
+    if isinstance(expr, L2Norm):
+        return VectorExpressionPattern.L2_NORM
+
+    if isinstance(expr, QuadraticForm):
+        return VectorExpressionPattern.QUADRATIC_FORM
+
+    # Binary operations
+    if isinstance(expr, BinaryOp):
+        if expr.op == "*":
+            # Check for c * pattern
+            # c * x, c * sum(x), c * ||x||
+            if isinstance(expr.left, Constant):
+                sub_pattern = detect_vector_gradient_pattern(expr.right, wrt)
+                if sub_pattern == VectorExpressionPattern.COMPONENT:
+                    return VectorExpressionPattern.SCALED_COMPONENT
+                if sub_pattern == VectorExpressionPattern.SUM:
+                    return VectorExpressionPattern.SCALED_SUM
+            elif isinstance(expr.right, Constant):
+                sub_pattern = detect_vector_gradient_pattern(expr.left, wrt)
+                if sub_pattern == VectorExpressionPattern.COMPONENT:
+                    return VectorExpressionPattern.SCALED_COMPONENT
+                if sub_pattern == VectorExpressionPattern.SUM:
+                    return VectorExpressionPattern.SCALED_SUM
+
+    return VectorExpressionPattern.UNKNOWN
+
+
 # =============================================================================
 # Main Gradient Function
 # =============================================================================
@@ -250,13 +361,397 @@ def _estimate_tree_depth(
         return depth
 
 
+# =============================================================================
+# Sparsity Analysis
+# =============================================================================
+
+
+@dataclass
+class SparsityPattern:
+    """Describes which gradient elements are structurally non-zero.
+
+    Enables O(nnz) gradient/Jacobian computation by identifying which
+    variables an expression depends on, without computing values.
+
+    Attributes:
+        nnz_indices: Sorted array of indices (into the variables list) that
+            have non-zero partial derivatives.
+        size: Total number of variables (length of full gradient vector).
+        is_constant: True if all non-zero gradients are constants (e.g. linear expr).
+        constant_values: If is_constant, the non-zero gradient values at nnz_indices.
+            None if gradients are not all constant.
+    """
+
+    nnz_indices: NDArray[np.intp]
+    size: int
+    is_constant: bool
+    constant_values: NDArray[np.floating] | None
+
+    @property
+    def nnz(self) -> int:
+        """Number of structurally non-zero elements."""
+        return len(self.nnz_indices)
+
+    @property
+    def density(self) -> float:
+        """Fraction of non-zero elements (0.0 to 1.0)."""
+        return self.nnz / self.size if self.size > 0 else 0.0
+
+    @property
+    def is_dense(self) -> bool:
+        """True if all elements are non-zero."""
+        return self.nnz == self.size
+
+
+def analyze_gradient_sparsity(
+    expr: Expression,
+    variables: list[Variable],
+) -> SparsityPattern:
+    """Analyze which gradient elements are structurally non-zero.
+
+    Determines which variables the expression depends on by walking the
+    expression tree, then optionally checks if those gradients are constant
+    (for linear expressions).
+
+    Args:
+        expr: The expression to analyze.
+        variables: List of variables defining the gradient vector ordering.
+
+    Returns:
+        SparsityPattern describing which gradient elements are non-zero.
+    """
+    from optyx.core.expressions import Constant, get_all_variables
+
+    n = len(variables)
+    expr_vars = get_all_variables(expr)
+
+    # Build name→index map for the variable list
+    var_index: dict[str, int] = {v.name: i for i, v in enumerate(variables)}
+
+    # Find which variables from the list appear in the expression
+    nnz_list: list[int] = []
+    for v in expr_vars:
+        idx = var_index.get(v.name)
+        if idx is not None:
+            nnz_list.append(idx)
+
+    nnz_indices = np.array(sorted(nnz_list), dtype=np.intp)
+
+    # Check if all non-zero gradients are constant (linear expression)
+    is_constant = False
+    constant_values = None
+
+    if len(nnz_indices) > 0:
+        # Fast path: if the expression is linear (degree <= 1), all gradients
+        # are guaranteed constant.
+        if expr.is_linear():
+            is_constant = True
+            # Use extract_all_linear_coefficients for O(n) single-pass extraction
+            # instead of n separate gradient computations
+            from optyx.analysis import extract_all_linear_coefficients
+
+            var_index_map: dict[str, int] = {v.name: i for i, v in enumerate(variables)}
+            try:
+                full_coeffs = extract_all_linear_coefficients(expr, var_index_map, n)
+                constant_values = full_coeffs[nnz_indices]
+            except Exception:
+                # Fallback: compute gradients individually
+                const_vals: list[float] = []
+                for idx in nnz_indices:
+                    g = gradient(expr, variables[idx])
+                    if isinstance(g, Constant):
+                        const_vals.append(float(g.value))
+                    elif not g.get_variables():
+                        const_vals.append(float(g.evaluate({})))
+                    else:
+                        is_constant = False
+                        break
+                if is_constant:
+                    constant_values = np.array(const_vals, dtype=np.float64)
+        else:
+            # For non-linear expressions, only check constancy for sparse rows
+            # (dense non-linear rows won't benefit from constant detection)
+            if len(nnz_indices) < n:
+                const_vals = []
+                all_constant = True
+                for idx in nnz_indices:
+                    g = gradient(expr, variables[idx])
+                    if isinstance(g, Constant):
+                        const_vals.append(float(g.value))
+                    elif not g.get_variables():
+                        const_vals.append(float(g.evaluate({})))
+                    else:
+                        all_constant = False
+                        break
+                if all_constant:
+                    is_constant = True
+                    constant_values = np.array(const_vals, dtype=np.float64)
+
+    return SparsityPattern(
+        nnz_indices=nnz_indices,
+        size=n,
+        is_constant=is_constant,
+        constant_values=constant_values,
+    )
+
+
+def analyze_jacobian_sparsity(
+    exprs: list[Expression],
+    variables: list[Variable],
+) -> list[SparsityPattern]:
+    """Analyze the sparsity structure of the full Jacobian matrix.
+
+    Returns per-row sparsity patterns describing which columns of each
+    Jacobian row are structurally non-zero.
+
+    Args:
+        exprs: List of m expressions (rows of the Jacobian).
+        variables: List of n variables (columns of the Jacobian).
+
+    Returns:
+        List of m SparsityPattern objects, one per row.
+    """
+    return [analyze_gradient_sparsity(expr, variables) for expr in exprs]
+
+
+@dataclass
+class VectorGradientPattern:
+    """Represents a gradient of the form ∇f(x) = Ax + b.
+
+    Used for vectorized compilation of gradients for:
+    - Linear combinations (A=None, b=c)
+    - Quadratic forms (A=Q+Q', b=0)
+    - Dot products (A=2I, b=0)
+    """
+
+    linear_term: NDArray[np.floating] | None  # A matrix (n×n)
+    constant_term: NDArray[np.floating] | None  # b vector (n,)
+    vector: Any  # VectorVariable (Any to avoid circular import issues)
+    # Structured metadata to avoid O(n²) diagonal detection in compile_vector_gradient
+    # "scaled_identity" | "diagonal" | "general" | None (when linear_term is None)
+    linear_type: str | None = None
+    linear_scale: float = 0.0  # For scaled_identity: the scale factor
+    linear_diag: NDArray[np.floating] | None = None  # For diagonal: diagonal values
+
+
+def detect_affine_gradient_pattern(
+    expr: Expression,
+) -> VectorGradientPattern | None:
+    """Detect if an expression has a vectorizable gradient pattern: ∇f(x) = Ax + b.
+
+    This enables O(1) compilation of gradients for common patterns like quadratic
+    forms, dot products, and linear combinations, entirely bypassing the
+    potentially large expression tree.
+
+    Args:
+        expr: The expression to analyze.
+
+    Returns:
+        VectorGradientPattern if detected, None otherwise.
+    """
+    from optyx.core.expressions import BinaryOp, Constant
+    from optyx.core.vectors import (
+        LinearCombination,
+        VectorSum,
+        DotProduct,
+        VectorVariable,
+    )
+    from optyx.core.matrices import QuadraticForm
+
+    # Case: c @ x  => grad = c (A=None, b=c)
+    if isinstance(expr, LinearCombination):
+        if isinstance(expr.vector, VectorVariable):
+            return VectorGradientPattern(
+                linear_term=None,
+                constant_term=expr.coefficients,
+                vector=expr.vector,
+            )
+
+    # Case: sum(x) => grad = ones (A=None, b=1)
+    if isinstance(expr, VectorSum):
+        if isinstance(expr.vector, VectorVariable):
+            return VectorGradientPattern(
+                linear_term=None,
+                constant_term=np.ones(expr.vector.size),
+                vector=expr.vector,
+            )
+
+    # Case: x.dot(x) => grad = 2*x (A=2I, b=None)
+    if isinstance(expr, DotProduct):
+        if isinstance(expr.left, VectorVariable) and expr.left is expr.right:
+            return VectorGradientPattern(
+                linear_term=None,
+                constant_term=None,
+                vector=expr.left,
+                linear_type="scaled_identity",
+                linear_scale=2.0,
+            )
+
+    # Case: QuadraticForm(x, Q) => grad = (Q + Q.T)x (A=Q+Q', b=None)
+    if isinstance(expr, QuadraticForm) and isinstance(expr.vector, VectorVariable):
+        Q = expr.matrix
+        A = Q + Q.T
+        return VectorGradientPattern(
+            linear_term=A,
+            constant_term=None,
+            vector=expr.vector,
+            linear_type="general",
+        )
+
+    # Recursive combinations
+    if isinstance(expr, BinaryOp):
+        # f + g, f - g
+        if expr.op in ("+", "-"):
+            p1 = detect_affine_gradient_pattern(expr.left)
+            # Handle Pattern + Constant (grad is Pattern)
+            if p1 and isinstance(expr.right, Constant):
+                return p1
+            # Handle Constant + Pattern (grad is Pattern)
+            if isinstance(expr.left, Constant):
+                p2 = detect_affine_gradient_pattern(expr.right)
+                if p2:
+                    if expr.op == "+":
+                        return p2
+                    else:  # Constant - Pattern
+                        return _negate_pattern(p2)
+
+            p2 = detect_affine_gradient_pattern(expr.right)
+            if p1 and p2:
+                # Must be w.r.t the same vector
+                if p1.vector.name == p2.vector.name:
+                    return _combine_patterns(p1, p2, expr.op)
+
+        # c * f
+        if expr.op == "*":
+            # Constant * Pattern
+            if isinstance(expr.left, Constant):
+                p2 = detect_affine_gradient_pattern(expr.right)
+                if p2:
+                    return _scale_pattern(p2, float(expr.left.value))
+            # Pattern * Constant
+            if isinstance(expr.right, Constant):
+                p1 = detect_affine_gradient_pattern(expr.left)
+                if p1:
+                    return _scale_pattern(p1, float(expr.right.value))
+
+    return None
+
+
+def _combine_patterns(
+    p1: VectorGradientPattern, p2: VectorGradientPattern, op: str
+) -> VectorGradientPattern:
+    """Combine two patterns (A1, b1) and (A2, b2)."""
+    # Combine constant terms (always O(n) at most)
+    if op == "+":
+        b = _safe_add(p1.constant_term, p2.constant_term)
+    else:
+        b = _safe_sub(p1.constant_term, p2.constant_term)
+
+    # Fast path: combine structured linear terms without materializing O(n²) matrices
+    lt1 = p1.linear_type
+    lt2 = p2.linear_type
+
+    if lt1 is None and lt2 is None:
+        # Both have no linear term
+        return VectorGradientPattern(None, b, p1.vector)
+
+    if lt1 == "scaled_identity" and lt2 == "scaled_identity":
+        s1 = p1.linear_scale
+        s2 = p2.linear_scale if op == "+" else -p2.linear_scale
+        return VectorGradientPattern(None, b, p1.vector, "scaled_identity", s1 + s2)
+
+    if lt1 is None and lt2 == "scaled_identity":
+        s2 = p2.linear_scale if op == "+" else -p2.linear_scale
+        return VectorGradientPattern(None, b, p1.vector, "scaled_identity", s2)
+
+    if lt1 == "scaled_identity" and lt2 is None:
+        return VectorGradientPattern(
+            None, b, p1.vector, "scaled_identity", p1.linear_scale
+        )
+
+    # General case: materialize and combine (O(n²) for general matrices)
+    if op == "+":
+        A = _safe_add(_materialize_linear(p1), _materialize_linear(p2))
+    else:
+        A = _safe_sub(_materialize_linear(p1), _materialize_linear(p2))
+
+    return VectorGradientPattern(A, b, p1.vector, "general" if A is not None else None)
+
+
+def _safe_add(
+    t1: NDArray[np.floating] | None, t2: NDArray[np.floating] | None
+) -> NDArray[np.floating] | None:
+    if t1 is None and t2 is None:
+        return None
+    if t1 is None:
+        return t2
+    if t2 is None:
+        return t1
+    return t1 + t2
+
+
+def _safe_sub(
+    t1: NDArray[np.floating] | None, t2: NDArray[np.floating] | None
+) -> NDArray[np.floating] | None:
+    if t1 is None and t2 is None:
+        return None
+    if t1 is None:  # 0 - t2
+        return -t2 if t2 is not None else None
+    if t2 is None:  # t1 - 0
+        return t1
+    return t1 - t2
+
+
+def _materialize_linear(p: VectorGradientPattern) -> NDArray[np.floating] | None:
+    """Get the full linear_term matrix, materializing from metadata if needed."""
+    if p.linear_term is not None:
+        return p.linear_term
+    if p.linear_type == "scaled_identity":
+        n = p.vector.size
+        return np.eye(n) * p.linear_scale
+    if p.linear_type == "diagonal" and p.linear_diag is not None:
+        return np.diag(p.linear_diag)
+    return None
+
+
+def _negate_pattern(p: VectorGradientPattern) -> VectorGradientPattern:
+    """Return new pattern negated."""
+    A = -p.linear_term if p.linear_term is not None else None
+    b = -p.constant_term if p.constant_term is not None else None
+    lt = p.linear_type
+    ls = -p.linear_scale
+    ld = -p.linear_diag if p.linear_diag is not None else None
+    return VectorGradientPattern(A, b, p.vector, lt, ls, ld)
+
+
+def _scale_pattern(p: VectorGradientPattern, c: float) -> VectorGradientPattern:
+    """Return new pattern scaled by c."""
+    A = c * p.linear_term if p.linear_term is not None else None
+    b = c * p.constant_term if p.constant_term is not None else None
+    lt = p.linear_type
+    ls = c * p.linear_scale
+    ld = c * p.linear_diag if p.linear_diag is not None else None
+    return VectorGradientPattern(A, b, p.vector, lt, ls, ld)
+
+
+# Backward-compatible alias for the previous internal name.
+AffineGradientPattern = VectorGradientPattern
+
+
 @lru_cache(maxsize=4096)
 def _gradient_cached(expr: Expression, wrt: Variable) -> Expression:
     """Cached recursive gradient computation.
 
     Used for shallow expression trees where recursion is safe and fast.
     """
-    from optyx.core.expressions import BinaryOp, Constant, UnaryOp, Variable as Var
+    from optyx.core.expressions import (
+        BinaryOp,
+        Constant,
+        NaryProduct,
+        NarySum,
+        UnaryOp,
+        Variable as Var,
+    )
     from optyx.core.functions import cos, sin, log, cosh, sinh
     from optyx.core.parameters import Parameter
 
@@ -460,6 +955,38 @@ def _gradient_cached(expr: Expression, wrt: Variable) -> Expression:
                 context="gradient computation (unary)",
             )
 
+    # N-ary operations
+    if isinstance(expr, NarySum):
+        # d/dx(a + b + c + ...) = da + db + dc + ...
+        # Collect non-zero gradients and return flat NarySum
+        grads: list[Expression] = []
+        for term in expr.terms:
+            g = _gradient_cached(term, wrt)
+            if not _is_zero(g):
+                grads.append(g)
+        if len(grads) == 0:
+            return Constant(0.0)
+        if len(grads) == 1:
+            return grads[0]
+        if len(grads) == 2:
+            return grads[0] + grads[1]
+        return NarySum(tuple(grads))
+
+    if isinstance(expr, NaryProduct):
+        # Generalized product rule:
+        # d/dx(a * b * c) = da*b*c + a*db*c + a*b*dc
+        factors = expr.factors
+        result = Constant(0.0)
+        for i, factor in enumerate(factors):
+            d_factor = _gradient_cached(factor, wrt)
+            # Build product of all other factors
+            other_product: Expression = Constant(1.0)
+            for j, other in enumerate(factors):
+                if j != i:
+                    other_product = _simplify_mul(other_product, other)
+            result = _simplify_add(result, _simplify_mul(d_factor, other_product))
+        return result
+
     raise InvalidExpressionError(
         expr_type=type(expr),
         context="gradient computation",
@@ -488,7 +1015,14 @@ def _gradient_iterative(expr: Expression, wrt: Variable) -> Expression:
     Returns:
         The gradient expression.
     """
-    from optyx.core.expressions import BinaryOp, Constant, UnaryOp, Variable as Var
+    from optyx.core.expressions import (
+        BinaryOp,
+        Constant,
+        NaryProduct,
+        NarySum,
+        UnaryOp,
+        Variable as Var,
+    )
     from optyx.core.functions import cos, sin, log, cosh, sinh
     from optyx.core.parameters import Parameter
 
@@ -655,6 +1189,55 @@ def _gradient_iterative(expr: Expression, wrt: Variable) -> Expression:
                 )
             continue
 
+        # N-ary operations
+        if isinstance(current, NarySum):
+            if phase == 0:
+                # Check if all children computed
+                all_done = all(id(t) in results for t in current.terms)
+                if not all_done:
+                    stack.append((current, 1, []))
+                    for t in reversed(current.terms):
+                        if id(t) not in results:
+                            stack.append((t, 0, []))
+                    continue
+            # Collect non-zero gradients and return flat NarySum
+            grads: list[Expression] = []
+            for t in current.terms:
+                g = results[id(t)]
+                if not _is_zero(g):
+                    grads.append(g)
+            if len(grads) == 0:
+                results[node_id] = Constant(0.0)
+            elif len(grads) == 1:
+                results[node_id] = grads[0]
+            elif len(grads) == 2:
+                results[node_id] = grads[0] + grads[1]
+            else:
+                results[node_id] = NarySum(tuple(grads))
+            continue
+
+        if isinstance(current, NaryProduct):
+            if phase == 0:
+                all_done = all(id(f) in results for f in current.factors)
+                if not all_done:
+                    stack.append((current, 1, []))
+                    for f in reversed(current.factors):
+                        if id(f) not in results:
+                            stack.append((f, 0, []))
+                    continue
+            # Generalized product rule
+            factors = current.factors
+            grad = Constant(0.0)
+            for i, factor in enumerate(factors):
+                d_factor = results[id(factor)]
+                other_product: Expression = Constant(1.0)
+                for j, other in enumerate(factors):
+                    if j != i:
+                        other_product = _simplify_mul(other_product, other)
+                grad = _simplify_add(grad, _simplify_mul(d_factor, other_product))
+            results[node_id] = grad
+            continue
+
         raise InvalidExpressionError(
             expr_type=type(current),
             context="iterative gradient computation",
@@ -683,6 +1266,7 @@ def _register_vector_gradient_rules() -> None:
         L1Norm,
         L2Norm,
         LinearCombination,
+        VectorBinaryOp,
         VectorSum,
         VectorVariable,
         VectorPowerSum,
@@ -691,6 +1275,76 @@ def _register_vector_gradient_rules() -> None:
     )
     from optyx.core.matrices import QuadraticForm
 
+    @register_gradient(VectorBinaryOp)
+    def gradient_vector_binary_op(expr: VectorBinaryOp, wrt: Variable) -> Expression:
+        """Gradient for sum(VectorBinaryOp) delegated from VectorExpressionSum.
+
+        Computes ∂(Σ(l_i op r_i))/∂x without materializing N BinaryOp nodes.
+
+        For VectorVariable operands, this is O(1) via name lookup.
+        Returns the summed gradient as a scalar Expression, or None to
+        signal fallback to per-element differentiation.
+
+        Derivative rules:
+            sum(l + r): ∂/∂x = count(x in l) + count(x in r)  → 0 or 1
+            sum(l - r): ∂/∂x = +1 if x in l, -1 if x in r
+            sum(c * x): ∂/∂x_i = c
+            sum(x * y): ∂/∂x_i = y_i  (not constant, fall back)
+            sum(x / c): ∂/∂x_i = 1/c
+        """
+        left = expr.left
+        right = expr.right
+        op = expr.op
+
+        def _var_in_vector(v: Variable, vec: object) -> bool:
+            if isinstance(vec, VectorVariable):
+                return any(var.name == v.name for var in vec._variables)
+            if hasattr(vec, "get_variables"):
+                return v in cast(_VariableContainer, vec).get_variables()
+            return False
+
+        in_left = _var_in_vector(wrt, left)
+        in_right = _var_in_vector(wrt, right)
+
+        if not in_left and not in_right:
+            return Constant(0.0)
+
+        # Fast O(1) rules only apply when operands are simple
+        # (VectorVariable or scalar). For nested vector expressions,
+        # fall back to per-element differentiation.
+        left_simple = isinstance(left, (VectorVariable, int, float))
+        right_simple = isinstance(right, (VectorVariable, int, float))
+        if not (left_simple and right_simple):
+            return None  # type: ignore[return-value]
+
+        if op == "+":
+            val = (1.0 if in_left else 0.0) + (1.0 if in_right else 0.0)
+            return Constant(val)
+
+        elif op == "-":
+            val = (1.0 if in_left else 0.0) - (1.0 if in_right else 0.0)
+            return Constant(val)
+
+        elif op == "*":
+            if isinstance(right, (int, float)):
+                # sum(x * c): ∂/∂x_i = c
+                return Constant(float(right)) if in_left else Constant(0.0)
+            if isinstance(left, (int, float)):
+                # sum(c * x): ∂/∂x_i = c
+                return Constant(float(left)) if in_right else Constant(0.0)
+            # sum(x * y) where both are vectors: ∂/∂x_i = y_i (not constant)
+            return None  # type: ignore[return-value]
+
+        elif op == "/":
+            if isinstance(right, (int, float)):
+                # sum(x / c): ∂/∂x_i = 1/c
+                return Constant(1.0 / float(right)) if in_left else Constant(0.0)
+            # sum(x / y): needs runtime values, fall back
+            return None  # type: ignore[return-value]
+
+        # Unrecognized op — fall back
+        return None  # type: ignore[return-value]
+
     @register_gradient(LinearCombination)
     def gradient_linear_combination(
         expr: LinearCombination, wrt: Variable
@@ -747,9 +1401,24 @@ def gradient_vector_expression_sum(
 
         For sum(expr) = f_0 + f_1 + ... + f_{n-1}:
         The gradient is the sum of the gradients of each element.
+
+        For VectorBinaryOp, delegates to the VectorBinaryOp gradient rule
+        which avoids O(N) materialization for simple patterns.
         """
+        from optyx.core.vectors import VectorBinaryOp
+
+        inner = expr.expression
+        if isinstance(inner, VectorBinaryOp) and has_gradient_rule(inner):  # type: ignore[arg-type]
+            # Each element's gradient w.r.t. wrt is the same as
+            # differentiating the VectorBinaryOp then summing.
+            # The VectorBinaryOp gradient rule returns per-element
+            # gradient expressions; we sum them.
+            elem_grad = apply_gradient_rule(inner, wrt)  # type: ignore[arg-type]
+            if elem_grad is not None:
+                return elem_grad
+
         result: Expression = Constant(0.0)
-        for elem in expr.expression._expressions:
+        for elem in inner._expressions:
             d_elem = gradient(elem, wrt)
             result = _simplify_add(result, d_elem)
         return result
@@ -1160,8 +1829,163 @@ def compute_hessian(
         The Hessian is symmetric, so H[i][j] = H[j][i].
         We compute the full matrix but could optimize by exploiting symmetry.
     """
+    # Imports inside function to avoid circular dependencies
+    from optyx.core.matrices import QuadraticForm
+    from optyx.core.vectors import (
+        DotProduct,
+        LinearCombination,
+        VectorSum,
+        VectorVariable,
+    )
+    from optyx.core.expressions import Constant, BinaryOp
+
     n = len(variables)
-    hessian: list[list[Expression]] = []
+
+    # Optimization 0: Linear Forms have Zero Hessian
+    # d/dx( c.x ) = c (constant), d/dx( c ) = 0
+    # Only applies if the vector components are variables (linear)
+    if isinstance(expr, (LinearCombination, VectorSum)) and isinstance(
+        expr.vector, VectorVariable
+    ):
+        # reuse ZERO for memory
+        ZERO = Constant(0.0)
+        return [[ZERO for _ in range(n)] for _ in range(n)]
+
+    # Optimization 1: QuadraticForm(x, Q) -> Hessian = Q + Q.T
+    # This avoids symbolic differentiation of the linear gradient (Q+Q.T)x
+    if isinstance(expr, QuadraticForm) and isinstance(expr.vector, VectorVariable):
+        # Map variable names to indices in the vector x
+        # This allows us to handle cases where 'variables' is a superset or subset of x
+        var_to_idx = {v.name: i for i, v in enumerate(expr.vector)}
+
+        Q = expr.matrix
+        # Hessian of x'Qx is Q + Q'
+        H_val = Q + Q.T
+
+        # Cache 0.0 constant to avoid creating O(N^2) objects
+        ZERO = Constant(0.0)
+
+        hessian: list[list[Expression]] = []
+        for v1 in variables:
+            row: list[Expression] = []
+            idx1 = var_to_idx.get(v1.name)
+            for v2 in variables:
+                idx2 = var_to_idx.get(v2.name)
+
+                if idx1 is not None and idx2 is not None:
+                    # Both variables are in the quadratic form vector
+                    val = float(H_val[idx1, idx2])
+                    if val == 0.0:
+                        row.append(ZERO)
+                    else:
+                        row.append(Constant(val))
+                else:
+                    # Partial derivative wrt a variable not in the form is 0
+                    row.append(ZERO)
+            hessian.append(row)
+        return hessian
+
+    # Optimization 2: DotProduct(x, x) -> Hessian = 2*I
+    if isinstance(expr, DotProduct):
+        # Check if left and right are the same VectorVariable
+        same_vector = (expr.left is expr.right) or (
+            isinstance(expr.left, VectorVariable)
+            and isinstance(expr.right, VectorVariable)
+            and expr.left.name == expr.right.name
+        )
+
+        if same_vector and isinstance(expr.left, VectorVariable):
+            var_to_idx = {v.name: i for i, v in enumerate(expr.left)}
+
+            # Cache constants
+            ZERO = Constant(0.0)
+            TWO = Constant(2.0)
+
+            hessian = []
+            for v1 in variables:
+                row = []
+                idx1 = var_to_idx.get(v1.name)
+                for v2 in variables:
+                    idx2 = var_to_idx.get(v2.name)
+
+                    if idx1 is not None and idx2 is not None:
+                        # 2 * delta_ij
+                        row.append(TWO if idx1 == idx2 else ZERO)
+                    else:
+                        row.append(ZERO)
+                hessian.append(row)
+            return hessian
+
+    # Optimization 3: Binary Operations (+, -, *)
+    if isinstance(expr, BinaryOp):
+        from optyx.core.expressions import BinaryOp
+
+        # Helper to check if node is constant 0.0
+        def is_zero(node: Expression) -> bool:
+            return isinstance(node, Constant) and node.value == 0.0
+
+        if expr.op in ("+", "-"):
+            # H(f +/- g) = H(f) +/- H(g)
+            H1 = compute_hessian(expr.left, variables)
+            H2 = compute_hessian(expr.right, variables)
+
+            hessian = []
+            for i in range(n):
+                row = []
+                for j in range(n):
+                    val1 = H1[i][j]
+                    val2 = H2[i][j]
+
+                    # Optimizations: 0 + x = x, x + 0 = x
+                    if is_zero(val1):
+                        if expr.op == "+":
+                            row.append(val2)
+                        else:  # 0 - val2
+                            # If val2 is constant, negate it directly
+                            if isinstance(val2, Constant):
+                                row.append(Constant(-val2.value))
+                            else:
+                                row.append(BinaryOp(Constant(0.0), val2, "-"))
+                    elif is_zero(val2):
+                        row.append(val1)  # val1 + 0 = val1, val1 - 0 = val1
+                    elif isinstance(val1, Constant) and isinstance(val2, Constant):
+                        v1 = val1.value
+                        v2 = val2.value
+                        res = v1 + v2 if expr.op == "+" else v1 - v2
+                        row.append(Constant(res))
+                    else:
+                        row.append(BinaryOp(val1, val2, expr.op))
+                hessian.append(row)
+            return hessian
+
+        elif expr.op == "*":
+            # H(c * f) = c * H(f) (if c is constant)
+            c_val = None
+            sub_expr = None
+
+            if isinstance(expr.left, Constant):
+                c_val = expr.left
+                sub_expr = expr.right
+            elif isinstance(expr.right, Constant):
+                c_val = expr.right
+                sub_expr = expr.left
+
+            if c_val is not None and sub_expr is not None:
+                H_sub = compute_hessian(sub_expr, variables)
+                hessian = []
+                for i in range(n):
+                    row = []
+                    for j in range(n):
+                        val = H_sub[i][j]
+                        if isinstance(val, Constant):
+                            # Pre-compute constant product
+                            row.append(Constant(c_val.value * val.value))
+                        else:
+                            row.append(BinaryOp(c_val, val, "*"))
+                    hessian.append(row)
+                return hessian
+
+    hessian = []
 
     # First compute the gradient
     grad = [gradient(expr, var) for var in variables]
@@ -1177,42 +2001,17 @@ def compute_hessian(
     return hessian
 
 
-def _is_scaled_variable_pattern(
-    jacobian_row: list[Expression],
-    variables: list[Variable],
-) -> tuple[NDArray[Any] | float | int, bool] | None:
-    """Check if a Jacobian row is c*x[i] for all variables.
-
-    For DotProduct(x, x), gradient is 2*x[i] for each x[i].
-    We can compile this as: lambda x: c * x
-
-    Returns:
-        (scale, match) tuple if all elements are c*var[i], None otherwise.
-    """
-    from optyx.core.expressions import Constant, BinaryOp
-
-    if len(jacobian_row) != len(variables):
-        return None
-
-    scale = None
-    for i, (expr, var) in enumerate(zip(jacobian_row, variables)):
-        # Check for pattern: Constant(c) * Variable(var)
-        if isinstance(expr, BinaryOp) and expr.op == "*":
-            if isinstance(expr.left, Constant) and expr.right is var:
-                c = expr.left.value
-            elif isinstance(expr.right, Constant) and expr.left is var:
-                c = expr.right.value
-            else:
-                return None
-
-            if scale is None:
-                scale = c
-            elif scale != c:
-                return None  # Different scales, not uniform
-        else:
-            return None
-
-    return (scale, True) if scale is not None else None
+def _eval_sparse_row(
+    x: NDArray[np.floating],
+    funcs: list[Callable],
+    nnz_indices: NDArray[np.intp],
+    size: int,
+) -> NDArray[np.floating]:
+    """Evaluate a sparse Jacobian row: only compute non-zero columns."""
+    result = np.zeros(size, dtype=np.float64)
+    for k, idx in enumerate(nnz_indices):
+        result[idx] = funcs[k](x)
+    return result
 
 
 def compile_jacobian(
@@ -1229,15 +2028,15 @@ def compile_jacobian(
         A callable that takes a 1D array and returns the Jacobian as a 2D array.
 
     Performance:
-        - For VectorPowerSum/VectorUnarySum, uses O(1) numpy vectorized gradients.
-        - For linear expressions where all Jacobian elements are constants,
-          returns a pre-computed array directly (9.7x speedup vs element-by-element).
-        - For DotProduct(x, x) pattern (gradient = c*x), uses vectorized NumPy.
+        - Checks for vector patterns (O(1)) per row.
+        - Checks for constant rows (O(1)).
+        - Batches execution per row (m calls instead of m*n).
     """
     import numpy as np
     from optyx.core.compiler import (
         compile_expression,
         _sanitize_derivatives,
+        compile_vector_gradient,
         _compile_vectorized_power_gradient,
         _compile_vectorized_unary_gradient,
     )
@@ -1246,75 +2045,321 @@ def compile_jacobian(
 
     m = len(exprs)
     n = len(variables)
+    row_fns = []
+
+    for i in range(m):
+        expr = exprs[i]
+
+    # Check if ALL rows are constant, for global optimization
+    # This restores the optimization tested by test_constant_jacobian_returns_same_object
+    # We detect this during row construction
+
+    # Store processed rows to check if we can build a full constant matrix later
+    processed_rows = []
+
+    for i in range(m):
+        expr = exprs[i]
+
+        # 1. Try vector gradient pattern (linear/quadratic => O(1) compile)
+        pattern_fn = compile_vector_gradient(expr, variables)
+        if pattern_fn is not None:
+            # Check if this pattern is actually constant (A=0, b!=None)
+            # Actually, compile_vector_gradient returns a function.
+            # We can't easily introspect it without evaluating or checking the pattern object again.
+            # But the row_fn logic handles it.
+            # If we want global constant optimization, we might need a separate pass or flag.
+
+            # For simplicity, let's keep the row_batching logic which is strictly better for performance generally,
+            # EXCEPT for the specific identity check test case.
+            # But wait, purely constant Jacobian is a very common case (Linear Programming).
+            # Returning a single object is much faster than running m row functions.
+            row_fns.append(pattern_fn)
+            processed_rows.append(None)  # Not explicitly constant data
+            continue
 
-    # Fast path 0: Single VectorPowerSum or VectorUnarySum - use vectorized gradient
-    if m == 1:
-        expr = exprs[0]
+        # 1.5 Try specialized vectorized gradients
         if isinstance(expr, VectorPowerSum):
             grad_fn = _compile_vectorized_power_gradient(expr, variables)
-
-            def power_jacobian_fn(x):
-                return grad_fn(x).reshape(1, -1)
-
-            return power_jacobian_fn
+            row_fns.append(grad_fn)
+            processed_rows.append(None)
+            continue
 
         if isinstance(expr, VectorUnarySum):
             grad_fn = _compile_vectorized_unary_gradient(expr, variables)
+            row_fns.append(grad_fn)
+            processed_rows.append(None)
+            continue
 
-            def unary_jacobian_fn(x):
-                return grad_fn(x).reshape(1, -1)
+        # 2. Use sparsity analysis to avoid redundant gradient computation
+        sparsity = analyze_gradient_sparsity(expr, variables)
 
-            return unary_jacobian_fn
+        # 2a. If sparsity analysis found constant gradients, use them directly
+        if sparsity.is_constant:
+            vals = np.zeros(n, dtype=np.float64)
+            if sparsity.constant_values is not None:
+                vals[sparsity.nnz_indices] = sparsity.constant_values
+            row_fns.append(lambda x, v=vals: v)
+            processed_rows.append(vals)
+            continue
 
-    jacobian_exprs = compute_jacobian(exprs, variables)
+        # 2b. Compute symbolic derivatives only for non-zero columns
+        if sparsity.nnz < n:
+            # Sparse row: only differentiate w.r.t. variables that appear
+            nnz_idx = sparsity.nnz_indices
+            sparse_row = [gradient(expr, variables[j]) for j in nnz_idx]
+
+            # Check if all computed gradients are constant
+            if all(isinstance(e, Constant) for e in sparse_row):
+                vals = np.zeros(n, dtype=np.float64)
+                for k, j in enumerate(nnz_idx):
+                    vals[j] = float(cast(Constant, sparse_row[k]).value)
+                row_fns.append(lambda x, v=vals: v)
+                processed_rows.append(vals)
+                continue
 
-    # Fast path 1: All Jacobian elements are constants - pre-compute once
-    all_constant = all(
-        isinstance(jacobian_exprs[i][j], Constant) for i in range(m) for j in range(n)
-    )
+            # Compile only non-zero columns, fill zeros for the rest
+            compiled_sparse = [compile_expression(e, variables) for e in sparse_row]
+            row_fns.append(
+                lambda x, funcs=compiled_sparse, idx=nnz_idx, sz=n: _eval_sparse_row(
+                    x, funcs, idx, sz
+                )
+            )
+            processed_rows.append(None)
+            continue
 
-    if all_constant:
-        # Pre-compute constant Jacobian matrix
-        const_jac = np.array(
-            [
-                [cast(Constant, jacobian_exprs[i][j]).value for j in range(n)]
-                for i in range(m)
-            ],
-            dtype=np.float64,
+        # 2c. Dense row: compute all symbolic derivatives
+        if hasattr(expr, "jacobian_row"):
+            row = expr.jacobian_row(variables)
+            if row is None:
+                row = [gradient(expr, v) for v in variables]
+        else:
+            row = [gradient(expr, v) for v in variables]
+
+        # 3. Check for Constant row (fast, O(1) execute)
+        if all(isinstance(e, Constant) for e in row):
+            vals = np.array([cast(Constant, e).value for e in row], dtype=np.float64)
+            # Use closure to capture vals
+            row_fns.append(lambda x, v=vals: v)
+            processed_rows.append(vals)
+            continue
+
+        # 4. Fallback: Compile scalar expressions
+        compiled_cols = [compile_expression(e, variables) for e in row]
+        row_fns.append(
+            lambda x, funcs=compiled_cols: np.array(
+                [f(x) for f in funcs], dtype=np.float64
+            )
         )
+        processed_rows.append(None)
+
+    # Global optimization: If all rows were identified as constant arrays
+    if all(r is not None for r in processed_rows):
+        # We can construct the full constant matrix once
+        const_jac = np.array(processed_rows, dtype=np.float64)
 
         def constant_jacobian_fn(x):
             return const_jac
 
         return constant_jacobian_fn
 
-    # Fast path 2: Single row with c*x[i] pattern (e.g., gradient of x.dot(x) = 2*x)
-    if m == 1:
-        pattern = _is_scaled_variable_pattern(jacobian_exprs[0], variables)
-        if pattern is not None:
-            scale, _ = pattern
-
-            def scaled_variable_jacobian_fn(x):
-                return (scale * x).reshape(1, -1)
-
-            return scaled_variable_jacobian_fn
-
-    # Standard path: compile each element
-    compiled_elements = [
-        [compile_expression(jacobian_exprs[i][j], variables) for j in range(n)]
-        for i in range(m)
-    ]
-
     def jacobian_fn(x):
-        result = np.zeros((m, n))
+        result = np.empty((m, n))
         for i in range(m):
-            for j in range(n):
-                result[i, j] = compiled_elements[i][j](x)
+            result[i, :] = row_fns[i](x)
         return _sanitize_derivatives(result)
 
     return jacobian_fn
 
 
+def compile_sparse_jacobian(
+    exprs: list[Expression],
+    variables: list[Variable],
+    density_threshold: float = 0.5,
+):
+    """Compile the Jacobian for fast evaluation, returning sparse output.
+
+    For sparse constraint systems (nnz << m*n), returns scipy.sparse.csr_matrix
+    with O(nnz) memory instead of O(m*n).  Falls back to dense for high-density
+    Jacobians.
+
+    Args:
+        exprs: List of expressions (rows of the Jacobian).
+        variables: List of variables (columns of the Jacobian).
+        density_threshold: If overall Jacobian density exceeds this, fall
+            back to the dense compile_jacobian (default 0.5).
+
+    Returns:
+        A callable that takes a 1D array and returns the Jacobian.
+        Output is scipy.sparse.csr_matrix for sparse problems, or a dense
+        2D ndarray for high-density problems.
+    """
+    import numpy as np
+    from scipy.sparse import csr_matrix
+    from optyx.core.compiler import compile_expression
+    from optyx.core.expressions import Constant
+
+    m = len(exprs)
+    n = len(variables)
+
+    if m == 0 or n == 0:
+        empty = csr_matrix((m, n), dtype=np.float64)
+        return lambda x, _e=empty: _e
+
+    # Analyze sparsity for all rows
+    row_sparsities = analyze_jacobian_sparsity(exprs, variables)
+
+    total_nnz = sum(sp.nnz for sp in row_sparsities)
+    density = total_nnz / (m * n) if m * n > 0 else 1.0
+
+    # Fall back to dense if overall density is high
+    if density > density_threshold:
+        return compile_jacobian(exprs, variables)
+
+    # Build sparse Jacobian compilation
+    # For each row we determine: constant, variable-sparse, or needs full computation
+    # Then at eval time we assemble COO-style data and convert to CSR.
+
+    # Pre-compute constant rows and compile variable rows
+    row_infos: list[dict] = []
+
+    for i in range(m):
+        sp = row_sparsities[i]
+
+        if sp.is_constant:
+            # Constant row — data known at compile time
+            if sp.nnz == 0 or sp.constant_values is None:
+                row_infos.append({"type": "zero"})
+            else:
+                row_infos.append(
+                    {
+                        "type": "constant",
+                        "cols": sp.nnz_indices.copy(),
+                        "vals": sp.constant_values.copy(),
+                    }
+                )
+            continue
+
+        if sp.nnz == 0:
+            row_infos.append({"type": "zero"})
+            continue
+
+        # Variable sparse row: compile only non-zero partials
+        nnz_idx = sp.nnz_indices
+        grad_exprs = [gradient(exprs[i], variables[j]) for j in nnz_idx]
+
+        # Double-check if computed gradients turned out constant
+        if all(isinstance(e, Constant) for e in grad_exprs):
+            vals = np.array(
+                [float(cast(Constant, e).value) for e in grad_exprs], dtype=np.float64
+            )
+            row_infos.append(
+                {
+                    "type": "constant",
+                    "cols": nnz_idx.copy(),
+                    "vals": vals,
+                }
+            )
+            continue
+
+        compiled_fns = [compile_expression(e, variables) for e in grad_exprs]
+        row_infos.append(
+            {
+                "type": "variable",
+                "cols": nnz_idx.copy(),
+                "fns": compiled_fns,
+            }
+        )
+
+    # Check if ALL rows are constant — pre-build the entire matrix
+    if all(info["type"] in ("constant", "zero") for info in row_infos):
+        # Build the constant sparse matrix once
+        rows_list, cols_list, data_list = [], [], []
+        for i, info in enumerate(row_infos):
+            if info["type"] == "constant":
+                k = len(info["cols"])
+                rows_list.append(np.full(k, i, dtype=np.int32))
+                cols_list.append(info["cols"])
+                data_list.append(info["vals"])
+
+        if rows_list:
+            all_rows = np.concatenate(rows_list)
+            all_cols = np.concatenate(cols_list)
+            all_data = np.concatenate(data_list)
+        else:
+            all_rows = np.array([], dtype=np.int32)
+            all_cols = np.array([], dtype=np.intp)
+            all_data = np.array([], dtype=np.float64)
+
+        from scipy.sparse import coo_matrix
+
+        const_jac = coo_matrix((all_data, (all_rows, all_cols)), shape=(m, n)).tocsr()
+
+        return lambda x, _j=const_jac: _j
+
+    # Pre-compute constant contributions (rows + cols + data that don't change)
+    const_rows, const_cols, const_data = [], [], []
+    var_row_indices = []
+    for i, info in enumerate(row_infos):
+        if info["type"] == "constant":
+            k = len(info["cols"])
+            const_rows.append(np.full(k, i, dtype=np.int32))
+            const_cols.append(info["cols"])
+            const_data.append(info["vals"])
+        elif info["type"] == "variable":
+            var_row_indices.append(i)
+
+    # Pre-concatenate constant parts
+    if const_rows:
+        c_rows = np.concatenate(const_rows)
+        c_cols = np.concatenate(const_cols)
+        c_data = np.concatenate(const_data)
+    else:
+        c_rows = np.array([], dtype=np.int32)
+        c_cols = np.array([], dtype=np.intp)
+        c_data = np.array([], dtype=np.float64)
+
+    # Pre-compute static structure for variable rows (row indices and column indices)
+    var_row_idx_arrays = []
+    var_col_arrays = []
+    var_fn_lists = []
+    for i in var_row_indices:
+        info = row_infos[i]
+        k = len(info["cols"])
+        var_row_idx_arrays.append(np.full(k, i, dtype=np.int32))
+        var_col_arrays.append(info["cols"])
+        var_fn_lists.append(info["fns"])
+
+    if var_row_idx_arrays:
+        v_rows = np.concatenate(var_row_idx_arrays)
+        v_cols = np.concatenate(var_col_arrays)
+    else:
+        v_rows = np.array([], dtype=np.int32)
+        v_cols = np.array([], dtype=np.intp)
+
+    n_const = len(c_data)
+    n_var = len(v_cols)
+
+    from scipy.sparse import coo_matrix
+
+    def sparse_jacobian_fn(x):
+        # Evaluate variable rows
+        v_data = np.empty(n_var, dtype=np.float64)
+        offset = 0
+        for fns in var_fn_lists:
+            for fn in fns:
+                v_data[offset] = fn(x)
+                offset += 1
+
+        # Combine constant + variable data
+        all_rows = np.concatenate([c_rows, v_rows]) if n_const > 0 else v_rows
+        all_cols = np.concatenate([c_cols, v_cols]) if n_const > 0 else v_cols
+        all_data = np.concatenate([c_data, v_data]) if n_const > 0 else v_data
+
+        return coo_matrix((all_data, (all_rows, all_cols)), shape=(m, n)).tocsr()
+
+    return sparse_jacobian_fn
+
+
 def compile_hessian(
     expr: Expression,
     variables: list[Variable],
@@ -1334,7 +2379,16 @@ def compile_hessian(
     """
     import numpy as np
     from optyx.core.compiler import compile_expression, _sanitize_derivatives
-    from optyx.core.vectors import VectorPowerSum, VectorUnarySum
+    from optyx.core.expressions import Constant
+    from optyx.core.vectors import (
+        VectorPowerSum,
+        VectorUnarySum,
+        VectorSum,
+        LinearCombination,
+        DotProduct,
+        VectorVariable,
+    )
+    from optyx.core.matrices import QuadraticForm
 
     n = len(variables)
 
@@ -1472,8 +2526,103 @@ def hess_log_sparse(x):
 
         # Fall through to general path for other ops
 
+    # New fast paths for constant/linear/quadratic expressions
+
+    # Linear expressions => zero Hessian
+    if isinstance(expr, (VectorSum, LinearCombination)):
+        zeros = np.zeros((n, n))
+
+        def hess_zero(x):
+            return zeros
+
+        return hess_zero
+
+    # x.dot(x) => 2*I (sparse if subset of variables)
+    if isinstance(expr, DotProduct):
+        if isinstance(expr.left, VectorVariable) and expr.left is expr.right:
+            vector_vars = expr.left._variables
+            var_name_to_idx = {v.name: i for i, v in enumerate(variables)}
+
+            # Map vector indices to variable indices
+            indices = [var_name_to_idx.get(v.name) for v in vector_vars]
+            valid_indices = [idx for idx in indices if idx is not None]
+
+            # Create Hessian with 2.0 on diagonal for relevant variables
+            hess_base = np.zeros((n, n))
+            for idx in valid_indices:
+                hess_base[idx, idx] = 2.0
+
+            def hess_dot_self(x):
+                return hess_base
+
+            return hess_dot_self
+
+    # QuadraticForm(x, Q) => Q + Q.T
+    if isinstance(expr, QuadraticForm) and isinstance(expr.vector, VectorVariable):
+        Q = expr.matrix
+        Q_sym = Q + Q.T
+
+        var_name_to_idx = {v.name: i for i, v in enumerate(variables)}
+        vector_vars = expr.vector._variables
+
+        # Mapping from index in Q (k) to index in Hessian (n_idx)
+        k_to_n = {}
+        for k, v in enumerate(vector_vars):
+            if v.name in var_name_to_idx:
+                k_to_n[k] = var_name_to_idx[v.name]
+
+        hess_base = np.zeros((n, n))
+
+        # Check if 1:1 match (optimization)
+        is_direct_match = (
+            len(vector_vars) == n
+            and len(k_to_n) == n
+            and all(k_to_n.get(i) == i for i in range(n))
+        )
+
+        if is_direct_match and Q_sym.shape == (n, n):
+            hess_base = Q_sym
+        else:
+            # General case: scatter
+            keys = sorted(k_to_n.keys())
+            for k_i in keys:
+                n_i = k_to_n[k_i]
+                for k_j in keys:
+                    n_j = k_to_n[k_j]
+                    hess_base[n_i, n_j] = Q_sym[k_i, k_j]
+
+        def hess_quadratic(x):
+            return hess_base
+
+        return hess_quadratic
+
     hessian_exprs = compute_hessian(expr, variables)
 
+    # Global optimization: Check if the entire Hessian is constant
+    # This covers cases where compute_hessian has successfully simplified the tree
+    # e.g., LinearCombination of QuadraticForms
+    all_constant = True
+    constant_matrix = np.zeros((n, n))
+
+    rows_to_check = range(n)
+    for i in rows_to_check:
+        for j in range(n):
+            elem = hessian_exprs[i][j]
+            if isinstance(elem, Constant):
+                constant_matrix[i, j] = elem.value
+            else:
+                all_constant = False
+                break
+        if not all_constant:
+            break
+
+    if all_constant:
+
+        def hessian_constant(x):
+            return constant_matrix
+
+        return hessian_constant
+
     # Compile each element (exploiting symmetry - only upper triangle)
     compiled_elements = {}
     for i in range(n):
diff --git a/src/optyx/core/compiler.py b/src/optyx/core/compiler.py
index d4ae180..73a7cfa 100644
--- a/src/optyx/core/compiler.py
+++ b/src/optyx/core/compiler.py
@@ -17,6 +17,7 @@
 import numpy as np
 
 from optyx.core.errors import UnknownOperatorError, InvalidExpressionError
+from optyx.core.expressions import NarySum, NaryProduct
 
 # Large but finite value to replace infinities in gradients.
 # This prevents solver crashes while maintaining gradient direction.
@@ -191,13 +192,9 @@ def _build_evaluator(
             indices = np.array([var_indices[v.name] for v in expr.vector._variables])
             return lambda x, c=coeffs, idx=indices: np.dot(c, x[idx])
         else:
-            # VectorExpression - build evaluators for each element
-            elem_fns = [
-                _build_evaluator(e, var_indices) for e in expr.vector._expressions
-            ]
-            return lambda x, c=coeffs, fns=elem_fns: np.dot(
-                c, np.array([f(x) for f in fns])
-            )
+            # VectorExpression/VectorBinaryOp - use vector evaluator
+            vec_fn = _build_vector_evaluator(expr.vector, var_indices)
+            return lambda x, c=coeffs, vf=vec_fn: np.dot(c, vf(x))
 
     elif isinstance(expr, VectorSum):
         # sum(x) = x[0] + x[1] + ... - efficient numpy implementation
@@ -206,6 +203,12 @@ def _build_evaluator(
 
     elif isinstance(expr, VectorExpressionSum):
         # sum(expr) where expr is a VectorExpression
+        # Fast path for VectorBinaryOp: single numpy op + sum
+        from optyx.core.vectors import VectorBinaryOp
+
+        if isinstance(expr.expression, VectorBinaryOp):
+            vec_fn = _build_vector_evaluator(expr.expression, var_indices)
+            return lambda x, vf=vec_fn: float(np.sum(vf(x)))
         elem_fns = [
             _build_evaluator(e, var_indices) for e in expr.expression._expressions
         ]
@@ -285,6 +288,21 @@ def _build_evaluator(
         numpy_func = expr._numpy_func
         return lambda x, f=operand_fn, np_f=numpy_func: np_f(f(x))
 
+    elif isinstance(expr, NarySum):
+        term_fns = tuple(_build_evaluator(t, var_indices) for t in expr.terms)
+        return lambda x, fns=term_fns: sum(fn(x) for fn in fns)
+
+    elif isinstance(expr, NaryProduct):
+        factor_fns = tuple(_build_evaluator(f, var_indices) for f in expr.factors)
+
+        def _eval_product(x: NDArray, fns: tuple = factor_fns) -> float:
+            result = 1.0
+            for fn in fns:
+                result = result * fn(x)
+            return result
+
+        return _eval_product
+
     else:
         raise InvalidExpressionError(
             expr_type=type(expr),
@@ -298,14 +316,42 @@ def _build_vector_evaluator(
     var_indices: dict[str, int],
 ) -> Callable[[NDArray[np.floating]], NDArray[np.floating]]:
     """Build an evaluator for a vector (returns array of values)."""
-    from optyx.core.vectors import VectorExpression, VectorVariable
+    from optyx.core.vectors import (
+        ElementwisePower,
+        VectorBinaryOp,
+        VectorExpression,
+        VectorVariable,
+    )
 
     if isinstance(vec, VectorVariable):
         indices = np.array([var_indices[v.name] for v in vec._variables])
         return lambda x, idx=indices: x[idx]
+    elif isinstance(vec, VectorBinaryOp):
+        # Single numpy op instead of N per-element evaluations
+        left_fn = _build_vector_evaluator(vec.left, var_indices)
+        right_fn = _build_vector_evaluator(vec.right, var_indices)
+        np_op = vec._NUMPY_OPS[vec.op]
+        return lambda x, lf=left_fn, rf=right_fn, op=np_op: op(lf(x), rf(x))
+    elif isinstance(vec, ElementwisePower):
+        base_fn = _build_vector_evaluator(vec.vector, var_indices)
+        p = vec.power
+        return lambda x, bf=base_fn, pw=p: bf(x) ** pw
     elif isinstance(vec, VectorExpression):
         elem_fns = [_build_evaluator(e, var_indices) for e in vec._expressions]
-        return lambda x, fns=elem_fns: np.array([f(x) for f in fns])
+        n_elems = len(elem_fns)
+
+        def vector_expr_eval(
+            x: NDArray[np.floating], fns=elem_fns, n=n_elems
+        ) -> NDArray[np.floating]:
+            res = np.empty(n)
+            for i, f in enumerate(fns):
+                res[i] = f(x)
+            return res
+
+        return vector_expr_eval
+    elif isinstance(vec, (int, float)):
+        val = np.array([float(vec)])
+        return lambda x, v=val: v
     else:
         raise InvalidExpressionError(
             expr_type=type(vec),
@@ -323,7 +369,14 @@ def _build_evaluator_iterative(
     Handles deep expression trees that would cause RecursionError.
     Uses explicit stack to build closures bottom-up.
     """
-    from optyx.core.expressions import BinaryOp, Constant, UnaryOp, Variable
+    from optyx.core.expressions import (
+        BinaryOp,
+        Constant,
+        NaryProduct,
+        NarySum,
+        UnaryOp,
+        Variable,
+    )
     from optyx.core.parameters import Parameter
     from optyx.core.vectors import (
         DotProduct,
@@ -369,23 +422,9 @@ def _build_evaluator_iterative(
                 )
                 result_stack.append(lambda x, c=coeffs, idx=indices: np.dot(c, x[idx]))
             else:
-                # VectorExpression - build non-recursive
-                elem_fns = []
-                for e in node.vector._expressions:
-                    if isinstance(e, Variable):
-                        idx = var_indices[e.name]
-                        elem_fns.append(lambda x, i=idx: x[i])
-                    elif isinstance(e, Constant):
-                        val = e.value
-                        elem_fns.append(lambda x, v=val: v)
-                    else:
-                        # Fallback to recursive for complex elements
-                        elem_fns.append(_build_evaluator(e, var_indices))
-                result_stack.append(
-                    lambda x, c=coeffs, fns=elem_fns: np.dot(
-                        c, np.array([f(x) for f in fns])
-                    )
-                )
+                # VectorExpression/VectorBinaryOp - use vector evaluator
+                vec_fn = _build_vector_evaluator(node.vector, var_indices)
+                result_stack.append(lambda x, c=coeffs, vf=vec_fn: np.dot(c, vf(x)))
             continue
 
         if isinstance(node, VectorSum):
@@ -395,6 +434,13 @@ def _build_evaluator_iterative(
 
         if isinstance(node, VectorExpressionSum):
             # sum(expr) where expr is a VectorExpression - build non-recursively
+            # Fast path for VectorBinaryOp: single numpy op + sum
+            from optyx.core.vectors import VectorBinaryOp
+
+            if isinstance(node.expression, VectorBinaryOp):
+                vec_fn = _build_vector_evaluator(node.expression, var_indices)
+                result_stack.append(lambda x, vf=vec_fn: float(np.sum(vf(x))))
+                continue
             elem_fns = []
             for e in node.expression._expressions:
                 if isinstance(e, Variable):
@@ -481,6 +527,24 @@ def _build_evaluator_iterative(
                 result_stack.append(lambda x, f=operand_fn, np_f=numpy_func: np_f(f(x)))
             continue
 
+        # N-ary expressions - flat children, compile each directly
+        if isinstance(node, NarySum):
+            term_fns = tuple(_build_evaluator(t, var_indices) for t in node.terms)
+            result_stack.append(lambda x, fns=term_fns: sum(fn(x) for fn in fns))
+            continue
+
+        if isinstance(node, NaryProduct):
+            factor_fns = tuple(_build_evaluator(f, var_indices) for f in node.factors)
+
+            def _eval_product_iter(x: NDArray, fns: tuple = factor_fns) -> float:
+                result = 1.0
+                for fn in fns:
+                    result = result * fn(x)
+                return result
+
+            result_stack.append(_eval_product_iter)
+            continue
+
         # Unknown type - try to evaluate directly
         raise InvalidExpressionError(
             expr_type=type(node),
@@ -518,16 +582,111 @@ def compile_to_dict_function(
     """
     array_fn = compile_expression(expr, variables)
     var_names = [v.name for v in variables]
+    n_vars = len(var_names)
 
     def dict_fn(
         values: dict[str, float | NDArray[np.floating]],
     ) -> NDArray[np.floating] | np.floating | float:
-        arr = np.array([values[name] for name in var_names])
+        arr = np.empty(n_vars)
+        for i, name in enumerate(var_names):
+            arr[i] = values[name]
         return array_fn(arr)
 
     return dict_fn
 
 
+def compile_vector_gradient(
+    expr: Expression,
+    variables: list[Variable],
+) -> Callable[[NDArray[np.floating]], NDArray[np.floating]] | None:
+    """Attempt to compile a fast vector gradient O(1)."""
+    from optyx.core.autodiff import detect_affine_gradient_pattern
+
+    pattern = detect_affine_gradient_pattern(expr)
+    if pattern is None:
+        return None
+
+    # Check if variables match exactly Pattern.vector
+    vec_vars = pattern.vector._variables
+    if len(variables) != len(vec_vars):
+        return None
+
+    # Fast check: are they the same objects?
+    if variables != vec_vars:
+        # Check names
+        for v1, v2 in zip(variables, vec_vars):
+            if v1.name != v2.name:
+                return None
+
+    b = pattern.constant_term
+    lt = pattern.linear_type
+
+    # Fast path: use structured metadata to avoid O(n²) matrix operations
+    if lt == "scaled_identity":
+        scale = pattern.linear_scale
+        if b is None:
+            return lambda x, _s=scale: _s * x
+        else:
+            b_val = b
+            return lambda x, _s=scale, _b=b_val: _s * x + _b
+
+    if lt == "diagonal":
+        diag = pattern.linear_diag
+        if b is None:
+            return lambda x, _d=diag: _d * x  # type: ignore
+        else:
+            b_val = b
+            return lambda x, _d=diag, _b=b_val: _d * x + _b  # type: ignore
+
+    A = pattern.linear_term
+
+    # Cases
+    if A is None and b is None:
+        zeros = np.zeros(len(variables))
+        return lambda x: zeros
+
+    if A is None:
+        b_val = b  # capture for closure
+        return lambda x: b_val  # type: ignore
+
+    if b is None:
+        # Gradient is A @ x — A is a general matrix (O(n²) checks only for general)
+        if lt != "general":
+            # Unknown type, try diagonal detection
+            A_diag = np.diagonal(A)
+            A_is_diag = np.count_nonzero(A - np.diag(A_diag)) == 0
+
+            if A_is_diag:
+                if np.all(A_diag == A_diag[0]):
+                    scale = float(A_diag[0])
+                    return lambda x, _s=scale: _s * x
+                return lambda x, _d=A_diag.copy(): _d * x
+
+        def grad_Ax(x: NDArray[np.floating]) -> NDArray[np.floating]:
+            return A @ x  # type: ignore
+
+        return grad_Ax
+
+    # b is not None, A is not None
+    if lt != "general":
+        A_diag = np.diagonal(A)
+        A_is_diag = np.count_nonzero(A - np.diag(A_diag)) == 0
+
+        if A_is_diag:
+            if np.all(A_diag == A_diag[0]):
+                scale = float(A_diag[0])
+                b_val = b
+                return lambda x, _s=scale, _b=b_val: _s * x + _b
+            b_val = b
+            d = A_diag.copy()
+            return lambda x, _d=d, _b=b_val: _d * x + _b
+
+    def grad_Ax_b(x: NDArray[np.floating]) -> NDArray[np.floating]:
+        return A @ x + b
+
+    return grad_Ax_b
+
+
 def compile_gradient(
     expr: Expression,
     variables: list[Variable],
@@ -555,7 +714,13 @@ def compile_gradient(
         >>> grad_fn = compile_gradient(expr, [x, y])
         >>> grad_fn(np.array([3.0, 4.0]))  # Returns [6.0, 8.0]
     """
-    from optyx.core.vectors import VectorPowerSum, VectorUnarySum
+    # Fast path: Vector Gradient Pattern (Linear/Quadratic forms)
+    vec_grad = compile_vector_gradient(expr, variables)
+    if vec_grad is not None:
+        return vec_grad
+
+    from optyx.core.vectors import VectorPowerSum, VectorUnarySum, VectorBinaryOp
+    from optyx.core.expressions import NarySum  # noqa: F811
 
     # Fast path for VectorPowerSum: gradient is k * x^(k-1), vectorized
     if isinstance(expr, VectorPowerSum):
@@ -565,6 +730,22 @@ def compile_gradient(
     if isinstance(expr, VectorUnarySum):
         return _compile_vectorized_unary_gradient(expr, variables)
 
+    # Fast path for VectorExpressionSum(VectorBinaryOp): vectorized gradient
+    from optyx.core.vectors import VectorExpressionSum
+
+    if isinstance(expr, VectorExpressionSum) and isinstance(
+        expr.expression, VectorBinaryOp
+    ):
+        result = _compile_vectorized_binary_op_sum_gradient(expr.expression, variables)
+        if result is not None:
+            return result
+
+    # Fast path for NarySum containing VectorExpressionSum(VectorBinaryOp) terms
+    if isinstance(expr, NarySum):
+        result = _compile_nary_sum_gradient_fast(expr, variables)
+        if result is not None:
+            return result
+
     # General path: symbolic differentiation
     from optyx.core.autodiff import gradient
 
@@ -573,15 +754,144 @@ def compile_gradient(
 
     # Compile each gradient expression
     grad_fns = [compile_expression(g, variables) for g in grad_exprs]
+    n_grads = len(grad_fns)
 
     def symbolic_gradient(x: NDArray[np.floating]) -> NDArray[np.floating]:
         """Compute gradient using symbolic differentiation."""
-        raw = np.array([fn(x) for fn in grad_fns])
+        raw = np.empty(n_grads)
+        for i, fn in enumerate(grad_fns):
+            raw[i] = fn(x)
         return _sanitize_derivatives(raw)
 
     return symbolic_gradient
 
 
+def compile_sparse_gradient(
+    expr: "Expression",
+    variables: list["Variable"],
+) -> Callable[["NDArray[np.floating]"], Any]:
+    """Compile a gradient that returns a sparse row vector (1×n csr_matrix).
+
+    Uses sparsity analysis to only compute non-zero partial derivatives,
+    returning a scipy.sparse.csr_matrix of shape (1, n) with O(nnz) memory.
+
+    For constant gradients (linear expressions), returns a pre-built sparse
+    matrix. For variable gradients, compiles only the non-zero columns.
+
+    Args:
+        expr: The expression to differentiate.
+        variables: Ordered list of variables.
+
+    Returns:
+        A callable that returns the gradient as a (1, n) csr_matrix.
+    """
+    from scipy.sparse import csr_matrix
+    from optyx.core.autodiff import analyze_gradient_sparsity, gradient as sym_gradient
+
+    n = len(variables)
+    sparsity = analyze_gradient_sparsity(expr, variables)
+
+    # Constant gradient: return pre-built sparse matrix
+    if sparsity.is_constant:
+        if sparsity.nnz == 0:
+            const_sparse = csr_matrix((1, n), dtype=np.float64)
+        else:
+            data = sparsity.constant_values
+            indices = sparsity.nnz_indices.copy()
+            indptr = np.array([0, len(indices)], dtype=np.int32)
+            const_sparse = csr_matrix((data, indices, indptr), shape=(1, n))
+
+        return lambda x, _m=const_sparse: _m
+
+    nnz_idx = sparsity.nnz_indices
+
+    if len(nnz_idx) == 0:
+        zero_sparse = csr_matrix((1, n), dtype=np.float64)
+        return lambda x, _m=zero_sparse: _m
+
+    # Compile only the non-zero columns
+    grad_exprs = [sym_gradient(expr, variables[j]) for j in nnz_idx]
+    compiled_fns = [compile_expression(e, variables) for e in grad_exprs]
+
+    def sparse_gradient(x: "NDArray[np.floating]") -> Any:
+        data = np.array([f(x) for f in compiled_fns], dtype=np.float64)
+        return csr_matrix((data, nnz_idx, np.array([0, len(nnz_idx)])), shape=(1, n))
+
+    return sparse_gradient
+
+
+def compile_sparse_gradient_dense_output(
+    expr: "Expression",
+    variables: list["Variable"],
+) -> Callable[["NDArray[np.floating]"], NDArray[np.floating]]:
+    """Compile a sparse-eval gradient that returns a dense vector.
+
+    This is intended for solver frontends such as ``scipy.optimize.minimize``
+    that require dense objective gradients. Only structurally non-zero partials
+    are compiled and evaluated, then scattered into a dense 1D array.
+    """
+    from optyx.core.autodiff import analyze_gradient_sparsity, gradient as sym_gradient
+
+    n = len(variables)
+    sparsity = analyze_gradient_sparsity(expr, variables)
+
+    if sparsity.is_constant:
+        const_dense = np.zeros(n, dtype=np.float64)
+        if sparsity.constant_values is not None:
+            const_dense[sparsity.nnz_indices] = sparsity.constant_values
+        return lambda x, _g=const_dense: _g
+
+    nnz_idx = sparsity.nnz_indices
+
+    if len(nnz_idx) == 0:
+        zero_dense = np.zeros(n, dtype=np.float64)
+        return lambda x, _g=zero_dense: _g
+
+    grad_exprs = [sym_gradient(expr, variables[j]) for j in nnz_idx]
+    compiled_fns = [compile_expression(e, variables) for e in grad_exprs]
+
+    def dense_sparse_gradient(x: "NDArray[np.floating]") -> NDArray[np.floating]:
+        result = np.zeros(n, dtype=np.float64)
+        for idx, fn in zip(nnz_idx, compiled_fns):
+            result[idx] = fn(x)
+        return _sanitize_derivatives(result)
+
+    return dense_sparse_gradient
+
+
+# Default density threshold for switching between sparse and dense
+_SPARSE_DENSITY_THRESHOLD = 0.5
+
+
+def compile_gradient_with_sparsity(
+    expr: "Expression",
+    variables: list["Variable"],
+    density_threshold: float = _SPARSE_DENSITY_THRESHOLD,
+) -> Callable[["NDArray[np.floating]"], Any]:
+    """Compile gradient, choosing sparse or dense format based on sparsity.
+
+    Analyzes the expression's sparsity pattern and returns:
+    - A sparse gradient (csr_matrix) if density <= threshold
+    - A dense gradient (ndarray) if density > threshold
+
+    Args:
+        expr: The expression to differentiate.
+        variables: Ordered list of variables.
+        density_threshold: Density above which dense format is used (default 0.5).
+
+    Returns:
+        A callable returning either a (1, n) csr_matrix or (n,) ndarray.
+    """
+    from optyx.core.autodiff import analyze_gradient_sparsity
+
+    sparsity = analyze_gradient_sparsity(expr, variables)
+
+    if sparsity.density <= density_threshold:
+        return compile_sparse_gradient(expr, variables)
+    else:
+        return compile_gradient(expr, variables)
+
+
 def _compile_vectorized_power_gradient(
     expr: "VectorPowerSum",
     variables: list["Variable"],
@@ -832,14 +1142,202 @@ def grad_abs_sparse(x: NDArray[np.floating]) -> NDArray[np.floating]:
 
         grad_exprs = [gradient(expr, var) for var in variables]
         grad_fns = [compile_expression(g, variables) for g in grad_exprs]
+        n_fns = len(grad_fns)
 
         def fallback_gradient(x: NDArray[np.floating]) -> NDArray[np.floating]:
-            raw = np.array([fn(x) for fn in grad_fns])
+            raw = np.empty(n_fns)
+            for i, fn in enumerate(grad_fns):
+                raw[i] = fn(x)
             return _sanitize_derivatives(raw)
 
         return fallback_gradient
 
 
+def _compile_vectorized_binary_op_sum_gradient(
+    vbo: Any,
+    variables: list["Variable"],
+) -> Callable[[NDArray[np.floating]], NDArray[np.floating]] | None:
+    """Compile O(1) gradient for sum(VectorBinaryOp).
+
+    Handles sum(left op right) where left/right are VectorVariable or scalar.
+    Returns None if the pattern isn't recognized (falls back to symbolic).
+
+    Derivative rules for sum(f(left, right)):
+        sum(l + r): ∂/∂l_i = 1, ∂/∂r_i = 1
+        sum(l - r): ∂/∂l_i = 1, ∂/∂r_i = -1
+        sum(c * x): ∂/∂x_i = c
+        sum(l * r): ∂/∂l_i = r_i, ∂/∂r_i = l_i  (needs runtime values)
+        sum(l / r): ∂/∂l_i = 1/r_i, ∂/∂r_i = -l_i/r_i^2
+    """
+    from optyx.core.vectors import VectorBinaryOp, VectorVariable
+
+    if not isinstance(vbo, VectorBinaryOp):
+        return None
+
+    op = vbo.op
+    left = vbo.left
+    right = vbo.right
+    n = len(variables)
+    var_name_to_idx = {v.name: i for i, v in enumerate(variables)}
+
+    def _get_indices(
+        vec: Any,
+    ) -> np.ndarray | None:
+        """Get variable indices for a vector operand, or None if scalar/const."""
+        if isinstance(vec, VectorVariable):
+            return np.array(
+                [
+                    var_name_to_idx[v.name]
+                    for v in vec._variables
+                    if v.name in var_name_to_idx
+                ],
+                dtype=np.intp,
+            )
+        return None
+
+    left_idx = _get_indices(left)
+    right_idx = _get_indices(right)
+    is_scalar_right = isinstance(right, (int, float))
+
+    if op == "+":
+        # sum(l + r): grad is 1 for each variable present in l or r
+        def grad_add_sum(x: NDArray[np.floating]) -> NDArray[np.floating]:
+            result = np.zeros(n)
+            if left_idx is not None:
+                result[left_idx] += 1.0
+            if right_idx is not None:
+                result[right_idx] += 1.0
+            return result
+
+        return grad_add_sum
+
+    elif op == "-":
+        # sum(l - r): grad is +1 for l vars, -1 for r vars
+        def grad_sub_sum(x: NDArray[np.floating]) -> NDArray[np.floating]:
+            result = np.zeros(n)
+            if left_idx is not None:
+                result[left_idx] += 1.0
+            if right_idx is not None:
+                result[right_idx] -= 1.0
+            return result
+
+        return grad_sub_sum
+
+    elif op == "*":
+        if is_scalar_right:
+            # sum(x * c): grad w.r.t. x_i = c
+            c = float(right)
+
+            def grad_scalar_mul_sum(x: NDArray[np.floating]) -> NDArray[np.floating]:
+                result = np.zeros(n)
+                if left_idx is not None:
+                    result[left_idx] = c
+                return result
+
+            return grad_scalar_mul_sum
+
+        elif left_idx is not None and right_idx is not None:
+            # sum(l * r): grad w.r.t. l_i = r_i, grad w.r.t. r_i = l_i
+            li = left_idx
+            ri = right_idx
+
+            def grad_vec_mul_sum(x: NDArray[np.floating]) -> NDArray[np.floating]:
+                result = np.zeros(n)
+                result[li] += x[ri]
+                result[ri] += x[li]
+                return result
+
+            return grad_vec_mul_sum
+
+        return None  # Unrecognized mul pattern
+
+    elif op == "/":
+        if is_scalar_right:
+            # sum(x / c): grad w.r.t. x_i = 1/c
+            inv_c = 1.0 / float(right)
+
+            def grad_scalar_div_sum(x: NDArray[np.floating]) -> NDArray[np.floating]:
+                result = np.zeros(n)
+                if left_idx is not None:
+                    result[left_idx] = inv_c
+                return result
+
+            return grad_scalar_div_sum
+
+        elif left_idx is not None and right_idx is not None:
+            # sum(l / r): ∂/∂l_i = 1/r_i, ∂/∂r_i = -l_i/r_i^2
+            li = left_idx
+            ri = right_idx
+
+            def grad_vec_div_sum(x: NDArray[np.floating]) -> NDArray[np.floating]:
+                result = np.zeros(n)
+                result[li] += 1.0 / x[ri]
+                result[ri] -= x[li] / (x[ri] ** 2)
+                return _sanitize_derivatives(result)
+
+            return grad_vec_div_sum
+
+        return None
+
+    # Unrecognized op (e.g., **) — fall back
+    return None
+
+
+def _compile_nary_sum_gradient_fast(
+    expr: Any,
+    variables: list["Variable"],
+) -> Callable[[NDArray[np.floating]], NDArray[np.floating]] | None:
+    """Try to compile a fast gradient for NarySum with VectorBinaryOp terms.
+
+    If some terms of the NarySum are VectorExpressionSum(VectorBinaryOp),
+    compile those with the fast path and use symbolic for the rest.
+    Only activates if at least one term benefits from the fast path.
+    """
+    from optyx.core.vectors import VectorExpressionSum, VectorBinaryOp
+
+    fast_grads: list[Callable] = []
+    slow_terms: list[Any] = []
+
+    for term in expr.terms:
+        if isinstance(term, VectorExpressionSum) and isinstance(
+            term.expression, VectorBinaryOp
+        ):
+            fg = _compile_vectorized_binary_op_sum_gradient(term.expression, variables)
+            if fg is not None:
+                fast_grads.append(fg)
+                continue
+        slow_terms.append(term)
+
+    if not fast_grads:
+        return None  # No benefit, fall back entirely
+
+    # Compile slow terms via symbolic differentiation
+    from optyx.core.autodiff import gradient as sym_gradient
+
+    slow_grad_fns: list[list[Callable]] = []
+    for term in slow_terms:
+        grad_exprs = [sym_gradient(term, var) for var in variables]
+        compiled = [compile_expression(g, variables) for g in grad_exprs]
+        slow_grad_fns.append(compiled)
+
+    n = len(variables)
+
+    def nary_gradient(x: NDArray[np.floating]) -> NDArray[np.floating]:
+        result = np.zeros(n)
+        # Fast vectorized contributions
+        for fg in fast_grads:
+            result += fg(x)
+        # Slow symbolic contributions
+        temp = np.empty(n)
+        for compiled in slow_grad_fns:
+            for i, fn in enumerate(compiled):
+                temp[i] = fn(x)
+            result += temp
+        return _sanitize_derivatives(result)
+
+    return nary_gradient
+
+
 class CompiledExpression:
     """A compiled expression with both value and gradient evaluation.
 
diff --git a/src/optyx/core/errors.py b/src/optyx/core/errors.py
index 58f967c..2e679fc 100644
--- a/src/optyx/core/errors.py
+++ b/src/optyx/core/errors.py
@@ -678,6 +678,39 @@ def __init__(
         )
 
 
+class UnsupportedOperationError(SolverConfigurationError, ValueError):
+    """Raised when Optyx cannot solve the requested problem class.
+
+    This is used for cases where the model itself is valid, but the current
+    solver stack does not support the requested combination of features,
+    such as MIQP/MINLP.
+    """
+
+    def __init__(
+        self,
+        operation: str,
+        solver_name: str = "optyx",
+        problem_feature: str | None = None,
+        suggestion: str | None = None,
+    ) -> None:
+        """Create an unsupported-operation error.
+
+        Args:
+            operation: Name of the unsupported operation or problem class.
+            solver_name: Name of the solver stack rejecting the request.
+            problem_feature: Optional feature combination causing the rejection.
+            suggestion: Optional remediation advice.
+        """
+        self.operation = operation
+
+        super().__init__(
+            f"Operation '{operation}' is not supported",
+            solver_name,
+            problem_feature=problem_feature,
+            suggestion=suggestion,
+        )
+
+
 # =============================================================================
 # Matrix-Specific Errors
 # =============================================================================
@@ -899,6 +932,7 @@ def _get_shape(obj: Any) -> tuple[int, ...] | int:
     "SolverError",
     "SolverConfigurationError",
     "IntegerVariableError",
+    "UnsupportedOperationError",
     "InfeasibleError",
     "UnboundedError",
     "NotSolvedError",
diff --git a/src/optyx/core/expressions.py b/src/optyx/core/expressions.py
index caf9c83..a76fd08 100644
--- a/src/optyx/core/expressions.py
+++ b/src/optyx/core/expressions.py
@@ -135,6 +135,20 @@ def eq(self, other: Expression | float | int) -> Constraint:
 
         return _make_constraint(self, "==", other)
 
+    def between(
+        self, lb: float | int | Expression, ub: float | int | Expression
+    ) -> list[Constraint]:
+        """Create range constraints: lb <= self <= ub.
+
+        Returns:
+            List of two constraints: [self >= lb, self <= ub].
+
+        Example:
+            >>> x = Variable("x")
+            >>> constraints = x.between(0, 10)
+        """
+        return [self >= lb, self <= ub]
+
     def constraint_eq(self, other: Expression | float | int) -> Constraint:
         """Create an == constraint: self == other.
 
@@ -231,7 +245,7 @@ class Variable(Expression):
         5.0
     """
 
-    __slots__ = ("name", "lb", "ub", "domain", "_sort_key")
+    __slots__ = ("name", "lb", "ub", "domain", "_sort_key", "obj")
 
     def __init__(
         self,
@@ -239,6 +253,7 @@ def __init__(
         lb: float | None = None,
         ub: float | None = None,
         domain: Literal["continuous", "integer", "binary"] = "continuous",
+        obj: float | int = 0.0,
     ) -> None:
         self._hash = None
         self._degree = None
@@ -246,6 +261,13 @@ def __init__(
         self.lb = lb
         self.ub = ub
         self.domain = domain
+        self.obj = float(obj)  # Linear objective coefficient
+
+        # Validate domain
+        if domain not in ("continuous", "integer", "binary"):
+            raise ValueError(
+                f"Unknown domain: {domain!r}. Must be 'continuous', 'integer', or 'binary'."
+            )
 
         # Pre-compute sort key for consistent ordering
         parts = _NUMBER_SPLIT_RE.split(name)
@@ -253,6 +275,10 @@ def __init__(
 
         # Binary variables have implicit bounds
         if domain == "binary":
+            if lb is not None and float(lb) != 0.0:
+                raise ValueError(f"Binary variable must have lb=0, got {lb!r}")
+            if ub is not None and float(ub) != 1.0:
+                raise ValueError(f"Binary variable must have ub=1, got {ub!r}")
             self.lb = 0.0
             self.ub = 1.0
 
@@ -295,6 +321,10 @@ class BinaryOp(Expression):
 
     __slots__ = ("left", "right", "op")
 
+    left: Expression
+    right: Expression
+    op: Literal["+", "-", "*", "/", "**"]
+
     # Operator dispatch table for evaluation
     _OPS = {
         "+": np.add,
@@ -431,6 +461,69 @@ def __repr__(self) -> str:
         return f"{self.op}({self.operand!r})"
 
 
+class NarySum(Expression):
+    """Sum of multiple expressions: a + b + c + ...
+
+    Flattening nested Add operations into a single node.
+    """
+
+    __slots__ = ("terms",)
+
+    def __init__(self, terms: tuple[Expression, ...]) -> None:
+        self._hash = None
+        self.terms = terms
+
+    def evaluate(
+        self, values: Mapping[str, ArrayLike | float]
+    ) -> NDArray[np.floating] | float:
+        # Start with 0 or first term? Implicitly 0 for sum.
+        # Ideally we want vectorized sum if possible, but terms might be mixed.
+        # Simple loop for now as per requirements.
+        result = 0.0
+        for term in self.terms:
+            result = result + term.evaluate(values)
+        return result
+
+    def get_variables(self) -> set[Variable]:
+        variables: set[Variable] = set()
+        for term in self.terms:
+            variables.update(term.get_variables())
+        return variables
+
+    def __repr__(self) -> str:
+        return f"Sum({', '.join(repr(t) for t in self.terms)})"
+
+
+class NaryProduct(Expression):
+    """Product of multiple expressions: a * b * c * ...
+
+    Flattening nested Multiply operations into a single node.
+    """
+
+    __slots__ = ("factors",)
+
+    def __init__(self, factors: tuple[Expression, ...]) -> None:
+        self._hash = None
+        self.factors = factors
+
+    def evaluate(
+        self, values: Mapping[str, ArrayLike | float]
+    ) -> NDArray[np.floating] | float:
+        result = 1.0
+        for factor in self.factors:
+            result = result * factor.evaluate(values)
+        return result
+
+    def get_variables(self) -> set[Variable]:
+        variables: set[Variable] = set()
+        for factor in self.factors:
+            variables.update(factor.get_variables())
+        return variables
+
+    def __repr__(self) -> str:
+        return f"Product({', '.join(repr(f) for f in self.factors)})"
+
+
 def _ensure_expr(value: Expression | float | int | ArrayLike) -> Expression:
     """Convert a value to an Expression if it isn't one already."""
     if isinstance(value, Expression):
@@ -558,6 +651,14 @@ def _get_variables_iterative(expr: Expression) -> set[Variable]:
             stack.append(node.operand)
             continue
 
+        # N-ary operations
+        if isinstance(node, (NarySum, NaryProduct)):
+            # Conveniently both have a tuple of expressions we can iterate
+            children = node.terms if isinstance(node, NarySum) else node.factors
+            for child in children:
+                stack.append(child)
+            continue
+
         # Fallback: call get_variables (might recurse for custom expressions)
         try:
             variables.update(node.get_variables())
diff --git a/src/optyx/core/matrices.py b/src/optyx/core/matrices.py
index bd8c636..597bcd4 100644
--- a/src/optyx/core/matrices.py
+++ b/src/optyx/core/matrices.py
@@ -10,7 +10,7 @@
 from __future__ import annotations
 
 from collections.abc import Mapping, Sequence
-from typing import TYPE_CHECKING, Iterator, Literal, overload
+from typing import TYPE_CHECKING, Any, Iterator, Literal, cast, overload
 
 import numpy as np
 
@@ -32,7 +32,53 @@
 
 if TYPE_CHECKING:
     from numpy.typing import NDArray, ArrayLike
-    from optyx.constraints import Constraint
+    from optyx.constraints import Constraint, MatrixConstraintBlock
+
+
+_AUTO_SPARSE_MIN_ENTRIES = 4096
+_AUTO_SPARSE_DENSITY_THRESHOLD = 0.25
+
+
+def _resolve_constant_matrix_data(
+    data: Any,
+    storage: Literal["auto", "dense", "sparse"],
+) -> Any:
+    from scipy import sparse as sp
+
+    if storage not in ("auto", "dense", "sparse"):
+        raise ValueError(
+            f"storage must be 'auto', 'dense', or 'sparse', got {storage!r}"
+        )
+
+    if sp.issparse(data):
+        matrix = data
+        if len(matrix.shape) != 2:
+            raise WrongDimensionalityError(
+                context="constant matrix",
+                expected_ndim=2,
+                got_ndim=len(matrix.shape),
+            )
+        if storage == "dense":
+            return np.asarray(matrix.toarray(), dtype=np.float64)
+        return matrix
+
+    matrix = np.asarray(data, dtype=np.float64)
+    if matrix.ndim != 2:
+        raise WrongDimensionalityError(
+            context="constant matrix",
+            expected_ndim=2,
+            got_ndim=matrix.ndim,
+        )
+
+    if storage == "sparse":
+        return sp.csr_matrix(matrix)
+
+    if storage == "auto" and matrix.size >= _AUTO_SPARSE_MIN_ENTRIES:
+        density = np.count_nonzero(matrix) / matrix.size if matrix.size > 0 else 0.0
+        if density <= _AUTO_SPARSE_DENSITY_THRESHOLD:
+            return sp.csr_matrix(matrix)
+
+    return matrix
 
 
 # =============================================================================
@@ -95,7 +141,9 @@ def __getitem__(self, key: tuple[int, int]) -> Expression:
             )
         return self._expressions[i][j]
 
-    def evaluate(self, values: Mapping[str, float]) -> NDArray[np.floating]:
+    def evaluate(
+        self, values: Mapping[str, "ArrayLike | float"]
+    ) -> NDArray[np.floating]:
         """Evaluate all elements with given variable values."""
         result = np.empty((self.rows, self.cols), dtype=np.float64)
         for i in range(self.rows):
@@ -266,6 +314,37 @@ def sum(self) -> MatrixSum:
         return MatrixSum(self)
 
 
+class ConstantMatrix:
+    """Wrapper for constant dense or sparse matrices used in symbolic products.
+
+    This allows ``A @ x`` syntax for matrices that don't naturally defer to
+    Optyx's ``VectorVariable.__rmatmul__``, notably ``scipy.sparse`` matrices.
+    """
+
+    __slots__ = ("data", "shape", "storage")
+    __array_ufunc__ = None
+
+    def __init__(
+        self,
+        data: Any,
+        storage: Literal["auto", "dense", "sparse"] = "auto",
+    ) -> None:
+        from scipy import sparse as sp
+
+        matrix = _resolve_constant_matrix_data(data, storage)
+        self.data = matrix
+        self.shape = matrix.shape
+        self.storage = "sparse" if sp.issparse(matrix) else "dense"
+
+    def __matmul__(self, other: object) -> "MatrixVectorProduct":
+        if isinstance(other, (VectorVariable, VectorExpression)):
+            return MatrixVectorProduct(self.data, other)
+        return NotImplemented
+
+    def __repr__(self) -> str:
+        return f"ConstantMatrix(shape={self.shape}, storage='{self.storage}')"
+
+
 def _matrix_binary_op(
     left: MatrixVariable | MatrixExpression,
     right: MatrixVariable | MatrixExpression | NDArray | float | int,
@@ -465,14 +544,26 @@ def shape(self) -> tuple[int, int]:
         """Shape of the underlying matrix."""
         return self.matrix.shape
 
-    def evaluate(self, values: Mapping[str, float]) -> float:
+    def evaluate(self, values: Mapping[str, "ArrayLike | float"]) -> float:
         """Evaluate the sum given variable values."""
         if isinstance(self.matrix, MatrixVariable):
-            total = 0.0
-            for i in range(self.matrix.rows):
-                for j in range(self.matrix.cols):
-                    total += float(self.matrix._variables[i][j].evaluate(values))
-            return total
+            # Casting to satisfy type checker (Variable.evaluate expects Mapping[str, float])
+            params = cast("Mapping[str, float]", values)
+
+            # Use np.fromiter for O(N) accumulation in C, avoiding Python loop overhead
+            return float(
+                np.sum(
+                    np.fromiter(
+                        (
+                            v.evaluate(params)
+                            for row in self.matrix._variables
+                            for v in row
+                        ),
+                        dtype=float,
+                        count=self.matrix.size,
+                    )
+                )
+            )
         else:  # MatrixExpression
             result = self.matrix.evaluate(values)
             return float(np.sum(result))
@@ -798,51 +889,62 @@ def rows_iter(self) -> Iterator[VectorVariable]:
         for i in range(self.rows):
             yield self[i, :]
 
-    def cols_iter(self) -> Iterator[VectorVariable]:
-        """Iterate over columns of the matrix.
-
-        Returns:
-            Iterator of VectorVariable, one for each column.
+    def diagonal(self, offset: int = 0) -> VectorVariable:
+        """Return the diagonal of the matrix.
 
-        Example:
-            >>> A = MatrixVariable("A", 3, 4)
-            >>> for j, col in enumerate(A.cols_iter()):
-            ...     print(f"Col {j}: {len(col)} elements")
-        """
-        for j in range(self.cols):
-            yield self[:, j]
-
-    def diagonal(self) -> VectorVariable:
-        """Extract the main diagonal of a square matrix.
+        Args:
+            offset: Diagonal offset from the main diagonal.
+                    Positive means above main diagonal,
+                    negative means below.
 
         Returns:
             VectorVariable containing the diagonal elements.
+        """
+        if offset >= 0:
+            start_row = 0
+            start_col = offset
+        else:
+            start_row = -offset
+            start_col = 0
 
-        Raises:
-            ValueError: If the matrix is not square.
+        diag_vars: list[Variable] = []
+        rows, cols = self.shape
+        i, j = start_row, start_col
 
-        Example:
-            >>> A = MatrixVariable("A", 3, 3)
-            >>> d = A.diagonal()
-            >>> len(d)  # 3
-            >>> d[0].name  # 'A[0,0]'
-        """
-        if self.rows != self.cols:
-            raise SquareMatrixError(
-                operation="diagonal",
-                shape=(self.rows, self.cols),
-            )
+        while i < rows and j < cols:
+            diag_vars.append(self._variables[i][j])
+            i += 1
+            j += 1
 
-        diag_vars = [self._variables[i][i] for i in range(self.rows)]
+        if not diag_vars:
+            raise InvalidOperationError(
+                operation="diagonal extraction",
+                operand_types=("MatrixVariable",),
+                suggestion=f"Offset {offset} is out of bounds for matrix with shape {self.shape}",
+            )
 
         return VectorVariable._from_variables(
-            name=f"diag({self.name})",
+            name=f"diag({self.name}, {offset})",
             variables=diag_vars,
             lb=self.lb,
             ub=self.ub,
             domain=self.domain,
         )
 
+    def cols_iter(self) -> Iterator[VectorVariable]:
+        """Iterate over columns of the matrix.
+
+        Returns:
+            Iterator of VectorVariable, one for each column.
+
+        Example:
+            >>> A = MatrixVariable("A", 3, 4)
+            >>> for j, col in enumerate(A.cols_iter()):
+            ...     print(f"Col {j}: {len(col)} elements")
+        """
+        for j in range(self.cols):
+            yield self[:, j]
+
     def trace(self) -> Expression:
         """Compute the trace (sum of diagonal elements) of a square matrix.
 
@@ -1179,20 +1281,30 @@ class MatrixVectorProduct(VectorExpression):
         [5.0, 11.0]  # [1*1+2*2, 3*1+4*2]
     """
 
-    __slots__ = ("matrix", "vector", "_expressions", "size")
+    __slots__ = ("matrix", "vector", "size", "_materialized")
 
     def __init__(
         self,
-        matrix: np.ndarray,
+        matrix: Any,
         vector: VectorVariable | VectorExpression,
     ) -> None:
-        matrix = np.asarray(matrix)
-        if matrix.ndim != 2:
-            raise WrongDimensionalityError(
-                context="matrix-vector product",
-                expected_ndim=2,
-                got_ndim=matrix.ndim,
-            )
+        from scipy import sparse as sp
+
+        if sp.issparse(matrix):
+            if len(matrix.shape) != 2:
+                raise WrongDimensionalityError(
+                    context="matrix-vector product",
+                    expected_ndim=2,
+                    got_ndim=len(matrix.shape),
+                )
+        else:
+            matrix = np.asarray(matrix, dtype=np.float64)
+            if matrix.ndim != 2:
+                raise WrongDimensionalityError(
+                    context="matrix-vector product",
+                    expected_ndim=2,
+                    got_ndim=matrix.ndim,
+                )
 
         vec_size = vector.size if hasattr(vector, "size") else len(vector)
         if matrix.shape[1] != vec_size:
@@ -1205,15 +1317,51 @@ def __init__(
         self.matrix = matrix
         self.vector = vector
         self.size = matrix.shape[0]
+        self._materialized = None
 
-        # Create a LinearCombination for each row
-        self._expressions: list[Expression] = [
-            LinearCombination(matrix[i, :], vector) for i in range(self.size)
-        ]
+    @property
+    def _expressions(self) -> Sequence[Expression]:
+        """Lazy creation of expression list when needed."""
+        from scipy import sparse as sp
+
+        if self._materialized is None:
+            # Create a LinearCombination for each row
+            # cast to list[Expression] to satisfy invariance if needed,
+            # but Sequence[Expression] return type handles covariance.
+            self._materialized = [
+                LinearCombination(
+                    (
+                        np.asarray(self.matrix[i, :].toarray()).ravel()
+                        if sp.issparse(self.matrix)
+                        else np.asarray(self.matrix[i, :], dtype=np.float64).ravel()
+                    ),
+                    self.vector,
+                )
+                for i in range(self.size)
+            ]
+        return self._materialized
 
     def evaluate(self, values: Mapping[str, ArrayLike | float]) -> list[float]:
-        """Evaluate the matrix-vector product."""
-        return [expr.evaluate(values) for expr in self._expressions]  # type: ignore[misc]
+        """Evaluate the matrix-vector product using BLAS."""
+        # Get vector values as a numpy array
+        if isinstance(self.vector, VectorVariable):
+            # Optimized path for VectorVariable - evaluate once
+            if hasattr(self.vector, "to_numpy"):
+                # Use to_numpy if available (it handles variable lookup)
+                # Note: to_numpy expects Mapping[str, float] but values might be restrictive
+                # We do a list comprehension manually to be safe and avoid type issues
+                vec_vals = np.array(
+                    [v.evaluate(values) for v in self.vector._variables]
+                )
+            else:
+                vec_vals = np.array([v.evaluate(values) for v in self.vector])
+        else:
+            # VectorExpression or list
+            vec_vals = np.array(self.vector.evaluate(values))
+
+        # Matrix-vector multiplication (BLAS)
+        result = self.matrix @ vec_vals
+        return np.asarray(result, dtype=np.float64).ravel().tolist()
 
     def get_variables(self) -> set[Variable]:
         """Return all variables this expression depends on."""
@@ -1221,6 +1369,53 @@ def get_variables(self) -> set[Variable]:
             return set(self.vector._variables)
         return self.vector.get_variables()
 
+    def _matrix_constraint_or_none(
+        self, other: object, sense: Literal["<=", ">=", "=="]
+    ) -> MatrixConstraintBlock | None:
+        from optyx.constraints import make_matrix_constraint_block
+
+        if isinstance(other, (np.ndarray, list)) and isinstance(
+            self.vector, VectorVariable
+        ):
+            return make_matrix_constraint_block(self.matrix, self.vector, sense, other)
+        return None
+
+    def __le__(
+        self,
+        other: VectorExpression | VectorVariable | float | int | np.ndarray | list,
+    ) -> MatrixConstraintBlock | list[Constraint]:
+        block = self._matrix_constraint_or_none(other, "<=")
+        if block is not None:
+            return block
+
+        from optyx.core.vectors import _vector_constraint
+
+        return _vector_constraint(self, other, "<=")
+
+    def __ge__(
+        self,
+        other: VectorExpression | VectorVariable | float | int | np.ndarray | list,
+    ) -> MatrixConstraintBlock | list[Constraint]:
+        block = self._matrix_constraint_or_none(other, ">=")
+        if block is not None:
+            return block
+
+        from optyx.core.vectors import _vector_constraint
+
+        return _vector_constraint(self, other, ">=")
+
+    def eq(
+        self,
+        other: VectorExpression | VectorVariable | float | int | np.ndarray | list,
+    ) -> MatrixConstraintBlock | list[Constraint]:
+        block = self._matrix_constraint_or_none(other, "==")
+        if block is not None:
+            return block
+
+        from optyx.core.vectors import _vector_constraint
+
+        return _vector_constraint(self, other, "==")
+
     def __repr__(self) -> str:
         vec_name = (
             self.vector.name if isinstance(self.vector, VectorVariable) else "expr"
@@ -1229,7 +1424,7 @@ def __repr__(self) -> str:
 
 
 def matmul(
-    matrix: np.ndarray, vector: VectorVariable | VectorExpression
+    matrix: Any, vector: VectorVariable | VectorExpression
 ) -> MatrixVectorProduct:
     """Matrix-vector multiplication: A @ x.
 
@@ -1249,6 +1444,23 @@ def matmul(
     return MatrixVectorProduct(matrix, vector)
 
 
+def as_matrix(
+    matrix: Any,
+    storage: Literal["auto", "dense", "sparse"] = "auto",
+) -> ConstantMatrix:
+    """Wrap a constant matrix for symbolic ``A @ x`` syntax.
+
+    Args:
+        matrix: Dense or sparse matrix-like input.
+        storage: Storage policy for the wrapped matrix.
+            - ``"auto"`` keeps sparse inputs sparse and may convert large,
+              low-density dense arrays to CSR storage.
+            - ``"dense"`` forces a NumPy ndarray.
+            - ``"sparse"`` forces CSR storage.
+    """
+    return ConstantMatrix(matrix, storage=storage)
+
+
 # =============================================================================
 # Quadratic Form
 # =============================================================================
diff --git a/src/optyx/core/optimizer.py b/src/optyx/core/optimizer.py
new file mode 100644
index 0000000..7ac4517
--- /dev/null
+++ b/src/optyx/core/optimizer.py
@@ -0,0 +1,96 @@
+"""Expression optimization passes."""
+
+from optyx.core.expressions import Expression, BinaryOp, NarySum, NaryProduct
+
+
+def flatten_expression(expr: Expression) -> Expression:
+    """Flatten an expression tree by coalescing associative operations.
+
+    Converts nested addition chains into NarySum nodes and nested multiplication
+    chains into NaryProduct nodes. This reduces tree depth from O(N) to O(1)
+    for loop-constructed sums/products.
+
+    Uses iterative traversal to handle deep trees without RecursionError.
+
+    Args:
+        expr: The expression to optimize.
+
+    Returns:
+        A new optimized expression (or the original if no changes needed).
+    """
+    # 1. Handle Associative Chains (Iteratively)
+    if isinstance(expr, BinaryOp) and expr.op in ("+", "*"):
+        terms = _gather_associative_terms(expr, expr.op)
+
+        # Optimize the gathered terms recursively
+        # (The depth of *different* operators is usually shallow, so recursion is safe here)
+        optimized_terms = tuple(flatten_expression(t) for t in terms)
+
+        # Reconstruct
+        if len(optimized_terms) == 2:
+            return BinaryOp(optimized_terms[0], optimized_terms[1], expr.op)  # type: ignore
+
+        if expr.op == "+":
+            return NarySum(optimized_terms)
+        elif expr.op == "*":
+            return NaryProduct(optimized_terms)
+
+    # 2. Recursively optimize other BinaryOps (e.g. -, /, **)
+    if isinstance(expr, BinaryOp):
+        left = flatten_expression(expr.left)
+        right = flatten_expression(expr.right)
+        if left is not expr.left or right is not expr.right:
+            return BinaryOp(left, right, expr.op)
+        return expr
+
+    # 3. Future: Recurse into UnaryOps, etc.
+
+    return expr
+
+
+def optimize_expression(expr: Expression) -> Expression:
+    """Run the expression optimizer pipeline.
+
+    Currently this is a thin wrapper over ``flatten_expression()`` so callers
+    can target a stable optimization entry point while additional passes remain
+    future work.
+
+    Args:
+        expr: The expression to optimize.
+
+    Returns:
+        The optimized expression.
+    """
+    return flatten_expression(expr)
+
+
+def _gather_associative_terms(expr: Expression, op: str) -> list[Expression]:
+    """Iteratively gather inputs for an associative chain.
+
+    Uses an explicit stack to avoid RecursionError on deep trees.
+    Preserves Left-to-Right operand order.
+    """
+    terms: list[Expression] = []
+
+    # Stack stores nodes to visit.
+    # To yield L then R, we must push R then L.
+    stack = [expr]
+
+    while stack:
+        node = stack.pop()
+
+        if isinstance(node, BinaryOp) and node.op == op:
+            stack.append(node.right)
+            stack.append(node.left)
+        elif isinstance(node, NarySum) and op == "+":
+            # NarySum stores terms (t1, t2, t3).
+            # To pop t1, t2, t3, push them in reverse: t3, t2, t1.
+            for term in reversed(node.terms):
+                stack.append(term)
+        elif isinstance(node, NaryProduct) and op == "*":
+            for factor in reversed(node.factors):
+                stack.append(factor)
+        else:
+            terms.append(node)
+
+    return terms
diff --git a/src/optyx/core/variable_dict.py b/src/optyx/core/variable_dict.py
new file mode 100644
index 0000000..fa6f35c
--- /dev/null
+++ b/src/optyx/core/variable_dict.py
@@ -0,0 +1,200 @@
+"""Dictionary-indexed variable collections.
+
+Provides VariableDict for modeling problems where variables are
+naturally indexed by strings (product names, cities, etc.) rather
+than integers.
+"""
+
+from __future__ import annotations
+
+from typing import Iterator, Literal, Mapping, Sequence
+
+
+from optyx.core.expressions import Constant, Expression, Variable
+
+
+class VariableDict:
+    """A dictionary-keyed collection of optimization variables.
+
+    Variables are indexed by string keys (e.g., product names, cities)
+    rather than integer indices. Supports weighted sums, partial sums,
+    and dict-like iteration.
+
+    Args:
+        name: Base name for all variables. Individual variables are
+            named ``"{name}[{key}]"``.
+        keys: Sequence of string keys.
+        lb: Lower bound — scalar (broadcast to all), or dict (per-key).
+        ub: Upper bound — scalar (broadcast to all), or dict (per-key).
+        domain: Variable domain — ``'continuous'``, ``'integer'``, or ``'binary'``.
+
+    Example:
+        >>> foods = ["hamburger", "chicken", "pizza", "salad"]
+        >>> buy = VariableDict("buy", foods, lb=0)
+        >>> buy["hamburger"]  # Variable("buy[hamburger]")
+        >>> buy.sum()         # sum of all buy variables
+        >>> buy.prod({"hamburger": 2.49, "chicken": 2.89, ...})  # weighted sum
+    """
+
+    __slots__ = ("name", "_keys", "_variables", "_key_to_var")
+    __array_ufunc__ = None  # Tell NumPy to defer to Python's operators
+
+    def __init__(
+        self,
+        name: str,
+        keys: Sequence[str],
+        lb: float | Mapping[str, float] | None = None,
+        ub: float | Mapping[str, float] | None = None,
+        domain: Literal["continuous", "integer", "binary"] = "continuous",
+    ) -> None:
+        if not keys:
+            raise ValueError("VariableDict requires at least one key.")
+
+        self.name = name
+        self._keys = list(keys)
+        self._variables: dict[str, Variable] = {}
+        self._key_to_var: dict[str, Variable] = {}
+
+        for key in self._keys:
+            var_lb = lb[key] if isinstance(lb, Mapping) else lb
+            var_ub = ub[key] if isinstance(ub, Mapping) else ub
+            var = Variable(f"{name}[{key}]", lb=var_lb, ub=var_ub, domain=domain)
+            self._variables[key] = var
+            self._key_to_var[key] = var
+
+    def __getitem__(self, key: str) -> Variable:
+        """Get the variable for a given key.
+
+        Args:
+            key: The string key.
+
+        Returns:
+            The Variable associated with this key.
+
+        Raises:
+            KeyError: If key not found.
+        """
+        try:
+            return self._variables[key]
+        except KeyError:
+            raise KeyError(
+                f"Key {key!r} not found in VariableDict {self.name!r}. "
+                f"Available keys: {self._keys}"
+            ) from None
+
+    def __contains__(self, key: str) -> bool:
+        """Check if a key exists in this VariableDict."""
+        return key in self._variables
+
+    def __len__(self) -> int:
+        """Number of variables in this VariableDict."""
+        return len(self._keys)
+
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over keys."""
+        return iter(self._keys)
+
+    def __repr__(self) -> str:
+        return f"VariableDict({self.name!r}, keys={self._keys})"
+
+    def keys(self) -> list[str]:
+        """Return the keys of this VariableDict."""
+        return list(self._keys)
+
+    def values(self) -> list[Variable]:
+        """Return the variables of this VariableDict."""
+        return [self._variables[k] for k in self._keys]
+
+    def items(self) -> list[tuple[str, Variable]]:
+        """Return (key, variable) pairs."""
+        return [(k, self._variables[k]) for k in self._keys]
+
+    def sum(self, keys: Sequence[str] | None = None) -> Expression:
+        """Sum of variables, optionally over a subset of keys.
+
+        Args:
+            keys: If provided, sum only these keys. Otherwise sum all.
+
+        Returns:
+            Expression representing the sum.
+
+        Example:
+            >>> buy.sum()                          # sum of all
+            >>> buy.sum(["hamburger", "chicken"])   # partial sum
+        """
+        subset = self._resolve_keys(keys)
+        if len(subset) == 1:
+            return self._variables[subset[0]]
+
+        result: Expression = self._variables[subset[0]]
+        for key in subset[1:]:
+            result = result + self._variables[key]
+        return result
+
+    def prod(self, coefficients: Mapping[str, float] | Sequence[float]) -> Expression:
+        """Weighted sum (inner product) of variables with coefficients.
+
+        Args:
+            coefficients: Either a dict mapping keys to coefficients,
+                or a sequence of coefficients in key order.
+
+        Returns:
+            Expression representing the weighted sum.
+
+        Example:
+            >>> cost = {"hamburger": 2.49, "chicken": 2.89}
+            >>> buy.prod(cost)  # 2.49*buy[hamburger] + 2.89*buy[chicken] + ...
+        """
+        if isinstance(coefficients, Mapping):
+            coeff_map = coefficients
+        else:
+            coeff_list = list(coefficients)
+            if len(coeff_list) != len(self._keys):
+                raise ValueError(
+                    f"Expected {len(self._keys)} coefficients, got {len(coeff_list)}."
+                )
+            coeff_map = dict(zip(self._keys, coeff_list))
+
+        terms: list[Expression] = []
+        for key in self._keys:
+            if key in coeff_map:
+                c = coeff_map[key]
+                if c != 0:
+                    terms.append(Constant(c) * self._variables[key])
+
+        if not terms:
+            return Constant(0.0)
+        result = terms[0]
+        for term in terms[1:]:
+            result = result + term
+        return result
+
+    def get_variables(self) -> list[Variable]:
+        """Return all Variable objects in key order."""
+        return [self._variables[k] for k in self._keys]
+
+    def to_dict(self, solution) -> dict[str, float]:
+        """Extract variable values from a solution as a ``{key: value}`` dict.
+
+        This is a convenience wrapper around ``solution[variable_dict]``.
+
+        Args:
+            solution: A :class:`~optyx.solution.Solution` object.
+
+        Returns:
+            Dict mapping each key to its optimal value.
+        """
+        return solution[self]
+
+    def _resolve_keys(self, keys: Sequence[str] | None) -> list[str]:
+        """Resolve and validate a key subset."""
+        if keys is None:
+            return self._keys
+        resolved = list(keys)
+        for key in resolved:
+            if key not in self._variables:
+                raise KeyError(
+                    f"Key {key!r} not found in VariableDict {self.name!r}. "
+                    f"Available keys: {self._keys}"
+                )
+        return resolved
diff --git a/src/optyx/core/vectors.py b/src/optyx/core/vectors.py
index 8e38201..7d09f7b 100644
--- a/src/optyx/core/vectors.py
+++ b/src/optyx/core/vectors.py
@@ -7,7 +7,7 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Iterator, Literal, Mapping, overload
+from typing import TYPE_CHECKING, Iterator, Literal, Mapping, cast, overload
 
 import numpy as np
 
@@ -16,7 +16,6 @@
     Variable,
     Constant,
     BinaryOp,
-    _ensure_expr,
 )
 from optyx.core.errors import (
     DimensionMismatchError,
@@ -129,7 +128,15 @@ def size(self) -> int:
     def evaluate(
         self, values: Mapping[str, ArrayLike | float]
     ) -> NDArray[np.floating] | float:
-        """Evaluate the sum given variable values."""
+        """Evaluate the sum given variable values.
+
+        For VectorBinaryOp, uses its vectorized evaluate() + np.sum()
+        to avoid triggering O(N) materialization of scalar expressions.
+        """
+        # Use type name check to avoid forward reference issue
+        # (VectorBinaryOp is defined later in this module)
+        if type(self.expression).__name__ == "VectorBinaryOp":
+            return float(np.sum(np.array(self.expression.evaluate(values))))
         return sum(e.evaluate(values) for e in self.expression._expressions)  # type: ignore[return-value]
 
     def get_variables(self) -> set[Variable]:
@@ -494,6 +501,7 @@ class ElementwisePower(Expression):
     def __init__(self, vector: VectorVariable, power: float | int) -> None:
         self.vector = vector
         self.power = float(power)
+        self._hash = None
 
     @property
     def size(self) -> int:
@@ -551,6 +559,7 @@ class VectorPowerSum(Expression):
     def __init__(self, vector: VectorVariable, power: float | int) -> None:
         self.vector = vector
         self.power = float(power)
+        self._hash = None
 
     def evaluate(self, values: Mapping[str, ArrayLike | float]) -> float:
         """Evaluate sum of powers using numpy."""
@@ -636,6 +645,7 @@ def __init__(self, vector: VectorVariable, op: str) -> None:
             )
         self.vector = vector
         self.op = op
+        self._hash = None
 
     @property
     def size(self) -> int:
@@ -729,6 +739,7 @@ def __init__(self, vector: VectorVariable, op: str) -> None:
             )
         self.vector = vector
         self.op = op
+        self._hash = None
 
     def evaluate(self, values: Mapping[str, ArrayLike | float]) -> float:
         """Evaluate sum of function values using numpy."""
@@ -821,7 +832,7 @@ class VectorExpression:
         3.0
     """
 
-    __slots__ = ("_expressions", "size")
+    __slots__ = ("_stored_expressions", "size")
 
     # Tell NumPy to defer to Python's operators
     __array_ufunc__ = None
@@ -832,9 +843,13 @@ def __init__(self, expressions: Sequence[Expression]) -> None:
                 container_type="VectorExpression",
                 operation="initialization",
             )
-        self._expressions = list(expressions)
+        self._stored_expressions = list(expressions)
         self.size = len(expressions)
 
+    @property
+    def _expressions(self) -> Sequence[Expression]:
+        return self._stored_expressions
+
     def __getitem__(self, key: int) -> Expression:
         """Get a single expression by index."""
         if key < 0:
@@ -894,10 +909,13 @@ def __sub__(
         """Element-wise subtraction."""
         return _vector_binary_op(self, other, "-")
 
-    def __rsub__(self, other: float | int) -> VectorExpression:
-        # other - self
-        return VectorExpression(
-            [BinaryOp(_ensure_expr(other), expr, "-") for expr in self._expressions]
+    def __rsub__(self, other: float | int) -> VectorBinaryOp:
+        # other - self: wrap scalar as left, self as right
+        return VectorBinaryOp(
+            VectorExpression([Constant(float(other))] * self.size),
+            self,
+            "-",
+            self.size,
         )
 
     def __mul__(self, other: float | int) -> VectorExpression:
@@ -911,15 +929,18 @@ def __truediv__(self, other: float | int) -> VectorExpression:
         """Scalar division."""
         return _vector_binary_op(self, other, "/")
 
-    def __rtruediv__(self, other: float | int) -> VectorExpression:
+    def __rtruediv__(self, other: float | int) -> VectorBinaryOp:
         """Right scalar division."""
-        return VectorExpression(
-            [BinaryOp(_ensure_expr(other), expr, "/") for expr in self._expressions]
+        return VectorBinaryOp(
+            VectorExpression([Constant(float(other))] * self.size),
+            self,
+            "/",
+            self.size,
         )
 
-    def __neg__(self) -> VectorExpression:
-        """Negate all elements."""
-        return VectorExpression([-expr for expr in self._expressions])
+    def __neg__(self) -> VectorBinaryOp:
+        """Negate all elements: -expr = (-1) * expr."""
+        return _vector_binary_op(self, -1, "*")
 
     def __pow__(self, other: float | int) -> VectorExpression:
         """Element-wise power."""
@@ -960,6 +981,18 @@ def eq(
         """
         return _vector_constraint(self, other, "==")
 
+    def between(
+        self,
+        lb: float | int | np.ndarray | list | VectorExpression | VectorVariable,
+        ub: float | int | np.ndarray | list | VectorExpression | VectorVariable,
+    ) -> list[Constraint]:
+        """Create element-wise range constraints: lb <= self <= ub.
+
+        Returns:
+            List of constraints covering both bounds.
+        """
+        return _vector_constraint(self, lb, ">=") + _vector_constraint(self, ub, "<=")
+
     def dot(self, other: VectorExpression | VectorVariable) -> DotProduct:
         """Compute dot product with another vector.
 
@@ -1027,6 +1060,150 @@ def __rmatmul__(self, other: np.ndarray | list) -> LinearCombination:
         return LinearCombination(arr, self)
 
 
+class VectorBinaryOp(VectorExpression):
+    """Element-wise binary operation between two vectors as a single node.
+
+    Instead of materializing N individual BinaryOp nodes, this stores the
+    operation symbolically and evaluates using a single NumPy call.
+
+    The ``_expressions`` list is created lazily on first access so that code
+    which iterates over individual elements (e.g. gradient computation) still
+    works, while the common compilation path avoids O(N) materialization.
+
+    Args:
+        left: Left operand vector.
+        right: Right operand vector (or broadcast scalar).
+        op: Binary operation (``+``, ``-``, ``*``, ``/``, ``**``).
+        size: Number of elements.
+
+    Example:
+        >>> x = VectorVariable("x", 3)
+        >>> y = VectorVariable("y", 3)
+        >>> z = x + y  # VectorBinaryOp, single node
+        >>> z.evaluate({"x[0]": 1, "x[1]": 2, "x[2]": 3, "y[0]": 4, "y[1]": 5, "y[2]": 6})
+        [5.0, 7.0, 9.0]
+    """
+
+    __slots__ = ("left", "right", "op", "_materialized")
+
+    _NUMPY_OPS: dict[str, np.ufunc] = {
+        "+": np.add,
+        "-": np.subtract,
+        "*": np.multiply,
+        "/": np.divide,
+        "**": np.power,
+    }
+
+    def __init__(
+        self,
+        left: VectorVariable | VectorExpression,
+        right: VectorVariable | VectorExpression | float | int,
+        op: str,
+        size: int,
+    ) -> None:
+        # Store vector-level operands for fast numpy compilation
+        self.left = left
+        self.right = right
+        self.op = op
+        self.size = size
+        # Lazy materialization: _expressions created only when accessed
+        self._materialized: list[BinaryOp] | None = None
+
+    @property
+    def _expressions(self) -> list[BinaryOp]:  # type: ignore[override]
+        """Lazily materialize per-element BinaryOp nodes.
+
+        Only called when code needs individual scalar expressions
+        (e.g., gradient fallback, iteration). The compiler fast path
+        and evaluate() never trigger this.
+        """
+        if self._materialized is None:
+            left_exprs = _iter_vector_exprs(self.left)
+            right_exprs = _iter_vector_exprs(self.right, broadcast_size=self.size)
+            op = cast("Literal['+', '-', '*', '/', '**']", self.op)
+            self._materialized = [
+                BinaryOp(le, re, op) for le, re in zip(left_exprs, right_exprs)
+            ]
+        return self._materialized
+
+    @_expressions.setter
+    def _expressions(self, value: list[BinaryOp]) -> None:
+        """Allow direct assignment for compatibility."""
+        self._materialized = value
+
+    # -- fast evaluate (no materialization) ----------------------------------
+
+    def evaluate(self, values: Mapping[str, ArrayLike | float]) -> list[float]:
+        """Evaluate using numpy — O(1) NumPy calls, no per-element overhead."""
+        left_vals = _eval_vector(self.left, values)
+        right_vals = _eval_vector(self.right, values)
+        result = self._NUMPY_OPS[self.op](left_vals, right_vals)
+        return [float(v) for v in result]
+
+    def get_variables(self) -> set[Variable]:
+        """Return all variables from both operands."""
+        result: set[Variable] = set()
+        if isinstance(self.left, VectorVariable):
+            result.update(self.left._variables)
+        elif isinstance(self.left, VectorExpression) and hasattr(
+            self.left, "get_variables"
+        ):
+            result.update(self.left.get_variables())
+        if isinstance(self.right, VectorVariable):
+            result.update(self.right._variables)
+        elif isinstance(self.right, (VectorVariable, VectorExpression)) and hasattr(
+            self.right, "get_variables"
+        ):
+            result.update(self.right.get_variables())  # type: ignore[union-attr]
+        return result
+
+    def __repr__(self) -> str:
+        left_name = self.left.name if isinstance(self.left, VectorVariable) else "expr"
+        right_name = (
+            self.right.name if isinstance(self.right, VectorVariable) else "expr"
+        )
+        return f"VectorBinaryOp({left_name} {self.op} {right_name}, size={self.size})"
+
+
+def _iter_vector_exprs(
+    vec: VectorVariable | VectorExpression | float | int,
+    broadcast_size: int | None = None,
+) -> list[Expression]:
+    """Extract a list of scalar expressions from a vector operand."""
+    if isinstance(vec, VectorVariable):
+        return list(vec._variables)
+    if isinstance(vec, ElementwisePower):
+        return list(vec)  # __iter__ yields BinaryOp(var, Constant(power), "**")
+    if isinstance(vec, VectorExpression):
+        return list(
+            vec._expressions
+        )  # triggers lazy materialization for VectorBinaryOp
+    if isinstance(vec, (int, float)):
+        return [Constant(vec)] * (broadcast_size or 1)
+    return [Constant(vec)] * (broadcast_size or 1)
+
+
+def _eval_vector(
+    vec: VectorVariable | VectorExpression | float | int,
+    values: Mapping[str, ArrayLike | float],
+) -> NDArray[np.floating]:
+    """Evaluate a vector operand to a numpy array."""
+    if isinstance(vec, VectorVariable):
+        return np.array([v.evaluate(values) for v in vec._variables])
+    if isinstance(vec, ElementwisePower):
+        base_vals = _eval_vector(vec.vector, values)
+        return base_vals**vec.power
+    if isinstance(vec, VectorBinaryOp):
+        # Recursive numpy evaluation — no materialization
+        left_vals = _eval_vector(vec.left, values)
+        right_vals = _eval_vector(vec.right, values)
+        return VectorBinaryOp._NUMPY_OPS[vec.op](left_vals, right_vals)
+    if isinstance(vec, VectorExpression):
+        return np.array([e.evaluate(values) for e in vec._expressions])
+    # scalar
+    return np.array([float(vec)])
+
+
 class VectorVariable:
     """A vector of optimization variables.
 
@@ -1056,8 +1233,8 @@ class VectorVariable:
     # Declare types for slots (helps type checkers)
     name: str
     size: int
-    lb: float | None
-    ub: float | None
+    lb: float | Sequence[float] | NDArray | None
+    ub: float | Sequence[float] | NDArray | None
     domain: DomainType
     _variables: list[Variable]
 
@@ -1065,8 +1242,8 @@ def __init__(
         self,
         name: str,
         size: int,
-        lb: float | None = None,
-        ub: float | None = None,
+        lb: float | Sequence[float] | NDArray | None = None,
+        ub: float | Sequence[float] | NDArray | None = None,
         domain: DomainType = "continuous",
     ) -> None:
         if size <= 0:
@@ -1082,10 +1259,35 @@ def __init__(
         self.ub = ub
         self.domain = domain
 
+        # Helper to get bound for index i
+        def get_bound(
+            b: float | Sequence[float] | NDArray | None, i: int, param_name: str
+        ) -> float | None:
+            if b is None:
+                return None
+            if isinstance(b, (int, float, np.number)):
+                return float(b)
+            if hasattr(b, "__len__") and hasattr(b, "__getitem__"):
+                if len(b) != size:
+                    raise InvalidSizeError(
+                        entity=f"{param_name} for {name}",
+                        size=len(b),
+                        reason=f"must match vector size {size}",
+                    )
+                return float(b[i])
+            # Fallback
+            if hasattr(b, "__float__"):
+                return float(b)  # type: ignore
+            return None
+
         # Create individual variables
-        self._variables: list[Variable] = [
-            Variable(f"{name}[{i}]", lb=lb, ub=ub, domain=domain) for i in range(size)
-        ]
+        self._variables: list[Variable] = []
+        for i in range(size):
+            val_l = get_bound(lb, i, "lb")
+            val_u = get_bound(ub, i, "ub")
+            self._variables.append(
+                Variable(f"{name}[{i}]", lb=val_l, ub=val_u, domain=domain)
+            )
 
     @overload
     def __getitem__(self, key: int) -> Variable: ...
@@ -1093,20 +1295,23 @@ def __getitem__(self, key: int) -> Variable: ...
     @overload
     def __getitem__(self, key: slice) -> VectorVariable: ...
 
-    def __getitem__(self, key: int | slice) -> Variable | VectorVariable:
+    def __getitem__(
+        self, key: int | slice | Sequence[int] | NDArray
+    ) -> Variable | VectorVariable:
         """Index or slice the vector.
 
         Args:
-            key: Integer index or slice object.
+            key: Integer index, slice object, list of indices, or boolean array.
 
         Returns:
-            Single Variable for integer index, VectorVariable for slice.
+            Single Variable for integer index, VectorVariable for slice or list/array.
 
         Example:
             >>> x = VectorVariable("x", 10)
             >>> x[0]  # Variable("x[0]")
             >>> x[-1]  # Variable("x[9]")
             >>> x[2:5]  # VectorVariable with 3 elements
+            >>> x[[0, 2, 4]]  # VectorVariable with elements 0, 2, 4
         """
         if isinstance(key, int):
             # Handle negative indices
@@ -1128,12 +1333,48 @@ def __getitem__(self, key: int | slice) -> Variable | VectorVariable:
             return VectorVariable._from_variables(
                 name=f"{self.name}[{key.start or 0}:{key.stop or self.size}]",
                 variables=sliced_vars,
-                lb=self.lb,
-                ub=self.ub,
+                lb=self.lb if isinstance(self.lb, (int, float, type(None))) else None,
+                ub=self.ub if isinstance(self.ub, (int, float, type(None))) else None,
+                domain=self.domain,
+            )
+
+        elif isinstance(key, (list, tuple, np.ndarray)):
+            # Fancy indexing
+            if isinstance(key, (list, tuple)):
+                key = np.array(key)
+
+            # Type ignore because we checked type above but type checker might not infer
+            indices: NDArray = key  # type: ignore
+
+            if indices.dtype == bool:
+                if len(indices) != self.size:
+                    raise IndexError(f"Boolean index has wrong length: {len(indices)}")
+                indices = np.where(indices)[0]
+
+            selected_vars = []
+            for idx in indices:
+                # Handle negative indices manually
+                i = int(idx)
+                if i < 0:
+                    i = self.size + i
+                if i < 0 or i >= self.size:
+                    raise IndexError(f"Index {i} out of range")
+                selected_vars.append(self._variables[i])
+
+            if len(selected_vars) == 0:
+                raise IndexError("Fancy indexing results in empty VectorVariable")
+
+            return VectorVariable._from_variables(
+                name=f"{self.name}[fancy]",
+                variables=selected_vars,
+                lb=self.lb if isinstance(self.lb, (int, float, type(None))) else None,
+                ub=self.ub if isinstance(self.ub, (int, float, type(None))) else None,
                 domain=self.domain,
             )
 
         else:
+            # Original error fallback
+            raise TypeError(f"Invalid index type: {type(key)}")
             raise InvalidOperationError(
                 operation="vector indexing",
                 operand_types=(type(key).__name__,),
@@ -1228,10 +1469,13 @@ def __sub__(
         """Element-wise subtraction: x - y or x - scalar."""
         return _vector_binary_op(self, other, "-")
 
-    def __rsub__(self, other: float | int) -> VectorExpression:
+    def __rsub__(self, other: float | int) -> VectorBinaryOp:
         """Right subtraction: scalar - vector."""
-        return VectorExpression(
-            [BinaryOp(_ensure_expr(other), v, "-") for v in self._variables]
+        return VectorBinaryOp(
+            VectorExpression([Constant(float(other))] * self.size),
+            self,
+            "-",
+            self.size,
         )
 
     def __mul__(self, other: float | int) -> VectorExpression:
@@ -1246,15 +1490,18 @@ def __truediv__(self, other: float | int) -> VectorExpression:
         """Scalar division: x / 2."""
         return _vector_binary_op(self, other, "/")
 
-    def __rtruediv__(self, other: float | int) -> VectorExpression:
+    def __rtruediv__(self, other: float | int) -> VectorBinaryOp:
         """Right scalar division: 1 / x."""
-        return VectorExpression(
-            [BinaryOp(_ensure_expr(other), v, "/") for v in self._variables]
+        return VectorBinaryOp(
+            VectorExpression([Constant(float(other))] * self.size),
+            self,
+            "/",
+            self.size,
         )
 
-    def __neg__(self) -> VectorExpression:
+    def __neg__(self) -> VectorBinaryOp:
         """Negate all elements: -x."""
-        return VectorExpression([-v for v in self._variables])
+        return _vector_binary_op(self, -1, "*")
 
     def __pow__(self, other: float | int) -> ElementwisePower:
         """Element-wise power: x ** 2.
@@ -1298,6 +1545,18 @@ def eq(
         """
         return _vector_constraint(self, other, "==")
 
+    def between(
+        self,
+        lb: float | int | np.ndarray | list | VectorExpression | VectorVariable,
+        ub: float | int | np.ndarray | list | VectorExpression | VectorVariable,
+    ) -> list[Constraint]:
+        """Create element-wise range constraints: lb <= self <= ub.
+
+        Returns:
+            List of constraints covering both bounds.
+        """
+        return _vector_constraint(self, lb, ">=") + _vector_constraint(self, ub, "<=")
+
     def dot(self, other: VectorVariable | VectorExpression) -> DotProduct | Expression:
         """Compute dot product with another vector.
 
@@ -1605,56 +1864,48 @@ def _vector_binary_op(
     left: VectorVariable | VectorExpression,
     right: VectorVariable | VectorExpression | float | int,
     op: Literal["+", "-", "*", "/", "**"],
-) -> VectorExpression:
+) -> VectorBinaryOp:
     """Helper for element-wise binary operations on vectors.
 
+    Returns a single VectorBinaryOp node instead of N individual BinaryOps.
+    The per-element BinaryOps are materialized lazily only when needed.
+
     Args:
         left: Left operand (VectorVariable or VectorExpression).
         right: Right operand (vector or scalar).
         op: Operation to perform.
 
     Returns:
-        VectorExpression with element-wise results.
+        VectorBinaryOp with element-wise operation.
 
     Raises:
-        ValueError: If vector sizes don't match.
+        DimensionMismatchError: If vector sizes don't match.
     """
-    # Get expressions from left
+    # Determine left size
     if isinstance(left, VectorVariable):
-        left_exprs = list(left._variables)
-    elif isinstance(left, ElementwisePower):
-        left_exprs = list(left)  # ElementwisePower is iterable
+        left_size = left.size
+    elif isinstance(left, (VectorExpression, ElementwisePower)):
+        left_size = left.size
     else:
-        left_exprs = list(left._expressions)
+        left_size = left.size
 
-    # Handle right operand
+    # Validate right operand and determine size
     if isinstance(right, (int, float)):
-        # Scalar broadcast
-        right_exprs = [Constant(right)] * len(left_exprs)
+        pass  # scalar broadcast, always valid
     elif isinstance(right, VectorVariable):
-        if len(right) != len(left_exprs):
-            raise DimensionMismatchError(
-                operation=f"vector {op}",
-                left_shape=len(left_exprs),
-                right_shape=len(right),
-            )
-        right_exprs = list(right._variables)
-    elif isinstance(right, VectorExpression):
-        if right.size != len(left_exprs):
+        if right.size != left_size:
             raise DimensionMismatchError(
                 operation=f"vector {op}",
-                left_shape=len(left_exprs),
+                left_shape=left_size,
                 right_shape=right.size,
             )
-        right_exprs = list(right._expressions)
-    elif isinstance(right, ElementwisePower):
-        if right.size != len(left_exprs):
+    elif isinstance(right, (VectorExpression, ElementwisePower)):
+        if right.size != left_size:
             raise DimensionMismatchError(
                 operation=f"vector {op}",
-                left_shape=len(left_exprs),
+                left_shape=left_size,
                 right_shape=right.size,
             )
-        right_exprs = list(right)  # ElementwisePower is iterable
     elif isinstance(right, (np.ndarray, list)):
         arr = np.asarray(right)
         if arr.ndim != 1:
@@ -1663,13 +1914,14 @@ def _vector_binary_op(
                 expected_ndim=1,
                 got_ndim=arr.ndim,
             )
-        if len(arr) != len(left_exprs):
+        if len(arr) != left_size:
             raise DimensionMismatchError(
                 operation=f"vector {op}",
-                left_shape=len(left_exprs),
+                left_shape=left_size,
                 right_shape=len(arr),
             )
-        right_exprs = [Constant(val) for val in arr]
+        # Wrap numpy array as a VectorExpression of Constants
+        right = VectorExpression([Constant(float(val)) for val in arr])
     else:
         raise InvalidOperationError(
             operation=f"vector {op}",
@@ -1677,13 +1929,7 @@ def _vector_binary_op(
             suggestion="Use VectorVariable, VectorExpression, scalar, numpy array, or list.",
         )
 
-    # Create element-wise operations
-    result_exprs = [
-        BinaryOp(left_expr, right_expr, op)
-        for left_expr, right_expr in zip(left_exprs, right_exprs)
-    ]
-
-    return VectorExpression(result_exprs)
+    return VectorBinaryOp(left, right, op, left_size)
 
 
 def vector_sum(vector: VectorVariable | VectorExpression) -> VectorSum | Expression:
diff --git a/src/optyx/io.py b/src/optyx/io.py
new file mode 100644
index 0000000..9d26681
--- /dev/null
+++ b/src/optyx/io.py
@@ -0,0 +1,878 @@
+"""LP format file export for optimization problems.
+
+Exports Problem objects to the standard LP file format, compatible with
+solvers like CPLEX, Gurobi, GLPK, and HiGHS.
+
+LP format reference:
+    https://www.ibm.com/docs/en/icos/22.1.1?topic=cplex-lp-file-format-algebraic-representation
+
+Supported features:
+    - Linear and quadratic objectives
+    - Linear constraints (<=, >=, ==)
+    - Variable bounds
+    - Integer (Generals) and binary (Binaries) variable types
+    - Named constraints
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from optyx.analysis import (
+    is_linear,
+    extract_linear_coefficient,
+    extract_constant_term,
+)
+from optyx.core.errors import InvalidOperationError
+from optyx.core.expressions import (
+    BinaryOp,
+    Constant,
+    Expression,
+    NarySum,
+    UnaryOp,
+    Variable,
+)
+
+if TYPE_CHECKING:
+    from optyx.problem import Problem
+
+
+def _compute_poly_degree(expr: Expression) -> int | None:
+    """Compute the true polynomial degree of an expression.
+
+    Unlike analysis.compute_degree() which treats var*var as non-polynomial
+    (optimized for LP detection), this correctly returns degree 2 for
+    quadratic expressions like x*y or x**2.
+
+    Returns:
+        Integer degree if polynomial, None if non-polynomial.
+    """
+    from optyx.core.matrices import QuadraticForm
+    from optyx.core.vectors import (
+        DotProduct,
+        LinearCombination,
+        VectorSum,
+        VectorPowerSum,
+        VectorUnarySum,
+        ElementwisePower,
+        ElementwiseUnary,
+    )
+    import numbers
+
+    if isinstance(expr, Constant):
+        return 0
+    if isinstance(expr, Variable):
+        return 1
+
+    # Vector expression types
+    if isinstance(expr, (LinearCombination, VectorSum)):
+        return 1
+    if isinstance(expr, (DotProduct, QuadraticForm)):
+        return 2
+    if isinstance(expr, VectorPowerSum):
+        p = expr.power
+        if isinstance(p, (int, float)) and float(p).is_integer() and p >= 0:
+            return int(p)
+        return None
+    if isinstance(expr, (VectorUnarySum, ElementwiseUnary)):
+        return None
+    if isinstance(expr, ElementwisePower):
+        p = expr.power
+        if isinstance(p, (int, float)) and float(p).is_integer() and p >= 0:
+            return int(p)
+        return None
+
+    if isinstance(expr, BinaryOp):
+        op = expr.op
+        if op == "**":
+            if not isinstance(expr.right, Constant):
+                return None
+            exp_val = expr.right.value
+            if not isinstance(exp_val, numbers.Number):
+                return None
+            exp_float = float(exp_val)
+            if not exp_float.is_integer() or exp_float < 0:
+                return None
+            left_deg = _compute_poly_degree(expr.left)
+            if left_deg is None:
+                return None
+            return left_deg * int(exp_float)
+        if op == "/":
+            if not isinstance(expr.right, Constant):
+                return None
+            return _compute_poly_degree(expr.left)
+        if op in ("+", "-"):
+            ld = _compute_poly_degree(expr.left)
+            if ld is None:
+                return None
+            rd = _compute_poly_degree(expr.right)
+            if rd is None:
+                return None
+            return max(ld, rd)
+        if op == "*":
+            ld = _compute_poly_degree(expr.left)
+            if ld is None:
+                return None
+            rd = _compute_poly_degree(expr.right)
+            if rd is None:
+                return None
+            return ld + rd
+
+    if isinstance(expr, UnaryOp):
+        if expr.op == "neg":
+            return _compute_poly_degree(expr.operand)
+        return None
+
+    if isinstance(expr, NarySum):
+        max_d = 0
+        for t in expr.terms:
+            d = _compute_poly_degree(t)
+            if d is None:
+                return None
+            max_d = max(max_d, d)
+        return max_d
+
+    return None
+
+
+def _is_at_most_quadratic(expr: Expression) -> bool:
+    """Check if an expression is at most quadratic (degree <= 2)."""
+    d = _compute_poly_degree(expr)
+    return d is not None and d <= 2
+
+
+def write_lp(problem: Problem, filename: str) -> None:
+    """Export a Problem to LP file format.
+
+    Args:
+        problem: The optimization problem to export.
+        filename: Path to the output .lp file.
+
+    Raises:
+        InvalidOperationError: If the problem contains nonlinear (non-quadratic)
+            expressions that cannot be represented in LP format.
+        NoObjectiveError: If no objective has been set.
+    """
+    content = _format_lp(problem)
+    with open(filename, "w") as f:
+        f.write(content)
+
+
+def format_lp(problem: Problem) -> str:
+    """Format a Problem as an LP format string (without writing to file).
+
+    Args:
+        problem: The optimization problem to format.
+
+    Returns:
+        The LP format string.
+
+    Raises:
+        InvalidOperationError: If the problem contains nonlinear expressions.
+    """
+    return _format_lp(problem)
+
+
+def _format_lp(problem: Problem) -> str:
+    """Build the LP format string for a problem."""
+    from optyx.core.errors import NoObjectiveError
+
+    if problem.objective is None:
+        raise NoObjectiveError(
+            suggestion="Set an objective with minimize() or maximize() before exporting."
+        )
+
+    variables = problem.variables
+    if not variables:
+        raise InvalidOperationError(
+            operation="LP export",
+            operand_types="Problem",
+            reason="Problem has no variables.",
+        )
+
+    # Validate: objective and constraints must be at most quadratic
+    obj = problem.objective
+    if not _is_at_most_quadratic(obj):
+        raise InvalidOperationError(
+            operation="LP export",
+            operand_types=type(obj).__name__,
+            reason="LP format only supports linear and quadratic objectives.",
+            suggestion="Nonlinear objectives cannot be exported to LP format.",
+        )
+
+    for i, c in enumerate(problem.constraints):
+        if not is_linear(c.expr):
+            name = c.name or f"c{i}"
+            raise InvalidOperationError(
+                operation="LP export",
+                operand_types=type(c.expr).__name__,
+                reason=f"Constraint '{name}' is not linear. LP format only supports linear constraints.",
+                suggestion="Only linear constraints can be exported to LP format.",
+            )
+
+    lines: list[str] = []
+
+    # Comment header
+    name = problem.name or "optyx_model"
+    lines.append(f"\\ Model {name}")
+    lines.append("")
+
+    # Objective section
+    _write_objective(lines, problem, variables)
+
+    # Constraints section
+    _write_constraints(lines, problem, variables)
+
+    # Bounds section
+    _write_bounds(lines, variables)
+
+    # Integer / Binary variable sections
+    _write_variable_types(lines, variables)
+
+    lines.append("End")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def _write_objective(
+    lines: list[str], problem: Problem, variables: list[Variable]
+) -> None:
+    """Write the objective function section."""
+    obj = problem.objective
+    assert obj is not None
+
+    sense = "Minimize" if problem.sense == "minimize" else "Maximize"
+    lines.append(sense)
+
+    # Extract linear part
+    linear_terms = _extract_linear_terms(obj, variables)
+    constant = (
+        extract_constant_term(obj)
+        if is_linear(obj)
+        else _extract_constant_from_quadratic(obj)
+    )
+
+    # Extract quadratic part (if any)
+    quad_terms: list[tuple[str, str, float]] = []
+    if not is_linear(obj):
+        quad_terms = _extract_quadratic_terms(obj, variables)
+
+    # Format the objective line
+    obj_str = _format_expression(linear_terms, quad_terms, constant)
+    lines.append(f"  obj: {obj_str}")
+    lines.append("")
+
+
+def _write_constraints(
+    lines: list[str], problem: Problem, variables: list[Variable]
+) -> None:
+    """Write the constraints section."""
+    all_constraints = problem.constraints
+    matrix_constraints = problem._matrix_constraints
+
+    if not all_constraints and not matrix_constraints:
+        return
+
+    lines.append("Subject To")
+
+    # Expression-based constraints
+    for i, c in enumerate(all_constraints):
+        name = c.name or f"c{i}"
+        linear_terms = _extract_linear_terms(c.expr, variables)
+        constant = extract_constant_term(c.expr)
+
+        # Constraint is: expr sense 0, so expr - constant sense -constant
+        # We write: linear_part sense -constant
+        lhs_str = _format_expression(linear_terms, [], 0.0)
+        rhs = -constant
+
+        if not lhs_str or lhs_str.strip() == "0":
+            lhs_str = "0"
+
+        sense_str = c.sense
+        lines.append(f"  {name}: {lhs_str} {sense_str} {_format_number(rhs)}")
+
+    # Matrix constraints: A @ x sense b
+    constraint_offset = len(all_constraints)
+    for mc in matrix_constraints:
+        A = mc.A
+        b = mc.b
+        sense_str = mc.sense
+        mc_vars = mc.variables
+
+        # Build variable name list for this matrix constraint
+        var_names = [v.name for v in mc_vars]
+
+        m = A.shape[0]
+        for row_idx in range(m):
+            name = f"c{constraint_offset + row_idx}"
+
+            # Extract row coefficients
+            from scipy import sparse as sp
+
+            if sp.issparse(A):
+                row = A.getrow(row_idx)
+                indices = row.indices
+                data = row.data
+                terms: list[tuple[str, float]] = [
+                    (var_names[j], float(data[k]))
+                    for k, j in enumerate(indices)
+                    if abs(data[k]) > 1e-15
+                ]
+            else:
+                row_data = A[row_idx]
+                terms = [
+                    (var_names[j], float(row_data[j]))
+                    for j in range(len(var_names))
+                    if abs(row_data[j]) > 1e-15
+                ]
+
+            lhs_str = _format_linear_terms(terms)
+            if not lhs_str:
+                lhs_str = "0"
+
+            rhs = float(b[row_idx])
+            lines.append(f"  {name}: {lhs_str} {sense_str} {_format_number(rhs)}")
+
+        constraint_offset += m
+
+    lines.append("")
+
+
+def _write_bounds(lines: list[str], variables: list[Variable]) -> None:
+    """Write the bounds section."""
+    lines.append("Bounds")
+
+    for v in variables:
+        lb = v.lb
+        ub = v.ub
+
+        # Skip binary variables (handled in Binaries section with implicit 0/1 bounds)
+        if v.domain == "binary":
+            lines.append(f"  0 <= {v.name} <= 1")
+            continue
+
+        if lb is None and ub is None:
+            # Free variable
+            lines.append(f"  {v.name} free")
+        elif lb is not None and ub is not None:
+            lines.append(f"  {_format_number(lb)} <= {v.name} <= {_format_number(ub)}")
+        elif lb is not None:
+            lines.append(f"  {_format_number(lb)} <= {v.name}")
+        else:
+            # ub only
+            assert ub is not None
+            lines.append(f"  -inf <= {v.name} <= {_format_number(ub)}")
+
+    lines.append("")
+
+
+def _write_variable_types(lines: list[str], variables: list[Variable]) -> None:
+    """Write Generals and Binaries sections."""
+    generals = [v.name for v in variables if v.domain == "integer"]
+    binaries = [v.name for v in variables if v.domain == "binary"]
+
+    if generals:
+        lines.append("Generals")
+        for name in generals:
+            lines.append(f"  {name}")
+        lines.append("")
+
+    if binaries:
+        lines.append("Binaries")
+        for name in binaries:
+            lines.append(f"  {name}")
+        lines.append("")
+
+
+# =============================================================================
+# Expression formatting helpers
+# =============================================================================
+
+
+def _extract_linear_terms(
+    expr: Expression, variables: list[Variable]
+) -> list[tuple[str, float]]:
+    """Extract linear coefficient for each variable from a (possibly quadratic) expression.
+
+    For quadratic expressions, this extracts only the linear part.
+    """
+    terms: list[tuple[str, float]] = []
+
+    if is_linear(expr):
+        for v in variables:
+            coeff = extract_linear_coefficient(expr, v)
+            if abs(coeff) > 1e-15:
+                terms.append((v.name, coeff))
+    else:
+        # Quadratic expression — extract linear terms by walking the tree
+        linear_coeffs = _extract_linear_from_quadratic(expr, variables)
+        for v, coeff in zip(variables, linear_coeffs):
+            if abs(coeff) > 1e-15:
+                terms.append((v.name, coeff))
+
+    return terms
+
+
+def _extract_quadratic_terms(
+    expr: Expression, variables: list[Variable]
+) -> list[tuple[str, str, float]]:
+    """Extract quadratic terms as (var_i, var_j, coeff) triples.
+
+    Returns terms where i <= j (upper triangle), with coefficients
+    adjusted for LP format conventions:
+    - Diagonal: x_i^2 has coefficient as-is
+    - Off-diagonal: x_i * x_j has coefficient (summed for both orderings)
+    """
+    n = len(variables)
+    var_index = {v.name: i for i, v in enumerate(variables)}
+    Q = np.zeros((n, n), dtype=np.float64)
+
+    _collect_quadratic_coefficients(expr, var_index, Q, 1.0)
+
+    # Convert Q matrix to list of (var_i, var_j, coeff) with i <= j
+    terms: list[tuple[str, str, float]] = []
+    for i in range(n):
+        for j in range(i, n):
+            if i == j:
+                coeff = Q[i, j]
+            else:
+                # Combine symmetric entries
+                coeff = Q[i, j] + Q[j, i]
+            if abs(coeff) > 1e-15:
+                terms.append((variables[i].name, variables[j].name, coeff))
+
+    return terms
+
+
+def _collect_quadratic_coefficients(
+    expr: Expression,
+    var_index: dict[str, int],
+    Q: np.ndarray,
+    multiplier: float,
+) -> None:
+    """Recursively collect quadratic coefficients into matrix Q.
+
+    Walks the expression tree accounting for + - * and known quadratic patterns.
+    """
+    from optyx.core.matrices import QuadraticForm
+    from optyx.core.vectors import (
+        DotProduct,
+        VectorVariable,
+        VectorPowerSum,
+    )
+
+    # Leaf nodes — no quadratic contribution
+    if isinstance(expr, (Constant, Variable)):
+        return
+
+    # QuadraticForm: x' Q x
+    if isinstance(expr, QuadraticForm):
+        if isinstance(expr.vector, VectorVariable):
+            qvars = expr.vector._variables
+            matrix = expr.matrix
+            for i, vi in enumerate(qvars):
+                idx_i = var_index.get(vi.name)
+                if idx_i is None:
+                    continue
+                for j, vj in enumerate(qvars):
+                    idx_j = var_index.get(vj.name)
+                    if idx_j is None:
+                        continue
+                    Q[idx_i, idx_j] += multiplier * matrix[i, j]
+        return
+
+    # DotProduct: x.dot(x) = sum(x_i^2) when left is right
+    if isinstance(expr, DotProduct):
+        if (
+            isinstance(expr.left, VectorVariable)
+            and isinstance(expr.right, VectorVariable)
+            and expr.left is expr.right
+        ):
+            for v in expr.left._variables:
+                idx = var_index.get(v.name)
+                if idx is not None:
+                    Q[idx, idx] += multiplier
+        return
+
+    # VectorPowerSum: sum(x ** 2)
+    if isinstance(expr, VectorPowerSum):
+        if expr.power == 2.0 and isinstance(expr.vector, VectorVariable):
+            for v in expr.vector._variables:
+                idx = var_index.get(v.name)
+                if idx is not None:
+                    Q[idx, idx] += multiplier
+        return
+
+    # BinaryOp
+    if isinstance(expr, BinaryOp):
+        if expr.op == "+":
+            _collect_quadratic_coefficients(expr.left, var_index, Q, multiplier)
+            _collect_quadratic_coefficients(expr.right, var_index, Q, multiplier)
+            return
+        if expr.op == "-":
+            _collect_quadratic_coefficients(expr.left, var_index, Q, multiplier)
+            _collect_quadratic_coefficients(expr.right, var_index, Q, -multiplier)
+            return
+        if expr.op == "*":
+            # scalar * quadratic_expr or quadratic_expr * scalar
+            if isinstance(expr.left, Constant):
+                _collect_quadratic_coefficients(
+                    expr.right, var_index, Q, multiplier * float(expr.left.value)
+                )
+                return
+            if isinstance(expr.right, Constant):
+                _collect_quadratic_coefficients(
+                    expr.left, var_index, Q, multiplier * float(expr.right.value)
+                )
+                return
+            # var * var — quadratic term
+            left_vars = expr.left.get_variables()
+            right_vars = expr.right.get_variables()
+            if len(left_vars) == 1 and len(right_vars) == 1:
+                lv = next(iter(left_vars))
+                rv = next(iter(right_vars))
+                li = var_index.get(lv.name)
+                ri = var_index.get(rv.name)
+                if li is not None and ri is not None:
+                    # Handle coefficient*var * coefficient*var
+                    lc = _get_scalar_linear_coeff(expr.left, lv)
+                    rc = _get_scalar_linear_coeff(expr.right, rv)
+                    Q[li, ri] += multiplier * lc * rc
+            return
+        if expr.op == "**":
+            # var ** 2
+            if isinstance(expr.right, Constant) and float(expr.right.value) == 2.0:
+                left_vars = expr.left.get_variables()
+                if len(left_vars) == 1:
+                    lv = next(iter(left_vars))
+                    li = var_index.get(lv.name)
+                    if li is not None:
+                        lc = _get_scalar_linear_coeff(expr.left, lv)
+                        Q[li, li] += multiplier * lc * lc
+            return
+        if expr.op == "/":
+            if isinstance(expr.right, Constant):
+                _collect_quadratic_coefficients(
+                    expr.left, var_index, Q, multiplier / float(expr.right.value)
+                )
+            return
+
+    # UnaryOp
+    if isinstance(expr, UnaryOp):
+        if expr.op == "neg":
+            _collect_quadratic_coefficients(expr.operand, var_index, Q, -multiplier)
+        return
+
+    # NarySum
+    if isinstance(expr, NarySum):
+        for term in expr.terms:
+            _collect_quadratic_coefficients(term, var_index, Q, multiplier)
+        return
+
+
+def _get_scalar_linear_coeff(expr: Expression, var: Variable) -> float:
+    """Get the linear coefficient of a single-variable linear expression.
+
+    For expressions like `3*x`, returns 3.0. For just `x`, returns 1.0.
+    """
+    if isinstance(expr, Variable):
+        return 1.0
+    if isinstance(expr, BinaryOp):
+        if expr.op == "*":
+            if isinstance(expr.left, Constant):
+                return float(expr.left.value) * _get_scalar_linear_coeff(
+                    expr.right, var
+                )
+            if isinstance(expr.right, Constant):
+                return _get_scalar_linear_coeff(expr.left, var) * float(
+                    expr.right.value
+                )
+        if expr.op == "/":
+            if isinstance(expr.right, Constant):
+                return _get_scalar_linear_coeff(expr.left, var) / float(
+                    expr.right.value
+                )
+    if isinstance(expr, UnaryOp) and expr.op == "neg":
+        return -_get_scalar_linear_coeff(expr.operand, var)
+    return 1.0
+
+
+def _extract_linear_from_quadratic(
+    expr: Expression, variables: list[Variable]
+) -> list[float]:
+    """Extract only the linear coefficients from a quadratic expression.
+
+    Walks the tree, ignoring quadratic terms, and collects linear contributions.
+    """
+    n = len(variables)
+    var_index = {v.name: i for i, v in enumerate(variables)}
+    result = [0.0] * n
+    _collect_linear_from_quadratic(expr, var_index, result, 1.0)
+    return result
+
+
+def _collect_linear_from_quadratic(
+    expr: Expression,
+    var_index: dict[str, int],
+    result: list[float],
+    multiplier: float,
+) -> None:
+    """Recursively collect linear coefficients, skipping quadratic terms."""
+    from optyx.core.matrices import QuadraticForm
+    from optyx.core.vectors import (
+        DotProduct,
+        VectorVariable,
+        VectorSum,
+        LinearCombination,
+        VectorPowerSum,
+    )
+
+    # Constant — no linear contribution
+    if isinstance(expr, Constant):
+        return
+
+    # Variable — linear contribution
+    if isinstance(expr, Variable):
+        idx = var_index.get(expr.name)
+        if idx is not None:
+            result[idx] += multiplier
+        return
+
+    # VectorSum: sum(x) — each variable coefficient is 1
+    if isinstance(expr, VectorSum):
+        if isinstance(expr.vector, VectorVariable):
+            for v in expr.vector._variables:
+                idx = var_index.get(v.name)
+                if idx is not None:
+                    result[idx] += multiplier
+        return
+
+    # LinearCombination: c @ x
+    if isinstance(expr, LinearCombination):
+        if isinstance(expr.vector, VectorVariable):
+            for i, v in enumerate(expr.vector._variables):
+                idx = var_index.get(v.name)
+                if idx is not None:
+                    result[idx] += multiplier * float(expr.coefficients[i])
+        return
+
+    # Purely quadratic — no linear contribution
+    if isinstance(expr, (QuadraticForm, DotProduct, VectorPowerSum)):
+        return
+
+    # BinaryOp
+    if isinstance(expr, BinaryOp):
+        if expr.op == "+":
+            _collect_linear_from_quadratic(expr.left, var_index, result, multiplier)
+            _collect_linear_from_quadratic(expr.right, var_index, result, multiplier)
+            return
+        if expr.op == "-":
+            _collect_linear_from_quadratic(expr.left, var_index, result, multiplier)
+            _collect_linear_from_quadratic(expr.right, var_index, result, -multiplier)
+            return
+        if expr.op == "*":
+            if isinstance(expr.left, Constant):
+                _collect_linear_from_quadratic(
+                    expr.right, var_index, result, multiplier * float(expr.left.value)
+                )
+                return
+            if isinstance(expr.right, Constant):
+                _collect_linear_from_quadratic(
+                    expr.left, var_index, result, multiplier * float(expr.right.value)
+                )
+                return
+            # var * var — quadratic, no linear contribution
+            return
+        if expr.op == "/":
+            if isinstance(expr.right, Constant):
+                _collect_linear_from_quadratic(
+                    expr.left, var_index, result, multiplier / float(expr.right.value)
+                )
+            return
+        if expr.op == "**":
+            # x**2 is quadratic, skip; x**1 is handled as Variable
+            if isinstance(expr.right, Constant) and float(expr.right.value) == 1.0:
+                _collect_linear_from_quadratic(expr.left, var_index, result, multiplier)
+            return
+
+    # UnaryOp
+    if isinstance(expr, UnaryOp):
+        if expr.op == "neg":
+            _collect_linear_from_quadratic(expr.operand, var_index, result, -multiplier)
+        return
+
+    # NarySum
+    if isinstance(expr, NarySum):
+        for term in expr.terms:
+            _collect_linear_from_quadratic(term, var_index, result, multiplier)
+        return
+
+
+def _extract_constant_from_quadratic(expr: Expression) -> float:
+    """Extract constant term from a quadratic expression."""
+    if isinstance(expr, Constant):
+        return float(expr.value)
+    if isinstance(expr, Variable):
+        return 0.0
+    if isinstance(expr, BinaryOp):
+        if expr.op == "+":
+            return _extract_constant_from_quadratic(
+                expr.left
+            ) + _extract_constant_from_quadratic(expr.right)
+        if expr.op == "-":
+            return _extract_constant_from_quadratic(
+                expr.left
+            ) - _extract_constant_from_quadratic(expr.right)
+        if expr.op == "*":
+            if isinstance(expr.left, Constant):
+                return float(expr.left.value) * _extract_constant_from_quadratic(
+                    expr.right
+                )
+            if isinstance(expr.right, Constant):
+                return _extract_constant_from_quadratic(expr.left) * float(
+                    expr.right.value
+                )
+            return 0.0
+        if expr.op == "/":
+            if isinstance(expr.right, Constant):
+                return _extract_constant_from_quadratic(expr.left) / float(
+                    expr.right.value
+                )
+            return 0.0
+        if expr.op == "**":
+            if isinstance(expr.right, Constant) and float(expr.right.value) == 0.0:
+                return 1.0
+            return 0.0
+    if isinstance(expr, UnaryOp):
+        if expr.op == "neg":
+            return -_extract_constant_from_quadratic(expr.operand)
+        return 0.0
+    if isinstance(expr, NarySum):
+        return sum(_extract_constant_from_quadratic(t) for t in expr.terms)
+    return 0.0
+
+
+def _format_expression(
+    linear_terms: list[tuple[str, float]],
+    quad_terms: list[tuple[str, str, float]],
+    constant: float,
+) -> str:
+    """Format an expression as LP format string.
+
+    LP format for quadratic objectives uses [ ... ] / 2 notation.
+    """
+    parts: list[str] = []
+
+    # Linear terms
+    linear_str = _format_linear_terms(linear_terms)
+    if linear_str:
+        parts.append(linear_str)
+
+    # Quadratic terms ([ ... ] / 2 notation)
+    if quad_terms:
+        quad_str = _format_quadratic_section(quad_terms)
+        parts.append(quad_str)
+
+    # Constant term
+    if abs(constant) > 1e-15:
+        const_str = _format_number(constant)
+        if parts:
+            if constant > 0:
+                parts.append(f"+ {const_str}")
+            else:
+                parts.append(f"- {_format_number(-constant)}")
+        else:
+            parts.append(const_str)
+
+    if not parts:
+        return "0"
+
+    return " ".join(parts)
+
+
+def _format_linear_terms(terms: list[tuple[str, float]]) -> str:
+    """Format linear terms like '2 x0 + 3 x1 - x2'."""
+    if not terms:
+        return ""
+
+    parts: list[str] = []
+    for i, (name, coeff) in enumerate(terms):
+        if i == 0:
+            # First term: no leading space/sign unless negative
+            if coeff == 1.0:
+                parts.append(name)
+            elif coeff == -1.0:
+                parts.append(f"- {name}")
+            elif coeff < 0:
+                parts.append(f"- {_format_number(-coeff)} {name}")
+            else:
+                parts.append(f"{_format_number(coeff)} {name}")
+        else:
+            # Subsequent terms: always have + or -
+            if coeff == 1.0:
+                parts.append(f"+ {name}")
+            elif coeff == -1.0:
+                parts.append(f"- {name}")
+            elif coeff < 0:
+                parts.append(f"- {_format_number(-coeff)} {name}")
+            else:
+                parts.append(f"+ {_format_number(coeff)} {name}")
+
+    return " ".join(parts)
+
+
+def _format_quadratic_section(
+    quad_terms: list[tuple[str, str, float]],
+) -> str:
+    """Format quadratic terms in LP format: [ 2 x0 ^2 + 4 x0 * x1 ] / 2.
+
+    LP format convention: the quadratic section is [ Q_terms ] / 2,
+    where Q_terms use doubled coefficients (so the actual contribution is halved).
+    """
+    parts: list[str] = []
+    for i, (vi, vj, coeff) in enumerate(quad_terms):
+        # Double the coefficient for LP [ ... ] / 2 convention
+        doubled = 2.0 * coeff
+
+        if vi == vj:
+            term = f"{vi} ^2"
+        else:
+            term = f"{vi} * {vj}"
+
+        if i == 0:
+            if doubled == 1.0:
+                parts.append(term)
+            elif doubled == -1.0:
+                parts.append(f"- {term}")
+            elif doubled < 0:
+                parts.append(f"- {_format_number(-doubled)} {term}")
+            else:
+                parts.append(f"{_format_number(doubled)} {term}")
+        else:
+            if doubled == 1.0:
+                parts.append(f"+ {term}")
+            elif doubled == -1.0:
+                parts.append(f"- {term}")
+            elif doubled < 0:
+                parts.append(f"- {_format_number(-doubled)} {term}")
+            else:
+                parts.append(f"+ {_format_number(doubled)} {term}")
+
+    return "[ " + " ".join(parts) + " ] / 2"
+
+
+def _format_number(value: float) -> str:
+    """Format a number for LP output, removing unnecessary trailing zeros."""
+    if value == float("inf"):
+        return "inf"
+    if value == float("-inf"):
+        return "-inf"
+    if value == int(value):
+        return str(int(value))
+    # Format with reasonable precision, strip trailing zeros
+    formatted = f"{value:.10g}"
+    return formatted
diff --git a/src/optyx/problem.py b/src/optyx/problem.py
index 71d6c85..5843c58 100644
--- a/src/optyx/problem.py
+++ b/src/optyx/problem.py
@@ -11,16 +11,36 @@
 from __future__ import annotations
 
 import re
-from typing import TYPE_CHECKING, Literal
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Callable, Literal, Iterable
+from types import TracebackType
 
-from optyx.core.errors import InvalidOperationError, ConstraintError, NoObjectiveError
+import numpy as np
+
+from optyx.core.errors import (
+    InvalidOperationError,
+    ConstraintError,
+    NoObjectiveError,
+    UnsupportedOperationError,
+)
 
 if TYPE_CHECKING:
+    from numpy.typing import NDArray
     from optyx.analysis import LPData
-    from optyx.constraints import Constraint
+    from optyx.constraints import Constraint, MatrixConstraintBlock
     from optyx.core.expressions import Expression, Variable
     from optyx.core.vectors import VectorVariable
-    from optyx.solution import Solution
+    from optyx.solution import Solution, SolverProgress
+
+
+@dataclass
+class _MatrixConstraint:
+    """Stores a batch of linear constraints in matrix form: A @ x sense b."""
+
+    A: Any  # NDArray or scipy.sparse matrix
+    b: NDArray[np.floating]
+    sense: Literal["<=", ">=", "=="]
+    variables: list[Variable]  # The VectorVariable's individual variables
 
 
 # Threshold for "small" problems where gradient-free methods are faster
@@ -29,6 +49,12 @@
 # Threshold for "large" problems where memory-efficient methods are preferred
 LARGE_PROBLEM_THRESHOLD = 1000
 
+# Thresholds for preferring trust-constr on large sparse NLPs
+SPARSE_NLP_ROW_THRESHOLD = 32
+SPARSE_NLP_VARIABLE_THRESHOLD = 64
+SPARSE_NLP_DENSITY_THRESHOLD = 0.15
+SPARSE_MATRIX_ENTRY_THRESHOLD = 4096
+
 # Pre-compiled regex for natural sorting of variable names
 _NUMBER_SPLIT_RE = re.compile(r"(\d+)")
 
@@ -133,19 +159,22 @@ def _try_get_single_vector_source(expr: "Expression") -> "VectorVariable | None"
 
         # DotProduct (x.dot(y)) - check if both sides are same VectorVariable
         if isinstance(current, DotProduct):
-            left_is_vec = isinstance(current.left, VectorVariable)
-            right_is_vec = isinstance(current.right, VectorVariable)
-            if left_is_vec and right_is_vec:
+            left = current.left
+            right = current.right
+            is_left_vec = isinstance(left, VectorVariable)
+            is_right_vec = isinstance(right, VectorVariable)
+
+            if is_left_vec and is_right_vec:
                 # Both are VectorVariables - must be the same
-                if current.left is current.right:
-                    candidate = current.left
+                if left is right:
+                    candidate = left
                     if found_source is None:
                         found_source = candidate
                     elif found_source is not candidate:
                         return None
                 else:
                     return None  # Two different VectorVariables
-            elif left_is_vec or right_is_vec:
+            elif is_left_vec or is_right_vec:
                 # One is VectorVariable, one is VectorExpression
                 return None  # Complex case, bail out
             else:
@@ -203,6 +232,7 @@ def __init__(self, name: str | None = None):
         self._objective: Expression | None = None
         self._sense: Literal["minimize", "maximize"] = "minimize"
         self._constraints: list[Constraint] = []
+        self._matrix_constraints: list[_MatrixConstraint] = []
         self._variables: list[Variable] | None = None  # Cached
         # Solver cache for compiled callables (reused across solve() calls)
         self._solver_cache: dict | None = None
@@ -210,6 +240,8 @@ def __init__(self, name: str | None = None):
         self._lp_cache: LPData | None = None
         # Cached linearity check result (None = not computed, True/False = result)
         self._is_linear_cache: bool | None = None
+        # Warm start: last solution array (used as x0 on re-solve)
+        self._last_solution: NDArray[np.floating] | None = None
 
     def _invalidate_caches(self) -> None:
         """Invalidate all cached data when problem is modified."""
@@ -218,7 +250,29 @@ def _invalidate_caches(self) -> None:
         self._lp_cache = None
         self._is_linear_cache = None
 
-    def minimize(self, expr: Expression) -> Problem:
+    def _invalidate_constraint_caches(self) -> None:
+        """Invalidate only constraint-related caches.
+
+        Preserves objective/gradient compiled callables in the solver cache
+        so they don't need to be recompiled when only constraints change.
+        """
+        self._variables = None
+        self._lp_cache = None
+        self._is_linear_cache = None
+        # Remove only constraint keys from solver cache, keeping obj_fn/grad_fn/hess_fn
+        if self._solver_cache is not None:
+            for key in (
+                "scipy_constraints",
+                "linear_constraints",
+                "sparse_constraint_jac_fn",
+                "constraint_exprs",
+                "constraint_fns",
+                "constraint_senses",
+                "constraint_variables",
+            ):
+                self._solver_cache.pop(key, None)
+
+    def minimize(self, expr: Expression | float | int) -> Problem:
         """Set the objective function to minimize.
 
         Args:
@@ -240,7 +294,7 @@ def minimize(self, expr: Expression) -> Problem:
         self._invalidate_caches()
         return self
 
-    def maximize(self, expr: Expression) -> Problem:
+    def maximize(self, expr: Expression | float | int) -> Problem:
         """Set the objective function to maximize.
 
         Args:
@@ -261,13 +315,46 @@ def maximize(self, expr: Expression) -> Problem:
         self._invalidate_caches()
         return self
 
-    def subject_to(self, constraint: Constraint | list[Constraint]) -> Problem:
+    def _append_matrix_constraint(self, block: MatrixConstraintBlock) -> None:
+        from scipy import sparse as sp
+
+        A = block.A
+        b_arr = np.asarray(block.b, dtype=np.float64).ravel()
+
+        if sp.issparse(A):
+            m, n = A.shape
+        else:
+            A = np.asarray(A, dtype=np.float64)
+            m, n = A.shape
+
+        variables = list(block.variables)
+        if n != len(variables):
+            raise ValueError(f"A has {n} columns but x has {len(variables)} variables")
+        if m != len(b_arr):
+            raise ValueError(f"A has {m} rows but b has {len(b_arr)} elements")
+        if block.sense not in ("<=", ">=", "=="):
+            raise ValueError(f"sense must be '<=', '>=', or '==', got '{block.sense}'")
+
+        self._matrix_constraints.append(
+            _MatrixConstraint(
+                A=A,
+                b=b_arr,
+                sense=block.sense,
+                variables=variables,
+            )
+        )
+
+    def subject_to(
+        self,
+        constraint: Constraint
+        | MatrixConstraintBlock
+        | Iterable[Constraint | MatrixConstraintBlock],
+    ) -> Problem:
         """Add a constraint or list of constraints to the problem.
 
         Args:
-            constraint: Constraint or list of constraints to add.
-                Lists are typically produced by vectorized constraints
-                like `x >= 0` on VectorVariable.
+            constraint: Constraint or iterable of constraints to add.
+                Accepts lists, tuples, generators, etc.
 
         Returns:
             Self for method chaining.
@@ -278,16 +365,110 @@ def subject_to(self, constraint: Constraint | list[Constraint]) -> Problem:
         Example:
             >>> x = VectorVariable("x", 100)
             >>> prob.subject_to(x >= 0)  # Adds 100 constraints
+            >>> prob.subject_to(x[i] >= 0 for i in range(10))  # Generator
         """
-        if isinstance(constraint, list):
+        from optyx.constraints import (
+            Constraint as ConstraintType,
+            MatrixConstraintBlock as MatrixConstraintBlockType,
+        )
+
+        if isinstance(constraint, ConstraintType):
+            self._constraints.append(self._validate_constraint(constraint))
+        elif isinstance(constraint, MatrixConstraintBlockType):
+            self._append_matrix_constraint(constraint)
+        elif isinstance(constraint, Iterable):
             for c in constraint:
-                self._constraints.append(self._validate_constraint(c))
+                if isinstance(c, ConstraintType):
+                    self._constraints.append(self._validate_constraint(c))
+                elif isinstance(c, MatrixConstraintBlockType):
+                    self._append_matrix_constraint(c)
+                else:
+                    self._constraints.append(self._validate_constraint(c))
         else:
-            self._constraints.append(self._validate_constraint(constraint))
-        self._invalidate_caches()
+            # Fallback
+            from optyx.core.expressions import Expression
+
+            if isinstance(constraint, Expression):
+                reason = f"Expected Constraint, got Expression ({type(constraint).__name__}). Did you forget a comparison operator (==, <=, >=)?"
+            else:
+                reason = f"Expected Constraint or iterable of Constraints, got {type(constraint).__name__}"
+
+            raise ConstraintError(
+                message=reason,
+                constraint_expr=str(constraint),
+            )
+        self._invalidate_constraint_caches()
+        return self
+
+    def remove_constraint(self, index_or_name: int | str) -> Problem:
+        """Remove a constraint by index or name.
+
+        Args:
+            index_or_name: If int, removes the constraint at that index.
+                If str, removes the first constraint with that name.
+
+        Returns:
+            Self for method chaining.
+
+        Raises:
+            IndexError: If integer index is out of range.
+            KeyError: If no constraint with the given name is found.
+
+        Example:
+            >>> prob.subject_to((x + y <= 10).name == "cap")
+            >>> prob.remove_constraint("cap")
+            >>> prob.remove_constraint(0)  # Remove first constraint
+        """
+        if isinstance(index_or_name, int):
+            idx = index_or_name
+            if idx < 0 or idx >= len(self._constraints):
+                raise IndexError(
+                    f"Constraint index {idx} out of range "
+                    f"(problem has {len(self._constraints)} constraints)"
+                )
+            self._constraints.pop(idx)
+        elif isinstance(index_or_name, str):
+            name = index_or_name
+            for i, c in enumerate(self._constraints):
+                if c.name == name:
+                    self._constraints.pop(i)
+                    break
+            else:
+                raise KeyError(
+                    f"No constraint named '{name}' found. "
+                    f"Named constraints: {[c.name for c in self._constraints if c.name]}"
+                )
+        else:
+            raise TypeError(f"Expected int or str, got {type(index_or_name).__name__}")
+        self._invalidate_constraint_caches()
+        return self
+
+    def __enter__(self) -> Problem:
+        """Context manager support."""
         return self
 
-    def _validate_expression(self, expr: Expression, context: str) -> Expression:
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Context manager exit (no-op)."""
+        pass
+
+    def reset(self) -> None:
+        """Reset the problem solver state (clears caches and warm start).
+
+        Forces a complete re-analysis and re-compilation of the problem
+        on the next solve() call. Also clears any stored warm start state,
+        forcing a cold start on the next solve.
+        """
+        self._invalidate_caches()
+        self._last_solution = None
+
+    def _validate_expression(
+        self, expr: Expression | float | int, context: str
+    ) -> Expression:
         """Validate that expr is a valid Expression type.
 
         Args:
@@ -422,6 +603,9 @@ def variables(self) -> list[Variable]:
         for constraint in self._constraints:
             all_vars.update(constraint.get_variables())
 
+        for mc in self._matrix_constraints:
+            all_vars.update(mc.variables)
+
         self._variables = sorted(all_vars, key=_natural_sort_key)
         return self._variables
 
@@ -433,7 +617,10 @@ def n_variables(self) -> int:
     @property
     def n_constraints(self) -> int:
         """Number of constraints."""
-        return len(self._constraints)
+        n = len(self._constraints)
+        for mc in self._matrix_constraints:
+            n += mc.A.shape[0]
+        return n
 
     def get_bounds(self) -> list[tuple[float | None, float | None]]:
         """Get variable bounds as a list of (lb, ub) tuples.
@@ -468,6 +655,7 @@ def _is_linear_problem(self) -> bool:
                 self._is_linear_cache = False
                 return False
 
+        # Matrix constraints are always linear by definition
         self._is_linear_cache = True
         return True
 
@@ -476,6 +664,9 @@ def _only_simple_bounds(self) -> bool:
 
         Simple bounds are constraints on a single variable like x >= 0 or x <= 10.
         """
+        if self._matrix_constraints:
+            return False
+
         if not self._constraints:
             return True
 
@@ -485,7 +676,73 @@ def _only_simple_bounds(self) -> bool:
 
     def _has_equality_constraints(self) -> bool:
         """Check if problem has any equality constraints."""
-        return any(c.sense == "==" for c in self._constraints)
+        return any(c.sense == "==" for c in self._constraints) or any(
+            mc.sense == "==" for mc in self._matrix_constraints
+        )
+
+    def _has_general_constraints(self) -> bool:
+        """Check if the problem has any non-bound constraints."""
+        return bool(self._constraints or self._matrix_constraints)
+
+    def _general_constraint_rows(self) -> int:
+        """Return the total number of scalar and matrix constraint rows."""
+        return len(self._constraints) + sum(
+            mc.A.shape[0] for mc in self._matrix_constraints
+        )
+
+    def _prefer_trust_constr_for_sparse_constraints(self) -> bool:
+        """Heuristic for large sparse constrained NLPs.
+
+        trust-constr can exploit batched sparse Jacobians and sparse linear
+        constraints better than SLSQP when the constrained NLP is large and the
+        Jacobian structure is sparse.
+        """
+        from scipy import sparse as sp
+
+        n = len(self.variables)
+        total_rows = self._general_constraint_rows()
+
+        if n == 0 or total_rows == 0:
+            return False
+
+        if self._matrix_constraints:
+            total_entries = 0
+            total_nnz = 0
+            sparse_blocks = 0
+
+            for mc in self._matrix_constraints:
+                m, cols = mc.A.shape
+                total_entries += m * cols
+                if sp.issparse(mc.A):
+                    sparse_blocks += 1
+                    total_nnz += mc.A.nnz
+                else:
+                    total_nnz += int(np.count_nonzero(mc.A))
+
+            density = total_nnz / total_entries if total_entries > 0 else 1.0
+
+            if sparse_blocks > 0 and (
+                n >= SPARSE_NLP_VARIABLE_THRESHOLD
+                or total_rows >= SPARSE_NLP_ROW_THRESHOLD
+            ):
+                return True
+
+            if (
+                total_entries >= SPARSE_MATRIX_ENTRY_THRESHOLD
+                and density <= SPARSE_NLP_DENSITY_THRESHOLD
+            ):
+                return True
+
+        if (
+            len(self._constraints) >= SPARSE_NLP_ROW_THRESHOLD
+            and n >= SPARSE_NLP_VARIABLE_THRESHOLD
+        ):
+            total_support = sum(len(c.get_variables()) for c in self._constraints)
+            density = total_support / (len(self._constraints) * n)
+            if density <= SPARSE_NLP_DENSITY_THRESHOLD:
+                return True
+
+        return False
 
     def _auto_select_method(self) -> str:
         """Automatically select the best solver method for this problem.
@@ -495,7 +752,7 @@ def _auto_select_method(self) -> str:
         2. Unconstrained:
            - n > 1000 → "L-BFGS-B" (memory efficient for large problems)
            - else → "L-BFGS-B" (fast, handles bounds, good default)
-        3. Only simple bounds → "L-BFGS-B"
+        3. Large sparse constrained NLP → "trust-constr"
         4. Non-linear + constraints → "trust-constr" (robust for non-convex)
         5. Linear/quadratic + constraints → "SLSQP" (faster, with fallback)
 
@@ -505,9 +762,12 @@ def _auto_select_method(self) -> str:
         from optyx.analysis import compute_degree
 
         # Unconstrained - use L-BFGS-B (fast, memory-efficient, handles bounds)
-        if not self._constraints:
+        if not self._has_general_constraints():
             return "L-BFGS-B"
 
+        if self._prefer_trust_constr_for_sparse_constraints():
+            return "trust-constr"
+
         # Only variable bounds (no general constraints)
         # FIXME: L-BFGS-B does not support constraints passed via the 'constraints' argument.
         # Until we implement merging of simple bound constraints into the variable bounds,
@@ -540,6 +800,9 @@ def solve(
         self,
         method: str = "auto",
         strict: bool = False,
+        warm_start: bool = True,
+        callback: Callable[[SolverProgress], bool | None] | None = None,
+        time_limit: float | None = None,
         **kwargs,
     ) -> Solution:
         """Solve the optimization problem.
@@ -564,14 +827,26 @@ def solve(
                 that the solver cannot handle exactly (e.g., integer/binary
                 variables with SciPy). If False (default), emit a warning and
                 use the best available approximation.
+            warm_start: If True (default), use the previous solution as the
+                initial point for re-solving. Only applies to NLP methods.
+                Call reset() to clear warm start state.
+            callback: Optional function called at each solver iteration with a
+                SolverProgress object. Return True to terminate early
+                (solution will have SolverStatus.TERMINATED). Only applies
+                to NLP methods (SciPy).
+            time_limit: Maximum wall-clock time in seconds. If exceeded, the
+                solver terminates early with SolverStatus.TERMINATED. Only
+                applies to NLP methods (SciPy).
             **kwargs: Additional arguments passed to the solver.
 
         Returns:
             Solution object with results.
 
         Raises:
-            ValueError: If no objective has been set, or if strict=True and
-                the problem contains unsupported features.
+            NoObjectiveError: If no objective has been set.
+            UnsupportedOperationError: If the problem is a nonlinear discrete
+                model (MIQP/MINLP), which the current solver stack does not
+                support.
         """
         if self._objective is None:
             raise NoObjectiveError(
@@ -583,26 +858,94 @@ def solve(
             if self._is_linear_problem():
                 from optyx.solvers.lp_solver import solve_lp
 
-                return solve_lp(self, strict=strict, **kwargs)
+                solution = solve_lp(self, strict=strict, **kwargs)
+                self._store_solution(solution)
+                return solution
             else:
                 method = self._auto_select_method()
 
+        # Check for MIQP/MINLP (nonlinear + integer vars) before NLP dispatch.
+        # This fires for all NLP methods, not just "auto", to prevent silent
+        # relaxation of integer/binary domains.
+        _NLP_METHODS = {
+            "SLSQP",
+            "trust-constr",
+            "L-BFGS-B",
+            "BFGS",
+            "CG",
+            "Newton-CG",
+            "Nelder-Mead",
+            "Powell",
+            "COBYLA",
+            "TNC",
+            "dogleg",
+            "trust-ncg",
+            "trust-exact",
+            "trust-krylov",
+        }
+        if method in _NLP_METHODS:
+            discrete_names = [
+                v.name for v in self.variables if v.domain in ("integer", "binary")
+            ]
+            if discrete_names and not self._is_linear_problem():
+                raise UnsupportedOperationError(
+                    "MIQP/MINLP solve",
+                    solver_name="SciPy/HiGHS",
+                    problem_feature=(
+                        "nonlinear objective or constraints with integer/binary "
+                        f"variables {discrete_names}"
+                    ),
+                    suggestion=(
+                        "Use the MILP solver for linear discrete models, or relax "
+                        "integrality / switch to a dedicated MIQP or MINLP solver"
+                    ),
+                )
+
+        # Handle explicit milp request
+        if method == "milp":
+            from optyx.solvers.lp_solver import solve_lp
+
+            solution = solve_lp(self, strict=strict, **kwargs)
+            self._store_solution(solution)
+            return solution
+
         # Handle explicit linprog request
         if method == "linprog":
             from optyx.solvers.lp_solver import solve_lp
 
-            return solve_lp(self, strict=strict, **kwargs)
+            solution = solve_lp(self, strict=strict, **kwargs)
+            self._store_solution(solution)
+            return solution
 
         # Route HiGHS methods to LP solver
         if method in ("highs", "highs-ds", "highs-ipm"):
             from optyx.solvers.lp_solver import solve_lp
 
-            return solve_lp(self, method=method, strict=strict, **kwargs)
+            solution = solve_lp(self, method=method, strict=strict, **kwargs)
+            self._store_solution(solution)
+            return solution
 
         # Use scipy solver for NLP methods
         from optyx.solvers.scipy_solver import solve_scipy
 
-        return solve_scipy(self, method=method, strict=strict, **kwargs)
+        solution = solve_scipy(
+            self,
+            method=method,
+            strict=strict,
+            warm_start=warm_start,
+            callback=callback,
+            time_limit=time_limit,
+            **kwargs,
+        )
+        self._store_solution(solution)
+        return solution
+
+    def _store_solution(self, solution: Solution) -> None:
+        """Store solution values for warm starting subsequent solves."""
+        if solution.values:
+            variables = self.variables
+            x = np.array([solution.values.get(v.name, 0.0) for v in variables])
+            self._last_solution = x
 
     def __repr__(self) -> str:
         obj_str = "not set" if self._objective is None else f"{self._sense}"
@@ -613,6 +956,50 @@ def __repr__(self) -> str:
             f"n_constraints={self.n_constraints})"
         )
 
+    def write(self, filename: str) -> None:
+        """Export the problem to LP file format.
+
+        Writes the problem formulation to a human-readable .lp file,
+        compatible with solvers like CPLEX, Gurobi, GLPK, and HiGHS.
+
+        Supports linear and quadratic objectives, linear constraints,
+        variable bounds, and integer/binary variable types.
+
+        Args:
+            filename: Path to the output .lp file.
+
+        Raises:
+            InvalidOperationError: If the problem contains nonlinear
+                expressions that cannot be represented in LP format.
+            NoObjectiveError: If no objective has been set.
+
+        Example:
+            >>> x = Variable("x", lb=0)
+            >>> y = Variable("y", lb=0)
+            >>> prob = Problem("example")
+            >>> prob.minimize(2 * x + 3 * y)
+            >>> prob.subject_to(x + y >= 1)
+            >>> prob.write("example.lp")
+        """
+        from optyx.io import write_lp
+
+        write_lp(self, filename)
+
+    def to_lp(self) -> str:
+        """Return the LP format string representation of the problem.
+
+        Like write(), but returns the string instead of writing to a file.
+
+        Returns:
+            The LP format string.
+
+        Raises:
+            InvalidOperationError: If the problem contains nonlinear expressions.
+        """
+        from optyx.io import format_lp
+
+        return format_lp(self)
+
     def summary(self) -> str:
         """Return a human-readable summary of the optimization problem.
 
diff --git a/src/optyx/solution.py b/src/optyx/solution.py
index 8a9e142..9997c59 100644
--- a/src/optyx/solution.py
+++ b/src/optyx/solution.py
@@ -9,6 +9,8 @@
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import TYPE_CHECKING
+import json
+import os
 
 import numpy as np
 
@@ -18,6 +20,7 @@
     from optyx.core.expressions import Variable
     from optyx.core.vectors import VectorVariable
     from optyx.core.matrices import MatrixVariable
+    from optyx.core.variable_dict import VariableDict
 else:
     from optyx.core.expressions import Variable
 
@@ -29,10 +32,30 @@ class SolverStatus(Enum):
     INFEASIBLE = "infeasible"
     UNBOUNDED = "unbounded"
     MAX_ITERATIONS = "max_iterations"
+    TERMINATED = "terminated"
     FAILED = "failed"
     NOT_SOLVED = "not_solved"
 
 
+@dataclass
+class SolverProgress:
+    """Snapshot of solver state passed to user callbacks during optimization.
+
+    Attributes:
+        iteration: Current iteration number.
+        objective_value: Current objective function value (in original sense).
+        constraint_violation: Maximum constraint violation (0.0 if feasible).
+        elapsed_time: Wall-clock time since solve started (seconds).
+        x: Current variable values as a numpy array.
+    """
+
+    iteration: int
+    objective_value: float
+    constraint_violation: float
+    elapsed_time: float
+    x: NDArray[np.floating]
+
+
 @dataclass
 class Solution:
     """Result of solving an optimization problem.
@@ -60,6 +83,8 @@ class Solution:
     iterations: int | None = None
     message: str = ""
     solve_time: float | None = None
+    mip_gap: float | None = None
+    best_bound: float | None = None
 
     @property
     def is_optimal(self) -> bool:
@@ -69,19 +94,92 @@ def is_optimal(self) -> bool:
     @property
     def is_feasible(self) -> bool:
         """Check if a feasible solution was found."""
-        return self.status in (SolverStatus.OPTIMAL, SolverStatus.MAX_ITERATIONS)
+        return self.status in (
+            SolverStatus.OPTIMAL,
+            SolverStatus.MAX_ITERATIONS,
+            SolverStatus.TERMINATED,
+        )
+
+    def to_dict(self) -> dict:
+        """Convert solution to dictionary."""
+        return {
+            "status": self.status.value,
+            "objective_value": self.objective_value,
+            "values": self.values,
+            "multipliers": self.multipliers,
+            "iterations": self.iterations,
+            "message": self.message,
+            "solve_time": self.solve_time,
+            "mip_gap": self.mip_gap,
+            "best_bound": self.best_bound,
+        }
+
+    def to_json(self, path: str | None = None) -> str:
+        """Convert solution to JSON string or save to file.
+
+        Args:
+            path: Optional file path to save JSON to.
+
+        Returns:
+            JSON string if path is None, otherwise empty string.
+        """
+        data = self.to_dict()
+        if path:
+            with open(path, "w") as f:
+                json.dump(data, f, indent=2)
+            return ""
+        return json.dumps(data, indent=2)
+
+    @classmethod
+    def from_json(cls, json_str_or_path: str) -> Solution:
+        """Create solution from JSON string or file path.
+
+        Args:
+            json_str_or_path: JSON string or path to JSON file.
+
+        Returns:
+            Solution object.
+        """
+        if os.path.isfile(json_str_or_path):
+            with open(json_str_or_path, "r") as f:
+                data = json.load(f)
+        else:
+            data = json.loads(json_str_or_path)
+
+        return cls(
+            status=SolverStatus(data["status"]),
+            objective_value=data.get("objective_value"),
+            values=data.get("values", {}),
+            multipliers=data.get("multipliers"),
+            iterations=data.get("iterations"),
+            message=data.get("message", ""),
+            solve_time=data.get("solve_time"),
+            mip_gap=data.get("mip_gap"),
+            best_bound=data.get("best_bound"),
+        )
+
+    def print_vars(self) -> None:
+        """Pretty-print variable values."""
+        print(f"Status: {self.status.value}")
+        if self.objective_value is not None:
+            print(f"Objective: {self.objective_value:.6g}")
+        print("Variables:")
+        for name, value in sorted(self.values.items()):
+            print(f"  {name}: {value:.6g}")
 
     def __getitem__(
         self, var: Variable | VectorVariable | MatrixVariable | str
-    ) -> float | NDArray[np.floating]:
+    ) -> float | NDArray[np.floating] | dict[str, float]:
         """Get the optimal value of a variable.
 
         For scalar Variable: returns float.
         For VectorVariable: returns 1D numpy array.
         For MatrixVariable: returns 2D numpy array.
+        For VariableDict: returns dict mapping keys to float values.
 
         Args:
-            var: Variable, VectorVariable, MatrixVariable, or variable name.
+            var: Variable, VectorVariable, MatrixVariable, VariableDict,
+                or variable name.
 
         Returns:
             The optimal value(s).
@@ -100,8 +198,11 @@ def __getitem__(
         # Import here to avoid circular imports
         from optyx.core.vectors import VectorVariable
         from optyx.core.matrices import MatrixVariable
+        from optyx.core.variable_dict import VariableDict
 
-        if isinstance(var, VectorVariable):
+        if isinstance(var, VariableDict):
+            return self._get_variable_dict(var)
+        elif isinstance(var, VectorVariable):
             return self._get_vector(var)
         elif isinstance(var, MatrixVariable):
             return self._get_matrix(var)
@@ -128,6 +229,20 @@ def _get_vector(self, vec: VectorVariable) -> NDArray[np.floating]:
             result[i] = self.values[v.name]
         return result
 
+    def _get_variable_dict(self, vd: VariableDict) -> dict[str, float]:
+        """Extract VariableDict values as a dict mapping keys to floats.
+
+        Args:
+            vd: VariableDict to extract.
+
+        Returns:
+            Dict mapping each key to its optimal value.
+
+        Raises:
+            KeyError: If any variable not found in solution.
+        """
+        return {key: self.values[var.name] for key, var in vd.items()}
+
     def _get_matrix(self, mat: MatrixVariable) -> NDArray[np.floating]:
         """Extract MatrixVariable values as 2D numpy array.
 
@@ -151,8 +266,8 @@ def _get_matrix(self, mat: MatrixVariable) -> NDArray[np.floating]:
     def get(
         self,
         var: Variable | VectorVariable | MatrixVariable | str,
-        default: float | NDArray[np.floating] | None = None,
-    ) -> float | NDArray[np.floating] | None:
+        default: float | NDArray[np.floating] | dict[str, float] | None = None,
+    ) -> float | NDArray[np.floating] | dict[str, float] | None:
         """Get the optimal value of a variable with a default.
 
         For scalar Variable: returns float.
diff --git a/src/optyx/solvers/__init__.py b/src/optyx/solvers/__init__.py
index 6cb86e8..297c4c8 100644
--- a/src/optyx/solvers/__init__.py
+++ b/src/optyx/solvers/__init__.py
@@ -1 +1,4 @@
-"""SciPy solver integration."""
+"""SciPy solver integration.
+
+Includes LP (linprog), NLP (minimize), and MILP (milp) solvers.
+"""
diff --git a/src/optyx/solvers/lp_solver.py b/src/optyx/solvers/lp_solver.py
index 545ee04..8f436f1 100644
--- a/src/optyx/solvers/lp_solver.py
+++ b/src/optyx/solvers/lp_solver.py
@@ -15,7 +15,6 @@
 from optyx.core.errors import (
     NoObjectiveError,
     NonLinearError,
-    IntegerVariableError,
     SolverError,
 )
 
@@ -91,24 +90,27 @@ def solve_lp(
                 suggestion="Use solve() with a nonlinear solver for nonlinear constraints.",
             )
 
-    # Check for non-continuous domains
+    # Check for non-continuous domains — route to MILP solver
     variables = problem.variables
     non_continuous = [v for v in variables if v.domain != "continuous"]
     if non_continuous:
-        names = ", ".join(v.name for v in non_continuous)
-        if strict:
-            raise IntegerVariableError(
-                solver_name="linprog",
-                variable_names=[v.name for v in non_continuous],
-            )
+        from optyx.solvers.milp_solver import solve_milp
+
+        # Extract LP coefficients (use cache if available)
+        if problem._lp_cache is not None:
+            lp_data = problem._lp_cache
         else:
-            warnings.warn(
-                f"Variables [{names}] have integer/binary domains but will be relaxed "
-                f"to continuous. linprog does not support integer programming. "
-                f"For true MIP, consider scipy.optimize.milp or PuLP.",
-                UserWarning,
-                stacklevel=2,
-            )
+            extractor = LinearProgramExtractor()
+            try:
+                lp_data = extractor.extract(problem)
+                problem._lp_cache = lp_data
+            except Exception as e:
+                raise SolverError(
+                    message=f"Failed to extract LP coefficients: {e}",
+                    solver_name="milp",
+                ) from e
+
+        return solve_milp(lp_data, variables, **kwargs)
 
     # Check SciPy version and select method
     if method is None:
@@ -157,8 +159,11 @@ def solve_lp(
         linprog_kwargs["A_eq"] = lp_data.A_eq
         linprog_kwargs["b_eq"] = lp_data.b_eq
 
-    if lp_data.bounds:
-        linprog_kwargs["bounds"] = lp_data.bounds
+    # Always re-extract bounds from live variable properties to ensure
+    # updates to v.lb/v.ub are respected even when LP data is cached.
+    fresh_bounds = [(v.lb, v.ub) for v in variables]
+    if fresh_bounds:
+        linprog_kwargs["bounds"] = fresh_bounds
 
     # Merge user kwargs (allow overriding)
     linprog_kwargs.update(kwargs)
diff --git a/src/optyx/solvers/milp_solver.py b/src/optyx/solvers/milp_solver.py
new file mode 100644
index 0000000..82e03dc
--- /dev/null
+++ b/src/optyx/solvers/milp_solver.py
@@ -0,0 +1,165 @@
+"""Mixed-Integer Linear Programming solver using scipy.optimize.milp.
+
+Routes linear problems with integer/binary variables to scipy's HiGHS-based
+MILP solver. Only supports linear objectives and constraints (no MIQP/MINLP).
+"""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+from scipy.optimize import milp, LinearConstraint, Bounds
+
+from optyx.solution import Solution, SolverStatus
+
+if TYPE_CHECKING:
+    from optyx.analysis import LPData
+    from optyx.core.expressions import Variable
+
+
+def solve_milp(
+    lp_data: LPData,
+    variables: list[Variable],
+    **kwargs: Any,
+) -> Solution:
+    """Solve a mixed-integer linear program via scipy.optimize.milp().
+
+    Args:
+        lp_data: Extracted LP data (objective, constraints, bounds).
+        variables: Ordered list of Variable objects (needed for domain info).
+        **kwargs: Additional arguments passed to scipy.optimize.milp.
+
+    Returns:
+        Solution object with optimization results including mip_gap.
+    """
+    # Build objective coefficients (handle maximization)
+    c = lp_data.c
+    is_max = lp_data.sense == "max"
+    if is_max:
+        c = -c
+
+    # Build integrality array: 0=continuous, 1=integer (vectorized)
+    domains = np.array([var.domain for var in variables], dtype=object)
+    integrality = ((domains == "integer") | (domains == "binary")).astype(int)
+
+    # Always rebuild bounds from live variable attributes so cached LP
+    # structure respects bound mutations across re-solves.
+    raw_bounds = [(var.lb, var.ub) for var in variables]
+    lb_arr = np.array([b[0] if b[0] is not None else -np.inf for b in raw_bounds])
+    ub_arr = np.array([b[1] if b[1] is not None else np.inf for b in raw_bounds])
+    bounds = Bounds(
+        lb=cast(Any, lb_arr),
+        ub=cast(Any, ub_arr),
+    )
+
+    # Build constraints for milp() using LinearConstraint
+    constraints_list: list[LinearConstraint] = []
+
+    if lp_data.A_ub is not None and lp_data.b_ub is not None:
+        A_ub = lp_data.A_ub
+        b_ub = lp_data.b_ub
+        m_ub = b_ub.shape[0] if hasattr(b_ub, "shape") else len(b_ub)
+        # A_ub @ x <= b_ub  →  -inf <= A_ub @ x <= b_ub
+        constraints_list.append(
+            LinearConstraint(
+                A_ub,
+                cast(Any, np.full(m_ub, -np.inf)),
+                cast(Any, b_ub),
+            )
+        )
+
+    if lp_data.A_eq is not None and lp_data.b_eq is not None:
+        A_eq = lp_data.A_eq
+        b_eq = lp_data.b_eq
+        # A_eq @ x == b_eq  →  b_eq <= A_eq @ x <= b_eq
+        constraints_list.append(
+            LinearConstraint(A_eq, cast(Any, b_eq), cast(Any, b_eq))
+        )
+
+    # Solve
+    start_time = time.perf_counter()
+
+    milp_kwargs: dict[str, Any] = {}
+    milp_kwargs.update(kwargs)
+
+    try:
+        result = milp(
+            c,
+            constraints=constraints_list if constraints_list else None,
+            integrality=integrality,
+            bounds=bounds,
+            **milp_kwargs,
+        )
+    except Exception as e:
+        return Solution(
+            status=SolverStatus.FAILED,
+            message=str(e),
+            solve_time=time.perf_counter() - start_time,
+        )
+
+    solve_time = time.perf_counter() - start_time
+
+    # Map milp result status
+    status = _map_milp_status(result)
+
+    # Build values dictionary
+    values: dict[str, float] = {}
+    if result.x is not None:
+        for i, var_name in enumerate(lp_data.variables):
+            values[var_name] = float(result.x[i])
+
+    # Compute objective value (undo negation for maximization)
+    objective_value: float | None = None
+    if result.fun is not None and np.isfinite(result.fun):
+        objective_value = float(result.fun)
+        if is_max:
+            objective_value = -objective_value
+
+    # Extract MIP gap if available
+    mip_gap: float | None = None
+    if hasattr(result, "mip_gap") and result.mip_gap is not None:
+        mip_gap = float(result.mip_gap)
+
+    # Extract best bound if available
+    best_bound: float | None = None
+    if hasattr(result, "mip_dual_bound") and result.mip_dual_bound is not None:
+        best_bound = float(result.mip_dual_bound)
+        if is_max:
+            best_bound = -best_bound
+
+    message = result.message if hasattr(result, "message") else ""
+
+    return Solution(
+        status=status,
+        objective_value=objective_value,
+        values=values,
+        message=message,
+        solve_time=solve_time,
+        mip_gap=mip_gap,
+        best_bound=best_bound,
+    )
+
+
+def _map_milp_status(result: Any) -> SolverStatus:
+    """Map scipy.optimize.milp result to SolverStatus."""
+    if result.success:
+        return SolverStatus.OPTIMAL
+
+    # scipy milp status codes:
+    # 0: Optimal
+    # 1: Iteration or time limit
+    # 2: Infeasible
+    # 3: Unbounded
+    # 4: Error
+    status_code = getattr(result, "status", -1)
+
+    if status_code == 1:
+        return SolverStatus.MAX_ITERATIONS
+    elif status_code == 2:
+        return SolverStatus.INFEASIBLE
+    elif status_code == 3:
+        return SolverStatus.UNBOUNDED
+    else:
+        return SolverStatus.FAILED
diff --git a/src/optyx/solvers/scipy_solver.py b/src/optyx/solvers/scipy_solver.py
index d1c77c4..644576c 100644
--- a/src/optyx/solvers/scipy_solver.py
+++ b/src/optyx/solvers/scipy_solver.py
@@ -7,18 +7,31 @@
 
 import time
 import warnings
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any, Callable, cast
 
 import numpy as np
-from scipy.optimize import minimize
+from scipy.optimize import Bounds, LinearConstraint, NonlinearConstraint, minimize
 
-from optyx.core.errors import IntegerVariableError, NoObjectiveError
+from optyx.core.errors import (
+    IntegerVariableError,
+    NoObjectiveError,
+    UnsupportedOperationError,
+)
 
 if TYPE_CHECKING:
     from optyx.problem import Problem
     from optyx.solution import Solution
 
 
+class _EarlyTermination(Exception):
+    """Raised inside SciPy callback to terminate optimization early."""
+
+    def __init__(self, x: np.ndarray, iteration: int, message: str) -> None:
+        self.x = x
+        self.iteration = iteration
+        self.message = message
+
+
 def solve_scipy(
     problem: Problem,
     method: str = "SLSQP",
@@ -27,6 +40,9 @@ def solve_scipy(
     maxiter: int | None = None,
     use_hessian: bool = True,
     strict: bool = False,
+    warm_start: bool = True,
+    callback: Callable | None = None,
+    time_limit: float | None = None,
     **kwargs: Any,
 ) -> Solution:
     """Solve an optimization problem using SciPy.
@@ -37,22 +53,32 @@ def solve_scipy(
             - "SLSQP": Sequential Least Squares Programming (default)
             - "trust-constr": Trust-region constrained optimization
             - "L-BFGS-B": Limited-memory BFGS with bounds (no constraints)
-        x0: Initial point. If None, uses midpoint of bounds or zeros.
+        x0: Initial point. If None, uses warm start (previous solution) when
+            available, otherwise midpoint of bounds or zeros.
         tol: Solver tolerance.
         maxiter: Maximum number of iterations.
         use_hessian: Whether to compute and pass the symbolic Hessian to methods
             that support it (trust-constr, Newton-CG, etc.). Default True.
             Set to False if Hessian computation is too expensive.
-        strict: If True, raise ValueError when the problem contains integer/binary
-            variables that cannot be enforced by the solver. If False (default),
-            emit a warning and relax to continuous.
+        strict: Retained for API compatibility with Problem.solve(). Direct
+            SciPy solves always reject integer/binary domains because SciPy
+            cannot enforce them.
+        warm_start: If True (default), use the previous solution stored on the
+            Problem as the initial point when x0 is not explicitly provided.
+        callback: Optional function receiving a SolverProgress object each
+            iteration.  Return True to terminate early.
+        time_limit: Maximum wall-clock seconds for the solve.  Terminates
+            early with SolverStatus.TERMINATED when exceeded.
         **kwargs: Additional arguments passed to scipy.optimize.minimize.
 
     Returns:
         Solution object with optimization results.
 
     Raises:
-        ValueError: If strict=True and problem contains integer/binary variables.
+        IntegerVariableError: If a linear discrete model is sent directly to a
+            continuous SciPy solver.
+        UnsupportedOperationError: If a nonlinear discrete model (MIQP/MINLP)
+            reaches this solver directly.
     """
     from optyx.core.autodiff import compile_hessian
     from optyx.solution import Solution, SolverStatus
@@ -92,41 +118,63 @@ def solve_scipy(
             message="Problem has no variables",
         )
 
-    # Check for non-continuous domains
+    # Check for non-continuous domains — always raise for MINLP.
+    # The caller (Problem.solve) should have caught this already, but
+    # guard here as a safety net.
     non_continuous = [v for v in variables if v.domain != "continuous"]
     if non_continuous:
-        names = ", ".join(v.name for v in non_continuous)
-        if strict:
+        if problem._is_linear_problem():
             raise IntegerVariableError(
                 solver_name="SciPy",
                 variable_names=[v.name for v in non_continuous],
             )
-        else:
-            warnings.warn(
-                f"Variables [{names}] have integer/binary domains but will be relaxed "
-                f"to continuous. SciPy solver does not support integer programming. "
-                f"For true MIP, consider PuLP or Pyomo.",
-                UserWarning,
-                stacklevel=3,
-            )
+
+        raise UnsupportedOperationError(
+            "MIQP/MINLP solve",
+            solver_name="SciPy",
+            problem_feature=(
+                "nonlinear objective or constraints with integer/binary "
+                f"variables {[v.name for v in non_continuous]}"
+            ),
+            suggestion=(
+                "Use the MILP path for linear discrete models, or switch to a "
+                "dedicated MIQP/MINLP solver"
+            ),
+        )
 
     # Check for cached compiled callables
     cache = problem._solver_cache
     if cache is None:
         cache = _build_solver_cache(problem, variables)
         problem._solver_cache = cache
+    elif "scipy_constraints" not in cache:
+        # Selective invalidation: objective cache preserved, rebuild constraints only
+        _rebuild_constraint_cache(cache, problem, variables)
 
     # Extract cached callables
     obj_fn = cache["obj_fn"]
     grad_fn = cache["grad_fn"]
-    scipy_constraints = cache["scipy_constraints"]
-    bounds = cache["bounds"]
+    scipy_constraints = cast(list[dict[str, Any]], cache["scipy_constraints"])
+    linear_constraints = cast(
+        list[LinearConstraint], cache.get("linear_constraints", [])
+    )
+
+    # Recompute bounds each time to ensure updates to variable properties are respected
+    lb_arr = np.empty(n)
+    ub_arr = np.empty(n)
+    for i, v in enumerate(variables):
+        lb_arr[i] = v.lb if v.lb is not None else -np.inf
+        ub_arr[i] = v.ub if v.ub is not None else np.inf
+    bounds = Bounds(lb=lb_arr, ub=ub_arr)  # type: ignore[arg-type]  # scipy stubs are wrong, Bounds accepts arrays
 
     def objective(x: np.ndarray) -> float:
         return float(obj_fn(x))
 
     def gradient(x: np.ndarray) -> np.ndarray:
-        return grad_fn(x).flatten()
+        grad = grad_fn(x)
+        if hasattr(grad, "toarray"):
+            return np.asarray(grad.toarray(), dtype=np.float64).ravel()
+        return np.asarray(grad, dtype=np.float64).ravel()
 
     # Build Hessian for methods that support it (not cached - method-dependent)
     hess_fn: Callable[[np.ndarray], np.ndarray] | None = None
@@ -147,9 +195,16 @@ def _hess_fn(x: np.ndarray) -> np.ndarray:
 
         hess_fn = _hess_fn
 
-    # Initial point
+    # Initial point: explicit x0 > warm start > computed
     if x0 is None:
-        x0 = _compute_initial_point(variables)
+        if (
+            warm_start
+            and problem._last_solution is not None
+            and len(problem._last_solution) == n
+        ):
+            x0 = problem._last_solution.copy()
+        else:
+            x0 = _compute_initial_point(variables)
 
     # Solver options
     options: dict[str, Any] = {}
@@ -175,6 +230,31 @@ def warning_handler(message, category, filename, lineno, file=None, line=None):
     # Determine if gradient should be passed (not for derivative-free methods)
     use_gradient = method not in DERIVATIVE_FREE_METHODS
 
+    # For trust-constr, use the vector-valued NonlinearConstraint with the
+    # batched sparse Jacobian when available.  Fall back to the old scalar
+    # constraint dicts for all other methods (e.g. SLSQP).
+    constraint_monitors: list[Any] = []
+    if method == "trust-constr":
+        tc_constraint = _build_trust_constr_constraints(cache)
+        if tc_constraint is not None:
+            constraint_monitors.append(tc_constraint)
+    else:
+        constraint_monitors.extend(scipy_constraints)
+
+    constraint_monitors.extend(linear_constraints)
+    constraints_arg: Any = constraint_monitors if constraint_monitors else ()
+
+    # Build composite callback for user callback and/or time_limit
+    scipy_callback = _build_scipy_callback(
+        callback=callback,
+        time_limit=time_limit,
+        start_time=start_time,
+        obj_fn=obj_fn,
+        constraints=constraint_monitors,
+        sense=problem.sense,
+        method=method,
+    )
+
     try:
         # Temporarily override warning handling during solve
         warnings.showwarning = warning_handler
@@ -185,12 +265,27 @@ def warning_handler(message, category, filename, lineno, file=None, line=None):
             method=method,
             jac=gradient if use_gradient else None,
             hess=hess_fn if hess_fn is not None else None,
-            bounds=bounds if bounds and method in BOUNDS_METHODS else None,
-            constraints=scipy_constraints if scipy_constraints else (),
+            bounds=bounds if method in BOUNDS_METHODS else None,
+            constraints=constraints_arg,
             tol=tol,
             options=options if options else None,
+            callback=scipy_callback,
             **kwargs,
         )
+    except _EarlyTermination as et:
+        warnings.showwarning = old_showwarning
+        solve_time = time.perf_counter() - start_time
+        obj_value = float(obj_fn(et.x))
+        if problem.sense == "maximize":
+            obj_value = -obj_value
+        return Solution(
+            status=SolverStatus.TERMINATED,
+            objective_value=obj_value,
+            values={v.name: float(et.x[i]) for i, v in enumerate(variables)},
+            iterations=et.iteration,
+            message=et.message,
+            solve_time=solve_time,
+        )
     except Exception as e:
         warnings.showwarning = old_showwarning
         return Solution(
@@ -210,22 +305,14 @@ def warning_handler(message, category, filename, lineno, file=None, line=None):
     constraints_violated = False
     max_violation = 0.0
 
-    if result.success and scipy_constraints:
-        for c in scipy_constraints:
-            c_val = c["fun"](result.x)
-            # Scaled tolerance based on constraint magnitude
-            scaled_tol = atol + rtol * max(1.0, abs(c_val))
-
-            if c["type"] == "ineq" and c_val < -scaled_tol:
-                # Inequality constraint violated (should be >= 0)
-                violation = -c_val
-                max_violation = max(max_violation, violation)
-                constraints_violated = True
-            elif c["type"] == "eq" and abs(c_val) > scaled_tol:
-                # Equality constraint violated (should be == 0)
-                violation = abs(c_val)
-                max_violation = max(max_violation, violation)
-                constraints_violated = True
+    if result.success and constraint_monitors:
+        max_violation = _compute_constraint_violation(
+            result.x,
+            constraint_monitors,
+            atol=atol,
+            rtol=rtol,
+        )
+        constraints_violated = max_violation > 0.0
 
     # If SLSQP returned "optimal" but constraints are violated, retry with trust-constr
     if constraints_violated and method == "SLSQP":
@@ -244,6 +331,8 @@ def warning_handler(message, category, filename, lineno, file=None, line=None):
             maxiter=maxiter,
             use_hessian=use_hessian,
             strict=strict,
+            callback=callback,
+            time_limit=time_limit,
             **kwargs,
         )
 
@@ -338,8 +427,12 @@ def _build_solver_cache(problem: Problem, variables: list) -> dict[str, Any]:
     Returns:
         Dict containing compiled callables and constraint data.
     """
-    from optyx.core.autodiff import compile_jacobian
-    from optyx.core.compiler import compile_expression
+    from optyx.core.autodiff import analyze_gradient_sparsity, compile_jacobian
+    from optyx.core.compiler import (
+        compile_expression,
+        compile_sparse_gradient_dense_output,
+    )
+    from optyx.core.optimizer import flatten_expression
 
     cache: dict[str, Any] = {}
 
@@ -349,30 +442,51 @@ def _build_solver_cache(problem: Problem, variables: list) -> dict[str, Any]:
         raise NoObjectiveError(
             suggestion="Call minimize() or maximize() on the problem first.",
         )
+
+    # Add Variable.obj contributions (linear objective coefficients set at creation)
+    obj_vars = [v for v in variables if v.obj != 0.0]
+    if obj_vars:
+        from optyx.core.expressions import Constant
+
+        obj_contrib = Constant(0.0)
+        for v in obj_vars:
+            obj_contrib = obj_contrib + Constant(v.obj) * v
+        obj_expr = obj_expr + obj_contrib
+
     if problem.sense == "maximize":
         obj_expr = -obj_expr  # Negate for maximization
 
+    # Flatten deep expression trees before compilation
+    obj_expr = flatten_expression(obj_expr)
+
     cache["obj_fn"] = compile_expression(obj_expr, variables)
-    cache["grad_fn"] = compile_jacobian([obj_expr], variables)
 
-    # Build bounds
-    bounds = []
-    for v in variables:
-        lb = v.lb if v.lb is not None else -np.inf
-        ub = v.ub if v.ub is not None else np.inf
-        bounds.append((lb, ub))
-    cache["bounds"] = bounds
+    # SciPy expects dense objective gradients. For sparse objectives, compile
+    # only the non-zero partials and scatter them into a dense vector.
+    obj_grad_sparsity = analyze_gradient_sparsity(obj_expr, variables)
+    if obj_grad_sparsity.density <= 0.5:
+        cache["grad_fn"] = compile_sparse_gradient_dense_output(obj_expr, variables)
+    else:
+        cache["grad_fn"] = compile_jacobian([obj_expr], variables)
 
     # Build constraints for SciPy
     scipy_constraints = []
+    constraint_exprs = []
+    constraint_fns = []
+    constraint_senses = []
 
     for c in problem.constraints:
         c_expr = c.expr
         if c_expr is None:
             continue
+        c_expr = flatten_expression(c_expr)
         c_fn = compile_expression(c_expr, variables)
         c_jac_fn = compile_jacobian([c_expr], variables)
 
+        constraint_exprs.append(c_expr)
+        constraint_fns.append(c_fn)
+        constraint_senses.append(c.sense)
+
         if c.sense == ">=":
             # f(x) >= 0 → SciPy ineq: f(x) >= 0 (return f(x))
             scipy_constraints.append(
@@ -401,5 +515,349 @@ def _build_solver_cache(problem: Problem, variables: list) -> dict[str, Any]:
             )
 
     cache["scipy_constraints"] = scipy_constraints
+    cache["linear_constraints"] = _build_matrix_linear_constraints(problem, variables)
+
+    # trust-constr builds the batched sparse Jacobian lazily so SLSQP-only
+    # solves don't pay cold-start compilation cost for unused sparse data.
+    if constraint_exprs:
+        cache["constraint_exprs"] = constraint_exprs
+        cache["constraint_fns"] = constraint_fns
+        cache["constraint_senses"] = constraint_senses
+        cache["constraint_variables"] = variables
 
     return cache
+
+
+def _rebuild_constraint_cache(
+    cache: dict[str, Any], problem: Problem, variables: list
+) -> None:
+    """Rebuild only the constraint portion of the solver cache.
+
+    Called when constraints have been added/removed but the objective
+    hasn't changed, so obj_fn/grad_fn/hess_fn are still valid.
+    """
+    from optyx.core.autodiff import compile_jacobian
+    from optyx.core.compiler import compile_expression
+    from optyx.core.optimizer import flatten_expression
+
+    scipy_constraints: list[dict[str, Any]] = []
+    constraint_exprs = []
+    constraint_fns = []
+    constraint_senses = []
+
+    for c in problem.constraints:
+        c_expr = c.expr
+        if c_expr is None:
+            continue
+        c_expr = flatten_expression(c_expr)
+        c_fn = compile_expression(c_expr, variables)
+        c_jac_fn = compile_jacobian([c_expr], variables)
+
+        constraint_exprs.append(c_expr)
+        constraint_fns.append(c_fn)
+        constraint_senses.append(c.sense)
+
+        if c.sense == ">=":
+            scipy_constraints.append(
+                {
+                    "type": "ineq",
+                    "fun": lambda x, fn=c_fn: float(fn(x)),
+                    "jac": lambda x, jfn=c_jac_fn: jfn(x).flatten(),
+                }
+            )
+        elif c.sense == "<=":
+            scipy_constraints.append(
+                {
+                    "type": "ineq",
+                    "fun": lambda x, fn=c_fn: -float(fn(x)),
+                    "jac": lambda x, jfn=c_jac_fn: -jfn(x).flatten(),
+                }
+            )
+        else:  # ==
+            scipy_constraints.append(
+                {
+                    "type": "eq",
+                    "fun": lambda x, fn=c_fn: float(fn(x)),
+                    "jac": lambda x, jfn=c_jac_fn: jfn(x).flatten(),
+                }
+            )
+
+    cache["scipy_constraints"] = scipy_constraints
+    cache["linear_constraints"] = _build_matrix_linear_constraints(problem, variables)
+
+    if constraint_exprs:
+        cache["constraint_exprs"] = constraint_exprs
+        cache["constraint_fns"] = constraint_fns
+        cache["constraint_senses"] = constraint_senses
+        cache["constraint_variables"] = variables
+    else:
+        cache.pop("sparse_constraint_jac_fn", None)
+        cache.pop("constraint_exprs", None)
+        cache.pop("constraint_fns", None)
+        cache.pop("constraint_senses", None)
+        cache.pop("constraint_variables", None)
+
+
+def _build_trust_constr_constraints(
+    cache: dict[str, Any],
+) -> NonlinearConstraint | None:
+    """Build a single NonlinearConstraint for trust-constr from cached data.
+
+    Uses the batched sparse Jacobian compiled by ``compile_sparse_jacobian``
+    and the vector of scalar constraint functions already stored in the cache.
+
+    Returns ``None`` when there are no constraints.
+    """
+    constraint_fns = cache.get("constraint_fns")
+    constraint_senses = cast(list[str] | None, cache.get("constraint_senses"))
+    sparse_jac_fn = cache.get("sparse_constraint_jac_fn")
+
+    if not constraint_fns or constraint_senses is None:
+        return None
+
+    if sparse_jac_fn is None:
+        from optyx.core.autodiff import compile_sparse_jacobian
+
+        constraint_exprs = cache.get("constraint_exprs")
+        constraint_variables = cache.get("constraint_variables")
+        if not constraint_exprs or constraint_variables is None:
+            return None
+        sparse_jac_fn = compile_sparse_jacobian(constraint_exprs, constraint_variables)
+        cache["sparse_constraint_jac_fn"] = sparse_jac_fn
+
+    m = len(constraint_fns)
+
+    # Build lb / ub vectors from senses.
+    # Stored expressions are normalised so that the constraint reads
+    #   expr(x)  {>=, <=, ==}  0
+    lb = np.full(m, -np.inf)
+    ub = np.full(m, np.inf)
+    for i, sense in enumerate(constraint_senses):
+        if sense == ">=":
+            lb[i] = 0.0
+        elif sense == "<=":
+            ub[i] = 0.0
+        else:  # "=="
+            lb[i] = 0.0
+            ub[i] = 0.0
+
+    # Vector-valued constraint function.
+    def _constraint_vector(x: np.ndarray) -> np.ndarray:
+        out = np.empty(m)
+        for i, fn in enumerate(constraint_fns):
+            out[i] = float(fn(x))
+        return out
+
+    jac_callback: Any = sparse_jac_fn
+
+    return NonlinearConstraint(
+        fun=_constraint_vector,
+        lb=lb,
+        ub=ub,
+        jac=cast(Any, jac_callback),
+    )
+
+
+def _build_matrix_linear_constraints(
+    problem: Problem,
+    variables: list,
+) -> list[LinearConstraint]:
+    """Build SciPy LinearConstraint objects for stored matrix blocks."""
+    from scipy import sparse as sp
+
+    if not problem._matrix_constraints:
+        return []
+
+    n = len(variables)
+    var_index = {var.name: i for i, var in enumerate(variables)}
+    linear_constraints: list[LinearConstraint] = []
+
+    for mc in problem._matrix_constraints:
+        mc_n = len(mc.variables)
+        col_indices = np.array([var_index[v.name] for v in mc.variables], dtype=np.intp)
+
+        if sp.issparse(mc.A):
+            if mc_n == n and np.array_equal(col_indices, np.arange(n)):
+                A_full = mc.A
+            else:
+                permutation = sp.csr_matrix(
+                    (np.ones(mc_n), (np.arange(mc_n), col_indices)),
+                    shape=(mc_n, n),
+                )
+                A_full = (mc.A @ permutation).tocsr()
+        else:
+            A_base = np.asarray(mc.A, dtype=np.float64)
+            if mc_n == n and np.array_equal(col_indices, np.arange(n)):
+                A_full = A_base
+            else:
+                A_full = np.zeros((A_base.shape[0], n), dtype=np.float64)
+                A_full[:, col_indices] = A_base
+
+        m = A_full.shape[0]
+        if mc.sense == "<=":
+            lb = np.full(m, -np.inf)
+            ub = mc.b
+        elif mc.sense == ">=":
+            lb = mc.b
+            ub = np.full(m, np.inf)
+        else:
+            lb = mc.b
+            ub = mc.b
+
+        linear_constraints.append(
+            LinearConstraint(A_full, lb=cast(Any, lb), ub=cast(Any, ub))
+        )
+
+    return linear_constraints
+
+
+def _compute_constraint_violation(
+    x: np.ndarray,
+    constraints: list[Any],
+    *,
+    atol: float = 0.0,
+    rtol: float = 0.0,
+) -> float:
+    """Compute maximum constraint violation for current iterate."""
+    max_violation = 0.0
+    for c in constraints:
+        if isinstance(c, dict):
+            val = float(c["fun"](x))
+            scaled_tol = atol + rtol * max(1.0, abs(val))
+            if c["type"] == "ineq":
+                violation = -val if val < -scaled_tol else 0.0
+            else:
+                violation = abs(val) if abs(val) > scaled_tol else 0.0
+        elif isinstance(c, LinearConstraint):
+            values = np.asarray(c.A @ x, dtype=np.float64).reshape(-1)
+            violation = _compute_bound_violation(
+                values, c.lb, c.ub, atol=atol, rtol=rtol
+            )
+        elif isinstance(c, NonlinearConstraint):
+            values = np.asarray(c.fun(x), dtype=np.float64).reshape(-1)
+            violation = _compute_bound_violation(
+                values, c.lb, c.ub, atol=atol, rtol=rtol
+            )
+        else:
+            continue
+
+        max_violation = max(max_violation, violation)
+    return max_violation
+
+
+def _compute_bound_violation(
+    values: np.ndarray,
+    lb: Any,
+    ub: Any,
+    *,
+    atol: float = 0.0,
+    rtol: float = 0.0,
+) -> float:
+    """Compute maximum bound-style constraint violation for a vector of values."""
+    vals = np.asarray(values, dtype=np.float64).reshape(-1)
+    lb_arr = np.broadcast_to(np.asarray(lb, dtype=np.float64), vals.shape)
+    ub_arr = np.broadcast_to(np.asarray(ub, dtype=np.float64), vals.shape)
+
+    max_violation = 0.0
+
+    lower_mask = np.isfinite(lb_arr)
+    if np.any(lower_mask):
+        lower_vals = vals[lower_mask]
+        lower_bounds = lb_arr[lower_mask]
+        lower_scale = np.maximum(
+            1.0, np.maximum(np.abs(lower_vals), np.abs(lower_bounds))
+        )
+        lower_tol = atol + rtol * lower_scale
+        lower_violation = lower_bounds - lower_vals
+        lower_violation = lower_violation[lower_violation > lower_tol]
+        if lower_violation.size:
+            max_violation = max(max_violation, float(np.max(lower_violation)))
+
+    upper_mask = np.isfinite(ub_arr)
+    if np.any(upper_mask):
+        upper_vals = vals[upper_mask]
+        upper_bounds = ub_arr[upper_mask]
+        upper_scale = np.maximum(
+            1.0, np.maximum(np.abs(upper_vals), np.abs(upper_bounds))
+        )
+        upper_tol = atol + rtol * upper_scale
+        upper_violation = upper_vals - upper_bounds
+        upper_violation = upper_violation[upper_violation > upper_tol]
+        if upper_violation.size:
+            max_violation = max(max_violation, float(np.max(upper_violation)))
+
+    return max_violation
+
+
+def _build_scipy_callback(
+    *,
+    callback: Callable | None,
+    time_limit: float | None,
+    start_time: float,
+    obj_fn: Callable,
+    constraints: list[Any],
+    sense: str,
+    method: str,
+) -> Callable | None:
+    """Build a SciPy-compatible callback combining user callback and time limit.
+
+    Returns None if neither callback nor time_limit is provided.
+    """
+    if callback is None and time_limit is None:
+        return None
+
+    from optyx.solution import SolverProgress
+
+    # Mutable iteration counter
+    state = {"iteration": 0}
+
+    def _unified_callback(xk, *args):
+        """Callback invoked by SciPy at each iteration.
+
+        For trust-constr, args[0] is an OptimizeResult with state info.
+        For other methods, only xk (current x) is provided.
+        """
+        state["iteration"] += 1
+        elapsed = time.perf_counter() - start_time
+
+        # Get current x — trust-constr passes OptimizeResult as first arg
+        if hasattr(xk, "x"):
+            # trust-constr passes OptimizeResult object
+            x = np.asarray(xk.x)
+        else:
+            x = np.asarray(xk)
+
+        # Compute objective value (undo negation for maximize)
+        obj_val = float(obj_fn(x))
+        if sense == "maximize":
+            obj_val = -obj_val
+
+        # Compute constraint violation
+        cv = _compute_constraint_violation(x, constraints)
+
+        # Check time limit first
+        if time_limit is not None and elapsed >= time_limit:
+            raise _EarlyTermination(
+                x=x,
+                iteration=state["iteration"],
+                message=f"Time limit ({time_limit:.1f}s) exceeded",
+            )
+
+        # Invoke user callback
+        if callback is not None:
+            progress = SolverProgress(
+                iteration=state["iteration"],
+                objective_value=obj_val,
+                constraint_violation=cv,
+                elapsed_time=elapsed,
+                x=x.copy(),
+            )
+            stop = callback(progress)
+            if stop is True:
+                raise _EarlyTermination(
+                    x=x,
+                    iteration=state["iteration"],
+                    message="Terminated by user callback",
+                )
+
+    return _unified_callback
diff --git a/tests/test_errors.py b/tests/test_errors.py
index d16212d..9e5bd48 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -25,6 +25,7 @@
     InvalidExpressionError,
     SolverConfigurationError,
     IntegerVariableError,
+    UnsupportedOperationError,
     SymmetryError,
     SquareMatrixError,
     InvalidSizeError,
@@ -597,6 +598,33 @@ def test_inherits_solver_config(self):
         assert isinstance(err, SolverConfigurationError)
 
 
+class TestUnsupportedOperationError:
+    """Test UnsupportedOperationError for unsupported problem classes."""
+
+    def test_basic_message(self):
+        """Basic error message includes operation."""
+        err = UnsupportedOperationError("MIQP/MINLP solve")
+        assert "MIQP/MINLP solve" in str(err)
+        assert "not supported" in str(err)
+
+    def test_with_feature_and_suggestion(self):
+        """Error includes feature details and remediation guidance."""
+        err = UnsupportedOperationError(
+            "MIQP/MINLP solve",
+            solver_name="SciPy",
+            problem_feature="nonlinear objective with integer variables",
+            suggestion="Use MILP for linear discrete models",
+        )
+        assert "nonlinear objective with integer variables" in str(err)
+        assert "Use MILP" in str(err)
+
+    def test_inherits_solver_config_and_value_error(self):
+        """UnsupportedOperationError should remain catchable as ValueError."""
+        err = UnsupportedOperationError("feature")
+        assert isinstance(err, SolverConfigurationError)
+        assert isinstance(err, ValueError)
+
+
 # =============================================================================
 # Tests for Matrix-Specific Errors
 # =============================================================================
diff --git a/tests/test_hessian_optimization.py b/tests/test_hessian_optimization.py
new file mode 100644
index 0000000..c25b86f
--- /dev/null
+++ b/tests/test_hessian_optimization.py
@@ -0,0 +1,137 @@
+import numpy as np
+from optyx import VectorVariable, Constant
+from optyx.core.autodiff import compute_hessian
+from optyx.core.matrices import QuadraticForm
+from optyx.core.vectors import DotProduct, VectorSum, LinearCombination
+
+
+class TestConstantHessianDetection:
+    """Tests for constant Hessian detection optimizations."""
+
+    def test_quadratic_form_hessian(self):
+        """Test that QuadraticForm(x, Q) has Hessian Q + Q.T."""
+        n = 3
+        x = VectorVariable("x", n)
+        # Random non-symmetric matrix
+        Q = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])
+
+        qf = QuadraticForm(x, Q)
+        hessian = compute_hessian(qf, list(x))
+
+        # Check values
+        Q_plus_QT = Q + Q.T
+        for i in range(n):
+            for j in range(n):
+                val_node = hessian[i][j]
+                # Optimization should return Constant nodes directly
+                assert isinstance(val_node, Constant), (
+                    f"Hessian element [{i},{j}] should be Constant"
+                )
+                np.testing.assert_almost_equal(val_node.value, Q_plus_QT[i, j])
+
+    def test_dot_product_self_hessian(self):
+        """Test that DotProduct(x, x) has Hessian 2I."""
+        n = 3
+        x = VectorVariable("x", n)
+        dot = DotProduct(x, x)
+
+        hessian = compute_hessian(dot, list(x))
+
+        for i in range(n):
+            for j in range(n):
+                val_node = hessian[i][j]
+                assert isinstance(val_node, Constant)
+                expected = 2.0 if i == j else 0.0
+                np.testing.assert_almost_equal(val_node.value, expected)
+
+    def test_vector_sum_hessian(self):
+        """Test that VectorSum(x) has zero Hessian."""
+        n = 5
+        x = VectorVariable("x", n)
+        vsum = VectorSum(x)
+
+        hessian = compute_hessian(vsum, list(x))
+
+        for i in range(n):
+            for j in range(n):
+                val_node = hessian[i][j]
+                assert isinstance(val_node, Constant)
+                # Should be exactly 0.0
+                assert val_node.value == 0.0
+
+    def test_linear_combination_hessian(self):
+        """Test that LinearCombination has zero Hessian."""
+        n = 3
+        x = VectorVariable("x", n)
+        coeffs = np.array([1.0, 2.0, 3.0])
+        # Arguments are (coefficients, vector)
+        lin_comb = LinearCombination(coeffs, x)
+
+        hessian = compute_hessian(lin_comb, list(x))
+
+        for i in range(n):
+            for j in range(n):
+                val_node = hessian[i][j]
+                assert isinstance(val_node, Constant)
+                assert val_node.value == 0.0
+
+    def test_quadratic_form_subset_variables(self):
+        """Test QuadraticForm Hessian with a subset/superset of variables."""
+        # Create x (size 2) and y (size 2)
+        x = VectorVariable("x", 2)
+        y = VectorVariable("y", 2)
+
+        Q = np.array([[1.0, 2.0], [3.0, 4.0]])
+
+        # Form depends only on x: x'Qx
+        qf = QuadraticForm(x, Q)
+
+        # Calculate Hessian wrt [x0, x1, y0]
+        # Top-left 2x2 should be Q+Q.T
+        # Rest should be 0
+        vars_to_diff = [x[0], x[1], y[0]]
+        hessian = compute_hessian(qf, vars_to_diff)
+
+        Q_plus_QT = Q + Q.T
+
+        # Check x-x part
+        np.testing.assert_almost_equal(hessian[0][0].value, Q_plus_QT[0, 0])
+        np.testing.assert_almost_equal(hessian[0][1].value, Q_plus_QT[0, 1])
+        np.testing.assert_almost_equal(hessian[1][0].value, Q_plus_QT[1, 0])
+        np.testing.assert_almost_equal(hessian[1][1].value, Q_plus_QT[1, 1])
+
+        # Check cross terms with y (should be 0)
+        assert hessian[0][2].value == 0.0  # d2/dx0dy0
+        assert hessian[1][2].value == 0.0  # d2/dx1dy0
+        assert hessian[2][0].value == 0.0  # d2/dy0dx0
+        assert hessian[2][1].value == 0.0  # d2/dy0dx1
+        assert hessian[2][2].value == 0.0  # d2/dy0dy0
+
+    def test_linear_combination_of_quadratic_forms(self):
+        """Test Hessian of c1*QF1 + c2*QF2 avoids re-evaluation."""
+        n = 2
+        x = VectorVariable("x", n)
+        Q1 = np.array([[1.0, 0.0], [0.0, 1.0]])
+        Q2 = np.array([[0.0, 1.0], [1.0, 0.0]])
+
+        # Expr = 2 * x'Q1x + 3 * x'Q2x
+        # Hessian should be 2*(Q1+Q1.T) + 3*(Q2+Q2.T)
+        expr = Constant(2.0) * QuadraticForm(x, Q1) + Constant(3.0) * QuadraticForm(
+            x, Q2
+        )
+
+        hessian = compute_hessian(expr, list(x))
+
+        # Expected value
+        # 2*[[2,0],[0,2]] + 3*[[0,2],[2,0]] = [[4,0],[0,4]] + [[0,6],[6,0]] = [[4,6],[6,4]]
+        H_val = np.array([[4.0, 6.0], [6.0, 4.0]])
+
+        for i in range(n):
+            for j in range(n):
+                val_node = hessian[i][j]
+                # Optimization should return Constant nodes directly (pre-computed)
+                # Not BinaryOp(BinaryOp(Constant...))
+                assert isinstance(val_node, Constant), (
+                    f"Hessian element [{i},{j}] should be Constant, got {type(val_node)}"
+                )
+                np.testing.assert_almost_equal(val_node.value, H_val[i, j])
diff --git a/tests/test_incremental_modification.py b/tests/test_incremental_modification.py
new file mode 100644
index 0000000..8c089d0
--- /dev/null
+++ b/tests/test_incremental_modification.py
@@ -0,0 +1,602 @@
+"""Tests for incremental model modification and warm start (Issue #104).
+
+Tests cover:
+- remove_constraint() by index and name
+- Selective cache invalidation
+- Warm start (previous solution as x0)
+- Bounds freshness (LP bounds never stale)
+- reset() clears warm start state
+- No cache staleness after modifications
+"""
+
+import numpy as np
+import pytest
+
+from optyx import Variable
+from optyx.core.vectors import VectorVariable
+from optyx.problem import Problem
+from optyx.solution import SolverStatus
+
+
+# ---------------------------------------------------------------------------
+# remove_constraint() tests
+# ---------------------------------------------------------------------------
+
+
+class TestRemoveConstraintByIndex:
+    """Test removing constraints by integer index."""
+
+    def test_remove_first_constraint(self):
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 3)
+        prob.subject_to(x >= 5)
+        assert prob.n_constraints == 2
+
+        prob.remove_constraint(0)
+        assert prob.n_constraints == 1
+        # Only x >= 5 remains
+        sol = prob.solve()
+        assert sol.status == SolverStatus.OPTIMAL
+        assert sol.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+    def test_remove_last_constraint(self):
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 5)
+        prob.subject_to(x >= 3)
+
+        prob.remove_constraint(1)
+        assert prob.n_constraints == 1
+        # Only x >= 5 remains
+        sol = prob.solve()
+        assert sol.status == SolverStatus.OPTIMAL
+        assert sol.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+    def test_remove_only_constraint(self):
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 5)
+
+        prob.remove_constraint(0)
+        assert prob.n_constraints == 0
+        # With no constraints, minimum is at lb=0
+        sol = prob.solve()
+        assert sol.status == SolverStatus.OPTIMAL
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+    def test_remove_invalid_index_raises(self):
+        x = Variable("x")
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 0)
+
+        with pytest.raises(IndexError, match="out of range"):
+            prob.remove_constraint(5)
+
+    def test_remove_negative_index_raises(self):
+        x = Variable("x")
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 0)
+
+        with pytest.raises(IndexError, match="out of range"):
+            prob.remove_constraint(-1)
+
+    def test_remove_from_empty_raises(self):
+        prob = Problem()
+        prob.minimize(Variable("x"))
+
+        with pytest.raises(IndexError, match="out of range"):
+            prob.remove_constraint(0)
+
+    def test_remove_returns_self(self):
+        x = Variable("x")
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 0)
+        result = prob.remove_constraint(0)
+        assert result is prob
+
+    def test_remove_invalid_type_raises(self):
+        prob = Problem()
+        prob.minimize(Variable("x"))
+        prob.subject_to(Variable("x") >= 0)
+
+        with pytest.raises(TypeError, match="Expected int or str"):
+            prob.remove_constraint(3.14)  # type: ignore[arg-type]
+
+
+class TestRemoveConstraintByName:
+    """Test removing constraints by name."""
+
+    def test_remove_named_constraint(self):
+        from optyx.constraints import Constraint
+
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+
+        c1 = Constraint(
+            expr=(x - 3).expr if hasattr(x - 3, "expr") else (x - 3),
+            sense=">=",
+            name="lower",
+        )
+        c2 = Constraint(
+            expr=(x - 7).expr if hasattr(x - 7, "expr") else (x - 7),
+            sense="<=",
+            name="upper",
+        )
+        prob.subject_to(c1)
+        prob.subject_to(c2)
+
+        prob.remove_constraint("lower")
+        assert prob.n_constraints == 1
+        assert prob.constraints[0].name == "upper"
+
+    def test_remove_nonexistent_name_raises(self):
+        x = Variable("x")
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 0)
+
+        with pytest.raises(KeyError, match="No constraint named"):
+            prob.remove_constraint("nonexistent")
+
+
+class TestRemoveConstraintCaching:
+    """Test that caches are properly invalidated after remove_constraint."""
+
+    def test_solve_after_remove(self):
+        """Problem solves correctly after removing a constraint."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 5)
+        prob.subject_to(x >= 8)
+
+        sol1 = prob.solve()
+        assert sol1.values["x"] == pytest.approx(8.0, abs=1e-4)
+
+        prob.remove_constraint(1)  # Remove x >= 8
+        sol2 = prob.solve()
+        assert sol2.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+    def test_add_then_remove_then_solve(self):
+        """Incremental add + remove + solve cycle works."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+
+        # Solve unconstrained
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+        # Add constraint and solve
+        prob.subject_to(x >= 5)
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+        # Remove constraint and solve
+        prob.remove_constraint(0)
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+    def test_nlp_selective_cache_invalidation(self):
+        """Objective cache is preserved when only constraints change (NLP)."""
+        x = Variable("x", lb=-10, ub=10)
+        prob = Problem()
+        prob.minimize(x**2)
+        prob.subject_to(x >= 3)
+
+        sol = prob.solve(method="SLSQP")
+        assert sol.values["x"] == pytest.approx(3.0, abs=1e-4)
+
+        # Solver cache should exist with obj_fn
+        assert prob._solver_cache is not None
+        obj_fn = prob._solver_cache.get("obj_fn")
+        assert obj_fn is not None
+
+        # Remove the constraint
+        prob.remove_constraint(0)
+
+        # Objective cache should be preserved
+        assert prob._solver_cache is not None
+        assert prob._solver_cache.get("obj_fn") is obj_fn
+        # Constraint cache should be cleared
+        assert "scipy_constraints" not in prob._solver_cache
+
+        # Solve again — should work correctly using rebuilt constraints
+        sol = prob.solve(method="SLSQP")
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+    def test_add_constraint_preserves_objective_cache(self):
+        """Adding a constraint preserves objective cache too."""
+        x = Variable("x", lb=-10, ub=10)
+        prob = Problem()
+        prob.minimize(x**2)
+
+        sol = prob.solve(method="SLSQP")
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+        obj_fn = prob._solver_cache["obj_fn"]
+
+        # Add constraint — objective cache should be preserved
+        prob.subject_to(x >= 3)
+        assert prob._solver_cache is not None
+        assert prob._solver_cache.get("obj_fn") is obj_fn
+
+        sol = prob.solve(method="SLSQP")
+        assert sol.values["x"] == pytest.approx(3.0, abs=1e-4)
+
+
+# ---------------------------------------------------------------------------
+# Warm start tests
+# ---------------------------------------------------------------------------
+
+
+class TestWarmStart:
+    """Test warm start (using previous solution as initial point)."""
+
+    def test_warm_start_stores_solution(self):
+        """After solve, _last_solution is populated."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize((x - 5) ** 2)
+
+        sol = prob.solve()
+        assert sol.status == SolverStatus.OPTIMAL
+        assert prob._last_solution is not None
+        assert prob._last_solution[0] == pytest.approx(5.0, abs=1e-4)
+
+    def test_warm_start_used_as_x0(self):
+        """Warm start uses previous solution for next solve."""
+        x = Variable("x", lb=0, ub=10)
+        y = Variable("y", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize((x - 3) ** 2 + (y - 4) ** 2)
+        prob.subject_to(x + y >= 5)
+
+        sol1 = prob.solve(method="SLSQP")
+        assert sol1.status == SolverStatus.OPTIMAL
+        assert prob._last_solution is not None
+
+        # Solve again with warm start — should converge faster or same result
+        sol2 = prob.solve(method="SLSQP")
+        assert sol2.status == SolverStatus.OPTIMAL
+        assert sol2.values["x"] == pytest.approx(sol1.values["x"], abs=1e-4)
+        assert sol2.values["y"] == pytest.approx(sol1.values["y"], abs=1e-4)
+
+    def test_warm_start_disabled(self):
+        """warm_start=False ignores previous solution."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize((x - 5) ** 2)
+
+        prob.solve(method="SLSQP")
+        assert prob._last_solution is not None
+
+        # With warm_start=False, x0 should be computed fresh (not from _last_solution)
+        sol2 = prob.solve(method="SLSQP", warm_start=False)
+        assert sol2.status == SolverStatus.OPTIMAL
+        assert sol2.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+    def test_warm_start_after_constraint_change(self):
+        """Warm start works after adding/removing constraints."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize((x - 5) ** 2)
+        prob.subject_to(x >= 7)
+
+        sol1 = prob.solve(method="SLSQP")
+        assert sol1.values["x"] == pytest.approx(7.0, abs=1e-4)
+
+        # Remove the constraint
+        prob.remove_constraint(0)
+
+        # Warm start should use x=7 as x0, but converge to x=5
+        sol2 = prob.solve(method="SLSQP")
+        assert sol2.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+    def test_warm_start_lp(self):
+        """LP solver stores solution for warm start state."""
+        x = Variable("x", lb=0, ub=10)
+        y = Variable("y", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x + y)
+        prob.subject_to(x + y >= 5)
+
+        sol = prob.solve()
+        assert sol.status == SolverStatus.OPTIMAL
+        # Solution should be stored
+        assert prob._last_solution is not None
+
+    def test_explicit_x0_overrides_warm_start(self):
+        """An explicit x0 takes precedence over warm start."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize((x - 5) ** 2)
+
+        prob.solve(method="SLSQP")
+        assert prob._last_solution is not None
+
+        # Pass explicit x0 — should use it instead of warm start
+        sol2 = prob.solve(method="SLSQP", x0=np.array([1.0]))
+        assert sol2.status == SolverStatus.OPTIMAL
+        assert sol2.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+
+# ---------------------------------------------------------------------------
+# reset() tests
+# ---------------------------------------------------------------------------
+
+
+class TestReset:
+    """Test that reset() clears warm start state."""
+
+    def test_reset_clears_warm_start(self):
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize((x - 5) ** 2)
+
+        prob.solve(method="SLSQP")
+        assert prob._last_solution is not None
+
+        prob.reset()
+        assert prob._last_solution is None
+        assert prob._solver_cache is None
+        assert prob._lp_cache is None
+
+    def test_solve_after_reset(self):
+        """Problem solves correctly after reset."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize((x - 5) ** 2)
+
+        prob.solve(method="SLSQP")
+        prob.reset()
+        sol2 = prob.solve(method="SLSQP")
+
+        assert sol2.status == SolverStatus.OPTIMAL
+        assert sol2.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+
+# ---------------------------------------------------------------------------
+# LP bounds freshness tests
+# ---------------------------------------------------------------------------
+
+
+class TestBoundsFreshness:
+    """Test that LP solver always uses fresh bounds from variables."""
+
+    def test_lp_bounds_update_respected(self):
+        """Changing variable bounds is reflected in subsequent LP solves."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+
+        sol1 = prob.solve()
+        assert sol1.status == SolverStatus.OPTIMAL
+        assert sol1.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+        # Change lower bound — should be respected even with cached LP data
+        x.lb = 5.0
+        sol2 = prob.solve()
+        assert sol2.status == SolverStatus.OPTIMAL
+        assert sol2.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+    def test_lp_bounds_tighten_and_relax(self):
+        """Bounds can be tightened and relaxed between solves."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+
+        # Baseline
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+        # Tighten
+        x.lb = 3.0
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(3.0, abs=1e-4)
+
+        # Relax back
+        x.lb = 0.0
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+    def test_upper_bound_update(self):
+        """Changing upper bound is reflected in LP solve."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.maximize(x)
+
+        sol1 = prob.solve()
+        assert sol1.values["x"] == pytest.approx(10.0, abs=1e-4)
+
+        x.ub = 5.0
+        sol2 = prob.solve()
+        assert sol2.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+    def test_fix_and_unfix_variable(self):
+        """Fix a variable (lb == ub) then unfix it."""
+        x = Variable("x", lb=0, ub=10)
+        y = Variable("y", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x + y)
+
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+        # Fix x = 5
+        x.lb = 5.0
+        x.ub = 5.0
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(5.0, abs=1e-4)
+        assert sol.values["y"] == pytest.approx(0.0, abs=1e-4)
+
+        # Unfix x
+        x.lb = 0.0
+        x.ub = 10.0
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+
+# ---------------------------------------------------------------------------
+# NLP bounds freshness (already correct, but verify)
+# ---------------------------------------------------------------------------
+
+
+class TestNLPBoundsFreshness:
+    """Verify NLP solver reads fresh bounds (was already correct)."""
+
+    def test_nlp_bounds_update(self):
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x**2)
+
+        sol = prob.solve(method="SLSQP")
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+        x.lb = 3.0
+        sol = prob.solve(method="SLSQP")
+        assert sol.values["x"] == pytest.approx(3.0, abs=1e-4)
+
+
+# ---------------------------------------------------------------------------
+# Incremental add/remove cycle tests
+# ---------------------------------------------------------------------------
+
+
+class TestIncrementalCycles:
+    """Test repeated add/remove/solve cycles."""
+
+    def test_multiple_incremental_modifications(self):
+        """Multiple rounds of add/remove with solves in between."""
+        x = Variable("x", lb=0, ub=20)
+        prob = Problem()
+        prob.minimize(x)
+
+        # Solve unconstrained
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+        # Add x >= 5
+        prob.subject_to(x >= 5)
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(5.0, abs=1e-4)
+
+        # Add x >= 10
+        prob.subject_to(x >= 10)
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(10.0, abs=1e-4)
+
+        # Remove x >= 5 (index 0)
+        prob.remove_constraint(0)
+        sol = prob.solve()
+        # x >= 10 is now index 0
+        assert sol.values["x"] == pytest.approx(10.0, abs=1e-4)
+
+        # Remove x >= 10
+        prob.remove_constraint(0)
+        sol = prob.solve()
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+    def test_nlp_incremental_cycle(self):
+        """NLP incremental add/remove cycle."""
+        x = Variable("x", lb=-10, ub=10)
+        prob = Problem()
+        prob.minimize(x**2)
+
+        sol = prob.solve(method="SLSQP")
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+        prob.subject_to(x >= 3)
+        sol = prob.solve(method="SLSQP")
+        assert sol.values["x"] == pytest.approx(3.0, abs=1e-4)
+
+        prob.subject_to(x <= 2)
+        # Infeasible: x >= 3 and x <= 2
+        sol = prob.solve(method="SLSQP")
+        # Solver may return infeasible or a compromised solution
+        # Just verify it completes without error
+
+        prob.remove_constraint(0)  # Remove x >= 3
+        sol = prob.solve(method="SLSQP")
+        # Now only x <= 2 remains
+        assert sol.values["x"] == pytest.approx(0.0, abs=1e-4)
+
+    def test_vector_variable_incremental(self):
+        """Incremental modification with VectorVariable."""
+        x = VectorVariable("x", 3, lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x[0] + x[1] + x[2])
+
+        sol = prob.solve()
+        assert sol.status == SolverStatus.OPTIMAL
+
+        # Add sum constraint
+        prob.subject_to(x[0] + x[1] + x[2] >= 10)
+        sol = prob.solve()
+        total = sol.values["x[0]"] + sol.values["x[1]"] + sol.values["x[2]"]
+        assert total == pytest.approx(10.0, abs=1e-4)
+
+        # Remove and verify
+        prob.remove_constraint(0)
+        sol = prob.solve()
+        total = sol.values["x[0]"] + sol.values["x[1]"] + sol.values["x[2]"]
+        assert total == pytest.approx(0.0, abs=1e-4)
+
+
+# ---------------------------------------------------------------------------
+# Cache staleness tests
+# ---------------------------------------------------------------------------
+
+
+class TestNoCacheStaleness:
+    """Ensure no stale cached data is ever used."""
+
+    def test_lp_cache_not_stale_after_remove(self):
+        """LP cache is invalidated after remove_constraint."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 5)
+
+        prob.solve()
+        assert prob._lp_cache is not None
+
+        prob.remove_constraint(0)
+        assert prob._lp_cache is None  # Should be invalidated
+
+    def test_linearity_cache_not_stale(self):
+        """Linearity cache invalidated when constraints change."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 5)
+
+        _ = prob._is_linear_problem()
+        assert prob._is_linear_cache is not None
+
+        prob.remove_constraint(0)
+        assert prob._is_linear_cache is None
+
+    def test_variables_cache_not_stale(self):
+        """Variable list recalculated after remove_constraint."""
+        x = Variable("x", lb=0, ub=10)
+        y = Variable("y", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(y >= 5)  # y only appears in constraint
+
+        vars_before = prob.variables
+        assert any(v.name == "y" for v in vars_before)
+
+        prob.remove_constraint(0)
+        vars_after = prob.variables
+        # y should no longer be in variables (only appears in removed constraint)
+        assert not any(v.name == "y" for v in vars_after)
diff --git a/tests/test_lp_export.py b/tests/test_lp_export.py
new file mode 100644
index 0000000..2f578bf
--- /dev/null
+++ b/tests/test_lp_export.py
@@ -0,0 +1,686 @@
+"""Tests for LP format export (Issue #106)."""
+
+from __future__ import annotations
+
+import os
+
+import numpy as np
+import pytest
+
+from optyx import (
+    BinaryVariable,
+    IntegerVariable,
+    Problem,
+    Variable,
+    VectorVariable,
+    VariableDict,
+    as_matrix,
+    quadratic_form,
+    sin,
+    exp,
+)
+from optyx.analysis import extract_quadratic_coefficients
+from optyx.core.errors import InvalidOperationError, NoObjectiveError
+
+
+# =============================================================================
+# Test Problem.write() and Problem.to_lp()
+# =============================================================================
+
+
+class TestProblemWrite:
+    """Tests for Problem.write() file output."""
+
+    def test_write_creates_file(self, tmp_path):
+        x = Variable("x", lb=0)
+        prob = Problem("test")
+        prob.minimize(x)
+        filepath = str(tmp_path / "model.lp")
+        prob.write(filepath)
+        assert os.path.exists(filepath)
+
+    def test_write_content_matches_to_lp(self, tmp_path):
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem("test")
+        prob.minimize(x + y)
+        prob.subject_to(x + y >= 1)
+        filepath = str(tmp_path / "model.lp")
+        prob.write(filepath)
+        with open(filepath) as f:
+            content = f.read()
+        assert content == prob.to_lp()
+
+    def test_to_lp_returns_string(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(x)
+        result = prob.to_lp()
+        assert isinstance(result, str)
+        assert "Minimize" in result
+        assert "End" in result
+
+
+# =============================================================================
+# Test LP Format Structure
+# =============================================================================
+
+
+class TestLPFormatStructure:
+    """Tests for the overall LP format structure."""
+
+    def test_model_name_in_comment(self):
+        prob = Problem("my_model")
+        prob.minimize(Variable("x", lb=0))
+        lp = prob.to_lp()
+        assert lp.startswith("\\ Model my_model")
+
+    def test_default_model_name(self):
+        prob = Problem()
+        prob.minimize(Variable("x", lb=0))
+        lp = prob.to_lp()
+        assert "\\ Model optyx_model" in lp
+
+    def test_sections_order(self):
+        x = Variable("x", lb=0)
+        y = IntegerVariable("y", lb=0, ub=5)
+        prob = Problem()
+        prob.minimize(x + y)
+        prob.subject_to(x + y >= 1)
+        lp = prob.to_lp()
+        lines = lp.split("\n")
+
+        # Find section positions
+        minimize_idx = next(i for i, ln in enumerate(lines) if ln.strip() == "Minimize")
+        subject_idx = next(
+            i for i, ln in enumerate(lines) if ln.strip() == "Subject To"
+        )
+        bounds_idx = next(i for i, ln in enumerate(lines) if ln.strip() == "Bounds")
+        generals_idx = next(i for i, ln in enumerate(lines) if ln.strip() == "Generals")
+        end_idx = next(i for i, ln in enumerate(lines) if ln.strip() == "End")
+
+        assert minimize_idx < subject_idx < bounds_idx < generals_idx < end_idx
+
+    def test_end_keyword(self):
+        prob = Problem()
+        prob.minimize(Variable("x", lb=0))
+        lp = prob.to_lp()
+        assert lp.strip().endswith("End")
+
+
+# =============================================================================
+# Test Linear Objectives
+# =============================================================================
+
+
+class TestLinearObjective:
+    """Tests for linear objective formatting."""
+
+    def test_minimize_single_variable(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(x)
+        lp = prob.to_lp()
+        assert "Minimize" in lp
+        assert "obj: x" in lp
+
+    def test_maximize(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.maximize(x)
+        lp = prob.to_lp()
+        assert "Maximize" in lp
+
+    def test_coefficient_formatting(self):
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(2 * x + 3 * y)
+        lp = prob.to_lp()
+        assert "2 x" in lp
+        assert "3 y" in lp
+
+    def test_negative_coefficient(self):
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(x - 2 * y)
+        lp = prob.to_lp()
+        assert "- 2 y" in lp
+
+    def test_unit_coefficient_omitted(self):
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(x + y)
+        lp = prob.to_lp()
+        # "1 x" should not appear — just "x"
+        assert "1 x" not in lp
+        assert "obj: x + y" in lp
+
+    def test_negative_unit_coefficient(self):
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(x - y)
+        lp = prob.to_lp()
+        assert "obj: x - y" in lp
+
+    def test_vector_sum_objective(self):
+        x = VectorVariable("x", 3, lb=0)
+        prob = Problem()
+        prob.minimize(x.sum())
+        lp = prob.to_lp()
+        assert "x[0]" in lp
+        assert "x[1]" in lp
+        assert "x[2]" in lp
+
+    def test_linear_combination_objective(self):
+        x = VectorVariable("x", 3, lb=0)
+        c = np.array([1.0, 2.0, 3.0])
+        prob = Problem()
+        prob.minimize(c @ x)
+        lp = prob.to_lp()
+        assert "x[0]" in lp
+        assert "2 x[1]" in lp
+        assert "3 x[2]" in lp
+
+
+# =============================================================================
+# Test Quadratic Objectives
+# =============================================================================
+
+
+class TestQuadraticObjective:
+    """Tests for quadratic objective formatting."""
+
+    def test_simple_quadratic(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(x**2)
+        lp = prob.to_lp()
+        assert "[" in lp
+        assert "] / 2" in lp
+        assert "x ^2" in lp
+
+    def test_cross_term(self):
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(x * y)
+        lp = prob.to_lp()
+        assert "x * y" in lp
+
+    def test_mixed_linear_quadratic(self):
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(x + y + x**2 + x * y + y**2)
+        lp = prob.to_lp()
+        # Should have both linear and quadratic parts
+        assert "x + y" in lp or ("x" in lp and "y" in lp)
+        assert "[" in lp
+        assert "] / 2" in lp
+
+    def test_dot_product_self(self):
+        x = VectorVariable("x", 3, lb=0)
+        prob = Problem()
+        prob.minimize(x.dot(x))
+        lp = prob.to_lp()
+        assert "x[0] ^2" in lp
+        assert "x[1] ^2" in lp
+        assert "x[2] ^2" in lp
+
+    def test_quadratic_form(self):
+        x = VectorVariable("x", 2, lb=0)
+        Q = np.array([[2.0, 1.0], [1.0, 3.0]])
+        prob = Problem()
+        prob.minimize(quadratic_form(x, Q))
+        lp = prob.to_lp()
+        assert "[" in lp
+        assert "x[0] ^2" in lp
+        assert "x[0] * x[1]" in lp
+        assert "x[1] ^2" in lp
+
+    def test_quadratic_form_coefficients(self):
+        """Verify quadratic coefficients are correct in LP format."""
+        x = VectorVariable("x", 2, lb=0)
+        Q = np.array([[2.0, 0.5], [0.5, 3.0]])
+        prob = Problem()
+        prob.minimize(quadratic_form(x, Q))
+        lp = prob.to_lp()
+        # LP format: [ 2*coeff terms ] / 2
+        # x[0]^2 coeff = 2.0, doubled = 4.0
+        assert "4 x[0] ^2" in lp
+        # x[0]*x[1] coeff = 0.5+0.5 = 1.0, doubled = 2.0
+        assert "2 x[0] * x[1]" in lp
+        # x[1]^2 coeff = 3.0, doubled = 6.0
+        assert "6 x[1] ^2" in lp
+
+
+# =============================================================================
+# Test Constraints
+# =============================================================================
+
+
+class TestConstraints:
+    """Tests for constraint formatting."""
+
+    def test_le_constraint(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x <= 10)
+        lp = prob.to_lp()
+        assert "<=" in lp
+        assert "10" in lp
+
+    def test_ge_constraint(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 1)
+        lp = prob.to_lp()
+        assert ">=" in lp
+        assert "1" in lp
+
+    def test_eq_constraint(self):
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(x + y)
+        prob.subject_to((x + y).eq(1))
+        lp = prob.to_lp()
+        assert "==" in lp
+
+    def test_multiple_constraints(self):
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(x + y)
+        prob.subject_to(x + y >= 1)
+        prob.subject_to(x - y <= 5)
+        prob.subject_to((x + y).eq(3))
+        lp = prob.to_lp()
+        assert "c0:" in lp
+        assert "c1:" in lp
+        assert "c2:" in lp
+
+    def test_named_constraint(self):
+        from optyx.constraints import Constraint
+
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(x + y)
+        c = Constraint(expr=x + y - 1, sense=">=", name="demand")
+        prob.subject_to(c)
+        lp = prob.to_lp()
+        assert "demand:" in lp
+
+    def test_no_constraints(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(x)
+        lp = prob.to_lp()
+        assert "Subject To" not in lp
+
+    def test_constraint_with_constant(self):
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(2 * x + 3 * y >= 6)
+        lp = prob.to_lp()
+        assert "2 x" in lp
+        assert "3 y" in lp
+        assert ">=" in lp
+        assert "6" in lp
+
+
+# =============================================================================
+# Test Matrix Constraints
+# =============================================================================
+
+
+class TestMatrixConstraints:
+    """Tests for matrix constraint formatting."""
+
+    def test_dense_matrix_constraints(self):
+        x = VectorVariable("x", 3, lb=0)
+        A = np.array([[1, 2, 3], [4, 5, 6]])
+        b = np.array([10, 20])
+        prob = Problem()
+        prob.minimize(x.sum())
+        prob.subject_to(A @ x <= b)
+        lp = prob.to_lp()
+        assert "<=" in lp
+        assert "10" in lp
+        assert "20" in lp
+
+    def test_sparse_matrix_constraints(self):
+        from scipy import sparse as sp
+
+        x = VectorVariable("x", 5, lb=0)
+        A = as_matrix(sp.csr_matrix(np.array([[1, 0, 0, 2, 0], [0, 3, 0, 0, 4]])))
+        b = np.array([5, 6])
+        prob = Problem()
+        prob.minimize(x.sum())
+        prob.subject_to(A @ x >= b)
+        lp = prob.to_lp()
+        assert ">=" in lp
+        # Zero coefficients should be omitted
+        lines = lp.split("\n")
+        constraint_lines = [ln for ln in lines if ln.strip().startswith("c")]
+        # First constraint should have x[0] and x[3]
+        assert "x[0]" in constraint_lines[0]
+        assert "x[3]" in constraint_lines[0]
+
+    def test_mixed_expression_and_matrix_constraints(self):
+        x = VectorVariable("x", 3, lb=0)
+        A = np.array([[1, 1, 1]])
+        b = np.array([10])
+        prob = Problem()
+        prob.minimize(x.sum())
+        prob.subject_to(x[0] >= 1)
+        prob.subject_to(A @ x <= b)
+        lp = prob.to_lp()
+        assert "c0:" in lp
+        assert "c1:" in lp
+
+
+# =============================================================================
+# Test Bounds
+# =============================================================================
+
+
+class TestBounds:
+    """Tests for variable bounds formatting."""
+
+    def test_lower_bound_only(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(x)
+        lp = prob.to_lp()
+        assert "0 <= x" in lp
+
+    def test_upper_bound_only(self):
+        x = Variable("x", ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        lp = prob.to_lp()
+        assert "-inf <= x <= 10" in lp
+
+    def test_both_bounds(self):
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        lp = prob.to_lp()
+        assert "0 <= x <= 10" in lp
+
+    def test_free_variable(self):
+        x = Variable("x")
+        prob = Problem()
+        prob.minimize(x)
+        lp = prob.to_lp()
+        assert "x free" in lp
+
+    def test_binary_bounds(self):
+        b = BinaryVariable("b")
+        prob = Problem()
+        prob.minimize(b)
+        lp = prob.to_lp()
+        assert "0 <= b <= 1" in lp
+
+
+# =============================================================================
+# Test Variable Types (Generals / Binaries)
+# =============================================================================
+
+
+class TestVariableTypes:
+    """Tests for integer and binary variable type sections."""
+
+    def test_integer_variable(self):
+        x = IntegerVariable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        lp = prob.to_lp()
+        assert "Generals" in lp
+        assert "  x" in lp
+
+    def test_binary_variable(self):
+        b = BinaryVariable("b")
+        prob = Problem()
+        prob.minimize(b)
+        lp = prob.to_lp()
+        assert "Binaries" in lp
+        assert "  b" in lp
+
+    def test_mixed_variable_types(self):
+        x = Variable("x", lb=0)
+        y = IntegerVariable("y", lb=0, ub=5)
+        z = BinaryVariable("z")
+        prob = Problem()
+        prob.minimize(x + y + z)
+        lp = prob.to_lp()
+        assert "Generals" in lp
+        assert "Binaries" in lp
+        # x should not appear in Generals or Binaries
+        generals_idx = lp.index("Generals")
+        binaries_idx = lp.index("Binaries")
+        generals_section = lp[generals_idx:binaries_idx]
+        assert "  y" in generals_section
+        binaries_section = lp[binaries_idx:]
+        assert "  z" in binaries_section
+
+    def test_no_generals_or_binaries_for_continuous(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(x)
+        lp = prob.to_lp()
+        assert "Generals" not in lp
+        assert "Binaries" not in lp
+
+    def test_vector_integer_variables(self):
+        x = VectorVariable("x", 3, lb=0, ub=10, domain="integer")
+        prob = Problem()
+        prob.minimize(x.sum())
+        lp = prob.to_lp()
+        assert "Generals" in lp
+        assert "x[0]" in lp
+        assert "x[1]" in lp
+        assert "x[2]" in lp
+
+    def test_vector_binary_variables(self):
+        b = VectorVariable("b", 4, domain="binary")
+        prob = Problem()
+        prob.minimize(b.sum())
+        lp = prob.to_lp()
+        assert "Binaries" in lp
+
+
+# =============================================================================
+# Test Error Cases
+# =============================================================================
+
+
+class TestErrors:
+    """Tests for error handling."""
+
+    def test_no_objective_raises(self):
+        prob = Problem()
+        prob.subject_to(Variable("x", lb=0) >= 0)
+        with pytest.raises(NoObjectiveError):
+            prob.to_lp()
+
+    def test_nonlinear_objective_raises(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(sin(x))
+        with pytest.raises(InvalidOperationError, match="LP format only supports"):
+            prob.to_lp()
+
+    def test_nonlinear_constraint_raises(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(sin(x) <= 1)
+        with pytest.raises(InvalidOperationError, match="not linear"):
+            prob.to_lp()
+
+    def test_exp_objective_raises(self):
+        x = Variable("x", lb=0)
+        prob = Problem()
+        prob.minimize(exp(x))
+        with pytest.raises(InvalidOperationError):
+            prob.to_lp()
+
+
+# =============================================================================
+# Test extract_quadratic_coefficients utility
+# =============================================================================
+
+
+class TestExtractQuadraticCoefficients:
+    """Tests for the extract_quadratic_coefficients analysis utility."""
+
+    def test_simple_square(self):
+        x = Variable("x")
+        Q = extract_quadratic_coefficients(x**2, [x])
+        assert Q.shape == (1, 1)
+        assert Q[0, 0] == pytest.approx(1.0)
+
+    def test_cross_term(self):
+        x = Variable("x")
+        y = Variable("y")
+        Q = extract_quadratic_coefficients(x * y, [x, y])
+        assert Q.shape == (2, 2)
+        # Symmetric: Q[0,1] = Q[1,0] = 0.5
+        assert Q[0, 1] == pytest.approx(0.5)
+        assert Q[1, 0] == pytest.approx(0.5)
+
+    def test_quadratic_form_extraction(self):
+        x = VectorVariable("x", 2)
+        Q_in = np.array([[2.0, 1.0], [1.0, 3.0]])
+        expr = quadratic_form(x, Q_in)
+        Q_out = extract_quadratic_coefficients(expr, list(x._variables))
+        np.testing.assert_array_almost_equal(Q_out, Q_in)
+
+    def test_dot_product_self(self):
+        x = VectorVariable("x", 3)
+        expr = x.dot(x)
+        Q = extract_quadratic_coefficients(expr, list(x._variables))
+        np.testing.assert_array_almost_equal(Q, np.eye(3))
+
+    def test_mixed_linear_quadratic_extracts_only_quadratic(self):
+        x = Variable("x")
+        y = Variable("y")
+        expr = x**2 + 3 * x + 2 * y
+        Q = extract_quadratic_coefficients(expr, [x, y])
+        assert Q[0, 0] == pytest.approx(1.0)
+        assert Q[0, 1] == pytest.approx(0.0)
+        assert Q[1, 1] == pytest.approx(0.0)
+
+    def test_nonlinear_raises(self):
+        x = Variable("x")
+        from optyx.core.errors import NonLinearError
+
+        with pytest.raises(NonLinearError):
+            extract_quadratic_coefficients(sin(x), [x])
+
+    def test_symmetry(self):
+        x = Variable("x")
+        y = Variable("y")
+        Q = extract_quadratic_coefficients(2 * x * y + x**2, [x, y])
+        np.testing.assert_array_almost_equal(Q, Q.T)
+
+
+# =============================================================================
+# Test VariableDict support
+# =============================================================================
+
+
+class TestVariableDictSupport:
+    """Tests for VariableDict LP export."""
+
+    def test_variable_dict_lp(self):
+        buy = VariableDict("buy", ["ham", "egg"], lb=0)
+        prob = Problem("diet")
+        prob.minimize(buy["ham"] + 2 * buy["egg"])
+        prob.subject_to(buy["ham"] + buy["egg"] >= 1)
+        lp = prob.to_lp()
+        assert "buy[ham]" in lp
+        assert "buy[egg]" in lp
+
+    def test_variable_dict_integer(self):
+        x = VariableDict("x", ["a", "b"], lb=0, ub=10, domain="integer")
+        prob = Problem()
+        prob.minimize(x["a"] + x["b"])
+        lp = prob.to_lp()
+        assert "Generals" in lp
+
+
+# =============================================================================
+# Test Round-Trip Accuracy
+# =============================================================================
+
+
+class TestRoundTrip:
+    """Tests verifying LP export matches the original model."""
+
+    def test_lp_objective_coefficients(self):
+        """Verify exported coefficients match the model."""
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        z = Variable("z", lb=0)
+        prob = Problem()
+        prob.minimize(5 * x - 3 * y + 7 * z)
+        lp = prob.to_lp()
+        assert "5 x" in lp
+        assert "- 3 y" in lp
+        assert "+ 7 z" in lp
+
+    def test_constraint_rhs(self):
+        """Verify constraint RHS values."""
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+        prob = Problem()
+        prob.minimize(x + y)
+        prob.subject_to(x + y >= 10)
+        prob.subject_to(x - y <= 3)
+        lp = prob.to_lp()
+        assert ">= 10" in lp
+        assert "<= 3" in lp
+
+    def test_write_and_read_back(self, tmp_path):
+        """Verify file can be written and read back."""
+        x = Variable("x", lb=0, ub=100)
+        y = Variable("y", lb=-5, ub=50)
+        prob = Problem("roundtrip")
+        prob.minimize(2 * x + 3 * y)
+        prob.subject_to(x + y >= 1)
+        prob.subject_to(x - y <= 10)
+
+        filepath = str(tmp_path / "roundtrip.lp")
+        prob.write(filepath)
+
+        with open(filepath) as f:
+            content = f.read()
+
+        assert "\\ Model roundtrip" in content
+        assert "Minimize" in content
+        assert "Subject To" in content
+        assert "Bounds" in content
+        assert "End" in content
+
+    def test_maximize_objective(self):
+        x = Variable("x", lb=0, ub=10)
+        y = Variable("y", lb=0, ub=10)
+        prob = Problem()
+        prob.maximize(3 * x + 5 * y)
+        prob.subject_to(x + y <= 10)
+        lp = prob.to_lp()
+        assert "Maximize" in lp
+        assert "3 x" in lp
+        assert "5 y" in lp
diff --git a/tests/test_matrix_constraints.py b/tests/test_matrix_constraints.py
new file mode 100644
index 0000000..0a67369
--- /dev/null
+++ b/tests/test_matrix_constraints.py
@@ -0,0 +1,354 @@
+"""Tests for matrix-form linear constraints via subject_to(A @ x <= b)."""
+
+import numpy as np
+import pytest
+from scipy import sparse as sp
+from scipy.optimize import linprog
+
+from optyx.analysis import LinearProgramExtractor
+from optyx import Problem, VectorVariable, as_matrix
+from optyx.core.errors import DimensionMismatchError
+
+
+class TestMatrixConstraintValidation:
+    """Validation for direct matrix constraints."""
+
+    def test_dimension_mismatch_columns(self):
+        x = VectorVariable("x", 3, lb=0)
+        A = np.ones((2, 4))  # 4 columns != 3 variables
+        b = np.ones(2)
+        prob = Problem().minimize(np.ones(3) @ x)
+        with pytest.raises(DimensionMismatchError, match=r"\(2, 4\).*(3,)"):
+            prob.subject_to(A @ x <= b)
+
+    def test_dimension_mismatch_rows(self):
+        x = VectorVariable("x", 3, lb=0)
+        A = np.ones((2, 3))
+        b = np.ones(5)  # 5 elements != 2 rows
+        prob = Problem().minimize(np.ones(3) @ x)
+        with pytest.raises(ValueError, match="2 rows.*5 elements"):
+            prob.subject_to(A @ x <= b)
+
+    def test_sparse_dimension_mismatch(self):
+        x = VectorVariable("x", 3, lb=0)
+        A = as_matrix(sp.csr_matrix(np.ones((2, 5))))  # 5 columns != 3
+        b = np.ones(2)
+        prob = Problem().minimize(np.ones(3) @ x)
+        with pytest.raises(DimensionMismatchError, match=r"\(2, 5\).*(3,)"):
+            prob.subject_to(A @ x <= b)
+
+
+class TestAsMatrixStorage:
+    """Storage policy overrides for as_matrix()."""
+
+    def test_force_sparse_from_dense(self):
+        wrapped = as_matrix(np.eye(8), storage="sparse")
+        assert sp.issparse(wrapped.data)
+        assert wrapped.storage == "sparse"
+
+    def test_force_dense_from_sparse(self):
+        wrapped = as_matrix(sp.eye(8, format="csr"), storage="dense")
+        assert isinstance(wrapped.data, np.ndarray)
+        assert wrapped.storage == "dense"
+
+    def test_auto_keeps_small_dense_matrices_dense(self):
+        wrapped = as_matrix(np.eye(4), storage="auto")
+        assert isinstance(wrapped.data, np.ndarray)
+        assert wrapped.storage == "dense"
+
+    def test_auto_converts_large_sparse_like_dense_matrices(self):
+        wrapped = as_matrix(np.eye(64), storage="auto")
+        assert sp.issparse(wrapped.data)
+        assert wrapped.storage == "sparse"
+
+    def test_invalid_storage_raises(self):
+        with pytest.raises(ValueError, match="storage"):
+            as_matrix(np.eye(2), storage="invalid")
+
+
+class TestSubjectToMatrixDense:
+    """Dense matrix constraints."""
+
+    def test_le_constraint(self):
+        """min c'x s.t. Ax <= b, x >= 0."""
+        x = VectorVariable("x", 3, lb=0)
+        A = np.array([[1, 2, 0], [0, 1, 3]])
+        b = np.array([10.0, 12.0])
+        c = np.array([1.0, 1.0, 1.0])
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to(A @ x <= b)
+
+        assert prob.n_constraints == 2
+        assert len(prob.variables) == 3
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+        assert sol.objective_value == pytest.approx(0.0, abs=1e-8)
+
+    def test_eq_constraint(self):
+        """min c'x s.t. Ax == b, x >= 0."""
+        x = VectorVariable("x", 2, lb=0)
+        A = np.array([[1.0, 1.0]])
+        b = np.array([10.0])
+        c = np.array([3.0, 1.0])
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to((A @ x).eq(b))
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+        # min 3x0 + x1 s.t. x0+x1=10 → x0=0, x1=10, value=10
+        assert sol.objective_value == pytest.approx(10.0, abs=1e-8)
+        assert sol.values["x[0]"] == pytest.approx(0.0, abs=1e-8)
+        assert sol.values["x[1]"] == pytest.approx(10.0, abs=1e-8)
+
+    def test_ge_constraint(self):
+        """min c'x s.t. Ax >= b, x >= 0, x <= 100."""
+        x = VectorVariable("x", 2, lb=0, ub=100)
+        A = np.array([[1.0, 0.0], [0.0, 1.0]])
+        b = np.array([5.0, 3.0])
+        c = np.array([1.0, 1.0])
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to(A @ x >= b)
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+        assert sol.objective_value == pytest.approx(8.0, abs=1e-8)
+
+    def test_method_chaining(self):
+        """Direct matrix constraints return self for fluent API."""
+        x = VectorVariable("x", 2, lb=0)
+        A = np.eye(2)
+        b = np.ones(2)
+        c = np.ones(2)
+
+        sol = Problem().minimize(c @ x).subject_to(A @ x <= b).solve()
+        assert sol.status.value == "optimal"
+
+    def test_b_as_list(self):
+        """b can be a Python list."""
+        x = VectorVariable("x", 2, lb=0)
+        A = np.eye(2)
+        b = [5.0, 3.0]
+        c = np.ones(2)
+
+        prob = Problem().minimize(c @ x).subject_to(A @ x <= b)
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+
+
+class TestSubjectToMatrixSparse:
+    """Sparse matrix constraints."""
+
+    def test_sparse_csr_le(self):
+        """CSR sparse matrix with <= constraints."""
+        n = 100
+        x = VectorVariable("x", n, lb=0)
+        A = as_matrix(sp.eye(n, format="csr"))
+        b = np.ones(n) * 10
+        c = np.ones(n)
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to(A @ x <= b)
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+        assert sol.objective_value == pytest.approx(0.0, abs=1e-6)
+
+    def test_sparse_csc_eq(self):
+        """CSC sparse matrix with == constraints."""
+        x = VectorVariable("x", 3, lb=0)
+        A = as_matrix(sp.csc_matrix(np.array([[1, 1, 1]])))
+        b = np.array([6.0])
+        c = np.array([2.0, 1.0, 3.0])
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to((A @ x).eq(b))
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+        # min 2x0 + x1 + 3x2 s.t. x0+x1+x2=6 → x1=6, value=6
+        assert sol.objective_value == pytest.approx(6.0, abs=1e-8)
+
+    def test_sparse_random(self):
+        """Random sparse matrix constraint produces correct solution."""
+        rng = np.random.default_rng(42)
+        n = 50
+        m = 30
+        x = VectorVariable("x", n, lb=0, ub=10)
+        A_sparse = sp.random(m, n, density=0.1, format="csr", random_state=rng)
+        A = as_matrix(A_sparse)
+        b = A_sparse @ np.ones(n) * 5  # feasible b
+        c = rng.standard_normal(n)
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to(A @ x <= b)
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+
+        # Verify against direct scipy linprog
+        bounds = [(0, 10)] * n
+        ref = linprog(c, A_ub=A_sparse, b_ub=b, bounds=bounds, method="highs")
+        assert ref.success
+        assert sol.objective_value == pytest.approx(ref.fun, rel=1e-6)
+
+    def test_sparse_ge(self):
+        """Sparse >= constraint."""
+        x = VectorVariable("x", 3, lb=0, ub=100)
+        A = as_matrix(sp.csr_matrix(np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]])))
+        b = np.array([2.0, 3.0, 4.0])
+        c = np.array([1.0, 1.0, 1.0])
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to(A @ x >= b)
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+        assert sol.objective_value == pytest.approx(9.0, abs=1e-8)
+
+
+class TestMixedConstraints:
+    """Matrix constraints combined with scalar expression constraints."""
+
+    def test_matrix_plus_expression_constraints(self):
+        """Matrix constraints and expression constraints work together."""
+        x = VectorVariable("x", 2, lb=0)
+
+        prob = Problem().minimize(x[0] + x[1])
+        # Matrix constraint: x0 + x1 >= 10
+        A = np.array([[1.0, 1.0]])
+        b = np.array([10.0])
+        prob.subject_to(A @ x >= b)
+        # Expression constraint: x0 <= 7
+        prob.subject_to(x[0] <= 7)
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+        assert sol.objective_value == pytest.approx(10.0, abs=1e-8)
+        # x0 <= 7 and x0+x1 >= 10, so x0+x1 = 10 at optimum
+        assert sol.values["x[0]"] + sol.values["x[1]"] == pytest.approx(10.0, abs=1e-8)
+        assert sol.values["x[0]"] <= 7.0 + 1e-8
+
+    def test_multiple_matrix_constraints(self):
+        """Multiple matrix constraints added through subject_to()."""
+        x = VectorVariable("x", 2, lb=0, ub=100)
+
+        prob = Problem().minimize(x[0] + x[1])
+        prob.subject_to(np.array([[1, 0]]) @ x >= np.array([3.0]))
+        prob.subject_to(np.array([[0, 1]]) @ x >= np.array([5.0]))
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+        assert sol.objective_value == pytest.approx(8.0, abs=1e-8)
+
+    def test_le_and_eq_matrix_constraints(self):
+        """Mix of <= and == matrix constraints."""
+        x = VectorVariable("x", 3, lb=0)
+
+        prob = Problem().minimize(x[0] + x[1] + x[2])
+        # x0 + x1 + x2 == 10
+        prob.subject_to((np.array([[1, 1, 1]]) @ x).eq(np.array([10.0])))
+        # x0 <= 3
+        prob.subject_to(np.array([[1, 0, 0]]) @ x <= np.array([3.0]))
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+        assert sol.objective_value == pytest.approx(10.0, abs=1e-8)
+
+
+class TestLPDataExtraction:
+    """Verify LP data extraction with matrix constraints."""
+
+    def test_sparse_preserved_in_lp_data(self):
+        """Sparse matrices are preserved (not densified) in LPData."""
+        n = 100
+        x = VectorVariable("x", n, lb=0)
+        A_sparse = sp.eye(n, format="csr") * 2
+        A = as_matrix(A_sparse)
+        b = np.ones(n) * 10
+        c = np.ones(n)
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to(A @ x <= b)
+
+        extractor = LinearProgramExtractor()
+        lp_data = extractor.extract(prob)
+
+        assert sp.issparse(lp_data.A_ub)
+        assert lp_data.A_ub.shape == (n, n)
+        np.testing.assert_array_almost_equal(lp_data.b_ub, b)
+
+    def test_dense_stays_dense(self):
+        """Dense matrix constraints produce dense LPData."""
+        x = VectorVariable("x", 3, lb=0)
+        A = np.eye(3)
+        b = np.ones(3) * 5
+        c = np.ones(3)
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to(A @ x <= b)
+
+        extractor = LinearProgramExtractor()
+        lp_data = extractor.extract(prob)
+
+        assert isinstance(lp_data.A_ub, np.ndarray)
+
+    def test_n_constraints_with_matrix(self):
+        """n_constraints counts matrix constraint rows."""
+        x = VectorVariable("x", 5, lb=0)
+        prob = Problem().minimize(np.ones(5) @ x)
+        prob.subject_to(np.eye(5) @ x <= np.ones(5) * 10)
+        prob.subject_to(x[0] >= 1)
+        assert prob.n_constraints == 6  # 5 matrix + 1 expression
+
+    def test_is_linear_with_matrix_constraints(self):
+        """Matrix constraints don't affect linearity detection."""
+        x = VectorVariable("x", 3, lb=0)
+        prob = Problem().minimize(np.ones(3) @ x)
+        prob.subject_to(np.eye(3) @ x <= np.ones(3))
+        assert prob._is_linear_problem()
+
+
+class TestLargeScale:
+    """Performance-oriented tests for large-scale LPs."""
+
+    def test_large_sparse_lp(self):
+        """n=1000 sparse LP solves correctly."""
+        rng = np.random.default_rng(123)
+        n = 1000
+        m = 500
+        x = VectorVariable("x", n, lb=0, ub=100)
+        A_sparse = sp.random(m, n, density=0.01, format="csr", random_state=rng)
+        A = as_matrix(A_sparse)
+        b = np.abs(A_sparse @ np.ones(n)) + 1
+        c = rng.standard_normal(n)
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to(A @ x <= b)
+
+        sol = prob.solve()
+        assert sol.status.value == "optimal"
+
+        # Verify against scipy
+        bounds = [(0, 100)] * n
+        ref = linprog(c, A_ub=A_sparse, b_ub=b, bounds=bounds, method="highs")
+        assert ref.success
+        assert sol.objective_value == pytest.approx(ref.fun, rel=1e-4)
+
+    def test_warm_solve_uses_cache(self):
+        """Second solve reuses LP cache."""
+        x = VectorVariable("x", 10, lb=0)
+        A = as_matrix(sp.eye(10, format="csr"))
+        b = np.ones(10) * 5
+        c = np.ones(10)
+
+        prob = Problem().minimize(c @ x)
+        prob.subject_to(A @ x <= b)
+
+        sol1 = prob.solve()
+        assert prob._lp_cache is not None
+        sol2 = prob.solve()
+        assert sol1.objective_value == sol2.objective_value
diff --git a/tests/test_milp_solver.py b/tests/test_milp_solver.py
new file mode 100644
index 0000000..beedf30
--- /dev/null
+++ b/tests/test_milp_solver.py
@@ -0,0 +1,450 @@
+"""Tests for MILP solver integration (scipy.optimize.milp)."""
+
+import numpy as np
+import pytest
+from scipy import sparse
+
+from optyx import Variable, BinaryVariable, IntegerVariable, VectorVariable, as_matrix
+from optyx.core.errors import UnsupportedOperationError
+from optyx.problem import Problem
+from optyx.solution import SolverStatus
+
+
+class TestMILPBinaryKnapsack:
+    """Binary knapsack problem solves correctly via milp()."""
+
+    def test_milp_binary_knapsack(self):
+        """Classic 0-1 knapsack: maximize value subject to weight capacity."""
+        # Items: (value, weight) = (10, 5), (6, 4), (4, 3)
+        # Capacity = 7
+        x1 = BinaryVariable("x1")
+        x2 = BinaryVariable("x2")
+        x3 = BinaryVariable("x3")
+
+        prob = Problem()
+        prob.maximize(10 * x1 + 6 * x2 + 4 * x3)
+        prob.subject_to(5 * x1 + 4 * x2 + 3 * x3 <= 7)
+
+        sol = prob.solve()
+
+        assert sol.is_optimal
+        # Optimal: take x2 + x3 (weight=7, value=10) or x1 (weight=5, value=10)
+        # Both give value=10; x1 alone also works
+        assert abs(sol.objective_value - 10) < 1e-6
+
+    def test_knapsack_all_binary(self):
+        """All solution values are 0 or 1."""
+        x1 = BinaryVariable("x1")
+        x2 = BinaryVariable("x2")
+
+        prob = Problem()
+        prob.maximize(3 * x1 + 2 * x2)
+        prob.subject_to(2 * x1 + x2 <= 2)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        for name in ["x1", "x2"]:
+            assert sol[name] == pytest.approx(0, abs=1e-6) or sol[
+                name
+            ] == pytest.approx(1, abs=1e-6)
+
+
+class TestMILPIntegerVariables:
+    """Integer-constrained LP produces integer solution."""
+
+    def test_milp_integer_variables(self):
+        """Integer variables produce integer solutions."""
+        x = IntegerVariable("x", lb=0, ub=10)
+        y = IntegerVariable("y", lb=0, ub=10)
+
+        prob = Problem()
+        prob.minimize(x + y)
+        prob.subject_to(x + y >= 5)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        # Solution should be integer
+        assert abs(sol["x"] - round(sol["x"])) < 1e-6
+        assert abs(sol["y"] - round(sol["y"])) < 1e-6
+        assert round(sol["x"]) + round(sol["y"]) >= 5
+
+    def test_integer_bounds_respected(self):
+        """Integer variable bounds are enforced."""
+        x = IntegerVariable("x", lb=2, ub=8)
+
+        prob = Problem()
+        prob.minimize(x)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol["x"] - 2) < 1e-6
+
+
+class TestMILPMixed:
+    """Mix of continuous and integer variables solves correctly."""
+
+    def test_milp_mixed(self):
+        """Continuous and integer vars solve together."""
+        x = Variable("x", lb=0)  # continuous
+        y = IntegerVariable("y", lb=0, ub=10)
+
+        prob = Problem()
+        prob.minimize(x + y)
+        prob.subject_to(x + y >= 3.5)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        # y should be integer, x continuous
+        y_val = sol["y"]
+        assert abs(y_val - round(y_val)) < 1e-6
+        # Total >= 3.5
+        assert sol["x"] + sol["y"] >= 3.5 - 1e-6
+
+
+class TestBinaryVariableAlias:
+    """BinaryVariable() creates Variable with domain='binary', lb=0, ub=1."""
+
+    def test_binary_variable_alias(self):
+        """BinaryVariable creates correct variable."""
+        x = BinaryVariable("x")
+
+        assert x.domain == "binary"
+        assert x.lb == 0
+        assert x.ub == 1
+
+    def test_binary_variable_in_problem(self):
+        """BinaryVariable works in optimization."""
+        x = BinaryVariable("x")
+        prob = Problem().minimize(x)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol["x"]) < 1e-6
+
+
+class TestIntegerVariableAlias:
+    """IntegerVariable() creates Variable with domain='integer'."""
+
+    def test_integer_variable_alias(self):
+        """IntegerVariable creates correct variable."""
+        x = IntegerVariable("x", lb=0, ub=5)
+
+        assert x.domain == "integer"
+        assert x.lb == 0
+        assert x.ub == 5
+
+    def test_integer_variable_default_bounds(self):
+        """IntegerVariable without explicit bounds."""
+        x = IntegerVariable("x")
+        assert x.domain == "integer"
+
+
+class TestVectorBinary:
+    """VectorVariable with domain='binary' creates binary vector."""
+
+    def test_vector_binary(self):
+        """VectorVariable with domain='binary' creates binary elements."""
+        x = VectorVariable("x", 3, domain="binary")
+
+        assert len(x) == 3
+        for v in x:
+            assert v.domain == "binary"
+            assert v.lb == 0
+            assert v.ub == 1
+
+    def test_vector_binary_in_problem(self):
+        """Binary vector solves in MILP."""
+        x = VectorVariable("x", 3, domain="binary")
+
+        prob = Problem()
+        prob.minimize(x[0] + x[1] + x[2])
+        prob.subject_to(x[0] + x[1] + x[2] >= 1)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        total = sum(sol[f"x[{i}]"] for i in range(3))
+        assert abs(total - 1) < 1e-6
+
+    def test_vector_integer(self):
+        """VectorVariable with domain='integer' creates integer elements."""
+        x = VectorVariable("x", 2, lb=0, ub=5, domain="integer")
+
+        for v in x:
+            assert v.domain == "integer"
+
+
+class TestMILPSolutionGap:
+    """Solution.mip_gap populated for MILP solve."""
+
+    def test_milp_solution_gap(self):
+        """mip_gap is populated after MILP solve."""
+        x = BinaryVariable("x")
+        prob = Problem().minimize(x)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        # mip_gap should be set (may be 0 for trivial problems)
+        if sol.mip_gap is not None:
+            assert sol.mip_gap >= 0
+
+    def test_milp_best_bound(self):
+        """best_bound is populated after MILP solve."""
+        x = BinaryVariable("x")
+        prob = Problem().minimize(x)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        # best_bound should be set
+        if sol.best_bound is not None:
+            assert isinstance(sol.best_bound, float)
+
+    def test_lp_no_mip_gap(self):
+        """Pure LP solve does not set mip_gap."""
+        x = Variable("x", lb=0)
+        prob = Problem().minimize(x)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert sol.mip_gap is None
+
+
+class TestMILPInfeasible:
+    """Infeasible MILP returns INFEASIBLE status."""
+
+    def test_milp_infeasible(self):
+        """Infeasible MILP correctly detected."""
+        x = BinaryVariable("x")
+
+        prob = Problem()
+        prob.minimize(x)
+        # x must be 0 or 1, but also >= 2 — infeasible
+        prob.subject_to(x >= 2)
+
+        sol = prob.solve()
+        assert not sol.is_optimal
+        assert sol.status == SolverStatus.INFEASIBLE
+
+
+class TestMILPRouting:
+    """LP without integers uses linprog(); with integers uses milp()."""
+
+    def test_milp_routing(self):
+        """Problem with integer vars routes to milp solver."""
+        x = IntegerVariable("x", lb=0, ub=10)
+        prob = Problem().minimize(x)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        # Integer result
+        assert abs(sol["x"] - round(sol["x"])) < 1e-6
+
+    def test_lp_routing(self):
+        """Problem without integer vars routes to linprog."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem().minimize(x)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert sol.mip_gap is None  # No MIP gap for LP
+
+    def test_method_milp_routing(self):
+        """method='milp' explicitly routes to MILP solver."""
+        x = IntegerVariable("x", lb=0, ub=5)
+        prob = Problem().minimize(x)
+
+        sol = prob.solve(method="milp")
+        assert sol.is_optimal
+
+    def test_milp_uses_live_bounds_after_resolve(self):
+        """MILP re-solves respect bound mutations after LP extraction is cached."""
+        x = IntegerVariable("x", lb=0, ub=10)
+        prob = Problem().maximize(x)
+
+        first = prob.solve()
+        assert first.is_optimal
+        assert first["x"] == pytest.approx(10.0)
+
+        x.ub = 3
+        second = prob.solve()
+        assert second.is_optimal
+        assert second["x"] == pytest.approx(3.0)
+
+
+class TestMIQPRaises:
+    """Quadratic objective + integer variables raises error."""
+
+    def test_miqp_raises(self):
+        """MIQP (quadratic + integer) raises UnsupportedOperationError."""
+        x = IntegerVariable("x", lb=0, ub=10)
+        prob = Problem().minimize((x - 3) ** 2)
+
+        with pytest.raises(UnsupportedOperationError, match="MIQP/MINLP"):
+            prob.solve()
+
+    def test_minlp_raises(self):
+        """MINLP (nonlinear + binary) raises UnsupportedOperationError."""
+        x = BinaryVariable("x")
+        prob = Problem().minimize(x**2 + x)
+
+        with pytest.raises(UnsupportedOperationError, match="MIQP/MINLP"):
+            prob.solve()
+
+
+class TestDomainValidation:
+    """Domain validation for variables."""
+
+    def test_domain_validation_binary(self):
+        """Binary domain enforces lb=0, ub=1."""
+        x = Variable("x", domain="binary")
+        assert x.lb == 0
+        assert x.ub == 1
+
+    def test_domain_validation_binary_conflicting_lb(self):
+        """Binary domain rejects conflicting lower bounds."""
+        with pytest.raises(ValueError, match="Binary variable must have lb=0"):
+            Variable("x", lb=2, domain="binary")
+
+    def test_domain_validation_binary_conflicting_ub(self):
+        """Binary domain rejects conflicting upper bounds."""
+        with pytest.raises(ValueError, match="Binary variable must have ub=1"):
+            Variable("x", ub=2, domain="binary")
+
+    def test_domain_validation_unknown(self):
+        """Unknown domain raises ValueError."""
+        with pytest.raises(ValueError, match="Unknown domain"):
+            Variable("x", domain="invalid")
+
+    def test_domain_continuous_default(self):
+        """Default domain is continuous."""
+        x = Variable("x")
+        assert x.domain == "continuous"
+
+
+class TestMILPSparseConstraints:
+    """MILP with sparse constraint matrix works correctly."""
+
+    def test_milp_sparse_constraints(self):
+        """Sparse constraints solve correctly in MILP."""
+        n = 10
+        x = VectorVariable("x", n, domain="binary")
+
+        prob = Problem()
+        prob.minimize(sum(x[i] for i in range(n)))
+        # At least 3 must be selected
+        prob.subject_to(sum(x[i] for i in range(n)) >= 3)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        total = sum(sol[f"x[{i}]"] for i in range(n))
+        assert abs(total - 3) < 1e-6
+
+    @pytest.mark.slow
+    def test_milp_sparse_constraints_large_scale(self):
+        """Large sparse MILP with 10,000 binaries solves through subject_to."""
+        group_size = 10
+        n_groups = 1000
+        n = group_size * n_groups
+
+        x = VectorVariable("x", n, domain="binary")
+        group_pattern = np.arange(group_size, 0, -1, dtype=float).reshape(1, group_size)
+        objective = np.tile(group_pattern.ravel(), n_groups)
+
+        A = as_matrix(
+            sparse.kron(
+                sparse.eye(n_groups, format="csr"),
+                np.ones((1, group_size), dtype=float),
+                format="csr",
+            )
+        )
+        b = np.ones(n_groups, dtype=float)
+
+        prob = Problem(name="sparse_milp_large_scale")
+        prob.maximize(objective @ x)
+        prob.subject_to(A @ x <= b)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert sol.objective_value == pytest.approx(float(n_groups * group_size))
+
+        values = np.array([sol[f"x[{i}]"] for i in range(n)], dtype=float).reshape(
+            n_groups, group_size
+        )
+        assert np.allclose(values.sum(axis=1), 1.0)
+        assert np.all(values[:, 0] > 0.5)
+        assert np.all(values[:, 1:] < 0.5)
+
+
+class TestFacilityLocationMILP:
+    """Facility location: binary open + continuous transport."""
+
+    def test_facility_location_milp(self):
+        """Simple facility location problem solves end-to-end."""
+        # 2 facilities, 2 customers
+        # Open cost: facility 0 = 10, facility 1 = 15
+        # Transport cost: (facility, customer) → cost
+        # f0→c0=2, f0→c1=4, f1→c0=5, f1→c1=1
+        # Customer demands: c0=1, c1=1
+
+        y0 = BinaryVariable("y0")  # open facility 0
+        y1 = BinaryVariable("y1")  # open facility 1
+        # Transport (continuous, but bounded by open)
+        x00 = Variable("x00", lb=0)  # f0 → c0
+        x01 = Variable("x01", lb=0)  # f0 → c1
+        x10 = Variable("x10", lb=0)  # f1 → c0
+        x11 = Variable("x11", lb=0)  # f1 → c1
+
+        prob = Problem()
+        # Minimize: fixed cost + transport cost
+        prob.minimize(10 * y0 + 15 * y1 + 2 * x00 + 4 * x01 + 5 * x10 + 1 * x11)
+
+        # Demand satisfaction
+        prob.subject_to(x00 + x10 >= 1)  # customer 0
+        prob.subject_to(x01 + x11 >= 1)  # customer 1
+
+        # Capacity: can only ship from open facility (big-M)
+        M = 10
+        prob.subject_to(x00 + x01 <= M * y0)
+        prob.subject_to(x10 + x11 <= M * y1)
+
+        sol = prob.solve()
+
+        assert sol.is_optimal
+        # At least one facility must be open
+        assert sol["y0"] > 0.5 or sol["y1"] > 0.5
+        # Demands met
+        assert sol["x00"] + sol["x10"] >= 1 - 1e-6
+        assert sol["x01"] + sol["x11"] >= 1 - 1e-6
+
+
+class TestMILPMaximization:
+    """MILP maximization problems."""
+
+    def test_milp_maximize(self):
+        """Maximization with integer variables."""
+        x = IntegerVariable("x", lb=0, ub=5)
+        y = IntegerVariable("y", lb=0, ub=5)
+
+        prob = Problem()
+        prob.maximize(x + y)
+        prob.subject_to(x + y <= 7)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol.objective_value - 7) < 1e-6
+
+
+class TestMILPEqualityConstraints:
+    """MILP with equality constraints."""
+
+    def test_milp_equality(self):
+        """Equality constraints work in MILP."""
+        x = IntegerVariable("x", lb=0, ub=10)
+        y = IntegerVariable("y", lb=0, ub=10)
+
+        prob = Problem()
+        prob.minimize(x + y)
+        prob.subject_to((x + y).eq(5))
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol["x"] + sol["y"] - 5) < 1e-6
diff --git a/tests/test_modeling_syntax.py b/tests/test_modeling_syntax.py
new file mode 100644
index 0000000..e9dd34f
--- /dev/null
+++ b/tests/test_modeling_syntax.py
@@ -0,0 +1,350 @@
+"""Tests for modeling syntax conveniences (Issue #97).
+
+Tests cover:
+1. Expression.between(lb, ub) and VectorVariable.between()
+2. subject_to() accepting generators and iterables
+3. Problem context manager (with Problem() as p:)
+4. Variable(obj=) shorthand for linear objective coefficients
+"""
+
+import numpy as np
+import pytest
+
+from optyx import Constant, Problem, Variable, VectorVariable
+from optyx.constraints import Constraint
+
+
+# ============================================================
+# 1. Expression.between(lb, ub) — Range Constraints
+# ============================================================
+
+
+class TestExpressionBetween:
+    """Tests for Expression.between() and VectorVariable.between()."""
+
+    def test_variable_between_returns_two_constraints(self):
+        """between() returns [self >= lb, self <= ub]."""
+        x = Variable("x")
+        constraints = x.between(0, 10)
+        assert len(constraints) == 2
+        assert all(isinstance(c, Constraint) for c in constraints)
+
+    def test_variable_between_senses(self):
+        """between() creates >= and <= constraints."""
+        x = Variable("x")
+        constraints = x.between(0, 10)
+        senses = {c.sense for c in constraints}
+        assert senses == {">=", "<="}
+
+    def test_variable_between_satisfied(self):
+        """between() constraints are satisfied for interior points."""
+        x = Variable("x")
+        constraints = x.between(2.0, 8.0)
+        point = {"x": 5.0}
+        assert all(c.is_satisfied(point) for c in constraints)
+
+    def test_variable_between_violated_below(self):
+        """between() detects violations below lower bound."""
+        x = Variable("x")
+        constraints = x.between(2.0, 8.0)
+        point = {"x": 1.0}
+        assert not all(c.is_satisfied(point) for c in constraints)
+
+    def test_variable_between_violated_above(self):
+        """between() detects violations above upper bound."""
+        x = Variable("x")
+        constraints = x.between(2.0, 8.0)
+        point = {"x": 9.0}
+        assert not all(c.is_satisfied(point) for c in constraints)
+
+    def test_expression_between(self):
+        """between() works on compound expressions."""
+        x = Variable("x")
+        y = Variable("y")
+        constraints = (x + y).between(-1, 1)
+        assert len(constraints) == 2
+        assert all(c.is_satisfied({"x": 0.3, "y": 0.2}) for c in constraints)
+        assert not all(c.is_satisfied({"x": 1.0, "y": 1.0}) for c in constraints)
+
+    def test_between_in_problem(self):
+        """between() constraints work in a solve."""
+        x = Variable("x", lb=-10, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x.between(3.0, 7.0))
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol[x] - 3.0) < 1e-6
+
+    def test_vector_between_scalar_bounds(self):
+        """VectorVariable.between() with scalar bounds."""
+        x = VectorVariable("x", 3)
+        constraints = x.between(0, 10)
+        assert len(constraints) == 6  # 3 >= + 3 <=
+
+    def test_vector_between_array_bounds(self):
+        """VectorVariable.between() with array bounds."""
+        x = VectorVariable("x", 3)
+        lb = np.array([0.0, 1.0, 2.0])
+        ub = np.array([10.0, 11.0, 12.0])
+        constraints = x.between(lb, ub)
+        assert len(constraints) == 6
+
+    def test_vector_between_in_problem(self):
+        """VectorVariable.between() works in a solve."""
+        x = VectorVariable("x", 3, lb=-10, ub=10)
+        c = np.array([1.0, 1.0, 1.0])
+        prob = Problem()
+        prob.minimize(c @ x)
+        prob.subject_to(x.between(2.0, 5.0))
+        sol = prob.solve()
+        assert sol.is_optimal
+        vals = sol[x]
+        assert np.allclose(vals, 2.0, atol=1e-6)
+
+
+# ============================================================
+# 2. subject_to() Accepts Generators and Iterables
+# ============================================================
+
+
+class TestSubjectToGenerators:
+    """Tests for subject_to() accepting generators and iterables."""
+
+    def test_subject_to_generator(self):
+        """subject_to() accepts a generator expression."""
+        x = VectorVariable("x", 5)
+        prob = Problem()
+        prob.minimize(x[0])
+        prob.subject_to(x[i] >= 0 for i in range(5))
+        assert prob.n_constraints == 5
+
+    def test_subject_to_list(self):
+        """subject_to() accepts a list of constraints."""
+        x = Variable("x")
+        y = Variable("y")
+        prob = Problem()
+        prob.minimize(x + y)
+        prob.subject_to([x >= 0, y >= 0, x + y <= 10])
+        assert prob.n_constraints == 3
+
+    def test_subject_to_tuple(self):
+        """subject_to() accepts a tuple of constraints."""
+        x = Variable("x")
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to((x >= 1, x <= 5))
+        assert prob.n_constraints == 2
+
+    def test_subject_to_single_constraint(self):
+        """subject_to() still accepts a single constraint."""
+        x = Variable("x")
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 0)
+        assert prob.n_constraints == 1
+
+    def test_subject_to_generator_solve(self):
+        """subject_to() with generator produces correct solution."""
+        x = VectorVariable("x", 3, lb=-10, ub=10)
+        c = np.array([1.0, 1.0, 1.0])
+        prob = Problem()
+        prob.minimize(c @ x)
+        prob.subject_to(x[i] >= float(i) for i in range(3))
+        sol = prob.solve()
+        assert sol.is_optimal
+        vals = sol[x]
+        assert np.allclose(vals, [0.0, 1.0, 2.0], atol=1e-6)
+
+    def test_subject_to_between_iterable(self):
+        """subject_to() accepts list from between() directly."""
+        x = Variable("x", lb=-10, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x.between(3.0, 7.0))
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol[x] - 3.0) < 1e-6
+
+    def test_subject_to_chaining(self):
+        """subject_to() returns self for method chaining."""
+        x = Variable("x")
+        prob = Problem()
+        result = prob.minimize(x).subject_to(x >= 0).subject_to(x <= 10)
+        assert result is prob
+        assert prob.n_constraints == 2
+
+    def test_subject_to_invalid_type_error(self):
+        """subject_to() raises ConstraintError for invalid types."""
+        from optyx.core.errors import ConstraintError
+
+        prob = Problem()
+        with pytest.raises(ConstraintError):
+            prob.subject_to(42)  # type: ignore[arg-type]
+
+
+# ============================================================
+# 3. Problem Context Manager
+# ============================================================
+
+
+class TestProblemContextManager:
+    """Tests for Problem context manager support."""
+
+    def test_context_manager_returns_self(self):
+        """__enter__ returns the Problem instance."""
+        prob = Problem()
+        with prob as p:
+            assert p is prob
+
+    def test_context_manager_basic_solve(self):
+        """Problem works correctly inside a with block."""
+        x = Variable("x", lb=0)
+        y = Variable("y", lb=0)
+
+        with Problem() as prob:
+            prob.minimize(x + y)
+            prob.subject_to(x + y >= 1)
+            sol = prob.solve()
+
+        assert sol.is_optimal
+        assert abs(sol.objective_value - 1.0) < 1e-6
+
+    def test_context_manager_with_name(self):
+        """Named Problem works in context manager."""
+        with Problem(name="test") as prob:
+            assert prob.name == "test"
+
+    def test_context_manager_no_exception_on_exit(self):
+        """__exit__ doesn't raise when no exception occurs."""
+        with Problem() as _prob:
+            pass  # No operations
+
+    def test_context_manager_propagates_exception(self):
+        """Context manager doesn't suppress exceptions."""
+        with pytest.raises(ValueError):
+            with Problem() as _prob:
+                raise ValueError("test error")
+
+    def test_context_manager_lp(self):
+        """Context manager works with LP problems."""
+        x = VectorVariable("x", 3, lb=0)
+        c = np.array([1.0, 2.0, 3.0])
+
+        with Problem() as prob:
+            prob.minimize(c @ x)
+            prob.subject_to(x[0] + x[1] + x[2] >= 1)
+            sol = prob.solve()
+
+        assert sol.is_optimal
+        assert abs(sol[x[0]] - 1.0) < 1e-6
+
+
+# ============================================================
+# 4. Variable(obj=) Shorthand
+# ============================================================
+
+
+class TestVariableObjShorthand:
+    """Tests for Variable(obj=) linear objective coefficient."""
+
+    def test_obj_default_zero(self):
+        """Variable obj defaults to 0.0."""
+        x = Variable("x")
+        assert x.obj == 0.0
+
+    def test_obj_stored(self):
+        """Variable stores obj coefficient."""
+        x = Variable("x", obj=5.0)
+        assert x.obj == 5.0
+
+    def test_obj_int_converted_to_float(self):
+        """Integer obj is converted to float."""
+        x = Variable("x", obj=3)
+        assert x.obj == 3.0
+        assert isinstance(x.obj, float)
+
+    def test_obj_negative(self):
+        """Negative obj coefficient works."""
+        x = Variable("x", obj=-2.5)
+        assert x.obj == -2.5
+
+    def test_obj_lp_minimize(self):
+        """Variable.obj contributes to LP objective in minimize."""
+        x = Variable("x", lb=0, ub=10, obj=1.0)
+        y = Variable("y", lb=0, ub=10, obj=2.0)
+
+        prob = Problem()
+        prob.minimize(Constant(0))  # Zero explicit objective
+        prob.subject_to(x + y >= 5)
+        sol = prob.solve()
+
+        # Effective objective: 1*x + 2*y, minimized
+        # Optimal: x=5, y=0 → obj=5
+        assert sol.is_optimal
+        assert abs(sol[x] - 5.0) < 1e-4
+        assert abs(sol[y] - 0.0) < 1e-4
+
+    def test_obj_lp_additive(self):
+        """Variable.obj adds to explicit objective coefficients."""
+        x = Variable("x", lb=0, ub=10, obj=1.0)
+        y = Variable("y", lb=0, ub=10, obj=0.0)
+
+        prob = Problem()
+        prob.minimize(x + 3 * y)  # Explicit: 1*x + 3*y
+        prob.subject_to(x + y >= 5)
+        sol = prob.solve()
+
+        # Effective objective: (1+1)*x + (3+0)*y = 2*x + 3*y
+        # Optimal: x=5, y=0 → obj=10
+        assert sol.is_optimal
+        assert abs(sol[x] - 5.0) < 1e-4
+        assert abs(sol[y] - 0.0) < 1e-4
+
+    def test_obj_lp_maximize(self):
+        """Variable.obj works with maximize."""
+        x = Variable("x", lb=0, ub=10, obj=1.0)
+        y = Variable("y", lb=0, ub=10, obj=2.0)
+
+        prob = Problem()
+        prob.maximize(Constant(0))
+        prob.subject_to(x + y <= 8)
+        sol = prob.solve()
+
+        # Effective objective: maximize 1*x + 2*y
+        # Optimal: x=0, y=8 → obj=16
+        assert sol.is_optimal
+        assert abs(sol[x] - 0.0) < 1e-4
+        assert abs(sol[y] - 8.0) < 1e-4
+
+    def test_obj_nlp(self):
+        """Variable.obj works with NLP solver."""
+        x = Variable("x", lb=0, ub=10, obj=2.0)
+
+        prob = Problem()
+        prob.minimize(x**2)  # Explicit: x², with obj: +2x
+        prob.subject_to(x >= 0)
+        sol = prob.solve()
+
+        # Effective: x² + 2x, minimum at x = -1 but lb=0 → x=0
+        assert sol.is_optimal
+        assert abs(sol[x] - 0.0) < 1e-4
+
+    def test_obj_zero_no_effect(self):
+        """Variable with obj=0 doesn't change the objective."""
+        x = Variable("x", lb=0, ub=10, obj=0.0)
+
+        prob = Problem()
+        prob.minimize(2 * x)
+        prob.subject_to(x >= 3)
+        sol = prob.solve()
+
+        assert sol.is_optimal
+        assert abs(sol[x] - 3.0) < 1e-6
+
+    def test_obj_with_bounds(self):
+        """Variable.obj works alongside lb/ub."""
+        x = Variable("x", lb=1, ub=5, obj=1.0)
+        assert x.lb == 1
+        assert x.ub == 5
+        assert x.obj == 1.0
diff --git a/tests/test_nary_expressions.py b/tests/test_nary_expressions.py
new file mode 100644
index 0000000..c28f3e8
--- /dev/null
+++ b/tests/test_nary_expressions.py
@@ -0,0 +1,323 @@
+"""Tests for NarySum, NaryProduct and flatten_expression."""
+
+from optyx.core.expressions import Variable, BinaryOp, NarySum, NaryProduct
+from optyx.core.optimizer import flatten_expression, optimize_expression
+
+
+def test_nary_sum_evaluation():
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+
+    expr = NarySum((x, y, z))
+    # 1 + 2 + 3 = 6
+    assert expr.evaluate({"x": 1, "y": 2, "z": 3}) == 6
+
+
+def test_nary_product_evaluation():
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+
+    expr = NaryProduct((x, y, z))
+    # 2 * 3 * 4 = 24
+    assert expr.evaluate({"x": 2, "y": 3, "z": 4}) == 24
+
+
+def test_flatten_binary_op_simple():
+    # a + b -> a + b (BinaryOp)
+    x = Variable("x")
+    y = Variable("y")
+
+    expr = x + y
+    flat = flatten_expression(expr)
+
+    assert isinstance(flat, BinaryOp)
+    assert flat.left is x
+    assert flat.right is y
+    assert flat.op == "+"
+
+
+def test_flatten_binary_op_nested_sum():
+    # (x + y) + z -> NarySum(x, y, z)
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+
+    expr = (x + y) + z
+    flat = flatten_expression(expr)
+
+    assert isinstance(flat, NarySum)
+    assert len(flat.terms) == 3
+    assert flat.terms[0] is x
+    assert flat.terms[1] is y
+    assert flat.terms[2] is z
+
+
+def test_flatten_binary_op_nested_product():
+    # (x * y) * z -> NaryProduct(x, y, z)
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+
+    expr = (x * y) * z
+    flat = flatten_expression(expr)
+
+    assert isinstance(flat, NaryProduct)
+    assert len(flat.factors) == 3
+    assert flat.factors[0] is x
+    assert flat.factors[1] is y
+    assert flat.factors[2] is z
+
+
+def test_flatten_deep_sum():
+    # x0 + x1 + ... + x99 using standard loop
+    vars = [Variable(f"x{i}") for i in range(100)]
+
+    # Simulate sum() behavior: ((var0 + var1) + var2) ...
+    expr = vars[0]
+    for i in range(1, 100):
+        expr = expr + vars[i]
+
+    flat = flatten_expression(expr)
+
+    assert isinstance(flat, NarySum)
+    assert len(flat.terms) == 100
+    for i in range(100):
+        assert flat.terms[i] is vars[i]
+
+
+def test_flatten_mixed_associativity():
+    # (a + b) + (c + d) -> NarySum(a, b, c, d)
+    a = Variable("a")
+    b = Variable("b")
+    c = Variable("c")
+    d = Variable("d")
+
+    expr = (a + b) + (c + d)
+    flat = flatten_expression(expr)
+
+    assert isinstance(flat, NarySum)
+    assert len(flat.terms) == 4
+    assert flat.terms == (a, b, c, d)
+
+
+def test_flatten_preserves_evaluation():
+    # ((x * 2) + y) * 3 + z
+    # Should optimize outer sums/products but keep structure
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+
+    # 3 * ((2*x) + y) + z
+    # This has structure:
+    #       +
+    #      / \
+    #     *   z
+    #    / \
+    #   3   +
+    #      / \
+    #     *   y
+    #    / \
+    #   2   x
+
+    # Top level + has 2 children: (*...) and z. So likely stays BinaryOp or NarySum(2).
+    # Since our logic says len==2 -> BinaryOp, it stays BinaryOp.
+
+    term1 = 3 * ((2 * x) + y)
+    expr = term1 + z
+
+    flat = flatten_expression(expr)
+
+    # Evaluate check
+    values = {"x": 2, "y": 5, "z": 10}
+    # (2*2 + 5) * 3 + 10 = 9 * 3 + 10 = 37
+
+    assert flat.evaluate(values) == 37.0
+
+
+def test_flatten_nary_sum_input():
+    # If input is already NarySum, flatten into it
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+
+    nary = NarySum((x, y))
+    expr = nary + z
+
+    flat = flatten_expression(expr)
+
+    assert isinstance(flat, NarySum)
+    assert len(flat.terms) == 3
+    assert flat.terms == (x, y, z)
+
+
+def test_optimize_expression_delegates_to_flatten_expression():
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+
+    expr = (x + y) + z
+    optimized = optimize_expression(expr)
+
+    assert isinstance(optimized, NarySum)
+    assert optimized.terms == (x, y, z)
+
+
+# ---- Gradient tests ----
+
+
+def test_nary_sum_gradient():
+    """d/dx(x + y + z) = 1 for any term, 0 for others."""
+    from optyx.core.autodiff import gradient
+
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+
+    expr = NarySum((x, y, z))
+    grad_x = gradient(expr, x)
+    grad_y = gradient(expr, y)
+
+    assert grad_x.evaluate({}) == 1.0
+    assert grad_y.evaluate({}) == 1.0
+
+
+def test_nary_product_gradient():
+    """d/dx(x * y * z) = y * z."""
+    from optyx.core.autodiff import gradient
+
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+
+    expr = NaryProduct((x, y, z))
+    grad_x = gradient(expr, x)
+
+    # d/dx(x * y * z) = y * z
+    assert grad_x.evaluate({"x": 2, "y": 3, "z": 5}) == 15.0
+
+
+def test_nary_sum_gradient_with_constants():
+    """d/dx(2 + x + 3) = 1."""
+    from optyx.core.autodiff import gradient
+    from optyx.core.expressions import Constant
+
+    x = Variable("x")
+    expr = NarySum((Constant(2.0), x, Constant(3.0)))
+    grad = gradient(expr, x)
+
+    assert grad.evaluate({"x": 99}) == 1.0
+
+
+def test_nary_get_variables():
+    """NarySum and NaryProduct report all contained variables."""
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+
+    s = NarySum((x, y, z))
+    p = NaryProduct((x, z))
+
+    assert s.get_variables() == {x, y, z}
+    assert p.get_variables() == {x, z}
+
+
+def test_flatten_deep_product():
+    """x0 * x1 * ... * x9 flattens to NaryProduct."""
+    vars = [Variable(f"x{i}") for i in range(10)]
+
+    expr = vars[0]
+    for i in range(1, 10):
+        expr = expr * vars[i]
+
+    flat = flatten_expression(expr)
+
+    assert isinstance(flat, NaryProduct)
+    assert len(flat.factors) == 10
+
+
+def test_flatten_does_not_mix_ops():
+    """(a + b) * (c + d) should NOT flatten across different operators."""
+    a = Variable("a")
+    b = Variable("b")
+    c = Variable("c")
+    d = Variable("d")
+
+    expr = (a + b) * (c + d)
+    flat = flatten_expression(expr)
+
+    # Top-level is *, children are sums — should not merge + and *
+    assert isinstance(flat, BinaryOp)
+    assert flat.op == "*"
+
+
+# ===================================================================
+# NarySum gradient flatness tests
+# ===================================================================
+
+
+def test_nary_sum_gradient_produces_flat_output():
+    """Gradient of NarySum with 4+ terms should produce NarySum, not nested BinaryOp."""
+    from optyx.core.autodiff import gradient
+
+    vars = [Variable(f"x{i}") for i in range(5)]
+    expr = NarySum(tuple(v * v for v in vars))  # sum(x_i^2)
+
+    g = gradient(expr, vars[0])
+
+    # ∂(sum(x_i^2))/∂x_0 = 2*x_0 — only one Non-zero term
+    # so it should just be a single expression, not NarySum
+    assert not isinstance(g, NarySum)
+    vals = {"x0": 3.0}
+    assert g.evaluate(vals) == 6.0
+
+
+def test_nary_sum_gradient_multiple_nonzero_terms():
+    """Gradient of NarySum where multiple terms contribute should produce NarySum."""
+    from optyx.core.autodiff import gradient
+
+    x = Variable("x")
+    # sum(x, 2*x, 3*x, 4*x, 5*x)
+    expr = NarySum((x, x * 2, x * 3, x * 4, x * 5))
+
+    g = gradient(expr, x)
+    # ∂/∂x = 1 + 2 + 3 + 4 + 5 = 15
+    assert g.evaluate({}) == 15.0
+    # Should be flat — either NarySum or simplified
+    if isinstance(g, NarySum):
+        # Flat NarySum with 5 terms (not nested BinaryOp chain)
+        assert len(g.terms) == 5
+    # Regardless of structure, must not be a deep chain
+    from optyx.core.expressions import _estimate_tree_depth
+
+    assert _estimate_tree_depth(g) < 5
+
+
+def test_nary_sum_gradient_all_zero_terms():
+    """Gradient of NarySum where wrt is not present returns Constant(0)."""
+    from optyx.core.autodiff import gradient
+    from optyx.core.expressions import Constant
+
+    x = Variable("x")
+    y = Variable("y")
+    expr = NarySum((y, y * 2, y * 3))
+
+    g = gradient(expr, x)
+    assert isinstance(g, Constant)
+    assert g.evaluate({}) == 0.0
+
+
+def test_nary_sum_gradient_single_nonzero_term():
+    """If only one term has nonzero gradient, no wrapping in NarySum."""
+    from optyx.core.autodiff import gradient
+
+    x = Variable("x")
+    y = Variable("y")
+    z = Variable("z")
+    expr = NarySum((x * 2, y, z))
+
+    g = gradient(expr, x)
+    # Only x*2 contributes: ∂(2*x)/∂x = 2
+    assert not isinstance(g, NarySum)
+    assert g.evaluate({}) == 2.0
diff --git a/tests/test_pattern_matching.py b/tests/test_pattern_matching.py
new file mode 100644
index 0000000..901d535
--- /dev/null
+++ b/tests/test_pattern_matching.py
@@ -0,0 +1,64 @@
+import numpy as np
+from optyx.core.expressions import Variable, Constant
+from optyx.core.vectors import (
+    VectorVariable,
+    VectorSum,
+    DotProduct,
+    L1Norm,
+    L2Norm,
+    LinearCombination,
+)
+from optyx.core.matrices import QuadraticForm
+from optyx.core.autodiff import (
+    detect_vector_gradient_pattern,
+    VectorExpressionPattern,
+)
+
+
+def test_detect_patterns():
+    x = Variable("x")
+    c = Constant(2.0)
+
+    # Base cases
+    assert detect_vector_gradient_pattern(x) == VectorExpressionPattern.COMPONENT
+    assert detect_vector_gradient_pattern(c) == VectorExpressionPattern.CONSTANT
+
+    # Scaled component
+    scaled = c * x
+    assert (
+        detect_vector_gradient_pattern(scaled)
+        == VectorExpressionPattern.SCALED_COMPONENT
+    )
+
+    # Vector expressions
+    n = 10
+    v = VectorVariable("v", n)
+    coeffs = np.ones(n)
+
+    # Sum
+    s = VectorSum(v)
+    assert detect_vector_gradient_pattern(s) == VectorExpressionPattern.SUM
+
+    # Scaled Sum
+    ss = c * s
+    assert detect_vector_gradient_pattern(ss) == VectorExpressionPattern.SCALED_SUM
+
+    # Linear Combination (c @ v)
+    lc = LinearCombination(coeffs, v)
+    assert detect_vector_gradient_pattern(lc) == VectorExpressionPattern.DOT_PRODUCT
+
+    # Dot Product
+    dp = DotProduct(v, v)  # Should be DOT_PRODUCT for now
+    assert detect_vector_gradient_pattern(dp) == VectorExpressionPattern.DOT_PRODUCT
+
+    # Norms
+    l1 = L1Norm(v)
+    assert detect_vector_gradient_pattern(l1) == VectorExpressionPattern.L1_NORM
+
+    l2 = L2Norm(v)
+    assert detect_vector_gradient_pattern(l2) == VectorExpressionPattern.L2_NORM
+
+    # Quadratic Form
+    Q = np.eye(n)
+    qf = QuadraticForm(v, Q)
+    assert detect_vector_gradient_pattern(qf) == VectorExpressionPattern.QUADRATIC_FORM
diff --git a/tests/test_solution_enhancements.py b/tests/test_solution_enhancements.py
new file mode 100644
index 0000000..719b5a1
--- /dev/null
+++ b/tests/test_solution_enhancements.py
@@ -0,0 +1,408 @@
+"""Tests for Solution/Problem enhancements (Issue #98).
+
+Tests cover:
+1. Solution.to_dict(), to_json(), from_json()
+2. Problem.reset()
+3. SolverStatus.TERMINATED
+Also covers print_vars() (roadmap 3.7).
+"""
+
+import json
+import os
+import tempfile
+
+
+from optyx import Problem, Variable
+from optyx.solution import Solution, SolverStatus
+
+
+# ============================================================
+# 1. Solution Serialization
+# ============================================================
+
+
+class TestSolutionToDict:
+    """Tests for Solution.to_dict()."""
+
+    def test_to_dict_basic(self):
+        """to_dict returns all fields."""
+        sol = Solution(
+            status=SolverStatus.OPTIMAL,
+            objective_value=42.0,
+            values={"x": 1.0, "y": 2.0},
+            iterations=10,
+            message="Optimal",
+            solve_time=0.5,
+        )
+        d = sol.to_dict()
+        assert d["status"] == "optimal"
+        assert d["objective_value"] == 42.0
+        assert d["values"] == {"x": 1.0, "y": 2.0}
+        assert d["iterations"] == 10
+        assert d["message"] == "Optimal"
+        assert d["solve_time"] == 0.5
+
+    def test_to_dict_none_fields(self):
+        """to_dict handles None fields."""
+        sol = Solution(status=SolverStatus.FAILED)
+        d = sol.to_dict()
+        assert d["status"] == "failed"
+        assert d["objective_value"] is None
+        assert d["values"] == {}
+        assert d["multipliers"] is None
+
+    def test_to_dict_with_multipliers(self):
+        """to_dict includes multipliers."""
+        sol = Solution(
+            status=SolverStatus.OPTIMAL,
+            values={"x": 1.0},
+            multipliers={"c1": 0.5},
+        )
+        d = sol.to_dict()
+        assert d["multipliers"] == {"c1": 0.5}
+
+    def test_to_dict_all_statuses(self):
+        """to_dict works with all SolverStatus values."""
+        for status in SolverStatus:
+            sol = Solution(status=status)
+            d = sol.to_dict()
+            assert d["status"] == status.value
+
+
+class TestSolutionToJson:
+    """Tests for Solution.to_json()."""
+
+    def test_to_json_string(self):
+        """to_json returns valid JSON string."""
+        sol = Solution(
+            status=SolverStatus.OPTIMAL,
+            objective_value=3.14,
+            values={"x": 1.0},
+        )
+        json_str = sol.to_json()
+        data = json.loads(json_str)
+        assert data["status"] == "optimal"
+        assert data["objective_value"] == 3.14
+        assert data["values"]["x"] == 1.0
+
+    def test_to_json_file(self):
+        """to_json saves to file when path is given."""
+        sol = Solution(
+            status=SolverStatus.OPTIMAL,
+            objective_value=99.0,
+            values={"a": 1.0, "b": 2.0},
+        )
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            path = f.name
+
+        try:
+            sol.to_json(path=path)
+            with open(path) as f:
+                data = json.load(f)
+            assert data["status"] == "optimal"
+            assert data["objective_value"] == 99.0
+            assert data["values"] == {"a": 1.0, "b": 2.0}
+        finally:
+            os.unlink(path)
+
+    def test_to_json_roundtrip(self):
+        """to_json -> from_json roundtrip preserves data."""
+        sol = Solution(
+            status=SolverStatus.OPTIMAL,
+            objective_value=42.0,
+            values={"x": 1.5, "y": -3.7},
+            iterations=25,
+            message="converged",
+            solve_time=1.23,
+        )
+        json_str = sol.to_json()
+        restored = Solution.from_json(json_str)
+        assert restored.status == sol.status
+        assert restored.objective_value == sol.objective_value
+        assert restored.values == sol.values
+        assert restored.iterations == sol.iterations
+        assert restored.message == sol.message
+        assert restored.solve_time == sol.solve_time
+
+
+class TestSolutionFromJson:
+    """Tests for Solution.from_json()."""
+
+    def test_from_json_string(self):
+        """from_json parses JSON string."""
+        json_str = '{"status": "optimal", "objective_value": 5.0, "values": {"x": 2.0}}'
+        sol = Solution.from_json(json_str)
+        assert sol.status == SolverStatus.OPTIMAL
+        assert sol.objective_value == 5.0
+        assert sol.values == {"x": 2.0}
+
+    def test_from_json_file(self):
+        """from_json reads from file path."""
+        data = {
+            "status": "infeasible",
+            "objective_value": None,
+            "values": {},
+            "message": "no feasible solution",
+        }
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump(data, f)
+            path = f.name
+
+        try:
+            sol = Solution.from_json(path)
+            assert sol.status == SolverStatus.INFEASIBLE
+            assert sol.objective_value is None
+            assert sol.message == "no feasible solution"
+        finally:
+            os.unlink(path)
+
+    def test_from_json_missing_optional_fields(self):
+        """from_json handles missing optional fields with defaults."""
+        json_str = '{"status": "failed"}'
+        sol = Solution.from_json(json_str)
+        assert sol.status == SolverStatus.FAILED
+        assert sol.objective_value is None
+        assert sol.values == {}
+        assert sol.multipliers is None
+        assert sol.iterations is None
+        assert sol.message == ""
+        assert sol.solve_time is None
+
+    def test_from_json_all_statuses(self):
+        """from_json handles all SolverStatus values."""
+        for status in SolverStatus:
+            json_str = json.dumps({"status": status.value})
+            sol = Solution.from_json(json_str)
+            assert sol.status == status
+
+    def test_from_json_file_roundtrip(self):
+        """to_json(path) -> from_json(path) roundtrip via file."""
+        sol = Solution(
+            status=SolverStatus.OPTIMAL,
+            objective_value=100.0,
+            values={"x": 10.0},
+            multipliers={"c0": 1.5},
+        )
+        with tempfile.NamedTemporaryFile(suffix=".json", delete=False) as f:
+            path = f.name
+
+        try:
+            sol.to_json(path=path)
+            restored = Solution.from_json(path)
+            assert restored.status == sol.status
+            assert restored.objective_value == sol.objective_value
+            assert restored.values == sol.values
+            assert restored.multipliers == sol.multipliers
+        finally:
+            os.unlink(path)
+
+    def test_from_json_with_solve(self):
+        """Roundtrip from actual solve result."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 3)
+        sol = prob.solve()
+
+        json_str = sol.to_json()
+        restored = Solution.from_json(json_str)
+        assert restored.status == SolverStatus.OPTIMAL
+        assert abs(restored.objective_value - 3.0) < 1e-6
+        assert abs(restored.values["x"] - 3.0) < 1e-6
+
+
+# ============================================================
+# 2. Problem.reset()
+# ============================================================
+
+
+class TestProblemReset:
+    """Tests for Problem.reset()."""
+
+    def test_reset_clears_solver_cache(self):
+        """reset() clears the solver cache."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x**2)
+        prob.subject_to(x >= 1)
+
+        # Solve to populate cache
+        prob.solve()
+        assert prob._solver_cache is not None
+
+        # Reset clears it
+        prob.reset()
+        assert prob._solver_cache is None
+
+    def test_reset_clears_lp_cache(self):
+        """reset() clears the LP cache."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 1)
+
+        prob.solve()
+        assert prob._lp_cache is not None
+
+        prob.reset()
+        assert prob._lp_cache is None
+
+    def test_reset_clears_linearity_cache(self):
+        """reset() clears the linearity check cache."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 1)
+
+        prob.solve()
+        # Linearity cache should be set after solve
+        assert prob._is_linear_cache is not None
+
+        prob.reset()
+        assert prob._is_linear_cache is None
+
+    def test_reset_preserves_problem_definition(self):
+        """reset() doesn't clear objective or constraints."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem(name="test")
+        prob.minimize(x)
+        prob.subject_to(x >= 3)
+
+        prob.solve()
+        prob.reset()
+
+        # Problem definition is preserved
+        assert prob.name == "test"
+        assert prob.objective is not None
+        assert prob.n_constraints == 1
+
+        # Can solve again after reset
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol[x] - 3.0) < 1e-6
+
+    def test_reset_forces_cold_solve(self):
+        """reset() forces recompilation on next solve."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x)
+        prob.subject_to(x >= 5)
+
+        sol1 = prob.solve()
+        prob.reset()
+        sol2 = prob.solve()
+
+        # Same result
+        assert abs(sol1[x] - sol2[x]) < 1e-8
+
+    def test_reset_nlp(self):
+        """reset() works for NLP problems."""
+        x = Variable("x", lb=-5, ub=5)
+        prob = Problem()
+        prob.minimize(x**2)
+
+        sol1 = prob.solve()
+        prob.reset()
+        assert prob._solver_cache is None
+
+        sol2 = prob.solve()
+        assert abs(sol1[x] - sol2[x]) < 1e-6
+
+
+# ============================================================
+# 3. SolverStatus.TERMINATED
+# ============================================================
+
+
+class TestSolverStatusTerminated:
+    """Tests for SolverStatus.TERMINATED."""
+
+    def test_terminated_exists(self):
+        """TERMINATED is a valid SolverStatus member."""
+        assert hasattr(SolverStatus, "TERMINATED")
+        assert SolverStatus.TERMINATED.value == "terminated"
+
+    def test_terminated_is_feasible(self):
+        """TERMINATED counts as feasible in is_feasible."""
+        sol = Solution(
+            status=SolverStatus.TERMINATED,
+            objective_value=10.0,
+            values={"x": 5.0},
+        )
+        assert sol.is_feasible
+        assert not sol.is_optimal
+
+    def test_terminated_serialization(self):
+        """TERMINATED roundtrips through JSON."""
+        sol = Solution(
+            status=SolverStatus.TERMINATED,
+            objective_value=10.0,
+            message="stopped by callback",
+        )
+        json_str = sol.to_json()
+        restored = Solution.from_json(json_str)
+        assert restored.status == SolverStatus.TERMINATED
+        assert restored.message == "stopped by callback"
+
+    def test_all_statuses_in_enum(self):
+        """All expected statuses exist in SolverStatus."""
+        expected = {
+            "OPTIMAL",
+            "INFEASIBLE",
+            "UNBOUNDED",
+            "MAX_ITERATIONS",
+            "TERMINATED",
+            "FAILED",
+            "NOT_SOLVED",
+        }
+        actual = {s.name for s in SolverStatus}
+        assert expected == actual
+
+
+# ============================================================
+# 4. print_vars() (Roadmap 3.7 bonus)
+# ============================================================
+
+
+class TestPrintVars:
+    """Tests for Solution.print_vars()."""
+
+    def test_print_vars_output(self, capsys):
+        """print_vars outputs variable values."""
+        sol = Solution(
+            status=SolverStatus.OPTIMAL,
+            objective_value=42.0,
+            values={"x": 1.0, "y": 2.5},
+        )
+        sol.print_vars()
+        captured = capsys.readouterr()
+        assert "Status: optimal" in captured.out
+        assert "Objective: 42" in captured.out
+        assert "x: 1" in captured.out
+        assert "y: 2.5" in captured.out
+
+    def test_print_vars_no_objective(self, capsys):
+        """print_vars handles None objective."""
+        sol = Solution(
+            status=SolverStatus.FAILED,
+            values={},
+        )
+        sol.print_vars()
+        captured = capsys.readouterr()
+        assert "Status: failed" in captured.out
+        assert "Objective" not in captured.out
+
+    def test_print_vars_sorted(self, capsys):
+        """print_vars outputs variables in sorted order."""
+        sol = Solution(
+            status=SolverStatus.OPTIMAL,
+            objective_value=0.0,
+            values={"z": 3.0, "a": 1.0, "m": 2.0},
+        )
+        sol.print_vars()
+        captured = capsys.readouterr()
+        lines = captured.out.strip().split("\n")
+        # Find variable lines (indented with "  ")
+        var_lines = [ln.strip() for ln in lines if ln.startswith("  ")]
+        names = [ln.split(":")[0] for ln in var_lines]
+        assert names == ["a", "m", "z"]
diff --git a/tests/test_solver_callbacks.py b/tests/test_solver_callbacks.py
new file mode 100644
index 0000000..c4d88c4
--- /dev/null
+++ b/tests/test_solver_callbacks.py
@@ -0,0 +1,373 @@
+"""Tests for solver progress callbacks and time limits (Issue #105)."""
+
+from __future__ import annotations
+
+
+import numpy as np
+import pytest
+
+from optyx import (
+    Variable,
+    VectorVariable,
+    Problem,
+    SolverProgress,
+    SolverStatus,
+)
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def simple_nlp():
+    """A simple NLP: minimize x^2 + y^2 subject to x + y >= 1."""
+    x = Variable("x", lb=-10, ub=10)
+    y = Variable("y", lb=-10, ub=10)
+    prob = Problem("callback_test")
+    prob.minimize(x**2 + y**2)
+    prob.subject_to(x + y >= 1)
+    return prob
+
+
+@pytest.fixture
+def unconstrained_nlp():
+    """An unconstrained NLP: minimize x^2 + y^2."""
+    x = Variable("x", lb=-10, ub=10)
+    y = Variable("y", lb=-10, ub=10)
+    prob = Problem("unconstrained")
+    prob.minimize(x**2 + y**2)
+    return prob
+
+
+@pytest.fixture
+def slow_nlp():
+    """An NLP that takes many iterations (Rosenbrock-like)."""
+    n = 20
+    v = VectorVariable("v", n, lb=-5, ub=5)
+    prob = Problem("slow_nlp")
+    obj = sum((1 - v[i]) ** 2 + 100 * (v[i + 1] - v[i] ** 2) ** 2 for i in range(n - 1))
+    prob.minimize(obj)
+    return prob
+
+
+# ---------------------------------------------------------------------------
+# SolverProgress dataclass tests
+# ---------------------------------------------------------------------------
+
+
+class TestSolverProgress:
+    def test_fields(self):
+        p = SolverProgress(
+            iteration=5,
+            objective_value=1.23,
+            constraint_violation=0.0,
+            elapsed_time=0.1,
+            x=np.array([1.0, 2.0]),
+        )
+        assert p.iteration == 5
+        assert p.objective_value == 1.23
+        assert p.constraint_violation == 0.0
+        assert p.elapsed_time == 0.1
+        np.testing.assert_array_equal(p.x, [1.0, 2.0])
+
+
+# ---------------------------------------------------------------------------
+# Callback tests
+# ---------------------------------------------------------------------------
+
+
+class TestCallback:
+    def test_callback_receives_progress(self, simple_nlp):
+        """Callback should be called with SolverProgress objects."""
+        progress_log: list[SolverProgress] = []
+
+        def on_progress(p: SolverProgress) -> None:
+            progress_log.append(p)
+
+        sol = simple_nlp.solve(method="SLSQP", callback=on_progress)
+        assert sol.status == SolverStatus.OPTIMAL
+        assert len(progress_log) > 0
+
+        # Check that each progress has valid fields
+        for p in progress_log:
+            assert isinstance(p, SolverProgress)
+            assert p.iteration >= 1
+            assert isinstance(p.objective_value, float)
+            assert p.constraint_violation >= 0.0
+            assert p.elapsed_time >= 0.0
+            assert isinstance(p.x, np.ndarray)
+
+    def test_callback_iterations_increase(self, simple_nlp):
+        """Iteration numbers should be monotonically increasing."""
+        iterations: list[int] = []
+
+        def on_progress(p: SolverProgress) -> None:
+            iterations.append(p.iteration)
+
+        simple_nlp.solve(method="SLSQP", callback=on_progress)
+        assert iterations == sorted(iterations)
+        assert iterations[0] == 1
+
+    def test_callback_elapsed_time_increases(self, simple_nlp):
+        """Elapsed time should be non-decreasing."""
+        times: list[float] = []
+
+        def on_progress(p: SolverProgress) -> None:
+            times.append(p.elapsed_time)
+
+        simple_nlp.solve(method="SLSQP", callback=on_progress)
+        for i in range(1, len(times)):
+            assert times[i] >= times[i - 1]
+
+    def test_callback_x_is_copy(self, simple_nlp):
+        """The x array should be a copy, not a view into solver internals."""
+        xs: list[np.ndarray] = []
+
+        def on_progress(p: SolverProgress) -> None:
+            xs.append(p.x)
+
+        simple_nlp.solve(method="SLSQP", callback=on_progress)
+        assert len(xs) > 0
+        # Mutate one — should not affect others
+        xs[0][:] = 999.0
+        if len(xs) > 1:
+            assert not np.allclose(xs[1], 999.0)
+
+    def test_callback_with_trust_constr(self, simple_nlp):
+        """Callback should work with trust-constr method."""
+        progress_log: list[SolverProgress] = []
+
+        def on_progress(p: SolverProgress) -> None:
+            progress_log.append(p)
+
+        sol = simple_nlp.solve(method="trust-constr", callback=on_progress)
+        assert sol.status == SolverStatus.OPTIMAL
+        assert len(progress_log) > 0
+
+    def test_callback_with_lbfgsb(self, unconstrained_nlp):
+        """Callback should work with L-BFGS-B method."""
+        progress_log: list[SolverProgress] = []
+
+        def on_progress(p: SolverProgress) -> None:
+            progress_log.append(p)
+
+        sol = unconstrained_nlp.solve(method="L-BFGS-B", callback=on_progress)
+        assert sol.status == SolverStatus.OPTIMAL
+        assert len(progress_log) > 0
+
+    def test_callback_objective_matches_sense(self):
+        """For maximize, objective_value in progress should be positive."""
+        x = Variable("x", lb=0, ub=10)
+        prob = Problem()
+        prob.maximize(x)
+        prob.subject_to(x <= 5)
+
+        obj_values: list[float] = []
+
+        def on_progress(p: SolverProgress) -> None:
+            obj_values.append(p.objective_value)
+
+        prob.solve(method="SLSQP", callback=on_progress)
+        # The last objective should be close to 5 (maximized value)
+        # All reported values should use the original (maximize) sense
+        # (not the negated internal representation)
+        assert len(obj_values) > 0
+
+
+# ---------------------------------------------------------------------------
+# Early termination tests
+# ---------------------------------------------------------------------------
+
+
+class TestEarlyTermination:
+    def test_callback_returns_true_terminates(self, simple_nlp):
+        """Returning True from callback should terminate with TERMINATED status."""
+
+        def stop_immediately(p: SolverProgress) -> bool:
+            return True
+
+        sol = simple_nlp.solve(method="SLSQP", callback=stop_immediately)
+        assert sol.status == SolverStatus.TERMINATED
+        assert "callback" in sol.message.lower()
+
+    def test_callback_returns_true_after_n(self, slow_nlp):
+        """Callback should be able to stop after N iterations."""
+        max_iters = 3
+
+        def stop_after_n(p: SolverProgress) -> bool:
+            return p.iteration >= max_iters
+
+        sol = slow_nlp.solve(method="SLSQP", callback=stop_after_n)
+        assert sol.status == SolverStatus.TERMINATED
+        assert sol.iterations is not None
+        assert sol.iterations <= max_iters + 1  # may be at most 1 over
+
+    def test_terminated_solution_has_values(self, simple_nlp):
+        """Terminated solution should still have variable values."""
+
+        def stop_immediately(p: SolverProgress) -> bool:
+            return True
+
+        sol = simple_nlp.solve(method="SLSQP", callback=stop_immediately)
+        assert sol.status == SolverStatus.TERMINATED
+        assert "x" in sol.values
+        assert "y" in sol.values
+        assert sol.objective_value is not None
+        assert sol.solve_time is not None
+        assert sol.solve_time > 0
+
+    def test_terminated_is_feasible(self, simple_nlp):
+        """TERMINATED status should count as feasible."""
+        sol = simple_nlp.solve(
+            method="SLSQP",
+            callback=lambda p: True,
+        )
+        assert sol.status == SolverStatus.TERMINATED
+        assert sol.is_feasible
+
+    def test_callback_returning_none_continues(self, simple_nlp):
+        """Returning None from callback should continue solving."""
+        count = {"n": 0}
+
+        def on_progress(p: SolverProgress):
+            count["n"] += 1
+            return None
+
+        sol = simple_nlp.solve(method="SLSQP", callback=on_progress)
+        assert sol.status == SolverStatus.OPTIMAL
+        assert count["n"] > 0
+
+    def test_callback_returning_false_continues(self, simple_nlp):
+        """Returning False from callback should continue solving."""
+        count = {"n": 0}
+
+        def on_progress(p: SolverProgress) -> bool:
+            count["n"] += 1
+            return False
+
+        sol = simple_nlp.solve(method="SLSQP", callback=on_progress)
+        assert sol.status == SolverStatus.OPTIMAL
+        assert count["n"] > 0
+
+    def test_early_termination_trust_constr(self, simple_nlp):
+        """Early termination should work with trust-constr."""
+        sol = simple_nlp.solve(
+            method="trust-constr",
+            callback=lambda p: True,
+        )
+        assert sol.status == SolverStatus.TERMINATED
+
+    def test_early_termination_lbfgsb(self, unconstrained_nlp):
+        """Early termination should work with L-BFGS-B."""
+        sol = unconstrained_nlp.solve(
+            method="L-BFGS-B",
+            callback=lambda p: True,
+        )
+        assert sol.status == SolverStatus.TERMINATED
+
+
+# ---------------------------------------------------------------------------
+# Time limit tests
+# ---------------------------------------------------------------------------
+
+
+class TestTimeLimit:
+    def test_time_limit_terminates(self, slow_nlp):
+        """time_limit should terminate the solver."""
+        sol = slow_nlp.solve(method="SLSQP", time_limit=0.001)
+        # With a very small time limit, it should terminate
+        assert sol.status == SolverStatus.TERMINATED
+        assert "time limit" in sol.message.lower()
+
+    def test_time_limit_has_solution(self, slow_nlp):
+        """Time-limited solution should still have variable values."""
+        sol = slow_nlp.solve(method="SLSQP", time_limit=0.001)
+        assert sol.values  # non-empty
+        assert sol.objective_value is not None
+        assert sol.solve_time is not None
+
+    def test_generous_time_limit_completes(self, simple_nlp):
+        """A generous time limit should allow normal completion."""
+        sol = simple_nlp.solve(method="SLSQP", time_limit=60.0)
+        assert sol.status == SolverStatus.OPTIMAL
+
+    def test_time_limit_with_callback(self, slow_nlp):
+        """time_limit and callback should work together."""
+        progress_log: list[SolverProgress] = []
+
+        def on_progress(p: SolverProgress) -> None:
+            progress_log.append(p)
+
+        sol = slow_nlp.solve(
+            method="SLSQP",
+            callback=on_progress,
+            time_limit=0.001,
+        )
+        assert sol.status == SolverStatus.TERMINATED
+        # Callback should have been called at least once before time limit
+        # (or the time limit hit on the first callback — either way TERMINATED)
+
+    def test_time_limit_trust_constr(self, slow_nlp):
+        """time_limit should work with trust-constr."""
+        sol = slow_nlp.solve(method="trust-constr", time_limit=0.001)
+        assert sol.status == SolverStatus.TERMINATED
+
+    def test_time_limit_lbfgsb(self):
+        """time_limit should work with L-BFGS-B."""
+        n = 20
+        v = VectorVariable("v", n, lb=-5, ub=5)
+        prob = Problem()
+        obj = sum(
+            (1 - v[i]) ** 2 + 100 * (v[i + 1] - v[i] ** 2) ** 2 for i in range(n - 1)
+        )
+        prob.minimize(obj)
+        sol = prob.solve(method="L-BFGS-B", time_limit=0.001)
+        assert sol.status == SolverStatus.TERMINATED
+
+
+# ---------------------------------------------------------------------------
+# No callback / no time_limit (regression)
+# ---------------------------------------------------------------------------
+
+
+class TestNoCallback:
+    def test_solve_without_callback(self, simple_nlp):
+        """Normal solve without callback should still work."""
+        sol = simple_nlp.solve(method="SLSQP")
+        assert sol.status == SolverStatus.OPTIMAL
+        assert abs(sol.objective_value - 0.5) < 1e-4
+
+    def test_solve_without_callback_trust_constr(self, simple_nlp):
+        """Normal solve without callback should work for trust-constr."""
+        sol = simple_nlp.solve(method="trust-constr")
+        assert sol.status == SolverStatus.OPTIMAL
+
+
+# ---------------------------------------------------------------------------
+# Constraint violation reporting
+# ---------------------------------------------------------------------------
+
+
+class TestConstraintViolation:
+    def test_feasible_has_zero_violation(self, simple_nlp):
+        """At convergence, constraint violation should be near zero."""
+        violations: list[float] = []
+
+        def on_progress(p: SolverProgress) -> None:
+            violations.append(p.constraint_violation)
+
+        simple_nlp.solve(method="SLSQP", callback=on_progress)
+        # The last violation should be near zero
+        assert violations[-1] < 1e-4
+
+    def test_unconstrained_has_zero_violation(self, unconstrained_nlp):
+        """Unconstrained problems should always report zero violation."""
+        violations: list[float] = []
+
+        def on_progress(p: SolverProgress) -> None:
+            violations.append(p.constraint_violation)
+
+        unconstrained_nlp.solve(method="L-BFGS-B", callback=on_progress)
+        assert all(v == 0.0 for v in violations)
diff --git a/tests/test_solvers.py b/tests/test_solvers.py
index 63e26dd..e79436a 100644
--- a/tests/test_solvers.py
+++ b/tests/test_solvers.py
@@ -5,45 +5,41 @@
 import numpy as np
 
 from optyx import Variable
-from optyx.core.errors import IntegerVariableError
+from optyx.core.errors import UnsupportedOperationError
 from optyx.problem import Problem
 
 
 class TestIntegerBinaryWarning:
-    """Tests for warnings when using integer/binary variables with SciPy."""
+    """Tests for integer/binary variable handling.
 
-    def test_binary_variable_emits_warning(self):
-        """Binary variables should emit a warning about relaxation."""
-        x = Variable("x", domain="binary")
-        prob = Problem().minimize((x - 0.5) ** 2)
+    With MIP support, linear problems with integer vars are routed to milp().
+    Nonlinear problems with integer vars raise UnsupportedOperationError.
+    """
 
-        with pytest.warns(UserWarning, match="integer/binary domains"):
-            sol = prob.solve()
+    def test_binary_variable_solves_via_milp(self):
+        """Binary variables in LP are solved via milp()."""
+        x = Variable("x", domain="binary")
+        prob = Problem().minimize(x)
+        sol = prob.solve()
 
         assert sol.is_optimal
-        # Solution is relaxed to continuous [0, 1]
-        assert 0 <= sol["x"] <= 1
+        assert abs(sol["x"]) < 1e-6
 
-    def test_integer_variable_emits_warning(self):
-        """Integer variables should emit a warning about relaxation."""
+    def test_integer_variable_solves_via_milp(self):
+        """Integer variables in LP are solved via milp()."""
         x = Variable("x", lb=0, ub=10, domain="integer")
-        prob = Problem().minimize((x - 3.7) ** 2)
-
-        with pytest.warns(UserWarning, match="integer/binary domains"):
-            sol = prob.solve()
+        prob = Problem().minimize(x)
+        sol = prob.solve()
 
         assert sol.is_optimal
-        # Solution is relaxed, not rounded to integer
-        assert abs(sol["x"] - 3.7) < 1e-4
+        assert abs(sol["x"]) < 1e-6
 
-    def test_warning_lists_variable_names(self):
-        """Warning should list all affected variable names."""
-        a = Variable("a", domain="binary")
-        b = Variable("b", domain="integer", lb=0, ub=5)
-        c = Variable("c")  # continuous, no warning
-        prob = Problem().minimize(a + b + c**2)
+    def test_nonlinear_integer_raises(self):
+        """Nonlinear + integer variables raises UnsupportedOperationError."""
+        x = Variable("x", domain="binary")
+        prob = Problem().minimize((x - 0.5) ** 2)
 
-        with pytest.warns(UserWarning, match=r"\[a, b\]"):
+        with pytest.raises(UnsupportedOperationError, match="nonlinear"):
             prob.solve()
 
     def test_continuous_no_warning(self):
@@ -61,22 +57,31 @@ def test_continuous_no_warning(self):
 class TestStrictMode:
     """Tests for strict mode enforcement of integer/binary variables."""
 
-    def test_strict_mode_raises_for_binary(self):
-        """strict=True should raise IntegerVariableError for binary variables."""
+    def test_strict_mode_ok_for_milp(self):
+        """strict=True still works for linear MIP (no error)."""
         x = Variable("x", domain="binary")
-        prob = Problem().minimize((x - 0.5) ** 2)
+        prob = Problem().minimize(x)
 
-        with pytest.raises(IntegerVariableError, match="integer/binary"):
-            prob.solve(strict=True)
+        sol = prob.solve(strict=True)
+        assert sol.is_optimal
 
-    def test_strict_mode_raises_for_integer(self):
-        """strict=True should raise IntegerVariableError for integer variables."""
+    def test_nonlinear_integer_raises_regardless_of_strict(self):
+        """Nonlinear + integer raises UnsupportedOperationError regardless of strict flag."""
         x = Variable("x", lb=0, ub=10, domain="integer")
         prob = Problem().minimize((x - 3.7) ** 2)
 
-        with pytest.raises(IntegerVariableError, match="integer/binary"):
+        with pytest.raises(UnsupportedOperationError, match="nonlinear"):
             prob.solve(strict=True)
 
+    @pytest.mark.parametrize("method", ["SLSQP", "trust-constr", "CG", "trust-krylov"])
+    def test_nonlinear_integer_named_nlp_methods_raise(self, method):
+        """Named NLP methods should reject MINLP models consistently."""
+        x = Variable("x", lb=0, ub=10, domain="integer")
+        prob = Problem().minimize((x - 3.7) ** 2)
+
+        with pytest.raises(UnsupportedOperationError, match="nonlinear"):
+            prob.solve(method=method)
+
     def test_strict_mode_ok_for_continuous(self):
         """strict=True should not raise for continuous variables."""
         x = Variable("x")
@@ -86,24 +91,24 @@ def test_strict_mode_ok_for_continuous(self):
         sol = prob.solve(strict=True)
         assert sol.is_optimal
 
-    def test_strict_false_still_warns(self):
-        """strict=False (default) should still emit warning."""
+    def test_milp_default_mode_solves(self):
+        """Default mode (strict=False) solves MILP correctly."""
         x = Variable("x", domain="binary")
-        prob = Problem().minimize((x - 0.5) ** 2)
-
-        with pytest.warns(UserWarning, match="integer/binary domains"):
-            sol = prob.solve(strict=False)
+        prob = Problem().minimize(x)
 
+        sol = prob.solve(strict=False)
         assert sol.is_optimal
 
-    def test_error_message_includes_variable_names(self):
-        """Error message should list affected variable names."""
+    def test_milp_linear_with_multiple_integer_vars(self):
+        """Multiple integer/binary vars in LP all route to milp()."""
         a = Variable("a", domain="binary")
         b = Variable("b", domain="integer", lb=0, ub=5)
         prob = Problem().minimize(a + b)
 
-        with pytest.raises(IntegerVariableError, match=r"\['a', 'b'\]"):
-            prob.solve(strict=True)
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol["a"]) < 1e-6
+        assert abs(sol["b"]) < 1e-6
 
 
 class TestUnconstrainedOptimization:
@@ -448,7 +453,7 @@ def test_cache_reused_on_repeated_solve(self):
         assert abs(sol1["y"] - sol2["y"]) < 1e-10
 
     def test_cache_invalidated_on_constraint_add(self):
-        """Adding a constraint should invalidate the cache."""
+        """Adding a constraint should selectively invalidate constraint cache."""
         x = Variable("x", lb=0)
         y = Variable("y", lb=0)
 
@@ -461,8 +466,11 @@ def test_cache_invalidated_on_constraint_add(self):
         # Add a constraint
         prob.subject_to(x + y >= 1)
 
-        # Cache should be invalidated
-        assert prob._solver_cache is None
+        # Objective cache should be preserved (selective invalidation)
+        assert prob._solver_cache is not None
+        assert "obj_fn" in prob._solver_cache
+        # Constraint cache should be cleared
+        assert "scipy_constraints" not in prob._solver_cache
 
     def test_cache_invalidated_on_objective_change(self):
         """Changing objective should invalidate the cache."""
diff --git a/tests/test_sparse_compilation.py b/tests/test_sparse_compilation.py
new file mode 100644
index 0000000..ff76ef4
--- /dev/null
+++ b/tests/test_sparse_compilation.py
@@ -0,0 +1,454 @@
+"""Tests for sparse gradient and Jacobian compilation (Issue #95)."""
+
+import numpy as np
+import pytest
+from scipy import sparse
+
+from optyx import Variable, sin, exp
+from optyx.core.autodiff import (
+    compile_jacobian,
+    compile_sparse_jacobian,
+)
+from optyx.core.compiler import (
+    compile_sparse_gradient,
+    compile_gradient_with_sparsity,
+    compile_gradient,
+)
+
+
+class TestCompileSparseGradient:
+    """Tests for compile_sparse_gradient function."""
+
+    def test_constant_linear_gradient(self):
+        """Linear expression should return constant sparse gradient."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+        expr = 2 * x + 3 * z  # y has zero gradient
+
+        grad_fn = compile_sparse_gradient(expr, [x, y, z])
+        result = grad_fn(np.array([1.0, 2.0, 3.0]))
+
+        assert sparse.issparse(result)
+        assert result.shape == (1, 3)
+        dense = result.toarray().flatten()
+        np.testing.assert_array_almost_equal(dense, [2.0, 0.0, 3.0])
+
+    def test_constant_gradient_returns_same_object(self):
+        """Constant sparse gradient should return same object each call."""
+        x = Variable("x")
+        y = Variable("y")
+        expr = 5 * x + 2 * y
+
+        grad_fn = compile_sparse_gradient(expr, [x, y])
+        r1 = grad_fn(np.array([1.0, 2.0]))
+        r2 = grad_fn(np.array([3.0, 4.0]))
+        assert r1 is r2
+
+    def test_nonlinear_sparse_gradient(self):
+        """Non-linear expression with sparse gradient."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+        expr = x**2 + z**3  # gradient: [2x, 0, 3z²]
+
+        grad_fn = compile_sparse_gradient(expr, [x, y, z])
+
+        result = grad_fn(np.array([3.0, 0.0, 2.0]))
+        assert sparse.issparse(result)
+        dense = result.toarray().flatten()
+        np.testing.assert_array_almost_equal(dense, [6.0, 0.0, 12.0])
+
+    def test_nonlinear_sparse_gradient_varies_with_x(self):
+        """Non-linear sparse gradient should give different values at different x."""
+        x = Variable("x")
+        y = Variable("y")
+        expr = x**2  # gradient: [2x, 0]
+
+        grad_fn = compile_sparse_gradient(expr, [x, y])
+
+        r1 = grad_fn(np.array([1.0, 0.0]))
+        r2 = grad_fn(np.array([5.0, 0.0]))
+
+        assert r1.toarray()[0, 0] == pytest.approx(2.0)
+        assert r2.toarray()[0, 0] == pytest.approx(10.0)
+
+    def test_zero_gradient(self):
+        """Expression independent of all variables."""
+        x = Variable("x")
+        y = Variable("y")
+        from optyx.core.expressions import Constant
+
+        expr = Constant(42.0)
+
+        grad_fn = compile_sparse_gradient(expr, [x, y])
+        result = grad_fn(np.array([1.0, 2.0]))
+
+        assert sparse.issparse(result)
+        assert result.nnz == 0
+        assert result.shape == (1, 2)
+
+    def test_sparse_format_is_csr(self):
+        """Output should be in CSR format."""
+        x = Variable("x")
+        y = Variable("y")
+        expr = x + y
+
+        grad_fn = compile_sparse_gradient(expr, [x, y])
+        result = grad_fn(np.array([1.0, 2.0]))
+        assert isinstance(result, sparse.csr_matrix)
+
+    def test_large_sparse_gradient(self):
+        """Sparse gradient with many variables but few non-zero."""
+        variables = [Variable(f"x{i}") for i in range(100)]
+        # Only depends on variables 0, 50, 99
+        expr = 2 * variables[0] + 3 * variables[50] + variables[99]
+
+        grad_fn = compile_sparse_gradient(expr, variables)
+        x = np.zeros(100)
+        result = grad_fn(x)
+
+        assert sparse.issparse(result)
+        assert result.shape == (1, 100)
+        assert result.nnz == 3
+        dense = result.toarray().flatten()
+        assert dense[0] == pytest.approx(2.0)
+        assert dense[50] == pytest.approx(3.0)
+        assert dense[99] == pytest.approx(1.0)
+
+    def test_matches_dense_gradient(self):
+        """Sparse gradient should match dense gradient numerically."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+        expr = x**2 * sin(z) + 3 * y
+
+        variables = [x, y, z]
+        sparse_fn = compile_sparse_gradient(expr, variables)
+        dense_fn = compile_gradient(expr, variables)
+
+        for _ in range(5):
+            point = np.random.randn(3)
+            sparse_result = sparse_fn(point).toarray().flatten()
+            dense_result = dense_fn(point)
+            np.testing.assert_array_almost_equal(sparse_result, dense_result)
+
+    def test_transcendental_sparse_gradient(self):
+        """Transcendental function with sparse gradient."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+        expr = sin(x) + exp(z)  # gradient: [cos(x), 0, exp(z)]
+
+        grad_fn = compile_sparse_gradient(expr, [x, y, z])
+        result = grad_fn(np.array([0.0, 0.0, 0.0]))
+
+        dense = result.toarray().flatten()
+        np.testing.assert_array_almost_equal(dense, [1.0, 0.0, 1.0])
+
+
+class TestCompileGradientWithSparsity:
+    """Tests for compile_gradient_with_sparsity function."""
+
+    def test_sparse_below_threshold(self):
+        """Returns sparse when density is below threshold."""
+        variables = [Variable(f"x{i}") for i in range(10)]
+        expr = variables[0] + variables[1]  # 2/10 = 0.2 density
+
+        grad_fn = compile_gradient_with_sparsity(expr, variables)
+        result = grad_fn(np.zeros(10))
+
+        # Should be sparse (density 0.2 < default threshold 0.5)
+        assert sparse.issparse(result)
+
+    def test_dense_above_threshold(self):
+        """Returns dense when density is above threshold."""
+        x = Variable("x")
+        y = Variable("y")
+        expr = x + y  # 2/2 = 1.0 density
+
+        grad_fn = compile_gradient_with_sparsity(expr, [x, y])
+        result = grad_fn(np.array([1.0, 2.0]))
+
+        # Should be dense (density 1.0 > default threshold 0.5)
+        assert isinstance(result, np.ndarray)
+
+    def test_custom_threshold(self):
+        """Custom threshold controls sparse/dense selection."""
+        variables = [Variable(f"x{i}") for i in range(10)]
+        expr = sum(variables[:4], variables[0])  # 4/10 = 0.4 density
+
+        # With threshold 0.3 → should be dense (0.4 > 0.3)
+        grad_fn_dense = compile_gradient_with_sparsity(
+            expr, variables, density_threshold=0.3
+        )
+        result_dense = grad_fn_dense(np.zeros(10))
+        assert isinstance(result_dense, np.ndarray)
+        assert not sparse.issparse(result_dense)
+
+        # With threshold 0.5 → should be sparse (0.4 < 0.5)
+        grad_fn_sparse = compile_gradient_with_sparsity(
+            expr, variables, density_threshold=0.5
+        )
+        result_sparse = grad_fn_sparse(np.zeros(10))
+        assert sparse.issparse(result_sparse)
+
+    def test_numerical_correctness(self):
+        """Sparse vs dense outputs should agree numerically."""
+        variables = [Variable(f"x{i}") for i in range(20)]
+        expr = variables[0] ** 2 + 3 * variables[10]
+
+        sparse_fn = compile_gradient_with_sparsity(
+            expr, variables, density_threshold=1.0
+        )
+        dense_fn = compile_gradient_with_sparsity(
+            expr, variables, density_threshold=0.0
+        )
+
+        point = np.random.randn(20)
+        sparse_result = sparse_fn(point)
+        dense_result = dense_fn(point)
+
+        if sparse.issparse(sparse_result):
+            sparse_result = sparse_result.toarray().flatten()
+        if sparse.issparse(dense_result):
+            dense_result = dense_result.toarray().flatten()
+
+        np.testing.assert_array_almost_equal(sparse_result, dense_result)
+
+
+class TestCompileSparseJacobian:
+    """Tests for compile_sparse_jacobian function."""
+
+    def test_linear_constraints_sparse(self):
+        """Linear constraints produce constant sparse Jacobian."""
+        n = 10
+        variables = [Variable(f"x{i}") for i in range(n)]
+
+        # Two sparse constraints: x0 + x1, x8 + x9 → density = 4/20 = 0.2
+        exprs = [variables[0] + variables[1], variables[8] + variables[9]]
+
+        jac_fn = compile_sparse_jacobian(exprs, variables)
+        result = jac_fn(np.zeros(n))
+
+        assert sparse.issparse(result)
+        dense = result.toarray()
+        expected = np.zeros((2, n))
+        expected[0, 0] = 1.0
+        expected[0, 1] = 1.0
+        expected[1, 8] = 1.0
+        expected[1, 9] = 1.0
+        np.testing.assert_array_almost_equal(dense, expected)
+
+    def test_constant_jacobian_same_object(self):
+        """All-constant sparse Jacobian returns same object."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+        exprs = [x + y, y + z]
+
+        jac_fn = compile_sparse_jacobian(exprs, [x, y, z])
+        r1 = jac_fn(np.array([1.0, 2.0, 3.0]))
+        r2 = jac_fn(np.array([4.0, 5.0, 6.0]))
+        assert r1 is r2
+
+    def test_nonlinear_sparse_jacobian(self):
+        """Non-linear sparse Jacobian varies with x."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+
+        # x² only depends on x, z³ only depends on z
+        exprs = [x**2, z**3]
+
+        jac_fn = compile_sparse_jacobian(exprs, [x, y, z])
+
+        result = jac_fn(np.array([3.0, 0.0, 2.0]))
+        assert sparse.issparse(result)
+        dense = result.toarray()
+        expected = np.array(
+            [
+                [6.0, 0.0, 0.0],  # d(x²)/dx=2x, 0, 0
+                [0.0, 0.0, 12.0],  # 0, 0, d(z³)/dz=3z²
+            ]
+        )
+        np.testing.assert_array_almost_equal(dense, expected)
+
+    def test_matches_dense_jacobian(self):
+        """Sparse Jacobian matches dense Jacobian numerically."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+        variables = [x, y, z]
+
+        exprs = [x**2 + y, sin(z), 2 * x + 3 * z]
+
+        sparse_fn = compile_sparse_jacobian(exprs, variables, density_threshold=1.0)
+        dense_fn = compile_jacobian(exprs, variables)
+
+        for _ in range(5):
+            point = np.random.randn(3)
+            sparse_result = sparse_fn(point)
+            dense_result = dense_fn(point)
+
+            if sparse.issparse(sparse_result):
+                sparse_result = sparse_result.toarray()
+
+            np.testing.assert_array_almost_equal(sparse_result, dense_result)
+
+    def test_high_density_falls_back_to_dense(self):
+        """High density Jacobian should fall back to dense output."""
+        x = Variable("x")
+        y = Variable("y")
+
+        # Both expressions depend on both variables → density = 1.0
+        exprs = [x + y, x * y]
+
+        jac_fn = compile_sparse_jacobian(exprs, [x, y], density_threshold=0.5)
+        result = jac_fn(np.array([1.0, 2.0]))
+
+        # Should be dense (falls back)
+        assert isinstance(result, np.ndarray)
+
+    def test_empty_expressions(self):
+        """Empty expression list produces empty sparse matrix."""
+        x = Variable("x")
+        jac_fn = compile_sparse_jacobian([], [x])
+        result = jac_fn(np.array([1.0]))
+        assert sparse.issparse(result)
+        assert result.shape == (0, 1)
+
+    def test_large_sparse_jacobian(self):
+        """Large sparse Jacobian with few non-zeros per row."""
+        n = 50
+        variables = [Variable(f"x{i}") for i in range(n)]
+
+        # Chain constraints: x_i + x_{i+1} for i in 0..n-2
+        # Each row has exactly 2 non-zeros → density = 2/n = 4%
+        exprs = [variables[i] + variables[i + 1] for i in range(n - 1)]
+
+        jac_fn = compile_sparse_jacobian(exprs, variables)
+        result = jac_fn(np.zeros(n))
+
+        assert sparse.issparse(result)
+        assert result.shape == (n - 1, n)
+        # Each row should have exactly 2 non-zeros
+        assert result.nnz == 2 * (n - 1)
+
+        # Verify structure: row i has nonzeros at columns i and i+1
+        dense = result.toarray()
+        for i in range(n - 1):
+            assert dense[i, i] == pytest.approx(1.0)
+            assert dense[i, i + 1] == pytest.approx(1.0)
+            # All other columns should be zero
+            assert np.sum(np.abs(dense[i, :])) == pytest.approx(2.0)
+
+    def test_mixed_constant_and_variable_rows(self):
+        """Jacobian with some constant and some variable rows."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+        variables = [x, y, z]
+
+        # Row 0: linear (constant gradient [2, 0, 3])
+        # Row 1: nonlinear (variable gradient [2x, 0, 0])
+        exprs = [2 * x + 3 * z, x**2]
+
+        jac_fn = compile_sparse_jacobian(exprs, variables)
+        result = jac_fn(np.array([4.0, 0.0, 0.0]))
+
+        assert sparse.issparse(result)
+        dense = result.toarray()
+        expected = np.array(
+            [
+                [2.0, 0.0, 3.0],
+                [8.0, 0.0, 0.0],
+            ]
+        )
+        np.testing.assert_array_almost_equal(dense, expected)
+
+    def test_onnz_memory(self):
+        """Sparse Jacobian should use O(nnz) storage, not O(m*n)."""
+        n = 100
+        variables = [Variable(f"x{i}") for i in range(n)]
+
+        # n-1 chain constraints, each with 2 nonzeros
+        exprs = [variables[i] + variables[i + 1] for i in range(n - 1)]
+
+        jac_fn = compile_sparse_jacobian(exprs, variables)
+        result = jac_fn(np.zeros(n))
+
+        # CSR storage: nnz data values + nnz column indices + (m+1) row pointers
+        # Should be much less than m*n = 99*100 = 9900
+        total_stored = result.nnz  # data + indices
+        assert total_stored == 2 * (n - 1)  # 198 vs 9900 dense
+
+
+class TestSparseJacobianFormats:
+    """Test sparse output format properties."""
+
+    def test_csr_format(self):
+        """Sparse Jacobian should be in CSR format."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+        exprs = [x + y, z]
+
+        jac_fn = compile_sparse_jacobian(exprs, [x, y, z])
+        result = jac_fn(np.zeros(3))
+        assert isinstance(result, sparse.csr_matrix)
+
+    def test_sparse_gradient_csr_format(self):
+        """Sparse gradient should be in CSR format."""
+        x = Variable("x")
+        y = Variable("y")
+        expr = x + y
+
+        grad_fn = compile_sparse_gradient(expr, [x, y])
+        result = grad_fn(np.zeros(2))
+        assert isinstance(result, sparse.csr_matrix)
+
+
+class TestSparseCompilationEdgeCases:
+    """Edge cases for sparse compilation."""
+
+    def test_single_expression_single_variable(self):
+        """Simplest case: one expression, few variables to ensure sparse."""
+        variables = [Variable(f"x{i}") for i in range(10)]
+        expr = variables[0] ** 2  # density 1/10 = 0.1
+
+        jac_fn = compile_sparse_jacobian([expr], variables)
+        result = jac_fn(np.array([3.0] + [0.0] * 9))
+
+        assert sparse.issparse(result)
+        assert result.toarray()[0, 0] == pytest.approx(6.0)
+
+    def test_zero_row_in_jacobian(self):
+        """Expression with zero gradient (constant)."""
+        x = Variable("x")
+        y = Variable("y")
+        from optyx.core.expressions import Constant
+
+        exprs = [Constant(5.0), x + y]
+
+        jac_fn = compile_sparse_jacobian(exprs, [x, y])
+        result = jac_fn(np.array([1.0, 2.0]))
+
+        assert sparse.issparse(result)
+        dense = result.toarray()
+        np.testing.assert_array_almost_equal(dense[0, :], [0.0, 0.0])
+        np.testing.assert_array_almost_equal(dense[1, :], [1.0, 1.0])
+
+    def test_all_zero_jacobian(self):
+        """All expressions are constants → all-zero Jacobian."""
+        x = Variable("x")
+        from optyx.core.expressions import Constant
+
+        exprs = [Constant(1.0), Constant(2.0)]
+
+        jac_fn = compile_sparse_jacobian(exprs, [x])
+        result = jac_fn(np.array([1.0]))
+
+        assert sparse.issparse(result)
+        assert result.nnz == 0
+        assert result.shape == (2, 1)
diff --git a/tests/test_sparse_trust_constr.py b/tests/test_sparse_trust_constr.py
new file mode 100644
index 0000000..710ab73
--- /dev/null
+++ b/tests/test_sparse_trust_constr.py
@@ -0,0 +1,131 @@
+"""Tests for sparse trust-constr constraint wiring."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+from scipy import sparse
+
+from optyx import Problem, Variable, VectorVariable, as_matrix
+from optyx.solvers.scipy_solver import (
+    _build_solver_cache,
+    _build_trust_constr_constraints,
+)
+
+
+def _build_sparse_chain_problem(n: int = 6) -> tuple[Problem, np.ndarray]:
+    """Build a sparse nonlinear problem with mixed constraint senses."""
+    variables = [Variable(f"x{i}", lb=0.0, ub=2.0) for i in range(n)]
+
+    prob = Problem(name=f"sparse_chain_{n}")
+    prob.minimize(sum((var - 1.0) ** 2 for var in variables))
+
+    for i in range(n - 1):
+        prob.subject_to(variables[i + 1] - variables[i] >= 0)
+    prob.subject_to(variables[0] <= 0.5)
+    prob.subject_to(variables[-1].eq(1.0))
+
+    x0 = np.linspace(0.2, 1.0, n)
+    return prob, x0
+
+
+def test_trust_constr_helper_builds_sparse_mixed_sense_constraint():
+    """Helper should build a mixed-sense NonlinearConstraint with CSR Jacobian."""
+    prob, x0 = _build_sparse_chain_problem(n=6)
+    cache = _build_solver_cache(prob, prob.variables)
+
+    assert "sparse_constraint_jac_fn" not in cache
+
+    constraint = _build_trust_constr_constraints(cache)
+    assert constraint is not None
+    assert "sparse_constraint_jac_fn" in cache
+
+    jac = constraint.jac(x0)
+    assert sparse.isspmatrix_csr(jac)
+
+    expected_lb = np.array([0.0, 0.0, 0.0, 0.0, 0.0, -np.inf, 0.0])
+    expected_ub = np.array([np.inf, np.inf, np.inf, np.inf, np.inf, 0.0, 0.0])
+    np.testing.assert_allclose(constraint.lb, expected_lb)
+    np.testing.assert_allclose(constraint.ub, expected_ub)
+    assert constraint.fun(x0).shape == (7,)
+
+
+def test_solver_cache_uses_dense_output_sparse_eval_for_sparse_objective():
+    """Sparse objective gradients should compute sparsely but return dense arrays."""
+    x = Variable("x", lb=0.0, ub=2.0)
+    y = Variable("y", lb=0.0, ub=2.0)
+    z = Variable("z", lb=0.0, ub=2.0)
+
+    prob = Problem(name="sparse_objective_grad")
+    prob.minimize((x - 1.0) ** 2)
+    prob.subject_to(y >= 0.25)
+    prob.subject_to(z <= 1.75)
+
+    cache = _build_solver_cache(prob, prob.variables)
+    grad = cache["grad_fn"](np.array([1.5, 0.3, 0.8]))
+
+    assert isinstance(grad, np.ndarray)
+    expected = np.array([1.0 if var.name == "x" else 0.0 for var in prob.variables])
+    np.testing.assert_allclose(grad, expected)
+
+
+@pytest.mark.filterwarnings("ignore:delta_grad == 0.0:UserWarning")
+def test_trust_constr_honors_sparse_matrix_constraints():
+    """trust-constr should honor sparse matrix blocks on the SciPy path."""
+    n = 8
+    x = VectorVariable("x", n, lb=0.0, ub=2.0)
+    A = as_matrix(sparse.eye(n, format="csr"), storage="sparse")
+
+    prob = Problem(name="sparse_matrix_trust_constr")
+    prob.minimize(sum((x[i] - 1.0) ** 2 for i in range(n)))
+    prob.subject_to(A @ x >= np.full(n, 0.25))
+
+    sol = prob.solve(method="trust-constr")
+
+    assert sol.is_optimal
+    values = np.array([sol[f"x[{i}]"] for i in range(n)])
+    assert np.all(values >= 0.25 - 1e-5)
+
+
+def test_slsqp_honors_matrix_constraints_with_variable_reordering():
+    """Matrix blocks should be aligned to the global variable order for SciPy."""
+    x = VectorVariable("x", 2, lb=0.0, ub=2.0)
+    a = Variable("a", lb=0.0, ub=2.0)
+
+    prob = Problem(name="matrix_reordering")
+    prob.minimize((x[0] - 0.2) ** 2 + (x[1] - 0.8) ** 2 + (a - 0.5) ** 2)
+    prob.subject_to(
+        as_matrix(np.array([[1.0, 1.0]]), storage="dense") @ x >= np.array([1.0])
+    )
+
+    sol = prob.solve(method="SLSQP")
+
+    assert sol.is_optimal
+    assert sol["a"] == pytest.approx(0.5, abs=1e-4)
+    assert sol["x[0]"] + sol["x[1]"] >= 1.0 - 1e-5
+
+
+def test_auto_select_prefers_trust_constr_for_large_sparse_matrix_nlp():
+    """Large sparse matrix-constrained NLPs should prefer trust-constr."""
+    n = 64
+    x = VectorVariable("x", n, lb=0.0, ub=2.0)
+
+    prob = Problem(name="auto_sparse_matrix_nlp")
+    prob.minimize(x.dot(x))
+    prob.subject_to(as_matrix(np.eye(n), storage="auto") @ x >= np.zeros(n))
+
+    assert prob._auto_select_method() == "trust-constr"
+
+
+@pytest.mark.filterwarnings("ignore:delta_grad == 0.0:UserWarning")
+def test_sparse_chain_problem_solves_with_trust_constr():
+    """trust-constr should solve sparse chain problems through the new path."""
+    prob, x0 = _build_sparse_chain_problem(n=8)
+
+    sol = prob.solve(method="trust-constr", x0=x0)
+
+    assert sol.is_optimal
+    values = np.array([sol[f"x{i}"] for i in range(8)])
+    assert np.all(np.diff(values) >= -1e-6)
+    assert values[0] <= 0.5 + 1e-6
+    assert values[-1] == pytest.approx(1.0, abs=1e-3)
diff --git a/tests/test_sparsity_analysis.py b/tests/test_sparsity_analysis.py
new file mode 100644
index 0000000..d92f2ff
--- /dev/null
+++ b/tests/test_sparsity_analysis.py
@@ -0,0 +1,299 @@
+"""Tests for sparsity analysis (Issue #94)."""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from optyx import Variable, VectorVariable
+from optyx.core.autodiff import (
+    SparsityPattern,
+    analyze_gradient_sparsity,
+    analyze_jacobian_sparsity,
+)
+from optyx.core.expressions import Constant
+
+
+class TestSparsityPattern:
+    """Test SparsityPattern dataclass properties."""
+
+    def test_nnz_count(self):
+        sp = SparsityPattern(
+            nnz_indices=np.array([0, 2, 4], dtype=np.intp),
+            size=5,
+            is_constant=False,
+            constant_values=None,
+        )
+        assert sp.nnz == 3
+
+    def test_density(self):
+        sp = SparsityPattern(
+            nnz_indices=np.array([0, 2], dtype=np.intp),
+            size=10,
+            is_constant=False,
+            constant_values=None,
+        )
+        assert sp.density == pytest.approx(0.2)
+
+    def test_is_dense(self):
+        sp = SparsityPattern(
+            nnz_indices=np.array([0, 1, 2], dtype=np.intp),
+            size=3,
+            is_constant=False,
+            constant_values=None,
+        )
+        assert sp.is_dense
+
+    def test_not_dense(self):
+        sp = SparsityPattern(
+            nnz_indices=np.array([0, 2], dtype=np.intp),
+            size=3,
+            is_constant=False,
+            constant_values=None,
+        )
+        assert not sp.is_dense
+
+    def test_empty_pattern(self):
+        sp = SparsityPattern(
+            nnz_indices=np.array([], dtype=np.intp),
+            size=5,
+            is_constant=False,
+            constant_values=None,
+        )
+        assert sp.nnz == 0
+        assert sp.density == 0.0
+        assert not sp.is_dense
+
+
+class TestAnalyzeGradientSparsity:
+    """Test analyze_gradient_sparsity for various expression types."""
+
+    def test_constant_expression(self):
+        """Constant expression has no non-zero gradients."""
+        x = Variable("x")
+        y = Variable("y")
+        expr = Constant(5.0)
+        sp = analyze_gradient_sparsity(expr, [x, y])
+        assert sp.nnz == 0
+        assert sp.size == 2
+        assert not sp.is_dense
+
+    def test_single_variable(self):
+        """Expression depending on one variable."""
+        x = Variable("x")
+        y = Variable("y")
+        expr = 2.0 * x + 3.0
+        sp = analyze_gradient_sparsity(expr, [x, y])
+        assert sp.nnz == 1
+        np.testing.assert_array_equal(sp.nnz_indices, [0])
+        assert sp.is_constant
+        np.testing.assert_array_almost_equal(sp.constant_values, [2.0])
+
+    def test_two_variables(self):
+        """Expression depending on two variables."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+        expr = x + y
+        sp = analyze_gradient_sparsity(expr, [x, y, z])
+        assert sp.nnz == 2
+        np.testing.assert_array_equal(sp.nnz_indices, [0, 1])
+        assert not sp.is_dense
+
+    def test_all_variables(self):
+        """Expression depending on all variables."""
+        x = Variable("x")
+        y = Variable("y")
+        expr = x * y
+        sp = analyze_gradient_sparsity(expr, [x, y])
+        assert sp.nnz == 2
+        assert sp.is_dense
+        # x*y has non-constant gradients (grad_x = y, grad_y = x)
+        assert not sp.is_constant
+
+    def test_linear_expression_constant_gradients(self):
+        """Linear expression has constant gradients."""
+        x = Variable("x")
+        y = Variable("y")
+        z = Variable("z")
+        expr = 3.0 * x - 2.0 * y + 5.0
+        sp = analyze_gradient_sparsity(expr, [x, y, z])
+        assert sp.nnz == 2
+        np.testing.assert_array_equal(sp.nnz_indices, [0, 1])
+        assert sp.is_constant
+        np.testing.assert_array_almost_equal(sp.constant_values, [3.0, -2.0])
+
+    def test_quadratic_expression_nonconstant_gradients(self):
+        """Quadratic expression has non-constant gradients."""
+        x = Variable("x")
+        y = Variable("y")
+        expr = x**2 + y
+        sp = analyze_gradient_sparsity(expr, [x, y])
+        assert sp.nnz == 2
+        # grad_x = 2*x (not constant), grad_y = 1 (constant)
+        # But is_constant should be False since not ALL are constant
+        assert not sp.is_constant
+
+    def test_vector_linear_combination(self):
+        """LinearCombination (c @ x) has constant gradient."""
+        x = VectorVariable("x", 5)
+        variables = list(x._variables)
+        c = np.array([1.0, 0.0, 3.0, 0.0, 5.0])
+        expr = c @ x
+        sp = analyze_gradient_sparsity(expr, variables)
+        # All 5 variables appear in c @ x even if coefficient is 0
+        # (because LinearCombination stores all variables)
+        assert sp.size == 5
+        assert sp.is_constant
+
+    def test_dot_product_dense(self):
+        """DotProduct x.dot(x) depends on all variables."""
+        x = VectorVariable("x", 4)
+        variables = list(x._variables)
+        expr = x.dot(x)
+        sp = analyze_gradient_sparsity(expr, variables)
+        assert sp.nnz == 4
+        assert sp.is_dense
+        # grad = 2*x, not constant
+        assert not sp.is_constant
+
+    def test_vector_sum(self):
+        """VectorSum depends on all variables with constant gradient."""
+        x = VectorVariable("x", 3)
+        variables = list(x._variables)
+        expr = x.sum()
+        sp = analyze_gradient_sparsity(expr, variables)
+        assert sp.nnz == 3
+        assert sp.is_dense
+        assert sp.is_constant
+        np.testing.assert_array_almost_equal(sp.constant_values, [1.0, 1.0, 1.0])
+
+    def test_sparse_constraint(self):
+        """Constraint that only involves a subset of variables."""
+        variables = [Variable(f"x{i}") for i in range(10)]
+        # Constraint: x0 + x5 <= 10
+        expr = variables[0] + variables[5]
+        sp = analyze_gradient_sparsity(expr, variables)
+        assert sp.nnz == 2
+        assert sp.density == pytest.approx(0.2)
+        np.testing.assert_array_equal(sp.nnz_indices, [0, 5])
+        assert sp.is_constant
+        np.testing.assert_array_almost_equal(sp.constant_values, [1.0, 1.0])
+
+
+class TestAnalyzeJacobianSparsity:
+    """Test analyze_jacobian_sparsity for multi-row Jacobians."""
+
+    def test_single_row(self):
+        """Single expression Jacobian."""
+        x = Variable("x")
+        y = Variable("y")
+        patterns = analyze_jacobian_sparsity([x + y], [x, y])
+        assert len(patterns) == 1
+        assert patterns[0].nnz == 2
+
+    def test_diagonal_jacobian(self):
+        """Each constraint depends on exactly one variable."""
+        variables = [Variable(f"x{i}") for i in range(3)]
+        exprs = [
+            2.0 * variables[0],
+            3.0 * variables[1],
+            4.0 * variables[2],
+        ]
+        patterns = analyze_jacobian_sparsity(exprs, variables)
+        assert len(patterns) == 3
+        for i, sp in enumerate(patterns):
+            assert sp.nnz == 1
+            np.testing.assert_array_equal(sp.nnz_indices, [i])
+            assert sp.is_constant
+
+    def test_sparse_jacobian(self):
+        """Mixed sparse constraint system."""
+        variables = [Variable(f"x{i}") for i in range(5)]
+        exprs = [
+            variables[0] + variables[1],  # depends on x0, x1
+            variables[2] * variables[3],  # depends on x2, x3
+            variables[4],  # depends on x4
+        ]
+        patterns = analyze_jacobian_sparsity(exprs, variables)
+        assert len(patterns) == 3
+        np.testing.assert_array_equal(patterns[0].nnz_indices, [0, 1])
+        np.testing.assert_array_equal(patterns[1].nnz_indices, [2, 3])
+        np.testing.assert_array_equal(patterns[2].nnz_indices, [4])
+
+    def test_dense_jacobian(self):
+        """All constraints depend on all variables."""
+        x = Variable("x")
+        y = Variable("y")
+        exprs = [x + y, x * y]
+        patterns = analyze_jacobian_sparsity(exprs, [x, y])
+        assert all(sp.is_dense for sp in patterns)
+
+
+class TestSparsityIntegration:
+    """Test that sparsity analysis integrates correctly with compile_jacobian."""
+
+    def test_sparse_jacobian_correctness(self):
+        """Verify compile_jacobian produces correct results with sparse rows."""
+        from optyx.core.autodiff import compile_jacobian
+
+        variables = [Variable(f"x{i}") for i in range(5)]
+        # Sparse constraint: only x0 + x3
+        expr = variables[0] + variables[3]
+        jac_fn = compile_jacobian([expr], variables)
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+        result = jac_fn(x)
+        expected = np.array([[1.0, 0.0, 0.0, 1.0, 0.0]])
+        np.testing.assert_array_almost_equal(result, expected)
+
+    def test_sparse_nonlinear_jacobian_correctness(self):
+        """Verify sparse nonlinear Jacobian row is correct."""
+        from optyx.core.autodiff import compile_jacobian
+
+        variables = [Variable(f"x{i}") for i in range(5)]
+        # Nonlinear constraint: x1^2 + x3
+        expr = variables[1] ** 2 + variables[3]
+        jac_fn = compile_jacobian([expr], variables)
+        x = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+        result = jac_fn(x)
+        # grad = [0, 2*x1, 0, 1, 0] = [0, 4, 0, 1, 0]
+        expected = np.array([[0.0, 4.0, 0.0, 1.0, 0.0]])
+        np.testing.assert_array_almost_equal(result, expected)
+
+    def test_mixed_sparse_dense_rows(self):
+        """Jacobian with both sparse and dense rows."""
+        from optyx.core.autodiff import compile_jacobian
+
+        variables = [Variable(f"x{i}") for i in range(3)]
+        exprs = [
+            variables[0],  # sparse: only x0
+            variables[0] + variables[1] + variables[2],  # dense: all vars
+        ]
+        jac_fn = compile_jacobian(exprs, variables)
+        x = np.array([1.0, 2.0, 3.0])
+        result = jac_fn(x)
+        expected = np.array(
+            [
+                [1.0, 0.0, 0.0],
+                [1.0, 1.0, 1.0],
+            ]
+        )
+        np.testing.assert_array_almost_equal(result, expected)
+
+    def test_large_sparse_system(self):
+        """Large system where each constraint is very sparse."""
+        from optyx.core.autodiff import compile_jacobian
+
+        n = 100
+        variables = [Variable(f"x{i}") for i in range(n)]
+        # Each constraint depends on only 2 consecutive variables
+        exprs = [variables[i] + variables[(i + 1) % n] for i in range(n)]
+        jac_fn = compile_jacobian(exprs, variables)
+        x = np.ones(n)
+        result = jac_fn(x)
+        # Each row should have exactly 2 non-zeros
+        for i in range(n):
+            row = result[i]
+            assert np.count_nonzero(row) == 2
+            assert row[i] == 1.0
+            assert row[(i + 1) % n] == 1.0
diff --git a/tests/test_variable_dict.py b/tests/test_variable_dict.py
new file mode 100644
index 0000000..e0cf1e6
--- /dev/null
+++ b/tests/test_variable_dict.py
@@ -0,0 +1,378 @@
+"""Tests for VariableDict — dict-indexed variable collections."""
+
+import numpy as np
+import pytest
+
+from optyx import (
+    Variable,
+    VariableDict,
+    Problem,
+)
+
+
+class TestVariableDictCreation:
+    """Test VariableDict construction and basic properties."""
+
+    def test_basic_creation(self):
+        foods = ["hamburger", "chicken", "pizza", "salad"]
+        buy = VariableDict("buy", foods, lb=0)
+        assert len(buy) == 4
+        assert buy.name == "buy"
+
+    def test_keys_preserved_order(self):
+        keys = ["z", "a", "m", "b"]
+        vd = VariableDict("x", keys)
+        assert vd.keys() == ["z", "a", "m", "b"]
+
+    def test_variable_naming(self):
+        vd = VariableDict("buy", ["ham", "egg"])
+        assert vd["ham"].name == "buy[ham]"
+        assert vd["egg"].name == "buy[egg]"
+
+    def test_scalar_bounds(self):
+        vd = VariableDict("x", ["a", "b", "c"], lb=0, ub=10)
+        for key in ["a", "b", "c"]:
+            assert vd[key].lb == 0
+            assert vd[key].ub == 10
+
+    def test_per_key_bounds(self):
+        lb = {"a": 0, "b": 1, "c": 2}
+        ub = {"a": 10, "b": 20, "c": 30}
+        vd = VariableDict("x", ["a", "b", "c"], lb=lb, ub=ub)
+        assert vd["a"].lb == 0
+        assert vd["a"].ub == 10
+        assert vd["b"].lb == 1
+        assert vd["b"].ub == 20
+        assert vd["c"].lb == 2
+        assert vd["c"].ub == 30
+
+    def test_no_bounds(self):
+        vd = VariableDict("x", ["a", "b"])
+        assert vd["a"].lb is None
+        assert vd["a"].ub is None
+
+    def test_domain_continuous(self):
+        vd = VariableDict("x", ["a", "b"])
+        assert vd["a"].domain == "continuous"
+
+    def test_domain_binary(self):
+        vd = VariableDict("x", ["a", "b"], domain="binary")
+        assert vd["a"].domain == "binary"
+        assert vd["a"].lb == 0.0
+        assert vd["a"].ub == 1.0
+
+    def test_domain_integer(self):
+        vd = VariableDict("x", ["a", "b"], domain="integer", lb=0, ub=5)
+        assert vd["a"].domain == "integer"
+
+    def test_empty_keys_raises(self):
+        with pytest.raises(ValueError, match="at least one key"):
+            VariableDict("x", [])
+
+    def test_repr(self):
+        vd = VariableDict("buy", ["ham", "egg"])
+        r = repr(vd)
+        assert "buy" in r
+        assert "ham" in r
+        assert "egg" in r
+
+
+class TestVariableDictAccess:
+    """Test indexing, iteration, and dict-like interface."""
+
+    def test_getitem(self):
+        vd = VariableDict("x", ["a", "b", "c"])
+        assert isinstance(vd["a"], Variable)
+        assert vd["a"].name == "x[a]"
+
+    def test_getitem_missing_key(self):
+        vd = VariableDict("x", ["a", "b"])
+        with pytest.raises(KeyError, match="not found"):
+            vd["z"]
+
+    def test_contains(self):
+        vd = VariableDict("x", ["a", "b", "c"])
+        assert "a" in vd
+        assert "z" not in vd
+
+    def test_len(self):
+        vd = VariableDict("x", ["a", "b", "c"])
+        assert len(vd) == 3
+
+    def test_iter(self):
+        keys = ["x", "y", "z"]
+        vd = VariableDict("v", keys)
+        assert list(vd) == keys
+
+    def test_keys(self):
+        vd = VariableDict("v", ["a", "b", "c"])
+        assert vd.keys() == ["a", "b", "c"]
+
+    def test_values(self):
+        vd = VariableDict("v", ["a", "b"])
+        vals = vd.values()
+        assert len(vals) == 2
+        assert all(isinstance(v, Variable) for v in vals)
+        assert vals[0].name == "v[a]"
+
+    def test_items(self):
+        vd = VariableDict("v", ["a", "b"])
+        items = vd.items()
+        assert len(items) == 2
+        assert items[0] == ("a", vd["a"])
+        assert items[1] == ("b", vd["b"])
+
+    def test_get_variables(self):
+        vd = VariableDict("v", ["a", "b", "c"])
+        vars_ = vd.get_variables()
+        assert len(vars_) == 3
+        assert all(isinstance(v, Variable) for v in vars_)
+
+
+class TestVariableDictExpressions:
+    """Test sum() and prod() expression building."""
+
+    def test_sum_all(self):
+        vd = VariableDict("x", ["a", "b", "c"], lb=0)
+        expr = vd.sum()
+        # Evaluate the expression
+        result = expr.evaluate({"x[a]": 1, "x[b]": 2, "x[c]": 3})
+        assert result == 6.0
+
+    def test_sum_subset(self):
+        vd = VariableDict("x", ["a", "b", "c"], lb=0)
+        expr = vd.sum(["a", "c"])
+        result = expr.evaluate({"x[a]": 1, "x[b]": 999, "x[c]": 3})
+        assert result == 4.0
+
+    def test_sum_single_key(self):
+        vd = VariableDict("x", ["a", "b", "c"])
+        expr = vd.sum(["b"])
+        # Should return the variable itself
+        assert isinstance(expr, Variable)
+        assert expr.name == "x[b]"
+
+    def test_sum_invalid_key(self):
+        vd = VariableDict("x", ["a", "b"])
+        with pytest.raises(KeyError, match="not found"):
+            vd.sum(["a", "z"])
+
+    def test_prod_with_dict(self):
+        vd = VariableDict("x", ["a", "b", "c"], lb=0)
+        coeffs = {"a": 2.0, "b": 3.0, "c": 4.0}
+        expr = vd.prod(coeffs)
+        result = expr.evaluate({"x[a]": 1, "x[b]": 2, "x[c]": 3})
+        assert result == pytest.approx(2.0 + 6.0 + 12.0)
+
+    def test_prod_with_sequence(self):
+        vd = VariableDict("x", ["a", "b", "c"], lb=0)
+        coeffs = [2.0, 3.0, 4.0]
+        expr = vd.prod(coeffs)
+        result = expr.evaluate({"x[a]": 1, "x[b]": 2, "x[c]": 3})
+        assert result == pytest.approx(20.0)
+
+    def test_prod_partial_dict(self):
+        """Coefficients dict can have fewer keys — missing keys get 0 coeff."""
+        vd = VariableDict("x", ["a", "b", "c"], lb=0)
+        coeffs = {"a": 5.0, "c": 10.0}  # b is missing
+        expr = vd.prod(coeffs)
+        result = expr.evaluate({"x[a]": 1, "x[b]": 999, "x[c]": 2})
+        assert result == pytest.approx(25.0)
+
+    def test_prod_wrong_length_sequence(self):
+        vd = VariableDict("x", ["a", "b", "c"])
+        with pytest.raises(ValueError, match="Expected 3"):
+            vd.prod([1.0, 2.0])
+
+    def test_prod_all_zero_coeffs(self):
+        vd = VariableDict("x", ["a", "b"], lb=0)
+        expr = vd.prod({"a": 0, "b": 0})
+        result = expr.evaluate({"x[a]": 5, "x[b]": 10})
+        assert result == 0.0
+
+
+class TestVariableDictSolve:
+    """Test VariableDict in end-to-end optimization problems."""
+
+    def test_lp_diet_problem(self):
+        """Classic diet problem using VariableDict."""
+        foods = ["burger", "chicken", "pizza"]
+        cost = {"burger": 2.49, "chicken": 2.89, "pizza": 1.99}
+        protein = {"burger": 25, "chicken": 31, "pizza": 15}
+
+        buy = VariableDict("buy", foods, lb=0, ub=10)
+        prob = Problem(name="diet")
+
+        # Minimize cost
+        prob.minimize(buy.prod(cost))
+
+        # Require at least 50g protein
+        prob.subject_to(buy.prod(protein) >= 50)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+
+        # Check solution extraction
+        result = sol[buy]
+        assert isinstance(result, dict)
+        assert set(result.keys()) == set(foods)
+        assert all(v >= -1e-6 for v in result.values())
+
+        # Protein constraint satisfied
+        total_protein = sum(result[f] * protein[f] for f in foods)
+        assert total_protein >= 50 - 1e-6
+
+    def test_lp_with_sum_constraint(self):
+        """Use sum() in constraints."""
+        items = ["a", "b", "c"]
+        x = VariableDict("x", items, lb=0, ub=5)
+
+        prob = Problem(name="sum_test")
+        prob.maximize(x.prod({"a": 3, "b": 2, "c": 1}))
+        prob.subject_to(x.sum() <= 10)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        result = sol[x]
+        assert sum(result.values()) <= 10 + 1e-6
+
+    def test_lp_partial_sum_constraint(self):
+        """Use sum(subset) in constraints."""
+        items = ["a", "b", "c", "d"]
+        x = VariableDict("x", items, lb=0, ub=10)
+
+        prob = Problem(name="partial_sum")
+        prob.maximize(x.sum())
+        # a + b <= 5
+        prob.subject_to(x.sum(["a", "b"]) <= 5)
+        # c + d <= 8
+        prob.subject_to(x.sum(["c", "d"]) <= 8)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        result = sol[x]
+        assert result["a"] + result["b"] <= 5 + 1e-6
+        assert result["c"] + result["d"] <= 8 + 1e-6
+        assert sum(result.values()) == pytest.approx(13.0, abs=1e-4)
+
+    def test_solution_getitem_variable_dict(self):
+        """Solution[VariableDict] returns dict."""
+        x = VariableDict("x", ["a", "b"], lb=0, ub=1)
+        prob = Problem(name="test")
+        prob.maximize(x.prod({"a": 1, "b": 2}))
+        sol = prob.solve()
+        assert sol.is_optimal
+
+        result = sol[x]
+        assert isinstance(result, dict)
+        assert "a" in result
+        assert "b" in result
+
+    def test_to_dict_convenience_method(self):
+        """VariableDict.to_dict(solution) mirrors Solution[VariableDict]."""
+        x = VariableDict("x", ["a", "b"], lb=0, ub=1)
+        prob = Problem(name="test_to_dict")
+        prob.maximize(x.prod({"a": 1, "b": 2}))
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert x.to_dict(sol) == sol[x]
+
+    def test_solution_getitem_individual_var(self):
+        """Solution[vd['key']] returns float for individual variable."""
+        x = VariableDict("x", ["a", "b"], lb=0, ub=1)
+        prob = Problem(name="test")
+        prob.maximize(x.prod({"a": 1, "b": 2}))
+        sol = prob.solve()
+
+        val_a = sol[x["a"]]
+        assert isinstance(val_a, float)
+
+    def test_milp_with_variable_dict(self):
+        """VariableDict with binary domain for MILP."""
+        items = ["laptop", "phone", "tablet"]
+        value = {"laptop": 1000, "phone": 500, "tablet": 300}
+        weight = {"laptop": 3, "phone": 1, "tablet": 2}
+
+        select = VariableDict("select", items, domain="binary")
+        prob = Problem(name="knapsack")
+        prob.maximize(select.prod(value))
+        prob.subject_to(select.prod(weight) <= 4)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+
+        result = sol[select]
+        # Should pick laptop + phone (value=1500, weight=4)
+        # or phone + tablet (value=800, weight=3)
+        total_weight = sum(result[i] * weight[i] for i in items)
+        assert total_weight <= 4 + 1e-6
+
+    def test_nlp_with_variable_dict(self):
+        """VariableDict in a nonlinear problem."""
+        dims = ["x", "y"]
+        v = VariableDict("v", dims)
+
+        prob = Problem(name="nlp_test")
+        # Minimize x^2 + y^2
+        prob.minimize(v["x"] ** 2 + v["y"] ** 2)
+        # Subject to x + y >= 1
+        prob.subject_to(v["x"] + v["y"] >= 1)
+
+        sol = prob.solve(x0=np.array([1.0, 1.0]))
+        assert sol.is_optimal
+        result = sol[v]
+        assert result["x"] == pytest.approx(0.5, abs=1e-4)
+        assert result["y"] == pytest.approx(0.5, abs=1e-4)
+
+
+class TestVariableDictEdgeCases:
+    """Edge cases and error handling."""
+
+    def test_single_key(self):
+        vd = VariableDict("x", ["only"])
+        assert len(vd) == 1
+        assert vd["only"].name == "x[only]"
+
+    def test_sum_single_element_dict(self):
+        vd = VariableDict("x", ["only"])
+        expr = vd.sum()
+        assert isinstance(expr, Variable)
+
+    def test_keys_with_spaces(self):
+        vd = VariableDict("buy", ["ice cream", "hot dog"])
+        assert vd["ice cream"].name == "buy[ice cream]"
+        assert vd["hot dog"].name == "buy[hot dog]"
+
+    def test_many_keys(self):
+        keys = [f"item_{i}" for i in range(100)]
+        vd = VariableDict("x", keys, lb=0)
+        assert len(vd) == 100
+        assert vd["item_50"].name == "x[item_50]"
+
+    def test_prod_with_numpy_array(self):
+        vd = VariableDict("x", ["a", "b", "c"], lb=0)
+        coeffs = np.array([1.0, 2.0, 3.0])
+        expr = vd.prod(coeffs)
+        result = expr.evaluate({"x[a]": 1, "x[b]": 1, "x[c]": 1})
+        assert result == pytest.approx(6.0)
+
+    def test_variable_dict_variables_are_independent(self):
+        """Each VariableDict creates unique variables."""
+        vd1 = VariableDict("x", ["a", "b"])
+        vd2 = VariableDict("y", ["a", "b"])
+        assert vd1["a"].name != vd2["a"].name
+
+    def test_mixed_in_constraint(self):
+        """VariableDict variables can mix with regular Variables."""
+        vd = VariableDict("x", ["a", "b"], lb=0, ub=10)
+        z = Variable("z", lb=0, ub=10)
+
+        prob = Problem(name="mixed")
+        prob.maximize(vd["a"] + vd["b"] + z)
+        prob.subject_to(vd["a"] + z <= 5)
+        prob.subject_to(vd["b"] <= 3)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert sol[z] + sol[vd["a"]] <= 5 + 1e-6
diff --git a/tests/test_vector_binary_op.py b/tests/test_vector_binary_op.py
new file mode 100644
index 0000000..e64709d
--- /dev/null
+++ b/tests/test_vector_binary_op.py
@@ -0,0 +1,552 @@
+"""Tests for VectorBinaryOp — single-node element-wise vector operations."""
+
+import numpy as np
+import pytest
+
+from optyx import VectorVariable, Problem
+from optyx.core.vectors import VectorBinaryOp, VectorExpression
+from optyx.core.compiler import compile_expression
+from optyx.core.autodiff import gradient
+
+
+class TestVectorBinaryOpConstruction:
+    """VectorBinaryOp should be produced by vector arithmetic."""
+
+    def test_add_produces_vector_binary_op(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        assert isinstance(result, VectorBinaryOp)
+        assert result.op == "+"
+        assert result.size == 3
+
+    def test_sub_produces_vector_binary_op(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x - y
+        assert isinstance(result, VectorBinaryOp)
+        assert result.op == "-"
+
+    def test_mul_scalar_produces_vector_binary_op(self):
+        x = VectorVariable("x", 3)
+        result = x * 2
+        assert isinstance(result, VectorBinaryOp)
+        assert result.op == "*"
+
+    def test_rmul_scalar_produces_vector_binary_op(self):
+        x = VectorVariable("x", 3)
+        result = 3 * x
+        assert isinstance(result, VectorBinaryOp)
+        assert result.op == "*"
+
+    def test_div_scalar_produces_vector_binary_op(self):
+        x = VectorVariable("x", 3)
+        result = x / 2
+        assert isinstance(result, VectorBinaryOp)
+        assert result.op == "/"
+
+    def test_rsub_produces_vector_binary_op(self):
+        x = VectorVariable("x", 3)
+        result = 5 - x
+        assert isinstance(result, VectorBinaryOp)
+        assert result.op == "-"
+
+    def test_rtruediv_produces_vector_binary_op(self):
+        x = VectorVariable("x", 3)
+        result = 1 / x
+        assert isinstance(result, VectorBinaryOp)
+        assert result.op == "/"
+
+    def test_neg_produces_vector_binary_op(self):
+        x = VectorVariable("x", 3)
+        result = -x
+        assert isinstance(result, VectorBinaryOp)
+        assert result.op == "*"
+
+    def test_is_subclass_of_vector_expression(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        assert isinstance(result, VectorExpression)
+
+    def test_chained_ops_produce_nested_vector_binary_ops(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y - x  # (x + y) - x
+        assert isinstance(result, VectorBinaryOp)
+        assert result.op == "-"
+        assert isinstance(result.left, VectorBinaryOp)
+
+    def test_dimension_mismatch_raises(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 4)
+        with pytest.raises(Exception):
+            _ = x + y
+
+    def test_vector_expression_add_produces_vector_binary_op(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        z = VectorVariable("z", 3)
+        result = (x + y) + z  # VectorBinaryOp + VectorVariable
+        assert isinstance(result, VectorBinaryOp)
+
+
+class TestVectorBinaryOpEvaluation:
+    """VectorBinaryOp should evaluate correctly using numpy."""
+
+    def test_add_evaluation(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3, "y[0]": 4, "y[1]": 5, "y[2]": 6}
+        assert result.evaluate(vals) == [5.0, 7.0, 9.0]
+
+    def test_sub_evaluation(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x - y
+        vals = {"x[0]": 10, "x[1]": 20, "x[2]": 30, "y[0]": 1, "y[1]": 2, "y[2]": 3}
+        assert result.evaluate(vals) == [9.0, 18.0, 27.0]
+
+    def test_scalar_mul_evaluation(self):
+        x = VectorVariable("x", 3)
+        result = x * 3
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3}
+        assert result.evaluate(vals) == [3.0, 6.0, 9.0]
+
+    def test_rsub_evaluation(self):
+        x = VectorVariable("x", 3)
+        result = 10 - x
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3}
+        assert result.evaluate(vals) == [9.0, 8.0, 7.0]
+
+    def test_rtruediv_evaluation(self):
+        x = VectorVariable("x", 3)
+        result = 12 / x
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3}
+        assert result.evaluate(vals) == [12.0, 6.0, 4.0]
+
+    def test_neg_evaluation(self):
+        x = VectorVariable("x", 3)
+        result = -x
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3}
+        assert result.evaluate(vals) == [-1.0, -2.0, -3.0]
+
+    def test_chained_evaluation(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = 2 * x + y
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3, "y[0]": 10, "y[1]": 20, "y[2]": 30}
+        assert result.evaluate(vals) == [12.0, 24.0, 36.0]
+
+
+class TestVectorBinaryOpMaterialization:
+    """_expressions should be lazily materialized only when accessed."""
+
+    def test_not_materialized_on_construction(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        assert result._materialized is None
+
+    def test_materialized_on_index_access(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        assert result._materialized is None
+        _ = result[0]  # triggers materialization
+        assert result._materialized is not None
+
+    def test_not_materialized_by_evaluate(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3, "y[0]": 4, "y[1]": 5, "y[2]": 6}
+        result.evaluate(vals)
+        assert result._materialized is None
+
+    def test_not_materialized_by_get_variables(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        _ = result.get_variables()
+        assert result._materialized is None
+
+    def test_not_materialized_by_len(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        assert len(result) == 3
+        assert result._materialized is None
+
+    def test_expressions_are_populated(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        assert len(result._expressions) == 3
+
+    def test_indexing_works(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        elem = result[0]
+        vals = {"x[0]": 1, "y[0]": 2}
+        assert elem.evaluate(vals) == 3.0
+
+    def test_iteration_works(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        elems = list(result)
+        assert len(elems) == 3
+
+    def test_get_variables(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        variables = result.get_variables()
+        assert len(variables) == 6
+
+    def test_chained_lazy(self):
+        """Chained VectorBinaryOps should all be lazy."""
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        z = x + y  # first VectorBinaryOp
+        w = z * 2  # second VectorBinaryOp wrapping first
+        assert z._materialized is None
+        assert w._materialized is None
+        # evaluate doesn't trigger either
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3, "y[0]": 4, "y[1]": 5, "y[2]": 6}
+        assert w.evaluate(vals) == [10.0, 14.0, 18.0]
+        assert z._materialized is None
+        assert w._materialized is None
+
+
+class TestVectorBinaryOpSum:
+    """sum() on VectorBinaryOp should work."""
+
+    def test_sum_evaluation(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        s = (x + y).sum()
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3, "y[0]": 4, "y[1]": 5, "y[2]": 6}
+        assert s.evaluate(vals) == 21.0
+
+    def test_sum_type(self):
+        from optyx.core.vectors import VectorExpressionSum
+
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        s = (x + y).sum()
+        assert isinstance(s, VectorExpressionSum)
+
+
+class TestVectorBinaryOpCompiler:
+    """Compiler should handle VectorBinaryOp efficiently."""
+
+    def test_dot_product_with_vector_binary_op(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        expr = (x + y).dot(x)  # dot product involving VectorBinaryOp
+        variables = list(x._variables) + list(y._variables)
+        fn = compile_expression(expr, variables)
+        vals = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        expected = np.dot([1 + 4, 2 + 5, 3 + 6], [1, 2, 3])
+        assert abs(fn(vals) - expected) < 1e-10
+
+    def test_sum_with_vector_binary_op_compile(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        expr = (x - y).sum()
+        variables = list(x._variables) + list(y._variables)
+        fn = compile_expression(expr, variables)
+        vals = np.array([10.0, 20.0, 30.0, 1.0, 2.0, 3.0])
+        assert abs(fn(vals) - 54.0) < 1e-10
+
+    def test_linear_combination_with_vector_binary_op(self):
+        from optyx.core.vectors import LinearCombination
+
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        vec_expr = x + y
+        lc = LinearCombination(np.array([1.0, 2.0, 3.0]), vec_expr)
+        variables = list(x._variables) + list(y._variables)
+        fn = compile_expression(lc, variables)
+        vals = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        # 1*(1+4) + 2*(2+5) + 3*(3+6) = 5 + 14 + 27 = 46
+        assert abs(fn(vals) - 46.0) < 1e-10
+
+
+class TestVectorBinaryOpGradient:
+    """Autodiff should work through VectorBinaryOp via materialized expressions."""
+
+    def test_gradient_of_sum(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        expr = (x + y).sum()
+        # ∂(sum(x + y))/∂x[0] = 1
+        grad = gradient(expr, x._variables[0])
+        assert grad.evaluate({}) == 1.0
+
+    def test_gradient_of_sum_wrt_y(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        expr = (x + y).sum()
+        # ∂(sum(x + y))/∂y[0] = 1
+        grad = gradient(expr, y._variables[0])
+        assert grad.evaluate({}) == 1.0
+
+    def test_gradient_of_weighted_sum(self):
+        x = VectorVariable("x", 3)
+        expr = (x * 3).sum()
+        # ∂(sum(3*x))/∂x[0] = 3
+        grad = gradient(expr, x._variables[0])
+        assert grad.evaluate({}) == 3.0
+
+    def test_gradient_of_difference_sum(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        expr = (x - y).sum()
+        # ∂(sum(x - y))/∂x[0] = 1
+        # ∂(sum(x - y))/∂y[0] = -1
+        grad_x = gradient(expr, x._variables[0])
+        grad_y = gradient(expr, y._variables[0])
+        assert grad_x.evaluate({}) == 1.0
+        assert grad_y.evaluate({}) == -1.0
+
+
+class TestVectorBinaryOpCompiledGradient:
+    """compile_gradient should produce fast vectorized gradients for VectorBinaryOp."""
+
+    def test_compiled_gradient_add_sum(self):
+        """sum(x + y): gradient w.r.t. all vars should be 1."""
+        from optyx.core.compiler import compile_gradient
+
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        expr = (x + y).sum()
+        variables = list(x._variables) + list(y._variables)
+        grad_fn = compile_gradient(expr, variables)
+        x_val = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        grad = grad_fn(x_val)
+        np.testing.assert_array_almost_equal(grad, np.ones(6))
+
+    def test_compiled_gradient_sub_sum(self):
+        """sum(x - y): gradient is [1,1,1,-1,-1,-1]."""
+        from optyx.core.compiler import compile_gradient
+
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        expr = (x - y).sum()
+        variables = list(x._variables) + list(y._variables)
+        grad_fn = compile_gradient(expr, variables)
+        x_val = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        grad = grad_fn(x_val)
+        np.testing.assert_array_almost_equal(grad, [1, 1, 1, -1, -1, -1])
+
+    def test_compiled_gradient_scalar_mul_sum(self):
+        """sum(x * 3): gradient is [3,3,3]."""
+        from optyx.core.compiler import compile_gradient
+
+        x = VectorVariable("x", 3)
+        expr = (x * 3).sum()
+        variables = list(x._variables)
+        grad_fn = compile_gradient(expr, variables)
+        x_val = np.array([1.0, 2.0, 3.0])
+        grad = grad_fn(x_val)
+        np.testing.assert_array_almost_equal(grad, [3.0, 3.0, 3.0])
+
+    def test_compiled_gradient_neg_sum(self):
+        """sum(-x): gradient is [-1,-1,-1]."""
+        from optyx.core.compiler import compile_gradient
+
+        x = VectorVariable("x", 3)
+        expr = (-x).sum()
+        variables = list(x._variables)
+        grad_fn = compile_gradient(expr, variables)
+        x_val = np.array([1.0, 2.0, 3.0])
+        grad = grad_fn(x_val)
+        np.testing.assert_array_almost_equal(grad, [-1.0, -1.0, -1.0])
+
+    def test_compiled_gradient_scalar_div_sum(self):
+        """sum(x / 2): gradient is [0.5, 0.5, 0.5]."""
+        from optyx.core.compiler import compile_gradient
+
+        x = VectorVariable("x", 3)
+        expr = (x / 2).sum()
+        variables = list(x._variables)
+        grad_fn = compile_gradient(expr, variables)
+        x_val = np.array([1.0, 2.0, 3.0])
+        grad = grad_fn(x_val)
+        np.testing.assert_array_almost_equal(grad, [0.5, 0.5, 0.5])
+
+    def test_compiled_gradient_vec_mul_sum(self):
+        """sum(x * y): ∂/∂x_i = y_i, ∂/∂y_i = x_i."""
+        from optyx.core.compiler import compile_gradient
+
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        expr = (x * y).sum()
+        variables = list(x._variables) + list(y._variables)
+        grad_fn = compile_gradient(expr, variables)
+        x_val = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        grad = grad_fn(x_val)
+        # ∂/∂x = [y0, y1, y2] = [4, 5, 6], ∂/∂y = [x0, x1, x2] = [1, 2, 3]
+        np.testing.assert_array_almost_equal(grad, [4, 5, 6, 1, 2, 3])
+
+    def test_compiled_gradient_no_materialization(self):
+        """Compiled gradient should not trigger _expressions materialization."""
+        from optyx.core.compiler import compile_gradient
+
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        z = x + y
+        expr = z.sum()
+        variables = list(x._variables) + list(y._variables)
+        grad_fn = compile_gradient(expr, variables)
+        # Check: the VectorBinaryOp was never materialized
+        assert z._materialized is None
+        # Gradient computation also shouldn't materialize
+        x_val = np.array([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+        _ = grad_fn(x_val)
+        assert z._materialized is None
+
+
+class TestVectorBinaryOpConstraints:
+    """Constraints on VectorBinaryOp should work."""
+
+    def test_le_constraints(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        constraints = (x + y) <= 10
+        assert len(constraints) == 3
+
+    def test_ge_constraints(self):
+        x = VectorVariable("x", 3)
+        constraints = (x * 2) >= 0
+        assert len(constraints) == 3
+
+
+class TestVectorBinaryOpSolve:
+    """End-to-end solve with VectorBinaryOp in the problem."""
+
+    def test_minimize_with_vector_binary_op(self):
+        """min sum((x - target)^2) should recover target."""
+        x = VectorVariable("x", 3)
+        target = np.array([1.0, 2.0, 3.0])
+        diff = x - target  # VectorBinaryOp
+        prob = Problem().minimize(diff.dot(diff))
+        sol = prob.solve()
+        assert sol.is_optimal
+        for i, t in enumerate(target):
+            assert abs(sol[x._variables[i]] - t) < 1e-4
+
+    def test_minimize_sum_of_vector_binary_op(self):
+        """min sum(x + y) s.t. x >= 0, y >= 0, sum(x) >= 3."""
+        x = VectorVariable("x", 3, lb=0)
+        y = VectorVariable("y", 3, lb=0)
+        expr = (x + y).sum()
+        prob = Problem().minimize(expr)
+        prob.subject_to(x._variables[0] >= 3)
+        sol = prob.solve()
+        assert sol.is_optimal
+        # y should be 0, x[0] = 3, x[1] = x[2] = 0
+        assert sol[x._variables[0]] >= 2.99
+
+    def test_repr(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        result = x + y
+        assert "VectorBinaryOp" in repr(result)
+        assert "+" in repr(result)
+        assert "3" in repr(result)
+
+
+class TestVectorExpressionSumEvaluateNoMaterialization:
+    """VectorExpressionSum.evaluate() should not trigger materialization."""
+
+    def test_evaluate_no_materialization(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        z = x + y
+        s = z.sum()
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3, "y[0]": 4, "y[1]": 5, "y[2]": 6}
+        result = s.evaluate(vals)
+        assert result == 21.0
+        assert z._materialized is None
+
+    def test_evaluate_sub_no_materialization(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        z = x - y
+        s = z.sum()
+        vals = {"x[0]": 10, "x[1]": 20, "x[2]": 30, "y[0]": 1, "y[1]": 2, "y[2]": 3}
+        result = s.evaluate(vals)
+        assert result == 54.0
+        assert z._materialized is None
+
+    def test_evaluate_scalar_mul_no_materialization(self):
+        x = VectorVariable("x", 3)
+        z = x * 5
+        s = z.sum()
+        vals = {"x[0]": 1, "x[1]": 2, "x[2]": 3}
+        result = s.evaluate(vals)
+        assert result == 30.0
+        assert z._materialized is None
+
+
+class TestVectorBinaryOpGradientRule:
+    """@register_gradient(VectorBinaryOp) should provide O(1) gradients."""
+
+    def test_gradient_rule_registered(self):
+        from optyx.core.autodiff import has_gradient_rule
+
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        z = x + y
+        assert has_gradient_rule(z)
+
+    def test_gradient_add_no_materialization(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        z = x + y
+        expr = z.sum()
+        g = gradient(expr, x._variables[0])
+        assert g.evaluate({}) == 1.0
+        assert z._materialized is None
+
+    def test_gradient_sub_no_materialization(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        z = x - y
+        expr = z.sum()
+        gx = gradient(expr, x._variables[0])
+        gy = gradient(expr, y._variables[0])
+        assert gx.evaluate({}) == 1.0
+        assert gy.evaluate({}) == -1.0
+        assert z._materialized is None
+
+    def test_gradient_scalar_mul_no_materialization(self):
+        x = VectorVariable("x", 3)
+        z = x * 7
+        expr = z.sum()
+        g = gradient(expr, x._variables[0])
+        assert g.evaluate({}) == 7.0
+        assert z._materialized is None
+
+    def test_gradient_scalar_div_no_materialization(self):
+        x = VectorVariable("x", 3)
+        z = x / 4
+        expr = z.sum()
+        g = gradient(expr, x._variables[0])
+        assert g.evaluate({}) == 0.25
+        assert z._materialized is None
+
+    def test_gradient_unrelated_var_is_zero(self):
+        x = VectorVariable("x", 3)
+        y = VectorVariable("y", 3)
+        z = x + x
+        expr = z.sum()
+        g = gradient(expr, y._variables[0])
+        assert g.evaluate({}) == 0.0
+        assert z._materialized is None
diff --git a/tests/test_vector_matrix_polish.py b/tests/test_vector_matrix_polish.py
new file mode 100644
index 0000000..8257c60
--- /dev/null
+++ b/tests/test_vector_matrix_polish.py
@@ -0,0 +1,404 @@
+"""Tests for vector/matrix polishing features (Issue #99).
+
+Tests cover:
+1. MatrixVariable.diagonal(offset=k) — main, super, sub-diagonals
+2. Per-element bounds arrays on VectorVariable constructor
+3. Fancy indexing x[[0, 2]] on VectorVariable
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from optyx import Problem, VectorVariable
+from optyx.core.matrices import MatrixVariable
+
+
+# ============================================================
+# 1. MatrixVariable.diagonal(offset=k)
+# ============================================================
+
+
+class TestMatrixDiagonal:
+    """Tests for MatrixVariable.diagonal() with offset."""
+
+    def test_main_diagonal(self):
+        """diagonal() with default offset returns main diagonal."""
+        A = MatrixVariable("A", 3, 3)
+        d = A.diagonal()
+        assert isinstance(d, VectorVariable)
+        assert len(d) == 3
+        assert d[0] is A[0, 0]
+        assert d[1] is A[1, 1]
+        assert d[2] is A[2, 2]
+
+    def test_main_diagonal_explicit_zero(self):
+        """diagonal(0) same as diagonal()."""
+        A = MatrixVariable("A", 3, 3)
+        d = A.diagonal(0)
+        assert len(d) == 3
+        assert d[0] is A[0, 0]
+        assert d[1] is A[1, 1]
+        assert d[2] is A[2, 2]
+
+    def test_super_diagonal(self):
+        """diagonal(1) returns first super-diagonal."""
+        A = MatrixVariable("A", 3, 3)
+        d = A.diagonal(1)
+        assert len(d) == 2
+        assert d[0] is A[0, 1]
+        assert d[1] is A[1, 2]
+
+    def test_sub_diagonal(self):
+        """diagonal(-1) returns first sub-diagonal."""
+        A = MatrixVariable("A", 3, 3)
+        d = A.diagonal(-1)
+        assert len(d) == 2
+        assert d[0] is A[1, 0]
+        assert d[1] is A[2, 1]
+
+    def test_super_diagonal_offset_2(self):
+        """diagonal(2) on 4x4 returns 2 elements."""
+        A = MatrixVariable("A", 4, 4)
+        d = A.diagonal(2)
+        assert len(d) == 2
+        assert d[0] is A[0, 2]
+        assert d[1] is A[1, 3]
+
+    def test_sub_diagonal_offset_minus2(self):
+        """diagonal(-2) on 4x4 returns 2 elements."""
+        A = MatrixVariable("A", 4, 4)
+        d = A.diagonal(-2)
+        assert len(d) == 2
+        assert d[0] is A[2, 0]
+        assert d[1] is A[3, 1]
+
+    def test_single_element_diagonal(self):
+        """diagonal with max offset returns single element."""
+        A = MatrixVariable("A", 3, 3)
+        d = A.diagonal(2)
+        assert len(d) == 1
+        assert d[0] is A[0, 2]
+
+    def test_rectangular_main_diagonal(self):
+        """diagonal() on non-square matrix."""
+        A = MatrixVariable("A", 2, 4)
+        d = A.diagonal()
+        assert len(d) == 2  # min(2, 4)
+        assert d[0] is A[0, 0]
+        assert d[1] is A[1, 1]
+
+    def test_rectangular_tall_diagonal(self):
+        """diagonal() on tall matrix."""
+        A = MatrixVariable("A", 4, 2)
+        d = A.diagonal()
+        assert len(d) == 2  # min(4, 2)
+        assert d[0] is A[0, 0]
+        assert d[1] is A[1, 1]
+
+    def test_out_of_bounds_offset_raises(self):
+        """diagonal with too-large offset raises error."""
+        A = MatrixVariable("A", 3, 3)
+        with pytest.raises(Exception):
+            A.diagonal(3)
+
+    def test_out_of_bounds_negative_offset_raises(self):
+        """diagonal with too-negative offset raises error."""
+        A = MatrixVariable("A", 3, 3)
+        with pytest.raises(Exception):
+            A.diagonal(-3)
+
+    def test_diagonal_in_constraint(self):
+        """diagonal can be used in optimization constraints."""
+        A = MatrixVariable("A", 2, 2, lb=0, ub=10)
+        prob = Problem()
+        diag = A.diagonal()
+        prob.minimize(diag.sum())
+        prob.subject_to(diag[0] >= 1)
+        prob.subject_to(diag[1] >= 2)
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol[A[0, 0]] - 1.0) < 1e-6
+        assert abs(sol[A[1, 1]] - 2.0) < 1e-6
+
+    def test_symmetric_diagonal(self):
+        """diagonal works on symmetric matrices."""
+        A = MatrixVariable("A", 3, 3, symmetric=True)
+        d = A.diagonal()
+        assert len(d) == 3
+
+
+# ============================================================
+# 2. Per-Element Bounds Arrays on VectorVariable
+# ============================================================
+
+
+class TestPerElementBounds:
+    """Tests for VectorVariable with per-element lb/ub arrays."""
+
+    def test_numpy_array_bounds(self):
+        """Accept numpy arrays for lb and ub."""
+        lb = np.array([0.0, 0.5, 0.2])
+        ub = np.array([1.0, 2.0, 1.5])
+        x = VectorVariable("x", 3, lb=lb, ub=ub)
+        assert x[0].lb == 0.0
+        assert x[0].ub == 1.0
+        assert x[1].lb == 0.5
+        assert x[1].ub == 2.0
+        assert x[2].lb == 0.2
+        assert x[2].ub == 1.5
+
+    def test_list_bounds(self):
+        """Accept plain lists for lb and ub."""
+        x = VectorVariable("x", 3, lb=[1.0, 2.0, 3.0], ub=[10.0, 20.0, 30.0])
+        assert x[0].lb == 1.0
+        assert x[1].lb == 2.0
+        assert x[2].lb == 3.0
+        assert x[0].ub == 10.0
+        assert x[1].ub == 20.0
+        assert x[2].ub == 30.0
+
+    def test_scalar_bounds_still_work(self):
+        """Scalar bounds apply to all elements."""
+        x = VectorVariable("x", 3, lb=0.0, ub=1.0)
+        for i in range(3):
+            assert x[i].lb == 0.0
+            assert x[i].ub == 1.0
+
+    def test_none_bounds_still_work(self):
+        """None bounds leave variables unbounded."""
+        x = VectorVariable("x", 3)
+        for i in range(3):
+            assert x[i].lb is None
+            assert x[i].ub is None
+
+    def test_mixed_scalar_and_array_bounds(self):
+        """Scalar lb with array ub, and vice versa."""
+        x = VectorVariable("x", 3, lb=0.0, ub=[10.0, 20.0, 30.0])
+        assert x[0].lb == 0.0
+        assert x[0].ub == 10.0
+        assert x[1].lb == 0.0
+        assert x[1].ub == 20.0
+        assert x[2].lb == 0.0
+        assert x[2].ub == 30.0
+
+    def test_wrong_size_bounds_raises(self):
+        """Mismatched bounds array size raises error."""
+        with pytest.raises(Exception):
+            VectorVariable("x", 3, lb=[0.0, 1.0])  # size 2 != 3
+
+    def test_wrong_size_ub_raises(self):
+        """Mismatched ub array size raises error."""
+        with pytest.raises(Exception):
+            VectorVariable("x", 3, ub=np.array([1.0, 2.0, 3.0, 4.0]))  # size 4 != 3
+
+    def test_per_element_bounds_solve(self):
+        """Per-element bounds are respected by the solver."""
+        lb = np.array([1.0, 2.0, 3.0])
+        ub = np.array([10.0, 20.0, 30.0])
+        x = VectorVariable("x", 3, lb=lb, ub=ub)
+
+        prob = Problem()
+        prob.minimize(x.sum())
+        sol = prob.solve()
+
+        assert sol.is_optimal
+        # Minimum should be at lower bounds
+        assert abs(sol[x[0]] - 1.0) < 1e-6
+        assert abs(sol[x[1]] - 2.0) < 1e-6
+        assert abs(sol[x[2]] - 3.0) < 1e-6
+
+    def test_per_element_bounds_maximize(self):
+        """Per-element bounds work with maximize."""
+        ub = np.array([5.0, 10.0, 15.0])
+        x = VectorVariable("x", 3, lb=0.0, ub=ub)
+
+        prob = Problem()
+        prob.maximize(x.sum())
+        sol = prob.solve()
+
+        assert sol.is_optimal
+        assert abs(sol[x[0]] - 5.0) < 1e-6
+        assert abs(sol[x[1]] - 10.0) < 1e-6
+        assert abs(sol[x[2]] - 15.0) < 1e-6
+
+    def test_per_element_bounds_nlp(self):
+        """Per-element bounds in NLP context."""
+        lb = np.array([0.0, -1.0])
+        ub = np.array([2.0, 3.0])
+        x = VectorVariable("x", 2, lb=lb, ub=ub)
+
+        prob = Problem()
+        prob.minimize(x.dot(x))  # min x0^2 + x1^2
+        sol = prob.solve()
+
+        assert sol.is_optimal
+        # Minimum of sum of squares with these bounds is at (0, 0)
+        assert abs(sol[x[0]] - 0.0) < 1e-4
+        assert abs(sol[x[1]] - 0.0) < 1e-4
+
+
+# ============================================================
+# 3. Fancy Indexing on VectorVariable
+# ============================================================
+
+
+class TestFancyIndexing:
+    """Tests for fancy indexing on VectorVariable."""
+
+    def test_list_indexing(self):
+        """x[[0, 2]] returns VectorVariable with those elements."""
+        x = VectorVariable("x", 5, lb=0, ub=10)
+        sub = x[[0, 2]]
+        assert isinstance(sub, VectorVariable)
+        assert len(sub) == 2
+        assert sub[0] is x[0]
+        assert sub[1] is x[2]
+
+    def test_list_indexing_order(self):
+        """Fancy indexing preserves the requested order."""
+        x = VectorVariable("x", 5)
+        sub = x[[4, 1, 3]]
+        assert len(sub) == 3
+        assert sub[0] is x[4]
+        assert sub[1] is x[1]
+        assert sub[2] is x[3]
+
+    def test_numpy_array_indexing(self):
+        """x[np.array([0, 2, 4])] works."""
+        x = VectorVariable("x", 5)
+        sub = x[np.array([0, 2, 4])]
+        assert isinstance(sub, VectorVariable)
+        assert len(sub) == 3
+        assert sub[0] is x[0]
+        assert sub[1] is x[2]
+        assert sub[2] is x[4]
+
+    def test_tuple_indexing(self):
+        """x[(0, 2)] works as fancy indexing."""
+        x = VectorVariable("x", 5)
+        sub = x[(0, 2)]
+        assert isinstance(sub, VectorVariable)
+        assert len(sub) == 2
+
+    def test_boolean_indexing(self):
+        """Boolean array indexing works."""
+        x = VectorVariable("x", 4)
+        mask = np.array([True, False, True, False])
+        sub = x[mask]
+        assert isinstance(sub, VectorVariable)
+        assert len(sub) == 2
+        assert sub[0] is x[0]
+        assert sub[1] is x[2]
+
+    def test_negative_fancy_indexing(self):
+        """Negative indices work in fancy indexing."""
+        x = VectorVariable("x", 5)
+        sub = x[[-1, -3]]
+        assert len(sub) == 2
+        assert sub[0] is x[4]
+        assert sub[1] is x[2]
+
+    def test_single_element_fancy(self):
+        """Fancy index with single element returns VectorVariable."""
+        x = VectorVariable("x", 5)
+        sub = x[[3]]
+        assert isinstance(sub, VectorVariable)
+        assert len(sub) == 1
+        assert sub[0] is x[3]
+
+    def test_empty_fancy_raises(self):
+        """Empty fancy index raises error."""
+        x = VectorVariable("x", 5)
+        with pytest.raises(IndexError):
+            x[[]]
+
+    def test_out_of_range_fancy_raises(self):
+        """Out-of-range fancy index raises error."""
+        x = VectorVariable("x", 5)
+        with pytest.raises(IndexError):
+            x[[0, 10]]
+
+    def test_boolean_wrong_size_raises(self):
+        """Boolean mask with wrong size raises error."""
+        x = VectorVariable("x", 4)
+        with pytest.raises(IndexError):
+            x[np.array([True, False])]
+
+    def test_fancy_indexing_in_optimization(self):
+        """Fancy-indexed sub-vector can be used in constraints."""
+        x = VectorVariable("x", 5, lb=0, ub=10)
+        prob = Problem()
+        prob.minimize(x.sum())
+
+        # Constrain only elements 0, 2, 4
+        selected = x[[0, 2, 4]]
+        for i in range(len(selected)):
+            prob.subject_to(selected[i] >= 3)
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        # x[0], x[2], x[4] >= 3, others at lb=0
+        assert abs(sol[x[0]] - 3.0) < 1e-6
+        assert abs(sol[x[1]] - 0.0) < 1e-6
+        assert abs(sol[x[2]] - 3.0) < 1e-6
+        assert abs(sol[x[3]] - 0.0) < 1e-6
+        assert abs(sol[x[4]] - 3.0) < 1e-6
+
+    def test_fancy_indexing_with_per_element_bounds(self):
+        """Fancy indexing combined with per-element bounds."""
+        lb = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
+        x = VectorVariable("x", 5, lb=lb, ub=100.0)
+
+        sub = x[[1, 3]]
+        assert sub[0] is x[1]
+        assert sub[1] is x[3]
+
+        # Each element retains its per-element bound
+        assert sub[0].lb == 2.0
+        assert sub[1].lb == 4.0
+
+    def test_fancy_indexing_nlp(self):
+        """Fancy indexing works in NLP solve context."""
+        x = VectorVariable("x", 4, lb=-10, ub=10)
+        prob = Problem()
+
+        # Only penalize elements 0 and 2
+        sub = x[[0, 2]]
+        prob.minimize(sub.dot(sub))
+
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol[x[0]]) < 1e-4
+        assert abs(sol[x[2]]) < 1e-4
+
+
+# ============================================================
+# 4. Integration: combining features
+# ============================================================
+
+
+class TestCombinedFeatures:
+    """Tests combining multiple features together."""
+
+    def test_diagonal_with_per_element_bounds(self):
+        """MatrixVariable diagonal works when underlying vars have bounds."""
+        A = MatrixVariable("A", 3, 3, lb=0, ub=10)
+        d = A.diagonal()
+        prob = Problem()
+        prob.minimize(d.sum())
+        prob.subject_to(d[0] >= 1)
+        sol = prob.solve()
+        assert sol.is_optimal
+        assert abs(sol[A[0, 0]] - 1.0) < 1e-6
+        assert abs(sol[A[1, 1]] - 0.0) < 1e-6
+        assert abs(sol[A[2, 2]] - 0.0) < 1e-6
+
+    def test_diagonal_fancy_index(self):
+        """Can fancy-index from a diagonal."""
+        A = MatrixVariable("A", 4, 4)
+        d = A.diagonal()
+        sub = d[[0, 3]]
+        assert sub[0] is A[0, 0]
+        assert sub[1] is A[3, 3]
diff --git a/tests/test_vectors.py b/tests/test_vectors.py
index 993949c..e4236a4 100644
--- a/tests/test_vectors.py
+++ b/tests/test_vectors.py
@@ -22,6 +22,7 @@
     norm,
 )
 from optyx.core.expressions import Variable
+from optyx.problem import Problem
 
 
 class TestVectorVariableCreation:
@@ -824,6 +825,69 @@ def test_linear_combination_repr(self):
         assert "3 coeffs" in repr(lc)
 
 
+class TestVectorSlicing:
+    """Tests for VectorVariable slicing and vectorized expressions."""
+
+    def test_slice_returns_vector_variable(self):
+        x = VectorVariable("x", 5)
+        s = x[1:4]
+        assert isinstance(s, VectorVariable)
+        assert s.size == 3
+
+    def test_slice_negative_index(self):
+        x = VectorVariable("x", 5)
+        head = x[:-1]
+        tail = x[1:]
+        assert head.size == 4
+        assert tail.size == 4
+
+    def test_slice_arithmetic(self):
+        x = VectorVariable("x", 4)
+        head = x[:-1]
+        tail = x[1:]
+        diff = tail - head
+        vals = diff.evaluate({"x[0]": 1.0, "x[1]": 3.0, "x[2]": 6.0, "x[3]": 10.0})
+        np.testing.assert_array_almost_equal(vals, [2.0, 3.0, 4.0])
+
+    def test_vectorized_rosenbrock_solves(self):
+        """Vectorized Rosenbrock via slicing should converge to global min."""
+        n = 5
+        v = VectorVariable("v", n, lb=-5, ub=5)
+        prob = Problem("rosenbrock_vec")
+        v_head = v[:-1]
+        v_tail = v[1:]
+        obj = ((1 - v_head) ** 2 + 100 * (v_tail - v_head**2) ** 2).sum()
+        prob.minimize(obj)
+        sol = prob.solve(method="SLSQP")
+        assert sol.status.value == "optimal"
+        assert sol.objective_value < 1e-6
+        # All variables should be near 1.0
+        for var in v:
+            assert abs(sol.values[var.name] - 1.0) < 0.01
+
+    def test_vectorized_matches_loop(self):
+        """Vectorized and loop-based Rosenbrock should give same result."""
+        n = 4
+        v = VectorVariable("v", n, lb=-5, ub=5)
+
+        # Loop
+        p1 = Problem()
+        obj1 = sum(
+            (1 - v[i]) ** 2 + 100 * (v[i + 1] - v[i] ** 2) ** 2 for i in range(n - 1)
+        )
+        p1.minimize(obj1)
+        s1 = p1.solve(method="SLSQP")
+
+        # Vectorized
+        p2 = Problem()
+        head, tail = v[:-1], v[1:]
+        obj2 = ((1 - head) ** 2 + 100 * (tail - head**2) ** 2).sum()
+        p2.minimize(obj2)
+        s2 = p2.solve(method="SLSQP")
+
+        assert abs(s1.objective_value - s2.objective_value) < 1e-6
+
+
 class TestNumpyIntegration:
     """Tests for NumPy integration with VectorVariable."""
 
diff --git a/uv.lock b/uv.lock
index cf1bf94..aaed694 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2018,7 +2018,7 @@ wheels = [
 
 [[package]]
 name = "optyx"
-version = "1.2.4"
+version = "1.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
@@ -2068,7 +2068,7 @@ dev = [
     { name = "matplotlib", specifier = ">=3.10.0" },
     { name = "pre-commit", specifier = ">=4.5.1" },
     { name = "pyomo", specifier = ">=6.7.0" },
-    { name = "pyright", specifier = ">=1.1.407" },
+    { name = "pyright", specifier = ">=1.1.408" },
     { name = "pytest", specifier = ">=9.0.2" },
     { name = "pytest-cov", specifier = ">=7.0.0" },
     { name = "pyyaml" },
@@ -2588,15 +2588,15 @@ wheels = [
 
 [[package]]
 name = "pyright"
-version = "1.1.407"
+version = "1.1.408"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "nodeenv" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a6/1b/0aa08ee42948b61745ac5b5b5ccaec4669e8884b53d31c8ec20b2fcd6b6f/pyright-1.1.407.tar.gz", hash = "sha256:099674dba5c10489832d4a4b2d302636152a9a42d317986c38474c76fe562262", size = 4122872, upload-time = "2025-10-24T23:17:15.145Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/b2/5db700e52554b8f025faa9c3c624c59f1f6c8841ba81ab97641b54322f16/pyright-1.1.408.tar.gz", hash = "sha256:f28f2321f96852fa50b5829ea492f6adb0e6954568d1caa3f3af3a5f555eb684", size = 4400578, upload-time = "2026-01-08T08:07:38.795Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/dc/93/b69052907d032b00c40cb656d21438ec00b3a471733de137a3f65a49a0a0/pyright-1.1.407-py3-none-any.whl", hash = "sha256:6dd419f54fcc13f03b52285796d65e639786373f433e243f8b94cf93a7444d21", size = 5997008, upload-time = "2025-10-24T23:17:13.159Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/82/a2c93e32800940d9573fb28c346772a14778b84ba7524e691b324620ab89/pyright-1.1.408-py3-none-any.whl", hash = "sha256:090b32865f4fdb1e0e6cd82bf5618480d48eecd2eb2e70f960982a3d9a4c17c1", size = 6399144, upload-time = "2026-01-08T08:07:37.082Z" },
 ]
 
 [[package]]