jax-ml/jax · error · InconclusiveDimensionOperation

Symbolic dimension comparison

Error message

Symbolic dimension comparison {cmp_str()} is inconclusive.{describe_scope}

What it means

JAX needed to decide whether one symbolic dimension is <, <=, ==, >= or > another, but the known constraints do not imply the answer either way. Symbolic comparisons are only resolved when provable, so an unconstrained comparison raises InconclusiveDimensionOperation.

Solutions

  1. Add explicit constraints to the SymbolicScope (e.g. 'n <= m', 'n >= 1') so the comparison becomes provable
  2. Restructure code to avoid comparing symbolic dims (use jnp.where / lax.select on values, not shapes)
  3. Make the compared dimension concrete by removing it from polymorphic_shapes

Example fix

# before
out = jnp.where(x.shape[0] >= 8, f(x), g(x))  # symbolic n >= 8 inconclusive
# after
constraints = ('n >= 8',)
exp = jax.export.export(shapes('n,'), constraints=constraints)(fn)
Defensive patterns

Strategy: try-catch

Validate before calling

# predeclare all needed orderings as constraints
constraints = tuple(f'{a} <= {b}' for a, b in known_orderings) + tuple(f'{v} >= 1' for v in vars)

Try / catch

from jax._src.export import shape_poly
try:
    branch = x.shape[0] >= 8
except shape_poly.InconclusiveDimensionOperation:
    branch = default_branch()  # restructure or add constraint

Prevention

When it happens

Trigger: Comparisons like n < m for independent symbolic vars during export; assertions on shapes (x.shape[0] == y.shape[0] with unrelated vars); broadcasting decisions that need ordering of symbolic dims.

Common situations: Branching on shape relationships inside traced code (if x.shape[0] > 1), padding/valid-checking logic, or eager vs. polymorphic export where a comparison that is constant for concrete shapes becomes symbolic.

Related errors


AI-assisted analysis of jax-ml/jax@1e1c6a8fc0 (2026-08-27). Data as JSON: /api/errors/d856370633ceab17. Report an issue: GitHub.

Appendix: source

Thrown at jax/_src/export/shape_poly.py:1199

  if isinstance(e1, _DimExpr):
    scope = e1.scope
    if isinstance(e2, _DimExpr):
      scope._check_same_scope(e2, f"when comparing {cmp_str()}")
  elif isinstance(e2, _DimExpr):
    scope = e2.scope
  else:
    return int(e1) >= int(e2)
  lb, ub = _bounds_decision(e1 - e2, BoundsPrecision.FOR_GEQ0_OR_LT0)
  if lb >= 0:
    return True
  if ub < 0:
    return False

  if scope._explicit_constraints:
    describe_scope = f"\nUsing symbolic scope {scope}"
  else:
    describe_scope = ""
  raise InconclusiveDimensionOperation(
      f"Symbolic dimension comparison {cmp_str()} is inconclusive.{describe_scope}")

core.pytype_aval_mappings[_DimExpr] = _DimExpr._get_aval
dtypes.register_weak_scalar_type(_DimExpr)

def _convertible_to_int(p: Any) -> TypeGuard[SupportsIndex]:
  try:
    op.index(p)
    return True
  except:
    return False

def _ensure_poly(p: DimSize,
                 operation_name: str,
                 scope: SymbolicScope) -> _DimExpr:
  if isinstance(p, _DimExpr):
    scope._check_same_scope(p, when=f"for operation {operation_name}")
    return p

View on GitHub (pinned to 1e1c6a8fc0)