Function classifyBigopDomain

src/compute-engine/library/utils.ts:65–111

(
  body: Expression | undefined,
  indexes: ReadonlyArray<Expression>,
  ce: ComputeEngine
)

export function isTupleTypedOperand(d: OperandDescriptor): boolean {
  return isTupleShapedType(d.type);
}

/**
 * Does this point operand carry a component that is itself an indexed
 * collection, so that the norm zips into one result per element?
 *
 * `‖(x+[0.5, 1], y)‖` is one norm per element, so the honest type is
 * `list<number>`, not `number` (Tycho item 74: a `number`-typed expression
 * evaluating to a `List` breaks consumers that dispatch on the declared type).
 *
 * A tuple-typed component is NOT a broadcasting collection (tuples are indexed
 * collections in the type lattice but bind atomically): the norm of
 * `((3,4), 12)` takes the inner point's norm and stays scalar.
 *
 * A point that is not written out (a tuple-TYPED symbol or parameter) has no
 * components to walk — its declared element types are inspected instead, so
 * `p: tuple<list<real>, real>` reports the same broadcast its evaluation
 * produces.
 */
export function pointNormBroadcasts(d: OperandDescriptor): boolean {
  const children = operandChildren(d);
  if (children !== undefined)
    return children.some(
      (c) =>
        isSubtype(c.type, INDEXED_COLLECTION_SHAPE_TYPE) &&
        !isTupleTypedOperand(c)
    );
  const t = d.type;
  return (
    typeof t !== 'string' &&
    t.kind === 'tuple' &&
    t.elements.some((el) => {
      const et = el.type;
      if (typeof et !== 'string' && et.kind === 'tuple') return false;
      return isSubtype(et, INDEXED_COLLECTION_SHAPE_TYPE);
    })
  );
}

/**
 * The result type of a Euclidean norm/distance over `components` — the scalar
 * `√(Σ|xᵢ|²)`.
 *
 * **A norm is REAL whatever its components are**: `|z|²` is real for a complex
 * `z`, so `‖(3+4i, 0)‖ = 5`. Claiming the wide `number` (which includes
 * complex) instead is not merely imprecise — it is refused by every
 * `real`-declared slot in the library, so `Hypot(‖p‖, ‖q‖)` reported
 * `incompatible-type('real', 'number')` on a value real by construction.
 *
 * The claim demands PROVEN finiteness of every component, because `real`