fix #254

Author: arnog

CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ### Improvements
 
+- **Interval Notation Parsing**: Added support for parsing mathematical interval
+  notation from LaTeX, including half-open intervals. Addresses #254.
+
+  ```javascript
+  // Half-open intervals (American notation)
+  ce.parse('[3, 4)').json;   // → ["Interval", 3, ["Open", 4]]
+  ce.parse('(3, 4]').json;   // → ["Interval", ["Open", 3], 4]
+
+  // Open intervals (ISO/European notation)
+  ce.parse(']3, 4[').json;   // → ["Interval", ["Open", 3], ["Open", 4]]
+
+  // LaTeX bracket commands
+  ce.parse('\\lbrack 3, 4\\rparen').json;  // → ["Interval", 3, ["Open", 4]]
+  ```
+
+  **Contextual Parsing**: Lists and tuples are automatically converted to
+  intervals when used in set contexts (Element, Union, Intersection, etc.):
+
+  ```javascript
+  ce.parse('x \\in [0, 1]').json;
+  // → ["Element", "x", ["Interval", 0, 1]]
+
+  ce.parse('[0, 1] \\cup [2, 3]').json;
+  // → ["Union", ["Interval", 0, 1], ["Interval", 2, 3]]
+
+  // Standalone notation remains backward compatible
+  ce.parse('[0, 1]').json;  // → ["List", 0, 1]
+  ce.parse('(0, 1)').json;  // → ["Tuple", 0, 1]
+  ```
+
 - **Absolute Value Power Simplification**: Fixed simplification of `|x^n|`
   expressions with even and rational exponents. Previously, expressions like
   `|x²|` and `|x^{2/3}|` were not simplified. Now they correctly simplify

src/compute-engine/latex-syntax/dictionary/definitions-sets.ts

@@ -16,6 +16,57 @@ import {
   COMPARISON_PRECEDENCE,
 } from '../types';
 
+/**
+ * Parse the body of an interval expression and create an Interval MathJSON expression.
+ *
+ * @param body - The parsed body between the delimiters (typically a Delimiter with comma separator)
+ * @param openLeft - If true, the left endpoint is open (excluded)
+ * @param openRight - If true, the right endpoint is open (excluded)
+ * @returns An Interval expression or null if the body doesn't have exactly 2 elements
+ */
+function parseIntervalBody(
+  body: Expression,
+  openLeft: boolean,
+  openRight: boolean
+): Expression | null {
+  // Handle empty body
+  if (isEmptySequence(body)) return null;
+
+  // Extract the two endpoints from the body
+  // The body is typically a Delimiter with a comma separator: ["Delimiter", ["Sequence", a, b], ","]
+  // or just a Sequence: ["Sequence", a, b]
+  let elements: Expression[];
+
+  const h = operator(body);
+  if (h === 'Delimiter') {
+    const delim = stringValue(operand(body, 2));
+    // Must be comma-separated
+    if (delim !== ',' && delim !== '(,)' && delim !== '[,]') return null;
+    const inner = operand(body, 1);
+    if (operator(inner) === 'Sequence') {
+      elements = [...operands(inner)];
+    } else {
+      elements = inner ? [inner] : [];
+    }
+  } else if (h === 'Sequence') {
+    elements = [...operands(body)];
+  } else {
+    // Single element - not valid for interval
+    return null;
+  }
+
+  // Intervals must have exactly two endpoints
+  if (elements.length !== 2) return null;
+
+  const [lower, upper] = elements;
+
+  // Build the Interval expression with Open wrappers for open endpoints
+  const lowerExpr: Expression = openLeft ? ['Open', lower] : lower;
+  const upperExpr: Expression = openRight ? ['Open', upper] : upper;
+
+  return ['Interval', lowerExpr, upperExpr];
+}
+
 export const DEFINITIONS_SETS: LatexDictionary = [
   //
   // Constants
@@ -184,9 +235,96 @@ export const DEFINITIONS_SETS: LatexDictionary = [
   },
   {
     name: 'Interval',
-    // @todo: parse opening '[' or ']' or '('
     serialize: serializeSet,
   },
+
+  //
+  // Interval Parsing - Half-open intervals with mismatched brackets
+  //
+  // These matchfix entries handle interval notations where the opening and closing
+  // delimiters differ, indicating open vs closed endpoints.
+  //
+
+  // [a, b) - Closed-open interval (American notation)
+  {
+    kind: 'matchfix',
+    openTrigger: ['['],
+    closeTrigger: [')'],
+    parse: (_parser: Parser, body: Expression): Expression | null =>
+      parseIntervalBody(body, false, true),
+  },
+  {
+    kind: 'matchfix',
+    openTrigger: ['\\lbrack'],
+    closeTrigger: ['\\rparen'],
+    parse: (_parser: Parser, body: Expression): Expression | null =>
+      parseIntervalBody(body, false, true),
+  },
+  {
+    kind: 'matchfix',
+    openTrigger: ['\\lbrack'],
+    closeTrigger: [')'],
+    parse: (_parser: Parser, body: Expression): Expression | null =>
+      parseIntervalBody(body, false, true),
+  },
+  {
+    kind: 'matchfix',
+    openTrigger: ['['],
+    closeTrigger: ['\\rparen'],
+    parse: (_parser: Parser, body: Expression): Expression | null =>
+      parseIntervalBody(body, false, true),
+  },
+
+  // (a, b] - Open-closed interval (American notation)
+  {
+    kind: 'matchfix',
+    openTrigger: ['('],
+    closeTrigger: [']'],
+    parse: (_parser: Parser, body: Expression): Expression | null =>
+      parseIntervalBody(body, true, false),
+  },
+  {
+    kind: 'matchfix',
+    openTrigger: ['\\lparen'],
+    closeTrigger: ['\\rbrack'],
+    parse: (_parser: Parser, body: Expression): Expression | null =>
+      parseIntervalBody(body, true, false),
+  },
+  {
+    kind: 'matchfix',
+    openTrigger: ['\\lparen'],
+    closeTrigger: [']'],
+    parse: (_parser: Parser, body: Expression): Expression | null =>
+      parseIntervalBody(body, true, false),
+  },
+  {
+    kind: 'matchfix',
+    openTrigger: ['('],
+    closeTrigger: ['\\rbrack'],
+    parse: (_parser: Parser, body: Expression): Expression | null =>
+      parseIntervalBody(body, true, false),
+  },
+
+  // ]a, b[ - Open interval (ISO/European reversed bracket notation)
+  {
+    kind: 'matchfix',
+    openTrigger: [']'],
+    closeTrigger: ['['],
+    parse: (_parser: Parser, body: Expression): Expression | null =>
+      parseIntervalBody(body, true, true),
+  },
+  {
+    kind: 'matchfix',
+    openTrigger: ['\\rbrack'],
+    closeTrigger: ['\\lbrack'],
+    parse: (_parser: Parser, body: Expression): Expression | null =>
+      parseIntervalBody(body, true, true),
+  },
+
+  // Note: ISO notation ]a, b] (open-closed) and [a, b[ (closed-open) are NOT
+  // supported with plain brackets because they conflict with nested list parsing.
+  // Use the American notation (a, b] and [a, b) instead, or use explicit
+  // commands like \rbrack a, b \rbrack which are unambiguous.
   {
     name: 'Multiple',
     // @todo: parse
@@ -467,12 +605,17 @@ function serializeSet(
       op2 = operand(op2, 1);
       openRight = true;
     }
+    // Use American notation for interval serialization:
+    // [a, b] closed, (a, b) open, [a, b) closed-open, (a, b] open-closed
+    // This enables round-trip parsing for half-open intervals.
+    // Note: [a, b] and (a, b) will parse back as List/Tuple respectively
+    // due to backward compatibility constraints.
     return joinLatex([
-      `\\mathopen${openLeft ? '\\rbrack' : '\\lbrack'}`,
+      openLeft ? '\\lparen' : '\\lbrack',
       serializer.serialize(op1),
       ', ',
       serializer.serialize(op2),
-      `\\mathclose${openRight ? '\\lbrack' : '\\rbrack'}`,
+      openRight ? '\\rparen' : '\\rbrack',
     ]);
   }
 

src/compute-engine/library/sets.ts

@@ -21,6 +21,37 @@ import {
   cantorEnumerateRationals,
 } from '../numerics/numeric';
 
+/**
+ * Transform a List or Tuple with exactly 2 elements to an Interval in set contexts.
+ *
+ * This enables contextual parsing where `[a, b]` and `(a, b)` are interpreted as
+ * intervals when used as operands of set operations like Element, Union, etc.
+ *
+ * - `["List", a, b]` → `["Interval", a, b]` (closed interval [a, b])
+ * - `["Tuple", a, b]` → `["Interval", ["Open", a], ["Open", b]]` (open interval (a, b))
+ *
+ * Returns the original expression unchanged if it's not a 2-element List/Tuple.
+ */
+function listToIntervalInSetContext(
+  ce: ComputeEngine,
+  expr: BoxedExpression
+): BoxedExpression {
+  // Transform List with 2 elements to closed Interval
+  if (expr.operator === 'List' && expr.nops === 2) {
+    return ce.function('Interval', [expr.op1.canonical, expr.op2.canonical]);
+  }
+
+  // Transform Tuple with 2 elements to open Interval
+  if (expr.operator === 'Tuple' && expr.nops === 2) {
+    return ce.function('Interval', [
+      ce.function('Open', [expr.op1.canonical]),
+      ce.function('Open', [expr.op2.canonical]),
+    ]);
+  }
+
+  return expr.canonical;
+}
+
 export const SETS_LIBRARY: SymbolDefinitions = {
   //
   // Constants
@@ -487,6 +518,21 @@ export const SETS_LIBRARY: SymbolDefinitions = {
     description:
       'Test whether a value is an element of a collection. ' +
       'Optional third argument is a boolean expression (condition) for filtered iteration in Sum/Product.',
+    canonical: (args, { engine: ce }) => {
+      if (args.length < 2) return ce._fn('Element', args);
+      const [value, collection, condition] = args;
+      // Transform List/Tuple with 2 elements to Interval in set context
+      const canonicalCollection = listToIntervalInSetContext(ce, collection);
+      // Only include condition if it's present and not Nothing
+      if (condition && condition.symbol !== 'Nothing') {
+        return ce._fn('Element', [
+          value.canonical,
+          canonicalCollection,
+          condition.canonical,
+        ]);
+      }
+      return ce._fn('Element', [value.canonical, canonicalCollection]);
+    },
     evaluate: ([value, collection, _condition], { engine: ce }) => {
       // Note: condition is only used during Sum/Product iteration,
       // not for standalone Element evaluation
@@ -514,6 +560,14 @@ export const SETS_LIBRARY: SymbolDefinitions = {
     signature: '(lhs:collection, rhs: collection) -> boolean',
     description:
       'Test whether the first collection is a strict subset of the second.',
+    canonical: (args, { engine: ce }) => {
+      if (args.length !== 2) return ce._fn('Subset', args);
+      // Transform List/Tuple with 2 elements to Interval in set context
+      return ce._fn('Subset', [
+        listToIntervalInSetContext(ce, args[0]),
+        listToIntervalInSetContext(ce, args[1]),
+      ]);
+    },
     evaluate: ([lhs, rhs], { engine: ce }) => {
       const result = subset(lhs, rhs);
       if (result === true) return ce.True;
@@ -527,6 +581,14 @@ export const SETS_LIBRARY: SymbolDefinitions = {
     signature: '(lhs:collection, rhs: collection) -> boolean',
     description:
       'Test whether the first collection is a subset (possibly equal) of the second.',
+    canonical: (args, { engine: ce }) => {
+      if (args.length !== 2) return ce._fn('SubsetEqual', args);
+      // Transform List/Tuple with 2 elements to Interval in set context
+      return ce._fn('SubsetEqual', [
+        listToIntervalInSetContext(ce, args[0]),
+        listToIntervalInSetContext(ce, args[1]),
+      ]);
+    },
     evaluate: ([lhs, rhs], { engine: ce }) => {
       const result = subset(lhs, rhs, false);
       if (result === true) return ce.True;
@@ -553,6 +615,14 @@ export const SETS_LIBRARY: SymbolDefinitions = {
     signature: '(lhs:collection, rhs: collection) -> boolean',
     description:
       'Test whether the first collection is a strict superset of the second.',
+    canonical: (args, { engine: ce }) => {
+      if (args.length !== 2) return ce._fn('Superset', args);
+      // Transform List/Tuple with 2 elements to Interval in set context
+      return ce._fn('Superset', [
+        listToIntervalInSetContext(ce, args[0]),
+        listToIntervalInSetContext(ce, args[1]),
+      ]);
+    },
     evaluate: ([lhs, rhs], { engine: ce }) => {
       const result = subset(rhs, lhs); // reversed
       if (result === true) return ce.True;
@@ -566,6 +636,14 @@ export const SETS_LIBRARY: SymbolDefinitions = {
     signature: '(lhs:collection, rhs: collection) -> boolean',
     description:
       'Test whether the first collection is a superset (possibly equal) of the second.',
+    canonical: (args, { engine: ce }) => {
+      if (args.length !== 2) return ce._fn('SupersetEqual', args);
+      // Transform List/Tuple with 2 elements to Interval in set context
+      return ce._fn('SupersetEqual', [
+        listToIntervalInSetContext(ce, args[0]),
+        listToIntervalInSetContext(ce, args[1]),
+      ]);
+    },
     evaluate: ([lhs, rhs], { engine: ce }) => {
       const result = subset(rhs, lhs, true); // reversed
       if (result === true) return ce.True;
@@ -643,13 +721,17 @@ export const SETS_LIBRARY: SymbolDefinitions = {
     canonical: (args, { engine: ce }) => {
       if (args.length === 0) return ce.symbol('EmptySet');
       if (args.length === 1) return ce.symbol('EmptySet');
-      args =
+      // Transform List/Tuple with 2 elements to Interval in set context
+      const transformedArgs = args.map((arg) =>
+        listToIntervalInSetContext(ce, arg)
+      );
+      const validatedArgs =
         validateArguments(
           ce,
-          flatten(args, 'Intersection'),
+          flatten(transformedArgs, 'Intersection'),
           parseType('(set+) -> set')
-        ) ?? args;
-      return ce._fn('Intersection', args);
+        ) ?? transformedArgs;
+      return ce._fn('Intersection', validatedArgs);
     },
     evaluate: intersection,
     collection: {
@@ -669,16 +751,20 @@ export const SETS_LIBRARY: SymbolDefinitions = {
     description: 'Return the union of two or more collections as a set.',
     canonical: (args, { engine: ce }) => {
       if (args.length === 0) return ce.symbol('EmptySet');
-      args =
+      // Transform List/Tuple with 2 elements to Interval in set context
+      const transformedArgs = args.map((arg) =>
+        listToIntervalInSetContext(ce, arg)
+      );
+      const validatedArgs =
         validateArguments(
           ce,
-          flatten(args, 'Union'),
+          flatten(transformedArgs, 'Union'),
           parseType('(collection+) -> set')
-        ) ?? args;
+        ) ?? transformedArgs;
       // Even if there is only one argument, we still need to call Union
       // to canonicalize the argument, since it may not be a set (it could
       // be a collection)
-      return ce._fn('Union', args);
+      return ce._fn('Union', validatedArgs);
     },
     evaluate: union,