Function matchIdentityTerm

src/compute-engine/boxed-expression/match.ts:1288–1323

Try to match a pattern operand against the identity value (0 for Add, 1 * for Multiply). If direct matching fails and the pattern is a product with * a free wildcard, set that wildcard to 0 (since 0 * anything = 0).

(
  patOp: Expression,
  identity: Expression,
  sub: BoxedSubstitution,
  options: PatternMatchOptions & { acceptVariants?: boolean },
  ce: Expression['engine']
)

function matchWithMissingTerms(
  expr: Expression,
  pattern: Expression,
  substitution: BoxedSubstitution,
  options: PatternMatchOptions & { acceptVariants?: boolean },
  ce: Expression['engine']
): BoxedSubstitution | null {
  if (!isFunction(expr) || !isFunction(pattern)) return null;

  const operator = expr.operator;
  const identity =
    operator === 'Add' ? ce.Zero : operator === 'Multiply' ? ce.One : null;
  if (!identity) return null;

  const patOps = pattern.ops;
  const missing = patOps.length - expr.nops;
  if (missing <= 0) return null;

  // Try all combinations of which pattern ops are identity terms.
  // Sort so combinations with simpler identity terms are tried first
  // (a bare wildcard `_c` is a better identity candidate than a complex
  // pattern like `Multiply(_a, Power(_x, 2))`).
  const combos = combinations(patOps.length, missing);
  combos.sort((a, b) => {
    const scoreA = a.reduce((s, i) => s + patternComplexity(patOps[i]), 0);
    const scoreB = b.reduce((s, i) => s + patternComplexity(patOps[i]), 0);
    return scoreA - scoreB;
  });

  for (const identityIndices of combos) {
    const activePatOps = patOps.filter((_, i) => !identityIndices.includes(i));
    const identityPatOps = identityIndices.map((i) => patOps[i]);

    // Create a sub-pattern with only the active ops and try matching
    const subPattern = ce.function(operator, activePatOps, { form: 'raw' });
    let sub = matchPermutation(expr, subPattern, substitution, options);
    if (sub === null) continue;

    // For each identity pattern op, try to match it against the identity value
    let failed = false;
    for (const patOp of identityPatOps) {