feat: implement support for solving linear inequality systems and add corresponding tests

Author: arnog

CHANGELOG.md

@@ -76,6 +76,26 @@
   // → { x: 36/7, y: -10/7 }
   ```
 
+- **Linear Inequality Systems**: The `solve()` method now handles systems of
+  linear inequalities in 2 variables, returning the vertices of the feasible
+  region (convex polygon). Supports all inequality operators: `<`, `<=`, `>`,
+  `>=`.
+
+  ```javascript
+  // Triangle: x >= 0, y >= 0, x + y <= 10
+  const e = ce.parse('\\begin{cases}x\\geq 0\\\\y\\geq 0\\\\x+y\\leq 10\\end{cases}');
+  const result = e.solve(['x', 'y']);
+  // → [{ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 0, y: 10 }]
+
+  // Square: 0 <= x <= 5, 0 <= y <= 5
+  const square = ce.parse('\\begin{cases}x\\geq 0\\\\x\\leq 5\\\\y\\geq 0\\\\y\\leq 5\\end{cases}');
+  square.solve(['x', 'y']);
+  // → [{ x: 0, y: 0 }, { x: 5, y: 0 }, { x: 5, y: 5 }, { x: 0, y: 5 }]
+  ```
+
+  Vertices are returned in counterclockwise convex hull order. Returns `null` for
+  infeasible systems or non-linear constraints.
+
 - **Extended Sqrt Equation Solving**: The equation solver now handles sqrt
   equations of the form `√(f(x)) = g(x)` by squaring both sides and solving
   the resulting polynomial. Extraneous roots are automatically filtered.

requirements/DONE.md

@@ -1693,3 +1693,57 @@ e3.solve(['x', 'y']);  // → null (discriminant < 0)
 - `test/compute-engine/solve.test.ts` - Added 8 new tests for non-linear systems
 - Updated documentation in CHANGELOG.md, doc/changelog.md, and
   doc/17-guide-linear-algebra.md
+
+---
+
+### 30. Linear Inequality Systems ✅
+
+**IMPLEMENTED:** The `solve()` method now handles systems of linear inequalities
+in 2 variables, returning the vertices of the feasible region (convex polygon).
+
+**Supported inequality operators:**
+
+- `<` (Less), `<=` (LessEqual), `>` (Greater), `>=` (GreaterEqual)
+
+**Examples that now work:**
+
+```typescript
+// Triangle: x >= 0, y >= 0, x + y <= 10
+const e = ce.parse('\\begin{cases}x\\geq 0\\\\y\\geq 0\\\\x+y\\leq 10\\end{cases}');
+e.solve(['x', 'y']);
+// → [{ x: 0, y: 0 }, { x: 10, y: 0 }, { x: 0, y: 10 }]
+
+// Square: 0 <= x <= 5, 0 <= y <= 5
+const square = ce.parse('\\begin{cases}x\\geq 0\\\\x\\leq 5\\\\y\\geq 0\\\\y\\leq 5\\end{cases}');
+square.solve(['x', 'y']);
+// → [{ x: 0, y: 0 }, { x: 5, y: 0 }, { x: 5, y: 5 }, { x: 0, y: 5 }]
+
+// Pentagon with multiple constraints
+const pentagon = ce.parse('\\begin{cases}x\\geq 0\\\\y\\geq 0\\\\x\\leq 4\\\\y\\leq 4\\\\x+y\\leq 6\\end{cases}');
+pentagon.solve(['x', 'y']);
+// → 5 vertices in counterclockwise order
+```
+
+**Algorithm:**
+
+1. Extract linear constraints from each inequality (normalize to `ax + by + c <= 0`)
+2. Find all pairwise intersections of constraint boundary lines
+3. Filter to vertices that satisfy all original constraints
+4. Order vertices in counterclockwise convex hull order
+5. Return as array of coordinate objects
+
+**Limitations:**
+
+- Only supports 2-variable systems
+- Returns `null` for infeasible regions (no valid vertices)
+- Returns `null` for non-linear constraints
+
+**Files modified:**
+
+- `src/compute-engine/boxed-expression/solve-linear-system.ts` - Added
+  `solveLinearInequalitySystem()` and supporting functions (`extractLinearConstraint()`,
+  `findLineIntersection()`, `satisfiesConstraint()`, `orderConvexHull()`)
+- `src/compute-engine/boxed-expression/boxed-function.ts` - Updated `solve()` to
+  detect and dispatch to inequality solver
+- `test/compute-engine/solve.test.ts` - Added 8 new tests for inequality systems
+- `doc/17-guide-linear-algebra.md` - Added documentation for linear inequality systems

requirements/TODO.md

@@ -485,43 +485,9 @@ ce.diagnoseSystem(equations, variables);
 
 ---
 
-### 30. Linear Inequality Systems
+### ~~30. Linear Inequality Systems~~ ✅ COMPLETED
 
-**Problem:** No support for systems of linear inequalities, which define feasible
-regions rather than point solutions.
-
-**Example:**
-
-```typescript
-const e = ce.parse('\\begin{cases}x+y\\leq 10\\\\x\\geq 0\\\\y\\geq 0\\end{cases}');
-e.solve(['x', 'y']);  // → currently null or error
-```
-
-**Possible return formats:**
-
-1. **Vertices of feasible region:** `[(0,0), (10,0), (0,10)]`
-2. **Parametric description:** `{ x: [0, 10], y: [0, 10-x] }`
-3. **Constraint set:** Keep as symbolic representation
-
-**Use cases:**
-
-- Linear programming feasibility
-- Constraint satisfaction
-- Geometric computations (polygon vertices)
-
-**Algorithm (2D vertex enumeration):**
-
-1. Convert inequalities to equalities (boundary lines)
-2. Find all pairwise intersections
-3. Filter to points satisfying all inequalities
-4. Order vertices (convex hull)
-
-**Complexity:** This is significantly more complex than equality systems. May
-want to start with 2-variable case only.
-
-**Files:**
-
-- `src/compute-engine/boxed-expression/solve-linear-system.ts` (or new file)
+See `requirements/DONE.md` for implementation details.
 
 ---
 

src/compute-engine/boxed-expression/boxed-function.ts

@@ -39,6 +39,7 @@ import { findUnivariateRoots } from './solve';
 import {
   solveLinearSystem,
   solvePolynomialSystem,
+  solveLinearInequalitySystem,
 } from './solve-linear-system';
 import { replace } from './rules';
 import { negate } from './negate';
@@ -927,6 +928,19 @@ export class BoxedFunction extends _BoxedExpression {
         const polyResult = solvePolynomialSystem([...equations], varNames);
         if (polyResult) return polyResult;
       }
+
+      // Check for inequality systems (Less, LessEqual, Greater, GreaterEqual)
+      const inequalityOps = ['Less', 'LessEqual', 'Greater', 'GreaterEqual'];
+      if (
+        equations &&
+        equations.every((eq) => inequalityOps.includes(eq.operator ?? ''))
+      ) {
+        const inequalityResult = solveLinearInequalitySystem(
+          [...equations],
+          varNames
+        );
+        if (inequalityResult) return inequalityResult;
+      }
     }
 
     // Existing univariate solving