Function compileRule

src/compute-engine/rubi/compile.ts:184–234

(
  ce: ComputeEngine,
  rule: RubiRule,
  id: string,
  priority: number
)

  ) {
    if (lhs[1] !== variable) out.add(lhs[1]);
  } else if (Array.isArray(lhs))
    for (const a of lhs.slice(1)) lhsNames(a, variable, out);
  return out;
}

export function compileRule(
  ce: ComputeEngine,
  rule: RubiRule,
  id: string,
  priority: number
): { rule: CompiledRule | null; reason?: string } {
  const skeleton = skeletonize(rule.lhs, rule.variable);
  let boxed: Expression;
  try {
    boxed = ce.expr(skeleton as any);
  } catch (e) {
    return { rule: null, reason: `box error: ${e}` };
  }
  if (!boxed.isValid)
    return { rule: null, reason: 'boxes to invalid expression' };

  const pat = toPat(ce, toTimesPower(ce, boxed), null, 1);
  const expected = lhsNames(rule.lhs, rule.variable);
  const got = slotNames(pat);
  const missing = [...expected].filter((n) => !got.has(n));
  if (missing.length > 0)
    return {
      rule: null,
      reason: `slots folded away by canonicalization: ${missing.join(',')}`,
    };

  // dispatch pre-screen: a node pattern matches only its own root
  // operator — unless it can collapse (all operands but one optional)
  let rootOp: string | null = null;
  if (pat.kind === 'node') {
    const optionals = pat.ops.filter((p) => p.kind === 'optslot').length;
    const collapsible = optionals >= 1 && pat.ops.length - optionals === 1;
    if (!collapsible) rootOp = pat.op;
  }

  return {
    rule: {
      id,
      priority,
      variable: rule.variable,
      pat,
      rootOp,
      requiredHeads: requiredHeads(pat),
      bindings: rule.bindings,
      condition: rule.condition,
      innerCondition: rule.innerCondition,
      rhs: rule.rhs,
      source: rule.source ?? '', // stripped from the shipped bundle
    },