Function normalizeRule

scripts/rubi/extract-rules.ts:164–232

(index: number, expr: Json, source: string)

}

function normalizeRule(index: number, expr: Json, source: string): RubiRule {
  const setDelayed = asCall(expr, 'SetDelayed');
  if (!setDelayed) throw new Error('rule is not a SetDelayed definition');
  const [, lhsCall, rhsExpr] = setDelayed;

  const int = asCall(lhsCall, 'Int');
  if (!int || int.length !== 3) throw new Error('LHS is not Int[…, x_Symbol]');
  const [, lhs, varPat] = int;
  // The integration-variable slot is `x_Symbol` or plain `x_`.
  const blank = asCall(varPat, 'Blank');
  if (
    !blank ||
    typeof blank[1] !== 'string' ||
    blank[1] === '' ||
    (blank[2] !== undefined && blank[2] !== 'Symbol')
  )
    throw new Error('integration variable is not an x_/x_Symbol pattern');
  const variable = blank[1];

  // Outer condition: rhs = Condition[body, cond]
  let body = rhsExpr;
  let condition: Json | null = null;
  const outerCond = asCall(body, 'Condition');
  if (outerCond) {
    body = outerCond[1];
    condition = outerCond[2];
  }

  // With/Module scope (possibly nested) with optional inner condition
  const bindings: RubiRule['bindings'] = [];
  let scoped: RubiRule['scoped'] = null;
  let innerCondition: Json | null = null;
  for (;;) {
    const scope = asCall(body, 'With') ?? asCall(body, 'Module');
    if (!scope) break;
    if (scope.length !== 3)
      throw new Error(`${scope[0]} with ${scope.length - 1} arguments`);
    scoped = scoped ?? ((scope[0] === 'With' ? 'with' : 'module') as const);
    const locals = asCall(scope[1], 'List');
    if (!locals) throw new Error(`${scope[0]} locals are not a List`);
    for (const local of locals.slice(1)) {
      const set = asCall(local, 'Set');
      if (set && typeof set[1] === 'string')
        bindings.push({ name: set[1], value: set[2] });
      else if (typeof local === 'string')
        bindings.push({ name: local, value: null });
      else throw new Error('unsupported local binding form');
    }
    body = scope[2];
    const inner = asCall(body, 'Condition');
    if (inner) {
      body = inner[1];
      innerCondition =
        innerCondition === null ? inner[2] : ['And', innerCondition, inner[2]];
    }
  }

  return {