Refactor interval bounds handling and enhance expression parsing

- Updated `assume.ts` to use `lower` and `upper` properties instead of `lowerBound` and `upperBound` for consistency in bounds representation.
- Introduced `extractIntervalBounds` function in `inequality-bounds.ts` to extract interval bounds from expressions, supporting various comparison forms and conditions.
- Enhanced `_BoxedExpression` class with a `getInterval` method to retrieve bounds for a specified symbol.
- Modified `compare.ts` to align with the new bounds structure and ensure correct comparisons.
- Updated `engine-assumptions.ts` to reflect changes in bounds retrieval.
- Adjusted LaTeX syntax definitions to accommodate new parsing rules for compact piecewise expressions.
- Added tests for interval extraction and compact piecewise parsing to ensure functionality and correctness.

Author: arnog

CHANGELOG.md

@@ -112,11 +112,44 @@
   `Less`/`LessEqual` operator — the signed-function semantics are preserved
   through the normalization.
 
+- **`BoxedExpression.getInterval(symbol)`** — new method for extracting
+  domain bounds from restriction expressions. Returns `IntervalBounds`
+  with `lower`/`upper`/`lowerStrict`/`upperStrict` for `When(e, cond)`,
+  `And(c1, c2, …)`, and bare comparison expressions (`Less`, `LessEqual`,
+  `Greater`, `GreaterEqual`); returns `undefined` for unsupported shapes.
+  Useful for 2D-plot domain derivation (e.g. clipping
+  `y = f(x)\{0 < x < 5\}` to `[0, 5]`). Also handles the
+  `Multiply(f, When(…))` parse shape produced by trailing
+  restriction-brace syntax. Exported alongside the existing
+  `getInequalityBoundsFromAssumptions` helper in `inequality-bounds.ts`.
+  Added `IntervalBounds` type to the public type surface.
+
+- **Compact Desmos piecewise `\{cond_1 : val_1, …, default\}`** — now
+  parses to `Which(c_1, v_1, c_2, v_2, …, True, default)`, the same head
+  CE produces for `\begin{cases}…\end{cases}`. Disambiguates from
+  set-builder `\{x : type\}`: if the LHS of the top-level `Colon` has a
+  comparison/boolean head (`Less`/`Greater`/`Equal`/`And`/`Or`/`Not`/…),
+  it's a piecewise branch; otherwise it's set-builder. Normal set
+  literals (`\{1, 2, 3\}`) and set-builder via `\mid` are unchanged.
+  - **Parser change**: `Colon` precedence lowered from 250 to 240
+    (below comparison operators) so `cond : val` parses as
+    `Colon(cond, val)` instead of binding the colon tighter than the
+    comparison. Function type annotations (`f : A \to B` where `\to`
+    is at 270) and set-builder via `\mid` (`Divides` at 160)
+    continue to parse correctly. Full test suite confirmed zero
+    regressions from the precedence change.
+
 #### Improved
 
 - **`parseTrig` Arctan2 handling** — the 2-arg `\arctan` lowering uses a
   tighter, single-branch form instead of an `effectiveFn` intermediate.
 
+- **`When` evaluator description** — expanded to document the masking
+  rule (`When(e, False) → Undefined`), stacked-restriction
+  canonicalization (`When(When(e, c1), c2) → When(e, And(c1, c2))`),
+  and ternary compilation behavior. No behavioral change — the rules
+  were already implemented; only the description was incomplete.
+
 #### Known issues
 
 - **JS `Loop` compile produces `undefined`** — the imperative `for`-loop IIFE

docs/plans/2026-05-22-058-a2-restrictions.md

@@ -312,9 +312,9 @@ function assumeInequality(proposition: Expression): AssumeResult {
           // We're asserting symbol > k or symbol >= k
           const isStrict = effectiveOp === 'greater';
 
-          if (bounds.lowerBound !== undefined) {
-            const lowerVal = isNumber(bounds.lowerBound)
-              ? bounds.lowerBound.numericValue
+          if (bounds.lower !== undefined) {
+            const lowerVal = isNumber(bounds.lower)
+              ? bounds.lower.numericValue
               : undefined;
             if (typeof lowerVal === 'number' && isFinite(lowerVal)) {
               // We already know symbol > lowerVal (or >=)
@@ -333,9 +333,9 @@ function assumeInequality(proposition: Expression): AssumeResult {
             }
           }
 
-          if (bounds.upperBound !== undefined) {
-            const upperVal = isNumber(bounds.upperBound)
-              ? bounds.upperBound.numericValue
+          if (bounds.upper !== undefined) {
+            const upperVal = isNumber(bounds.upper)
+              ? bounds.upper.numericValue
               : undefined;
             if (typeof upperVal === 'number' && isFinite(upperVal)) {
               // We know symbol < upperVal (or <=), now checking symbol > k
@@ -357,9 +357,9 @@ function assumeInequality(proposition: Expression): AssumeResult {
           // We're asserting symbol < k or symbol <= k
           const isStrict = effectiveOp === 'less';
 
-          if (bounds.upperBound !== undefined) {
-            const upperVal = isNumber(bounds.upperBound)
-              ? bounds.upperBound.numericValue
+          if (bounds.upper !== undefined) {
+            const upperVal = isNumber(bounds.upper)
+              ? bounds.upper.numericValue
               : undefined;
             if (typeof upperVal === 'number' && isFinite(upperVal)) {
               // We already know symbol < upperVal (or <=)
@@ -375,9 +375,9 @@ function assumeInequality(proposition: Expression): AssumeResult {
             }
           }
 
-          if (bounds.lowerBound !== undefined) {
-            const lowerVal = isNumber(bounds.lowerBound)
-              ? bounds.lowerBound.numericValue
+          if (bounds.lower !== undefined) {
+            const lowerVal = isNumber(bounds.lower)
+              ? bounds.lower.numericValue
               : undefined;
             if (typeof lowerVal === 'number' && isFinite(lowerVal)) {
               // We know symbol > lowerVal (or >=), now checking symbol < k

src/compute-engine/assume.ts

@@ -39,6 +39,7 @@ import { toAsciiMath } from './ascii-math';
 import { cmp, eq, same } from './compare';
 import { CancellationError } from '../../common/interruptible';
 import { isSymbol, isString, isNumber, isFunction } from './type-guards';
+import { extractIntervalBounds } from './inequality-bounds';
 
 // Lazy reference to break circular dependency:
 // serialize → numerics → utils → abstract-boxed-expression
@@ -890,6 +891,10 @@ export abstract class _BoxedExpression implements Expression {
     }
   }
 
+  getInterval(symbol: string) {
+    return extractIntervalBounds(this, symbol);
+  }
+
   simplify(_options?: Partial<SimplifyOptions>): Expression {
     return this;
   }

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

@@ -234,8 +234,8 @@ export function cmp(
         if (aNum !== undefined && Number.isFinite(aNum)) {
           // We're comparing a (number) to b (symbol)
           // If b has a lower bound > a, then a < b
-          if (bounds.lowerBound !== undefined) {
-            const lb = bounds.lowerBound;
+          if (bounds.lower !== undefined) {
+            const lb = bounds.lower;
             const lowerNum = isNumber(lb)
               ? typeof lb.numericValue === 'number'
                 ? lb.numericValue
@@ -254,8 +254,8 @@ export function cmp(
           }
 
           // If b has an upper bound < a, then a > b
-          if (bounds.upperBound !== undefined) {
-            const ub = bounds.upperBound;
+          if (bounds.upper !== undefined) {
+            const ub = bounds.upper;
             const upperNum = isNumber(ub)
               ? typeof ub.numericValue === 'number'
                 ? ub.numericValue
@@ -302,8 +302,8 @@ export function cmp(
 
       // We're comparing a (symbol) to b (number)
       // If a has a lower bound >= b, then a > b (or a >= b)
-      if (bounds.lowerBound !== undefined) {
-        const lb = bounds.lowerBound;
+      if (bounds.lower !== undefined) {
+        const lb = bounds.lower;
         const lowerNum = isNumber(lb)
           ? typeof lb.numericValue === 'number'
             ? lb.numericValue
@@ -322,8 +322,8 @@ export function cmp(
       }
 
       // If a has an upper bound <= b, then a < b (or a <= b)
-      if (bounds.upperBound !== undefined) {
-        const ub = bounds.upperBound;
+      if (bounds.upper !== undefined) {
+        const ub = bounds.upper;
         const upperNum = isNumber(ub)
           ? typeof ub.numericValue === 'number'
             ? ub.numericValue
@@ -420,8 +420,8 @@ export function cmp(
 
       if (bNum !== undefined && Number.isFinite(bNum)) {
         // If symbol has a lower bound >= b, then symbol > b (or symbol >= b)
-        if (bounds.lowerBound !== undefined) {
-          const lb = bounds.lowerBound;
+        if (bounds.lower !== undefined) {
+          const lb = bounds.lower;
           const lowerNum = isNumber(lb)
             ? typeof lb.numericValue === 'number'
               ? lb.numericValue
@@ -440,8 +440,8 @@ export function cmp(
         }
 
         // If symbol has an upper bound <= b, then symbol < b (or symbol <= b)
-        if (bounds.upperBound !== undefined) {
-          const ub = bounds.upperBound;
+        if (bounds.upper !== undefined) {
+          const ub = bounds.upper;
           const upperNum = isNumber(ub)
             ? typeof ub.numericValue === 'number'
               ? ub.numericValue