Function mAC

src/compute-engine/rubi/match.ts:185–239

(
  pat: { op: string; ops: Pat[] },
  expr: Expression,
  x: Expression,
  env: Env,
  k: () => boolean
)

  )
    return false;

  const defaults = (i: number, kk: () => boolean): boolean => {
    if (i === optionals.length) return kk();
    const o = optionals[i] as { name: string; default: Expression };
    return bindIn(env, o.name, o.default, () => defaults(i + 1, kk));
  };
  return defaults(0, () => m(others[0], expr, x, env, k));
}

function mSeq(
  pats: Pat[],
  exprs: ReadonlyArray<Expression>,
  x: Expression,
  env: Env,
  k: () => boolean
): boolean {
  if (pats.length === 0) return k();
  return m(pats[0], exprs[0], x, env, () =>
    mSeq(pats.slice(1), exprs.slice(1), x, env, k)
  );
}

// Orderless + flat matching for Add/Multiply.
//
// Pattern operands are ordered deterministic-first (var, const, node,
// slots last) and assigned to expression operands by backtracking.
// Optional slots may bind their default instead of consuming an operand.
// The FINAL pattern operand, when it is a slot, absorbs all remaining
// expression operands ("u_. absorbs the rest of the product").
function mAC(
  pat: { op: string; ops: Pat[] },
  expr: Expression,
  x: Expression,
  env: Env,
  k: () => boolean
): boolean {
  const exprOps = expr.ops!;
  const rank = (p: Pat): number =>
    p.kind === 'var'
      ? 0
      : p.kind === 'const'
        ? 1
        : p.kind === 'node'
          ? 2
          : p.kind === 'slot'
            ? 3
            : 4;
  const ordered = [...pat.ops].sort((a, b) => rank(a) - rank(b));

  const used = new Array<boolean>(exprOps.length).fill(false);
  const ce = expr.engine;

  const assign = (i: number): boolean => {
    if (i === ordered.length) return used.every(Boolean) && k();
    const p = ordered[i];
    const isLast = i === ordered.length - 1;

    // Final slot absorbs the rest (flat matching)