openscvx 0.5.3.dev38__tar.gz → 0.5.3.dev39__tar.gz

{openscvx-0.5.3.dev38/openscvx.egg-info → openscvx-0.5.3.dev39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscvx
-Version: 0.5.3.dev38
+Version: 0.5.3.dev39
 Summary: A general Python-based successive convexification implementation which uses a JAX backend.
 Author-email: Chris Hayner and Griffin Norris <haynec@uw.edu>
 License: Apache Software License

{openscvx-0.5.3.dev38 → openscvx-0.5.3.dev39}/openscvx/__init__.py

@@ -90,6 +90,7 @@ from openscvx.symbolic.expr import (
     ctcs,
 )
 from openscvx.symbolic.expr.time import Time
+from openscvx.symbolic.lower import to_latex
 from openscvx.utils.cache import clear_cache, get_cache_dir, get_cache_size
 
 load_results = OptimizationResults.load
@@ -186,6 +187,8 @@ __all__ = [
     "ctcs",
     # Data parallelism
     "Vmap",
+    # LaTeX rendering
+    "to_latex",
     # Submodules
     "init",
     "stl",

{openscvx-0.5.3.dev38 → openscvx-0.5.3.dev39}/openscvx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.5.3.dev38'
-__version_tuple__ = version_tuple = (0, 5, 3, 'dev38')
+__version__ = version = '0.5.3.dev39'
+__version_tuple__ = version_tuple = (0, 5, 3, 'dev39')
 
-__commit_id__ = commit_id = 'g235acbb25'
+__commit_id__ = commit_id = 'g56a68269b'

{openscvx-0.5.3.dev38 → openscvx-0.5.3.dev39}/openscvx/problem.py

@@ -26,7 +26,7 @@ import time
 import warnings
 from dataclasses import fields as dc_fields
 from dataclasses import replace as dc_replace
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
 import jax
 import numpy as np
@@ -525,6 +525,10 @@ class Problem:
             dynamics, adapter_byof = dynamics.expand()
             byof = _merge_byof(byof, adapter_byof)
 
+        # Stash the user-authored dynamics (pre-augmentation) for `to_latex`.
+        # Shallow-copy so later user mutation of their dict doesn't alias.
+        self._dynamics_dict: dict = dict(dynamics)
+
         # Resolve byof: dict → ByofSpec (validates keys and nested specs)
         if byof is not None:
             byof = ByofSpec.model_validate(byof)
@@ -678,6 +682,107 @@ class Problem:
 
         # SCP algorithm (resolved from `algorithm` parameter above)
 
+    @property
+    def dynamics(self) -> dict:
+        """The user-authored dynamics dict, ``{state_name: expr}``.
+
+        This is the problem as written, *before* the solver augments it with a
+        time-dilation control and per-CTCS penalty states.  Handy for rendering
+        or inspecting a single equation, e.g. ``ox.to_latex(problem.dynamics["v"])``.
+
+        Returns:
+            A dict mapping each user state name to its symbolic time derivative.
+        """
+        return self._dynamics_dict
+
+    def to_latex(
+        self,
+        *,
+        dynamics: Literal["inline", "separate"] = "separate",
+        constraints: Literal["inline", "symbolic", "separate"] = "inline",
+        weights: Literal["symbolic", "numeric"] = "symbolic",
+    ) -> str:
+        """Render the problem as a Mayer-form LaTeX formulation.
+
+        The rendered problem is the one you wrote — pre-augmentation, so no
+        time-dilation control or CTCS penalty states appear; CTCS constraints
+        show up as continuous-time path constraints.  The result is a complete
+        display-math fragment — a ``subequations`` + ``align`` block (with
+        ``"separate"`` definitions as bare ``align`` blocks) that pastes into a
+        paper as-is, no ``$$`` wrapping.
+
+        Dynamics render at one of two detail levels:
+
+        - ``"separate"`` (default): the formulation carries ``\\dot{x} = f(x, u)``
+          and the per-state ``\\dot{x}_{i} = \\ldots`` definitions follow as
+          their own ``align`` block.
+        - ``"inline"``: one ``\\dot{x}_{i} = \\ldots`` row per equation inside
+          the formulation.
+
+        Constraints add a middle level:
+
+        - ``"inline"`` (default): full constraint bodies with annotations.
+        - ``"symbolic"``: numbered ``g_i(x, u) \\le 0`` / ``h_j(x, u) = 0``
+          references only (with their ``\\forall t`` / node annotations).
+        - ``"separate"``: symbolic references plus an appended definition block.
+
+        Args:
+            dynamics: Detail level for the dynamics section.
+            constraints: Detail level for the constraint section.
+            weights: How objective coefficients render. ``"symbolic"`` (the
+                default) shows each as a ``\\lambda`` subscripted by the state's
+                symbol and element (``\\lambda_{t}``, ``\\lambda_{\\mathrm{v},1}``);
+                ``"numeric"`` substitutes the tuned ``lam_cost`` values (``%g``,
+                omitted when equal to 1).
+
+        Returns:
+            The formulation as a single LaTeX string; ``"separate"`` modes append
+            the definition blocks after it.
+
+        Example:
+            Default (separate dynamics, inline constraints, symbolic weights)::
+
+                print(problem.to_latex())
+
+            Everything expanded in a single block::
+
+                print(problem.to_latex(dynamics="inline"))
+
+            Substitute the tuned objective weights::
+
+                print(problem.to_latex(weights="numeric"))
+        """
+        from openscvx.symbolic.lowerers.latex import problem_to_latex
+
+        return problem_to_latex(
+            self.symbolic,
+            self._dynamics_dict,
+            self.algorithm.lam_cost,
+            dynamics=dynamics,
+            constraints=constraints,
+            weights=weights,
+        )
+
+    def _repr_latex_(self) -> str:
+        """Render as display math in Jupyter (default detail levels, in ``$$``).
+
+        Uses the builder's ``aligned`` envelope rather than the ``subequations``
+        + ``align`` form ``to_latex`` returns: MathJax/KaTeX (the notebook and
+        docs renderers) do not implement ``subequations``, and ``align`` cannot
+        nest inside ``$$``, whereas ``aligned`` can.
+        """
+        from openscvx.symbolic.lowerers.latex import problem_to_latex
+
+        body = problem_to_latex(
+            self.symbolic,
+            self._dynamics_dict,
+            self.algorithm.lam_cost,
+            dynamics="separate",
+            constraints="inline",
+            env="aligned",
+        )
+        return f"$$\n{body}\n$$"
+
     @property
     def solver(self) -> ConvexSolver:
         """Access the convex subproblem solver instance.

{openscvx-0.5.3.dev38 → openscvx-0.5.3.dev39}/openscvx/symbolic/expr/expr.py

@@ -420,6 +420,25 @@ class Expr:
             lines.append(child.pretty(indent + 1))
         return "\n".join(lines)
 
+    def _repr_latex_(self) -> Union[str, None]:
+        """Render this expression as inline LaTeX for Jupyter.
+
+        Jupyter calls this hook to display an object as math. The expression
+        is lowered to LaTeX and wrapped in ``$...$``. Nodes without a
+        registered LaTeX visitor return ``None`` so Jupyter falls back to the
+        plain ``__repr__``.
+
+        Returns:
+            The inline-math string ``"$...$"``, or ``None`` when the
+            expression contains a node the LaTeX backend does not support.
+        """
+        from openscvx.symbolic.lower import to_latex
+
+        try:
+            return f"${to_latex(self)}$"
+        except NotImplementedError:
+            return None
+
     def _hash_into(self, hasher: "hashlib._Hash") -> None:
         """Contribute this expression's structural identity to a hash.
 

{openscvx-0.5.3.dev38 → openscvx-0.5.3.dev39}/openscvx/symbolic/lower.py

@@ -84,6 +84,7 @@ if TYPE_CHECKING:
 __all__ = [
     "lower",
     "lower_to_jax",
+    "to_latex",
     "lower_cvxpy_constraints",
     "create_cvxpy_variables",
     "lower_symbolic_problem",
@@ -169,6 +170,47 @@ def lower_to_jax(exprs: Union[Expr, Sequence[Expr]]) -> Union[callable, list[cal
     return fns
 
 
+def to_latex(exprs: Union[Expr, Sequence[Expr]]) -> Union[str, list[str]]:
+    """Lower symbolic expression(s) to LaTeX math string(s).
+
+    Convenience wrapper that creates a LatexLowerer and renders one or more
+    symbolic expressions as LaTeX. This is the escape hatch for rendering a
+    single expression (or a handful) — e.g. one entry of a problem's dynamics
+    dict — without going through ``Problem.to_latex``.
+
+    Args:
+        exprs: Single expression or sequence of expressions to lower
+
+    Returns:
+        - If exprs is a single Expr: Returns a single LaTeX string.
+        - If exprs is a sequence: Returns a list of LaTeX strings in order.
+
+    Example:
+        Single expression::
+
+            x = ox.State("x", shape=(3,))
+            to_latex(ox.Norm(x) - 5.0)
+            # '\\left\\| x \\right\\| - 5'
+
+        Multiple expressions::
+
+            exprs = [ox.Norm(x), ox.Sum(x)]
+            to_latex(exprs)
+            # ['\\left\\| x \\right\\|', '\\sum x']
+
+    Note:
+        The returned strings carry no ``$`` delimiters — callers add their own.
+        Nodes without a registered LaTeX visitor (STL, Lie, spatial, ...) raise
+        ``NotImplementedError``.
+    """
+    from openscvx.symbolic.lowerers.latex import LatexLowerer
+
+    ll = LatexLowerer()
+    if isinstance(exprs, Expr):
+        return lower(exprs, ll)
+    return [lower(e, ll) for e in exprs]
+
+
 def _tile_sparsity(pattern_2d: np.ndarray, K: int):
     """Convert a 2-D boolean pattern to CVXPY sparsity indices tiled over *K* slices.
 

openscvx-0.5.3.dev39/openscvx/symbolic/lowerers/latex/__init__.py

@@ -0,0 +1,49 @@
+"""LaTeX backend for lowering symbolic expressions to math strings.
+
+This package implements the LaTeX lowering backend that converts symbolic
+expression AST nodes into LaTeX math strings.  Like the JAX and CVXPy
+backends, lowering uses a visitor pattern where each expression type has a
+corresponding visitor function registered via ``@visitor``.
+
+The visitor functions are split across submodules that mirror the
+``openscvx.symbolic.expr`` package structure.  Importing this package
+triggers registration of all visitors, which now cover every shipped node
+type — arithmetic, linear algebra, elementwise math, arrays, constraints,
+logic, spatial, Lie-group, STL, and ``Vmap``.  A future node added without a
+visitor raises ``NotImplementedError`` — the designed fallback until its
+visitor lands.  (The legacy ``stljax`` operators are intentionally left
+unregistered; the GMSR ``ox.stl`` surface is the rendered one.)
+
+Example::
+
+    from openscvx.symbolic.lowerers.latex import LatexLowerer
+
+    lowerer = LatexLowerer()
+    s = lowerer.lower(ox.Norm(x) - 5.0)  # '\\left\\| x \\right\\| - 5'
+"""
+
+# Import visitor modules to trigger @visitor registration.
+# Each module populates _LATEX_VISITORS as a side effect of import.
+from openscvx.symbolic.lowerers.latex import (
+    arithmetic,  # noqa: F401
+    array,  # noqa: F401
+    constraint,  # noqa: F401
+    control,  # noqa: F401
+    expr,  # noqa: F401
+    lie,  # noqa: F401
+    linalg,  # noqa: F401
+    logic,  # noqa: F401
+    math,  # noqa: F401
+    spatial,  # noqa: F401
+    state,  # noqa: F401
+    stl,  # noqa: F401
+    vmap,  # noqa: F401
+)
+from openscvx.symbolic.lowerers.latex._lowerer import (
+    LatexLowerer,
+    format_constant,
+    latex_symbol,
+)
+from openscvx.symbolic.lowerers.latex.formulation import problem_to_latex
+
+__all__ = ["LatexLowerer", "latex_symbol", "format_constant", "problem_to_latex"]

openscvx-0.5.3.dev39/openscvx/symbolic/lowerers/latex/_lowerer.py

@@ -0,0 +1,263 @@
+"""LatexLowerer class definition and shared string helpers.
+
+The visitor methods that populate the registry live in sibling modules
+(``arithmetic``, ``math``, ``linalg``, etc.) and are registered via
+``@visitor`` at import time.  This module also carries the pieces every
+visitor leans on: precedence-aware parenthesization (:data:`_PRECEDENCE`,
+:func:`wrap`), symbol rendering (:func:`latex_symbol`), and constant rendering
+(:func:`format_constant`).
+"""
+
+import numpy as np
+
+from openscvx.symbolic.expr import Expr
+from openscvx.symbolic.expr.arithmetic import Add, MatMul, Mul, Neg, Power, Sub
+from openscvx.symbolic.lowerers.latex._registry import dispatch
+
+
+class LatexLowerer:
+    """LaTeX backend for lowering symbolic expressions to math strings.
+
+    This class implements the visitor pattern for converting symbolic
+    expression AST nodes to LaTeX. Each expression type has a corresponding
+    visitor function decorated with ``@visitor`` that returns a ``str``.
+
+    The lowering is recursive: each visitor lowers its children first, then
+    composes them into a LaTeX fragment, calling :func:`wrap` on children that
+    may need parentheses for the surrounding precedence.
+
+    Unlike :class:`~openscvx.symbolic.lowerers.jax.JaxLowerer`, the LaTeX
+    lowerer is stateless — rendering is pure string assembly with no trace,
+    node cache, or memoization.
+
+    Example:
+        Lower an expression to a LaTeX string::
+
+            lowerer = LatexLowerer()
+            s = lowerer.lower(ox.Norm(x) - 5.0)
+            # '\\left\\| x \\right\\| - 5'
+    """
+
+    def lower(self, expr: Expr) -> str:
+        """Lower a symbolic expression to a LaTeX string.
+
+        Main entry point for lowering. Delegates to :func:`dispatch`, which
+        looks up the appropriate visitor based on the expression type.
+
+        Args:
+            expr: Symbolic expression to lower (any Expr subclass)
+
+        Returns:
+            LaTeX math string (no ``$`` delimiters — callers add their own)
+
+        Raises:
+            NotImplementedError: If no visitor exists for the expression type
+        """
+        return dispatch(self, expr)
+
+
+# Precedence-aware parenthesization: visitors call wrap() on children, passing
+# the precedence of the surrounding context. Leaves and function-style nodes
+# (Norm, Sin, Div-as-\frac, ...) are self-delimiting and default to 10.
+_PRECEDENCE = {Add: 1, Sub: 1, Mul: 2, MatMul: 2, Neg: 3, Power: 4}
+
+
+def wrap(lowerer: LatexLowerer, child: Expr, parent_precedence: int) -> str:
+    """Lower ``child`` and parenthesize it if the parent binds tighter.
+
+    A child whose precedence is strictly lower than ``parent_precedence`` is
+    wrapped in ``\\left( ... \\right)``. Leaves and function-style nodes
+    default to precedence 10 and are never wrapped.
+
+    Args:
+        lowerer: The LatexLowerer performing the lowering.
+        child: The child expression to render.
+        parent_precedence: Precedence of the surrounding operator; pass a value
+            one higher than the operator's own precedence for the right operand
+            of a non-associative operator (e.g. ``Sub``) so equal-precedence
+            children are still parenthesized.
+
+    Returns:
+        The child's LaTeX, parenthesized when required.
+    """
+    s = lowerer.lower(child)
+    if _PRECEDENCE.get(type(child), 10) < parent_precedence:
+        return rf"\left( {s} \right)"
+    return s
+
+
+# Greek-word names that map to a LaTeX command of the same name.
+_GREEK = {
+    "alpha",
+    "beta",
+    "gamma",
+    "delta",
+    "epsilon",
+    "zeta",
+    "eta",
+    "theta",
+    "iota",
+    "kappa",
+    "lambda",
+    "mu",
+    "nu",
+    "xi",
+    "pi",
+    "rho",
+    "sigma",
+    "tau",
+    "upsilon",
+    "phi",
+    "chi",
+    "psi",
+    "omega",
+    "Gamma",
+    "Delta",
+    "Theta",
+    "Lambda",
+    "Xi",
+    "Pi",
+    "Sigma",
+    "Upsilon",
+    "Phi",
+    "Psi",
+    "Omega",
+}
+
+
+def latex_symbol(name: str) -> str:
+    """Render a variable name as a LaTeX symbol.
+
+    Rules, in order:
+
+    - A Greek-word name renders as its command: ``'alpha'`` -> ``'\\alpha'``.
+    - A single character renders bare: ``'x'`` -> ``'x'``.
+    - A ``base_sub`` name splits on the first underscore into a subscript:
+      ``'x_pos'`` -> ``'x_{\\mathrm{pos}}'`` (base and subscript are rendered
+      recursively).
+    - Any other multi-letter name renders upright: ``'position'`` ->
+      ``'\\mathrm{position}'``, with underscores escaped.
+
+    Args:
+        name: The variable name to render.
+
+    Returns:
+        The LaTeX fragment for the name.
+    """
+    if name in _GREEK:
+        return rf"\{name}"
+    if len(name) == 1:
+        return name
+    # base_sub -> subscript, when the split yields non-empty halves.
+    if "_" in name and not name.startswith("_") and not name.endswith("_"):
+        base, sub = name.split("_", 1)
+        return rf"{latex_symbol(base)}_{{{latex_symbol(sub)}}}"
+    escaped = name.replace("_", r"\_")
+    return rf"\mathrm{{{escaped}}}"
+
+
+def merge_subscript(base: str, sub) -> str:
+    """Append a subscript to a symbol, merging into an existing subscript group.
+
+    If ``base`` already ends in a ``_{...}`` group, ``sub`` is spliced in before
+    the closing brace as ``,<sub>`` (``x_{\\mathrm{velocity}}`` + ``0`` ->
+    ``x_{\\mathrm{velocity},0}``); otherwise ``_{<sub>}`` is appended
+    (``\\theta`` + ``0`` -> ``\\theta_{0}``).  This never emits a double
+    subscript like ``x_{a}_{b}``, which is invalid LaTeX.
+
+    The trailing group is matched by depth-scanning braces (not a naive
+    ``[^{}]`` regex), so nested groups like ``\\mathrm{velocity}`` inside the
+    subscript are handled, and a non-subscript trailing group such as the
+    ``\\dot{x}`` accent or ``\\mathrm{position}`` correctly appends instead of
+    splicing.
+
+    Args:
+        base: The symbol to subscript (already-rendered LaTeX).
+        sub: The subscript to add (stringified).
+
+    Returns:
+        ``base`` with ``sub`` merged into its subscript.
+    """
+    sub = str(sub)
+    if base.endswith("}"):
+        depth = 0
+        open_idx = None
+        for i in range(len(base) - 1, -1, -1):
+            if base[i] == "}":
+                depth += 1
+            elif base[i] == "{":
+                depth -= 1
+                if depth == 0:
+                    open_idx = i
+                    break
+        # A trailing group is a subscript group only when its `{` follows `_`.
+        if open_idx is not None and open_idx >= 1 and base[open_idx - 1] == "_":
+            return f"{base[:-1]},{sub}}}"
+    return rf"{base}_{{{sub}}}"
+
+
+def state_symbol(name: str) -> str:
+    """Render a state's role-prefixed symbol: ``x_{<sym>}``.
+
+    States are grounded in the skeleton's ``f(x, u)`` by prefixing the role
+    letter ``x``; ``<sym>`` is the :func:`latex_symbol` rendering of the name
+    (``x_{\\mathrm{velocity}}``, ``x_{\\theta}``).  A state literally named
+    ``x`` renders bare as ``x``.
+    """
+    if name == "x":
+        return "x"
+    return merge_subscript("x", latex_symbol(name))
+
+
+def control_symbol(name: str) -> str:
+    """Render a control's role-prefixed symbol: ``u_{<sym>}``.
+
+    Mirrors :func:`state_symbol` with the role letter ``u``; a control literally
+    named ``u`` renders bare as ``u``.
+    """
+    if name == "u":
+        return "u"
+    return merge_subscript("u", latex_symbol(name))
+
+
+def _format_scalar(value: float) -> str:
+    """Render a scalar with ``%g`` (compact, no trailing zeros)."""
+    return "%g" % value
+
+
+def format_constant(value: np.ndarray) -> str:
+    """Render a numeric constant as LaTeX.
+
+    Scalars render via ``%g``. Vectors render as a column ``bmatrix`` and
+    matrices as a 2-D ``bmatrix``, up to 6 entries per axis. Larger arrays
+    render as a placeholder ``\\mathrm{const} \\in \\mathbb{R}^{...}`` rather
+    than an unreadable wall of numbers.
+
+    Args:
+        value: The constant value (scalar, vector, matrix, or higher-rank
+            array).
+
+    Returns:
+        The LaTeX fragment for the constant.
+    """
+    arr = np.asarray(value)
+
+    if arr.ndim == 0:
+        return _format_scalar(arr.item())
+
+    if arr.ndim == 1:
+        if arr.shape[0] > 6:
+            return rf"\mathrm{{const}} \in \mathbb{{R}}^{{{arr.shape[0]}}}"
+        body = r" \\ ".join(_format_scalar(v) for v in arr)
+        return rf"\begin{{bmatrix}} {body} \end{{bmatrix}}"
+
+    if arr.ndim == 2:
+        m, n = arr.shape
+        if m > 6 or n > 6:
+            return rf"\mathrm{{const}} \in \mathbb{{R}}^{{{m} \times {n}}}"
+        rows = [" & ".join(_format_scalar(v) for v in row) for row in arr]
+        body = r" \\ ".join(rows)
+        return rf"\begin{{bmatrix}} {body} \end{{bmatrix}}"
+
+    shape = r" \times ".join(str(d) for d in arr.shape)
+    return rf"\mathrm{{const}} \in \mathbb{{R}}^{{{shape}}}"

openscvx-0.5.3.dev39/openscvx/symbolic/lowerers/latex/_registry.py

@@ -0,0 +1,82 @@
+"""Visitor registry for the LaTeX lowerer.
+
+This module holds the shared visitor dictionary, the ``@visitor`` decorator,
+and the ``dispatch`` function.  It is deliberately kept free of heavyweight
+imports (no expression subclasses beyond the base ``Expr``) so that the visitor
+modules can import from it without circular-dependency issues.
+
+The registry is independent of the JAX and CVXPy registries.  It covers every
+shipped node type; a future node added without a registered LaTeX visitor (or a
+deliberately-unregistered legacy node like the ``stljax`` operators) raises
+``NotImplementedError`` on dispatch — the designed fallback.
+"""
+
+from typing import Any, Callable, Dict, Type
+
+from openscvx.symbolic.expr import Expr
+
+_LATEX_VISITORS: Dict[Type[Expr], Callable] = {}
+"""Registry mapping expression types to their visitor functions."""
+
+
+def visitor(expr_cls: Type[Expr]) -> Callable[[Callable], Callable]:
+    """Decorator to register a visitor function for an expression type.
+
+    This decorator registers a visitor method to handle a specific expression
+    type during LaTeX lowering. The decorated function is stored in
+    _LATEX_VISITORS and will be called by dispatch() when lowering that
+    expression type.
+
+    Args:
+        expr_cls: The Expr subclass this visitor handles (e.g., Add, Mul, Norm)
+
+    Returns:
+        Decorator function that registers the visitor and returns it unchanged
+
+    Example:
+        Register a visitor function for the Add expression::
+
+            @visitor(Add)
+            def _visit_add(lowerer, node: Add):
+                ...
+
+    Note:
+        Dispatch is exact-type, so shared behaviour must be registered per
+        concrete class.  Multiple types can share a visitor by stacking
+        decorators::
+
+            @visitor(Equality)
+            @visitor(Inequality)
+            def _visit_constraint(lowerer, node: Constraint):
+                ...
+    """
+
+    def register(fn: Callable[[Any, Expr], str]):
+        _LATEX_VISITORS[expr_cls] = fn
+        return fn
+
+    return register
+
+
+def dispatch(lowerer: Any, expr: Expr) -> str:
+    """Dispatch an expression to its registered visitor function.
+
+    Looks up the visitor function for the expression's type and calls it.
+    This is the core of the visitor pattern implementation.
+
+    Args:
+        lowerer: The LatexLowerer instance (provides context for visitor methods)
+        expr: The expression node to lower
+
+    Returns:
+        The result of calling the visitor function (a LaTeX string)
+
+    Raises:
+        NotImplementedError: If no visitor is registered for the expression type
+    """
+    fn = _LATEX_VISITORS.get(type(expr))
+    if fn is None:
+        raise NotImplementedError(
+            f"{lowerer.__class__.__name__!r} has no visitor for {type(expr).__name__}"
+        )
+    return fn(lowerer, expr)