Function checkForms

test/compute-engine/canonical-form.test.ts:1245–1289

* * Print/check boxed expression variants in a similar way to function 'checkJson', but only prints * for variants 'boxed' (non-canonical), 'canonical', but also 'canonForms' (i.e. partial-canonical). * * Only prints 'canonical' if this differs from 'boxed'. * * <!-- * **NOTE**: * -Unlike 'c

(
  inExpr: string | ExpressionInput,
  forms: CanonicalForm[],
  engine?: ComputeEngine
)

  });

  test('function({ structural: true }) keeps Power instead of folding to Root', () => {
    const ce = new ComputeEngine();
    const p = ce.function('Power', [ce.symbol('x'), ce.number([1, 3])], {
      structural: true,
    });
    expect((p as any).isStructural).toBe(true);
    expect(p.json).toEqual(['Power', 'x', ['Rational', 1, 3]]);
  });

  test('explicit `form` takes precedence over `canonical`', () => {
    const ce = new ComputeEngine();
    expect(
      ce.expr(['Add', 'a', 1], {
        form: 'canonical',
        canonical: false,
      } as any).isCanonical
    ).toBe(true);
  });

  test('assume() canonicalizes a non-canonical predicate', () => {
    // The RHS `Subtract(3, 3)` must fold to `0` for the bound-extraction to
    // record `x > 0`, even though the caller boxed the predicate
    // non-canonically. Without canonicalization in assume() the raw
    // `Greater(x, Subtract(3, 3))` does not yield a numeric bound.
    const ce = new ComputeEngine();
    const pred = ce.expr(['Greater', 'x', ['Subtract', 3, 3]], {
      canonical: false,
    });
    expect(pred.isCanonical).toBe(false);
    expect(ce.assume(pred)).toBe('ok');
    expect(ce.expr('x').isPositive).toBe(true);
  });
});

describe('structural-aware subs', () => {
  // Regression: `.subs()` on a STRUCTURAL receiver used to request a CANONICAL
  // rebuild, silently erasing the parse vocabulary that structural form exists
  // to preserve (`Subtract`, `Divide`, `InvisibleOperator`, `Delimiter`,
  // operand order) and folding its exact literals. The receiver's form is now
  // preserved three ways: canonical → canonical, structural → structural,
  // raw → raw. An EXPLICIT `canonical` option keeps its former meaning.
  const LATEX = '2(x+1) - \\frac{y}{3}';

  test('a structural receiver stays structural, shape preserved', () => {
    const ce = new ComputeEngine();
    const expr = ce.parse(LATEX, { form: 'structural' });
    expect((expr as any).isStructural).toBe(true);