math2tex 1.0.0__py3-none-any.whl

math2tex/parser.py

@@ -0,0 +1,967 @@
+"""
+math2tex.parser — Recursive-descent parser converting tokens into an AST.
+"""
+
+from dataclasses import dataclass, fields as dataclass_fields
+from typing import List, Optional
+
+from .config import (
+    ALL_FUNC_NAMES, BIG_OPS, BUILTIN_LATEX_FUNCS, GREEK_LETTERS,
+    IMPLICIT_MULT_STOP, MATRIX_FUNCS, MAX_DEPTH, SPECIAL_CONSTANTS,
+    WORD_ADD_OPS, WORD_MULT_OPS, WORD_RELATIONS,
+    levenshtein_distance,
+)
+from .ast_nodes import (
+    Abs, BigOp, BinOp, Derivative, Factorial, Fraction, Func, Group,
+    InnerProduct, Integral, IntervalNode, MatrixNode, Node, Norm, Num,
+    PiecewiseNode, Power, Prime, SetBuilder, Subscript, TextLiteral,
+    UnOp, Var,
+)
+from .lexer import ParseError, Token, _Backtrack
+
+# =============================================================================
+# Parser State
+# =============================================================================
+
+@dataclass
+class _ParserState:
+    pos: int = 0
+    in_abs: int = 0
+    in_set_builder: bool = False
+    in_bound: bool = False
+    in_superscript: bool = False
+    depth: int = 0
+
+_STATE_FIELDS = tuple(f.name for f in dataclass_fields(_ParserState))
+
+# =============================================================================
+# Depth Guard Decorator
+# =============================================================================
+
+def depth_guarded(func):
+    def wrapper(self, *args, **kwargs):
+        self.depth += 1
+        if self.depth > MAX_DEPTH:
+            raise ParseError('Expression too deeply nested')
+        try:
+            return func(self, *args, **kwargs)
+        finally:
+            self.depth -= 1
+    return wrapper
+
+# =============================================================================
+# Parser
+# =============================================================================
+
+class Parser:
+    def __init__(self, tokens: List[Token],
+                 text_map: Optional[dict] = None,
+                 macro_env: Optional[dict] = None):
+        # Immutable configuration
+        self.text_map = text_map or {}
+        self.macro_env = macro_env or {}
+        self.tokens = tokens
+
+        _defaults = _ParserState()
+        for fname in _STATE_FIELDS:
+            setattr(self, fname, getattr(_defaults, fname))
+
+        # --- Derivative token splitting ---
+        valid_words = (
+            ALL_FUNC_NAMES | BIG_OPS | GREEK_LETTERS | set(SPECIAL_CONSTANTS)
+            | set(WORD_RELATIONS) | set(WORD_MULT_OPS)
+            | set(WORD_ADD_OPS) | set(MATRIX_FUNCS.keys())
+            | {'if', 'otherwise', 'else', 'choose', 'from', 'to', 'of', 'as'}
+            | set(self.macro_env.keys())
+        )
+
+        new_tokens: List[Token] = []
+        for t in tokens:
+            val = t.value
+            is_deriv = False
+            if t.type == 'ID':
+                if (val.startswith('d') and len(val) > 1
+                        and (val[1:] in valid_words
+                             or (len(val[1:]) == 1 and val[1:].isalpha()))):
+                    is_deriv = True
+                elif (val.startswith('partial') and len(val) > 7
+                      and (val[7:] in valid_words
+                           or (len(val[7:]) == 1 and val[7:].isalpha()))):
+                    is_deriv = True
+
+            new_tokens.append(t)
+
+        self.tokens = new_tokens
+        self._valid_words = valid_words
+
+    # ------------------------------------------------------------------
+    # Diagnostic fuzzy matching
+    # ------------------------------------------------------------------
+
+    def _suggest_correction(self, token_value: str) -> str:
+        if len(token_value) < 4:
+            return ''
+        best_match = None
+        best_dist = 3
+        for word in self._valid_words:
+            dist = levenshtein_distance(token_value, word)
+            if dist <= 2 and dist < best_dist:
+                best_match = word
+                best_dist = dist
+        if best_match:
+            return f" (Did you mean '{best_match}'?)"
+        return ''
+
+    # ------------------------------------------------------------------
+    # Token access
+    # ------------------------------------------------------------------
+
+    @property
+    def current(self) -> Token:
+        return self.tokens[self.pos]
+
+    def consume(self, expected_type: str = None) -> Token:
+        tok = self.current
+        if expected_type and tok.type != expected_type:
+            raise SyntaxError(
+                f"Expected {expected_type}, got {tok.type} '{tok.value}'"
+            )
+        self.pos += 1
+        return tok
+
+    def match(self, ttype: str, val: str = None) -> bool:
+        if (self.current.type == ttype
+                and (val is None or self.current.value == val)):
+            self.pos += 1
+            return True
+        return False
+
+    def peek(self, offset: int = 1) -> Token:
+        idx = self.pos + offset
+        if idx >= len(self.tokens):
+            return self.tokens[-1]
+        return self.tokens[idx]
+
+    def rewind(self, n: int = 1) -> None:
+        self.pos -= n
+
+    # ------------------------------------------------------------------
+    # State snapshot / restore
+    # ------------------------------------------------------------------
+
+    def _snapshot_state(self) -> dict:
+        return {f: getattr(self, f) for f in _STATE_FIELDS}
+
+    def _restore_state(self, snapshot: dict) -> None:
+        for f, v in snapshot.items():
+            setattr(self, f, v)
+
+    def try_parse(self, parse_func):
+        snapshot = self._snapshot_state()
+        try:
+            return parse_func()
+        except _Backtrack:
+            self._restore_state(snapshot)
+            return None
+
+    # ------------------------------------------------------------------
+    # Entry
+    # ------------------------------------------------------------------
+
+    def parse(self) -> Node:
+        if self.current.type == 'EOF':
+            return Var('')
+        expr = self.parse_expression()
+        if self.current.type != 'EOF':
+            tok = self.current
+            hint = self._suggest_correction(tok.value) if tok.type == 'ID' else ''
+            raise ParseError(
+                f"Unexpected token at end: {tok}{hint}\n"
+                f"% Input: {' '.join(t.value for t in self.tokens)}"
+            )
+        return expr
+
+    # ------------------------------------------------------------------
+    # Precedence Levels
+    # ------------------------------------------------------------------
+
+    @depth_guarded
+    def parse_expression(self) -> Node:
+        left = self.parse_relational()
+        if self.current.type == 'ID' and self.current.value == 'if':
+            self.consume('ID')
+            right = self.parse_relational()
+            return BinOp('if', left, right)
+        if self.current.type == 'ID' and self.current.value == 'otherwise':
+            self.consume('ID')
+            return BinOp('otherwise', left, Var(''))
+        return left
+
+    @depth_guarded
+    def parse_relational(self) -> Node:
+        left = self.parse_choose()
+        while True:
+            if self.current.type in ('REL', 'ARROW', 'COLON'):
+                op = self.consume().value
+                right = self.parse_choose()
+                left = BinOp(op, left, right)
+            elif (self.current.type == 'ID'
+                  and self.current.value in WORD_RELATIONS):
+                op = self.consume().value
+                right = self.parse_choose()
+                left = BinOp(op, left, right)
+            else:
+                break
+        return left
+
+    @depth_guarded
+    def parse_choose(self) -> Node:
+        left = self.parse_additive()
+        while self.match('ID', 'choose'):
+            right = self.parse_additive()
+            left = BinOp('choose', left, right)
+        return left
+
+    @depth_guarded
+    def parse_additive(self) -> Node:
+        left = self.parse_multiplicative()
+        while True:
+            if (self.current.type == 'OP'
+                    and self.current.value in ('+', '-')):
+                op = self.consume().value
+                right = self.parse_multiplicative()
+                left = BinOp(op, left, right)
+            elif self.current.type == 'PM':
+                op = self.consume().value
+                right = self.parse_multiplicative()
+                left = BinOp(op, left, right)
+            elif (self.current.type == 'ID'
+                  and self.current.value in WORD_ADD_OPS):
+                op = self.consume().value
+                right = self.parse_multiplicative()
+                left = BinOp(op, left, right)
+            else:
+                break
+        return left
+
+    @depth_guarded
+    def parse_multiplicative(self) -> Node:
+        left = self.parse_implicit()
+        while True:
+            if self.current.type == 'OP' and self.current.value == '*':
+                self.consume()
+                right = self.parse_implicit()
+                left = BinOp('*', left, right)
+            elif self.current.type == 'OP' and self.current.value == '/':
+                self.consume()
+                right = self.parse_postfix()
+                left = Fraction(left, right)
+                while (self.current.type in ('ID', 'NUMBER', 'LPAREN',
+                                              'LBRACK', 'LBRACE', 'ELLIPSIS')
+                       or (self.current.type in ('BAR', 'DBLBAR')
+                           and self.in_abs == 0
+                           and not self.in_set_builder)):
+                    if (self.current.type == 'ID'
+                            and self.current.value in IMPLICIT_MULT_STOP):
+                        break
+                    if (self.current.type == 'ID'
+                            and self.current.value in BIG_OPS):
+                        break
+                    right = self.parse_postfix()
+                    left = BinOp(' ', left, right)
+            elif (self.current.type == 'ID'
+                  and self.current.value in WORD_MULT_OPS):
+                op = self.consume().value
+                right = self.parse_implicit()
+                left = BinOp(op, left, right)
+            else:
+                break
+        return left
+
+    @depth_guarded
+    def parse_implicit(self) -> Node:
+        # Check for big operators first
+        if (self.current.type == 'ID'
+                and self.current.value in BIG_OPS):
+            if self.current.value == 'inf':
+                if self.pos + 1 < len(self.tokens) and self.tokens[self.pos + 1].value == '_':
+                    return self.parse_bigop()
+            else:
+                return self.parse_bigop()
+
+        left = self.parse_postfix()
+
+        # Implicit multiplication lookahead
+        while (self.current.type in ('ID', 'NUMBER', 'LPAREN',
+                                     'LBRACK', 'LBRACE', 'ELLIPSIS')
+               or (self.current.type in ('BAR', 'DBLBAR')
+                   and self.in_abs == 0
+                   and not self.in_set_builder)):
+            if (self.current.type == 'ID'
+                    and self.current.value in IMPLICIT_MULT_STOP):
+                break
+            if (self.current.type == 'ID'
+                    and self.current.value in BIG_OPS):
+                break
+            right = self.parse_postfix()
+            left = BinOp(' ', left, right)
+        return left
+
+    @depth_guarded
+    def parse_postfix(self) -> Node:
+        node = self.parse_power()
+        while True:
+            if self.current.type == 'OP' and self.current.value == '!':
+                self.consume()
+                node = Factorial(node)
+            elif self.current.type == 'PRIME':
+                count = len(self.consume().value)
+                node = Prime(node, count)
+            elif (self.current.type == 'OP'
+                   and self.current.value in ('^', '_')):
+                if self.current.value == '_' and self.in_superscript:
+                    break
+                op = self.consume().value
+                if op == '^':
+                    old_sup = self.in_superscript
+                    self.in_superscript = True
+                    node = Power(node, self.parse_power())
+                    self.in_superscript = old_sup
+                else:
+                    node = Subscript(node, self.parse_subscript())
+            else:
+                break
+        return node
+
+    @depth_guarded
+    def parse_subscript(self) -> Node:
+        node = self.parse_unary()
+        if self.current.type == 'OP' and self.current.value == '_':
+            self.consume()
+            node = Subscript(node, self.parse_subscript())
+        return node
+
+    @depth_guarded
+    def parse_power(self) -> Node:
+        node = self.parse_unary()
+        while (self.current.type == 'OP'
+               and self.current.value in ('^', '_')):
+            if self.current.value == '_' and self.in_superscript:
+                break
+
+            op = self.consume().value
+            if op == '^':
+                old_sup = self.in_superscript
+                self.in_superscript = True
+                node = Power(node, self.parse_power())  # right-associative power
+                self.in_superscript = old_sup
+            else:
+                # Subscripts are right-associative among themselves, but ^ binds left
+                node = Subscript(node, self.parse_subscript())
+        return node
+
+    @depth_guarded
+    def parse_unary(self) -> Node:
+        if self.current.type == 'OP' and self.current.value in ('+', '-'):
+            return UnOp(self.consume().value, self.parse_unary())
+        if self.current.type == 'PM':
+            op = self.consume().value
+            expr = self.parse_unary()
+            return BinOp(op, Var(''), expr)
+        return self.parse_primary()
+
+    @depth_guarded
+    def parse_primary(self) -> Node:
+        deriv = self.try_parse(self._parse_derivative)
+        if deriv is not None:
+            return deriv
+
+        inner = self.try_parse(self._parse_inner_product)
+        if inner is not None:
+            return inner
+
+        tok = self.current
+
+        if tok.type == 'NUMBER':
+            return Num(self.consume().value)
+
+        elif tok.type == 'ELLIPSIS':
+            self.consume()
+            return Var('...')
+
+        elif tok.type == 'ID':
+            val = self.consume().value
+
+            if val in self.text_map:
+                return TextLiteral(self.text_map[val])
+
+            if val in MATRIX_FUNCS and self.current.type == 'LBRACK':
+                self.consume('LBRACK')
+                matrix_node = self.parse_matrix_bracket()
+                if isinstance(matrix_node, MatrixNode):
+                    return MatrixNode(matrix_node.rows,
+                                     kind=MATRIX_FUNCS[val])
+                elif isinstance(matrix_node, IntervalNode):
+                    return MatrixNode(
+                        [[matrix_node.left_expr, matrix_node.right_expr]],
+                        kind=MATRIX_FUNCS[val])
+                return matrix_node
+
+            if val in BIG_OPS:
+                if val == 'inf':
+                    if self.current.type == 'OP' and self.current.value == '_':
+                        self.rewind(1)
+                        return self.parse_bigop()
+                else:
+                    self.rewind(1)
+                    return self.parse_bigop()
+
+            snapshot = self._snapshot_state()
+            prime_count = 0
+            if self.current.type == 'PRIME':
+                prime_count = len(self.consume().value)
+
+            sub = None
+            power = None
+            if not self.in_bound:
+                while (self.current.type == 'OP'
+                       and self.current.value in ('_', '^')):
+                    op = self.consume().value
+                    old = self.in_bound
+                    self.in_bound = True
+                    if op == '_':
+                        sub = self.parse_primary()
+                    elif op == '^':
+                        old_sup = self.in_superscript
+                        self.in_superscript = True
+                        power = self.parse_postfix()
+                        self.in_superscript = old_sup
+                    self.in_bound = old
+
+            is_known = (val in ALL_FUNC_NAMES or val in self.macro_env
+                        or val in self.text_map)
+            
+            is_func = is_known or (self.current.type == 'LPAREN') or (val in ALL_FUNC_NAMES and self.current.type == 'ID' and self.current.value == 'of')
+
+            if not is_func:
+                self._restore_state(snapshot)
+                return Var(val)
+
+            if (self.current.type == 'LPAREN'
+                    and (not self.in_bound or is_known)):
+                self.consume('LPAREN')
+                args = []
+                if self.current.type != 'RPAREN':
+                    args.append(self.parse_relational())
+                    while self.match('COMMA'):
+                        args.append(self.parse_relational())
+                self.consume('RPAREN')
+
+                if val in self.macro_env:
+                    from .macros import substitute
+                    macro = self.macro_env[val]
+                    if len(args) != len(macro.args):
+                        raise ParseError(
+                            f"Macro '{val}' expects {len(macro.args)} "
+                            f"arguments, got {len(args)}."
+                        )
+                    bindings = dict(zip(macro.args, args))
+                    node = substitute(macro.body, bindings)
+                    if prime_count > 0:
+                        node = Prime(node, prime_count)
+                    if sub is not None:
+                        node = Subscript(node, sub)
+                    if power is not None:
+                        node = Power(node, power)
+                    return node
+
+                func_node = Func(val, args, sub, power, prime_count)
+
+                from .config import ACCENT_FUNCTIONS, FONT_FUNCTIONS
+                if (val in ACCENT_FUNCTIONS or val in FONT_FUNCTIONS) and self.current.type == 'LPAREN':
+                    self.consume('LPAREN')
+                    call_args = []
+                    if self.current.type != 'RPAREN':
+                        call_args.append(self.parse_relational())
+                        while self.match('COMMA'):
+                            call_args.append(self.parse_relational())
+                    self.consume('RPAREN')
+
+                    return Func(val, args, sub, power, prime_count, call_args=call_args)
+                return func_node
+
+            elif val in ALL_FUNC_NAMES and self.match('ID', 'of'):
+                arg = self.parse_relational()
+                return Func(val, [arg], sub, power, prime_count)
+            elif val in self.macro_env and self.match('ID', 'of'):
+                from .macros import substitute
+                arg = self.parse_relational()
+                macro = self.macro_env[val]
+                if len(macro.args) != 1:
+                    raise ParseError(
+                        f"Macro '{val}' expects {len(macro.args)} "
+                        f"arguments, got 1."
+                    )
+                node = substitute(macro.body, {macro.args[0]: arg})
+                if prime_count > 0:
+                    node = Prime(node, prime_count)
+                if sub is not None:
+                    node = Subscript(node, sub)
+                if power is not None:
+                    node = Power(node, power)
+                return node
+
+            if val in self.macro_env:
+                from .macros import substitute
+                macro = self.macro_env[val]
+                if len(macro.args) > 0:
+                    raise ParseError(
+                        f"Macro '{val}' expects {len(macro.args)} "
+                        f"arguments, but none were provided."
+                    )
+                node = substitute(macro.body, {})
+            else:
+                node = Var(val)
+
+            if prime_count > 0:
+                node = Prime(node, prime_count)
+            if sub is not None:
+                node = Subscript(node, sub)
+            if power is not None:
+                node = Power(node, power)
+            return node
+
+        elif tok.type == 'LPAREN':
+            self.consume('LPAREN')
+            if self.current.type == 'RPAREN':
+                raise ParseError(
+                    "Empty parentheses '()' are not allowed "
+                    "outside of function calls."
+                )
+            expr = self.parse_relational()
+            if self.match('COMMA'):
+                expr2 = self.parse_relational()
+                if self.current.type == 'RPAREN':
+                    self.consume('RPAREN')
+                    return IntervalNode('(', expr, expr2, ')')
+                elif self.current.type == 'RBRACK':
+                    self.consume('RBRACK')
+                    return IntervalNode('(', expr, expr2, ']')
+                else:
+                    raise ParseError("Expected ')' or ']' for interval")
+            self.consume('RPAREN')
+            return expr
+
+        elif tok.type == 'BAR':
+            return self._parse_abs_or_norm('abs', 'BAR', 'BAR')
+
+        elif tok.type == 'DBLBAR':
+            return self._parse_abs_or_norm('norm', 'DBLBAR', 'DBLBAR')
+
+        elif tok.type == 'LBRACK':
+            self.consume('LBRACK')
+
+            if self.current.type == 'LBRACK':
+                rows = []
+                while (self.current.type != 'RBRACK'
+                       and self.current.type != 'EOF'):
+                    self.consume('LBRACK')
+                    row = []
+                    if self.current.type != 'RBRACK':
+                        row.append(self.parse_relational())
+                        while self.match('COMMA'):
+                            row.append(self.parse_relational())
+                    self.consume('RBRACK')
+                    rows.append(row)
+                    self.match('COMMA')
+                self.consume('RBRACK')
+                return MatrixNode(rows)
+            else:
+                expr = self.parse_relational()
+                if self.match('COMMA'):
+                    expr2 = self.parse_relational()
+                    if self.current.type == 'RPAREN':
+                        self.consume('RPAREN')
+                        return IntervalNode('[', expr, expr2, ')')
+                    elif self.current.type == 'RBRACK':
+                        self.consume('RBRACK')
+                        return IntervalNode('[', expr, expr2, ']')
+                    else:
+                        row = [expr, expr2]
+                        rows: list = []
+                        while True:
+                            if self.match('COMMA'):
+                                row.append(self.parse_relational())
+                            elif self.match('SEMI'):
+                                rows.append(row)
+                                row = [self.parse_relational()]
+                            else:
+                                break
+                        if row:
+                            rows.append(row)
+                        self.consume('RBRACK')
+                        return MatrixNode(rows)
+                elif self.match('SEMI'):
+                    row = [expr]
+                    rows = []
+                    while True:
+                        expr = self.parse_relational()
+                        row.append(expr)
+                        if self.match('COMMA'):
+                            pass
+                        elif self.match('SEMI'):
+                            rows.append(row)
+                            row = []
+                        else:
+                            break
+                    if row:
+                        rows.append(row)
+                    self.consume('RBRACK')
+                    return MatrixNode(rows)
+                else:
+                    self.consume('RBRACK')
+                    return MatrixNode([[expr]])
+
+        elif tok.type == 'LBRACE':
+            return self.parse_brace_structure()
+
+        raise ParseError(f"Unexpected token: {tok}")
+
+    # ------------------------------------------------------------------
+    # Specialised Parsers
+    # ------------------------------------------------------------------
+
+    def _parse_derivative(self) -> Derivative:
+        val = self.current.value
+        is_attached = False
+        if self.current.type != 'ID':
+            raise _Backtrack()
+
+        if val in ('d', 'partial'):
+            pass
+        elif (val.startswith('d') and len(val) >= 2
+              and (val[1:] in GREEK_LETTERS
+                   or (len(val[1:]) == 1 and val[1:].isalpha()))):
+            is_attached = True
+        elif (val.startswith('partial') and len(val) > 7
+              and (val[7:] in GREEK_LETTERS
+                   or (len(val[7:]) == 1 and val[7:].isalpha()))):
+            is_attached = True
+        else:
+            raise _Backtrack()
+
+        try:
+            tok = self.consume('ID')
+            is_partial = tok.value.startswith('partial')
+
+            order = None
+            if self.match('OP', '^'):
+                order = self.parse_unary()
+
+            target = None
+            if is_attached:
+                if is_partial:
+                    target = Var(tok.value[7:])
+                else:
+                    target = Var(tok.value[1:])
+            else:
+                if not (self.current.type == 'OP'
+                        and self.current.value == '/'):
+                    target = self.parse_implicit()
+
+            if not self.match('OP', '/'):
+                raise _Backtrack()
+
+            den_tok = self.consume('ID')
+            var2 = None
+            if is_partial:
+                if (den_tok.value != 'partial'
+                        and not den_tok.value.startswith('partial')):
+                    raise _Backtrack()
+
+                if den_tok.value == 'partial':
+                    var = self.consume('ID').value
+                else:
+                    var = den_tok.value[7:]
+
+                if order and self.match('OP', '^'):
+                    self.parse_unary()
+
+                if (self.current.type == 'ID'
+                        and self.current.value.startswith('partial')):
+                    tok2 = self.consume('ID')
+                    if tok2.value == 'partial':
+                        var2 = self.consume('ID').value
+                    else:
+                        var2 = tok2.value[7:]
+                    
+                    if order and self.match('OP', '^'):
+                        self.parse_unary()
+            else:
+                if den_tok.value == 'd':
+                    var = self.consume('ID').value
+                elif (den_tok.value.startswith('d')
+                      and len(den_tok.value) > 1):
+                    var = den_tok.value[1:]
+                else:
+                    raise _Backtrack()
+
+                if order and self.match('OP', '^'):
+                    self.parse_unary()
+
+            if target:
+                expr = target
+            else:
+                if self.current.type != 'EOF':
+                    expr = self.parse_implicit()
+                else:
+                    expr = Var('')
+
+            return Derivative(expr, var, order, is_partial, var2)
+        except ParseError:
+            raise _Backtrack()
+
+    def _parse_bound(self) -> Node:
+        """Parse a single integral bound (handles fractions like pi/2)."""
+        node = self.parse_postfix()
+        if self.match('OP', '/'):
+            den = self.parse_postfix()
+            node = Fraction(node, den)
+        return node
+
+    @depth_guarded
+    def parse_bigop(self) -> Node:
+        op_name = self.consume('ID').value
+        if op_name == 'integrate':
+            op_name = 'integral'
+
+        self.match('ID', 'of')
+
+        if op_name in ('integral', 'int', 'iint', 'iiint',
+                        'oint', 'oiint'):
+            lower, upper = None, None
+
+            if self.match('ID', 'from'):
+                lower = self._parse_bound()
+                if self.match('ID', 'to'):
+                    upper = self._parse_bound()
+            else:
+                while (self.current.type == 'OP'
+                       and self.current.value in ('_', '^')):
+                    op = self.consume().value
+                    old = self.in_bound
+                    self.in_bound = True
+                    if op == '_':
+                        lower = self.parse_unary()
+                    else:
+                        upper = self.parse_unary()
+                    self.in_bound = old
+
+            try:
+                expr = self.parse_additive()
+            except ParseError:
+                if self.current.type == 'EOF':
+                    expr = Var('')
+                else:
+                    raise
+
+            if lower is None and upper is None:
+                if self.match('ID', 'from'):
+                    lower = self._parse_bound()
+                    if self.match('ID', 'to'):
+                        upper = self._parse_bound()
+
+            kind_map = {
+                'integral': 'single', 'int': 'single',
+                'iint': 'double', 'iiint': 'triple',
+                'oint': 'contour', 'oiint': 'double_contour',
+            }
+            return Integral(expr, lower, upper,
+                            kind_map.get(op_name, 'single'))
+
+        elif op_name in ('sum', 'prod'):
+            lower, upper = None, None
+
+            while (self.current.type == 'OP'
+                   and self.current.value in ('_', '^')):
+                op = self.consume().value
+                old = self.in_bound
+                self.in_bound = True
+                if op == '_':
+                    lower = self.parse_unary()
+                else:
+                    upper = self.parse_unary()
+                self.in_bound = old
+
+            if lower is not None or upper is not None:
+                try:
+                    expr = self.parse_additive()
+                except ParseError:
+                    if self.current.type == 'EOF':
+                        expr = Var('')
+                    else:
+                        raise
+                return BigOp(op_name, lower, upper, expr)
+
+            try:
+                expr = self.parse_additive()
+            except ParseError:
+                if self.current.type == 'EOF':
+                    expr = Var('')
+                else:
+                    raise
+
+            if self.match('COMMA'):
+                lower = self.parse_relational()
+                if self.match('COMMA'):
+                    upper = self.parse_relational()
+                elif self.match('ID', 'to'):
+                    upper = self.parse_relational()
+            elif self.match('ID', 'from'):
+                lower = self.parse_relational()
+                if self.match('ID', 'to'):
+                    upper = self.parse_relational()
+
+            return BigOp(op_name, lower, upper, expr)
+
+        elif op_name == 'lim':
+            lower = None
+
+            if self.match('OP', '_'):
+                lower = self.parse_unary()
+                expr = self.parse_multiplicative()
+                return BigOp(op_name, lower, None, expr)
+
+            try:
+                expr = self.parse_multiplicative()
+            except ParseError:
+                expr = Var('')
+
+            if self.match('ID', 'as'):
+                lower = self.parse_relational()
+
+            return BigOp(op_name, lower, None, expr)
+
+        lower, upper = None, None
+        while (self.current.type == 'OP'
+               and self.current.value in ('_', '^')):
+            op = self.consume().value
+            old = self.in_bound
+            self.in_bound = True
+            if op == '_':
+                lower = self.parse_unary()
+            else:
+                upper = self.parse_unary()
+            self.in_bound = old
+
+        try:
+            expr = self.parse_multiplicative()
+        except ParseError:
+            if self.current.type == 'EOF':
+                expr = Var('')
+            else:
+                raise
+        return BigOp(op_name, lower, upper, expr)
+
+    def _parse_abs_or_norm(self, kind: str,
+                           open_tok: str, close_tok: str) -> Node:
+        self.consume(open_tok)
+        self.in_abs += 1
+        expr = self.parse_relational()
+        self.in_abs -= 1
+        self.consume(close_tok)
+        if kind == 'abs':
+            return Abs(expr)
+        return Norm(expr)
+
+    def _parse_inner_product(self) -> InnerProduct:
+        if not self.match('REL', '<'):
+            raise _Backtrack()
+        left = self.parse_additive()
+        if not self.match('COMMA'):
+            raise _Backtrack()
+        right = self.parse_additive()
+        if not self.match('REL', '>'):
+            raise _Backtrack()
+        return InnerProduct(left, right)
+
+    def parse_matrix_bracket(self) -> Node:
+        rows: list = []
+        if self.match('LBRACK'):
+            # Nested format: [[1,2],[3,4]]
+            while True:
+                row = [self.parse_relational()]
+                while self.match('COMMA'):
+                    row.append(self.parse_relational())
+                self.consume('RBRACK')
+                rows.append(row)
+                if not self.match('COMMA'):
+                    break
+                self.consume('LBRACK')
+            self.consume('RBRACK')
+            return MatrixNode(rows)
+
+        else:
+            # Flat list: [a, b] or [1,2; 3,4]
+            row = [self.parse_relational()]
+            while True:
+                if self.match('COMMA'):
+                    row.append(self.parse_relational())
+                elif self.match('SEMI'):
+                    rows.append(row)
+                    row = [self.parse_relational()]
+                else:
+                    break
+            if row:
+                rows.append(row)
+            self.consume('RBRACK')
+
+            if len(rows) == 1 and len(rows[0]) == 2:
+                return IntervalNode('[', rows[0][0], rows[0][1], ']')
+            return MatrixNode(rows)
+
+    def parse_brace_structure(self) -> Node:
+        self.consume('LBRACE')
+
+        old_in_set = self.in_set_builder
+        self.in_set_builder = True
+        first = self.parse_relational()
+        self.in_set_builder = old_in_set
+
+        # Set builder: {expr | condition}
+        if self.match('BAR'):
+            cond = self.parse_relational()
+            self.consume('RBRACE')
+            return SetBuilder(first, cond)
+
+        # Piecewise: {expr if cond, expr2 if cond2, ...}
+        conditions = []
+        is_piecewise = False
+        cond = None
+
+        if self.match('ID', 'if'):
+            cond = self.parse_relational()
+            is_piecewise = True
+        elif (self.current.type == 'ID'
+              and self.current.value in ('otherwise', 'else')):
+            self.consume('ID')
+            cond = Var(r'\text{otherwise}')
+            is_piecewise = True
+
+        if is_piecewise:
+            conditions.append((first, cond))
+            while self.match('COMMA'):
+                expr = self.parse_relational()
+                cond = None
+                if self.match('ID', 'if'):
+                    cond = self.parse_relational()
+                elif (self.current.type == 'ID'
+                      and self.current.value in ('otherwise', 'else')):
+                    self.consume('ID')
+                    cond = Var(r'\text{otherwise}')
+                conditions.append((expr, cond))
+            self.consume('RBRACE')
+            return PiecewiseNode(conditions)
+
+        self.consume('RBRACE')
+        return first